001package org.hl7.fhir.r5.model;
002
003
004/*
005  Copyright (c) 2011+, HL7, Inc.
006  All rights reserved.
007  
008  Redistribution and use in source and binary forms, with or without modification, \
009  are permitted provided that the following conditions are met:
010  
011   * Redistributions of source code must retain the above copyright notice, this \
012     list of conditions and the following disclaimer.
013   * Redistributions in binary form must reproduce the above copyright notice, \
014     this list of conditions and the following disclaimer in the documentation \
015     and/or other materials provided with the distribution.
016   * Neither the name of HL7 nor the names of its contributors may be used to 
017     endorse or promote products derived from this software without specific 
018     prior written permission.
019  
020  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \
021  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \
022  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \
023  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \
024  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \
025  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \
026  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \
027  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \
028  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \
029  POSSIBILITY OF SUCH DAMAGE.
030  */
031
032// Generated on Thu, Mar 23, 2023 19:59+1100 for FHIR v5.0.0
033
034
035import org.hl7.fhir.instance.model.api.*;
036import org.hl7.fhir.utilities.Utilities;
037import org.hl7.fhir.exceptions.FHIRException;
038
039public class Enumerations {
040
041// In here: 
042//   ActionCardinalityBehavior: Defines behavior for an action or a group for how many times that item may be repeated.[PlanDefinition, RequestOrchestration]
043//   ActionConditionKind: Defines the kinds of conditions that can appear on actions.[PlanDefinition, RequestOrchestration]
044//   ActionGroupingBehavior: Defines organization behavior of a group.[PlanDefinition, RequestOrchestration]
045//   ActionParticipantType: The type of participant for the action.[ActivityDefinition, PlanDefinition, RequestOrchestration]
046//   ActionPrecheckBehavior: Defines selection frequency behavior for an action or group.[PlanDefinition, RequestOrchestration]
047//   ActionRelationshipType: Defines the types of relationships between actions.[PlanDefinition, RequestOrchestration]
048//   ActionRequiredBehavior: Defines expectations around whether an action or action group is required.[PlanDefinition, RequestOrchestration]
049//   ActionSelectionBehavior: Defines selection behavior of a group.[PlanDefinition, RequestOrchestration]
050//   AdministrativeGender: The gender of a person used for administrative purposes.[ObservationDefinition, Patient, Person, Practitioner, RelatedPerson]
051//   AllLanguages: This value set includes all possible codes from BCP-47 (see http://tools.ietf.org/html/bcp47)[Account, ActivityDefinition, ActorDefinition, AdministrableProductDefinition, AdverseEvent, AllergyIntolerance, Appointment, AppointmentResponse, ArtifactAssessment, Attachment, AuditEvent, Basic, Binary, BiologicallyDerivedProduct, BiologicallyDerivedProductDispense, BodyStructure, Bundle, CanonicalResource, CapabilityStatement, CarePlan, CareTeam, ChargeItem, ChargeItemDefinition, Citation, Claim, ClaimResponse, ClinicalImpression, ClinicalUseDefinition, CodeSystem, Communication, CommunicationRequest, CompartmentDefinition, Composition, ConceptMap, Condition, ConditionDefinition, Consent, Contract, Coverage, CoverageEligibilityRequest, CoverageEligibilityResponse, DetectedIssue, Device, DeviceAssociation, DeviceDefinition, DeviceDispense, DeviceMetric, DeviceRequest, DeviceUsage, DiagnosticReport, DocumentReference, DomainResource, Encounter, EncounterHistory, Endpoint, EnrollmentRequest, EnrollmentResponse, EpisodeOfCare, EventDefinition, Evidence, EvidenceReport, EvidenceVariable, ExampleScenario, ExplanationOfBenefit, FamilyMemberHistory, Flag, FormularyItem, GenomicStudy, Goal, GraphDefinition, Group, GuidanceResponse, HealthcareService, ImagingSelection, ImagingStudy, Immunization, ImmunizationEvaluation, ImmunizationRecommendation, ImplementationGuide, Ingredient, InsurancePlan, InventoryItem, InventoryReport, Invoice, Library, Linkage, List, Location, ManufacturedItemDefinition, Measure, MeasureReport, Medication, MedicationAdministration, MedicationDispense, MedicationKnowledge, MedicationRequest, MedicationStatement, MedicinalProductDefinition, MessageDefinition, MessageHeader, MetadataResource, MolecularSequence, NamingSystem, NutritionIntake, NutritionOrder, NutritionProduct, Observation, ObservationDefinition, OperationDefinition, OperationOutcome, Organization, OrganizationAffiliation, PackagedProductDefinition, Parameters, Patient, PaymentNotice, PaymentReconciliation, Permission, Person, PlanDefinition, Practitioner, PractitionerRole, Procedure, Provenance, Questionnaire, QuestionnaireResponse, RegulatedAuthorization, RelatedPerson, RequestOrchestration, Requirements, ResearchStudy, ResearchSubject, Resource, RiskAssessment, Schedule, SearchParameter, ServiceRequest, Slot, Specimen, SpecimenDefinition, StructureDefinition, StructureMap, Subscription, SubscriptionStatus, SubscriptionTopic, Substance, SubstanceDefinition, SubstanceNucleicAcid, SubstancePolymer, SubstanceProtein, SubstanceReferenceInformation, SubstanceSourceMaterial, SupplyDelivery, SupplyRequest, Task, TerminologyCapabilities, TestPlan, TestReport, TestScript, Transport, ValueSet, VerificationResult, VisionPrescription]
052//   BindingStrength: Indication of the degree of conformance expectations associated with a binding.[ElementDefinition, OperationDefinition]
053//   CapabilityStatementKind: How a capability statement is intended to be used.[CapabilityStatement, TerminologyCapabilities]
054//   ClaimProcessingCodes: This value set includes Claim Processing Outcome codes.[ClaimResponse, ExplanationOfBenefit]
055//   CodeSystemContentMode: The extent of the content of the code system (the concepts and codes it defines) are represented in a code system resource.[CodeSystem, TerminologyCapabilities]
056//   CommonLanguages: This value set includes common codes from BCP-47 (see http://tools.ietf.org/html/bcp47)[InventoryItem, TerminologyCapabilities]
057//   CompartmentType: Which type a compartment definition describes.[CompartmentDefinition, GraphDefinition]
058//   CompositionStatus: The workflow/clinical status of the composition.[Composition, DocumentReference]
059//   ConceptMapRelationship: The relationship between concepts.[ConceptMap]
060//   ConsentDataMeaning: How a resource reference is interpreted when testing consent restrictions.[Consent, Permission]
061//   ConsentProvisionType: How a rule statement is applied, such as adding additional consent or removing consent.[Consent, Permission]
062//   Currencies: Currency codes from ISO 4217 (see https://www.iso.org/iso-4217-currency-codes.html)[Account, Money]
063//   DaysOfWeek: The days of the week.[Appointment, Availability, Timing]
064//   DeviceNameType: The type of name the device is referred by.[Device, DeviceDefinition]
065//   EncounterStatus: Current state of the encounter.[Encounter, EncounterHistory]
066//   EventStatus: Codes identifying the lifecycle stage of an event.[ClinicalImpression, Communication, NutritionIntake, Procedure]
067//   EvidenceVariableHandling: The handling of the variable in statistical analysis for exposures or outcomes (E.g. Dichotomous, Continuous, Descriptive).[Evidence, EvidenceVariable]
068//   ExampleScenarioActorType: The type of actor - system or human.[ActorDefinition, ExampleScenario]
069//   FHIRTypes: All FHIR types[DataRequirement, Measure, OperationDefinition, ParameterDefinition]
070//   FHIRVersion: All published FHIR Versions.[CapabilityStatement, ImplementationGuide, StructureDefinition]
071//   FilterOperator: The kind of operation to perform as a part of a property based filter.[CodeSystem, ValueSet]
072//   FinancialResourceStatusCodes: This value set includes Status codes.[Claim, ClaimResponse, Coverage, CoverageEligibilityRequest, CoverageEligibilityResponse, EnrollmentRequest, EnrollmentResponse, PaymentNotice, PaymentReconciliation, VisionPrescription]
073//   ListMode: The processing mode that applies to this list.[EvidenceReport, List]
074//   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]
075//   MimeTypes: This value set includes all possible codes from BCP-13 (see http://tools.ietf.org/html/bcp13)[Attachment, Binary, CapabilityStatement, ElementDefinition, Endpoint, Signature, Subscription, TestScript]
076//   ObservationStatus: Codes providing the status of an observation.[Observation, RiskAssessment]
077//   OperationParameterUse: Whether an operation parameter is an input or an output parameter.[OperationDefinition, ParameterDefinition]
078//   PublicationStatus: The lifecycle status of an artifact.[ActivityDefinition, ActorDefinition, AdministrableProductDefinition, CanonicalResource, CapabilityStatement, ChargeItemDefinition, Citation, CodeSystem, CompartmentDefinition, ConceptMap, ConditionDefinition, EventDefinition, Evidence, EvidenceReport, EvidenceVariable, ExampleScenario, GraphDefinition, ImplementationGuide, Ingredient, InsurancePlan, Library, ManufacturedItemDefinition, Measure, MessageDefinition, MetadataResource, NamingSystem, ObservationDefinition, OperationDefinition, PlanDefinition, Questionnaire, RelatedArtifact, Requirements, ResearchStudy, ResearchSubject, SearchParameter, SpecimenDefinition, StructureDefinition, StructureMap, SubscriptionTopic, TerminologyCapabilities, TestPlan, TestScript, ValueSet]
079//   QuantityComparator: How the Quantity should be understood and represented.[Age, Count, Distance, Duration, Quantity]
080//   RequestIntent: Codes indicating the degree of authority/intentionality associated with a request.[ActivityDefinition, CommunicationRequest, DeviceRequest, NutritionOrder, RequestOrchestration, ServiceRequest]
081//   RequestPriority: Identifies the level of importance to be assigned to actioning the request.[ActivityDefinition, Communication, CommunicationRequest, DeviceRequest, MedicationRequest, NutritionOrder, PlanDefinition, RequestOrchestration, ServiceRequest, SupplyRequest, Task, Transport]
082//   RequestStatus: Codes identifying the lifecycle stage of a request.[CarePlan, CommunicationRequest, DeviceRequest, NutritionOrder, RequestOrchestration, ServiceRequest]
083//   ResourceTypeEnum: Concrete FHIR Resource Types[CapabilityStatement, CompartmentDefinition, ImplementationGuide, MessageDefinition, Questionnaire]
084//   SearchComparator: What Search Comparator Codes are supported in search.[SearchParameter, Subscription, SubscriptionTopic]
085//   SearchModifierCode: A supported modifier for a search parameter.[SearchParameter, Subscription, SubscriptionTopic]
086//   SearchParamType: Data types allowed to be used for search parameters.[CapabilityStatement, OperationDefinition, SearchParameter]
087//   SubscriptionStatusCodes: State values for FHIR Subscriptions.[Subscription, SubscriptionStatus]
088//   Use: The purpose of the Claim: predetermination, preauthorization, claim.[Claim, ClaimResponse, ExplanationOfBenefit]
089//   VersionIndependentResourceTypesAll: Current and past FHIR resource types (deleted or renamed), including abstract types[GraphDefinition, OperationDefinition, SearchParameter]
090
091
092    public enum ActionCardinalityBehavior {
093        /**
094         * The action may only be selected one time.
095         */
096        SINGLE, 
097        /**
098         * The action may be selected multiple times.
099         */
100        MULTIPLE, 
101        /**
102         * added to help the parsers
103         */
104        NULL;
105        public static ActionCardinalityBehavior fromCode(String codeString) throws FHIRException {
106            if (codeString == null || "".equals(codeString))
107                return null;
108        if ("single".equals(codeString))
109          return SINGLE;
110        if ("multiple".equals(codeString))
111          return MULTIPLE;
112        throw new FHIRException("Unknown ActionCardinalityBehavior code '"+codeString+"'");
113        }
114        public static boolean isValidCode(String codeString) {
115            if (codeString == null || "".equals(codeString))
116                return false;
117          return Utilities.existsInList(codeString, "single", "multiple");
118        }
119        public String toCode() {
120          switch (this) {
121            case SINGLE: return "single";
122            case MULTIPLE: return "multiple";
123            case NULL: return null;
124            default: return "?";
125          }
126        }
127        public String getSystem() {
128          switch (this) {
129            case SINGLE: return "http://hl7.org/fhir/action-cardinality-behavior";
130            case MULTIPLE: return "http://hl7.org/fhir/action-cardinality-behavior";
131            case NULL: return null;
132            default: return "?";
133          }
134        }
135        public String getDefinition() {
136          switch (this) {
137            case SINGLE: return "The action may only be selected one time.";
138            case MULTIPLE: return "The action may be selected multiple times.";
139            case NULL: return null;
140            default: return "?";
141          }
142        }
143        public String getDisplay() {
144          switch (this) {
145            case SINGLE: return "Single";
146            case MULTIPLE: return "Multiple";
147            case NULL: return null;
148            default: return "?";
149          }
150        }
151    }
152
153  public static class ActionCardinalityBehaviorEnumFactory implements EnumFactory<ActionCardinalityBehavior> {
154    public ActionCardinalityBehavior fromCode(String codeString) throws IllegalArgumentException {
155      if (codeString == null || "".equals(codeString))
156            if (codeString == null || "".equals(codeString))
157                return null;
158        if ("single".equals(codeString))
159          return ActionCardinalityBehavior.SINGLE;
160        if ("multiple".equals(codeString))
161          return ActionCardinalityBehavior.MULTIPLE;
162        throw new IllegalArgumentException("Unknown ActionCardinalityBehavior code '"+codeString+"'");
163        }
164
165        public Enumeration<ActionCardinalityBehavior> fromType(PrimitiveType<?> code) throws FHIRException {
166          if (code == null)
167            return null;
168          if (code.isEmpty())
169            return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.NULL, code);
170          String codeString = ((PrimitiveType) code).asStringValue();
171          if (codeString == null || "".equals(codeString))
172            return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.NULL, code);
173        if ("single".equals(codeString))
174          return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.SINGLE, code);
175        if ("multiple".equals(codeString))
176          return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.MULTIPLE, code);
177        throw new FHIRException("Unknown ActionCardinalityBehavior code '"+codeString+"'");
178        }
179    public String toCode(ActionCardinalityBehavior code) {
180       if (code == ActionCardinalityBehavior.NULL)
181           return null;
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 static boolean isValidCode(String codeString) {
222            if (codeString == null || "".equals(codeString))
223                return false;
224          return Utilities.existsInList(codeString, "applicability", "start", "stop");
225        }
226        public String toCode() {
227          switch (this) {
228            case APPLICABILITY: return "applicability";
229            case START: return "start";
230            case STOP: return "stop";
231            case NULL: return null;
232            default: return "?";
233          }
234        }
235        public String getSystem() {
236          switch (this) {
237            case APPLICABILITY: return "http://hl7.org/fhir/action-condition-kind";
238            case START: return "http://hl7.org/fhir/action-condition-kind";
239            case STOP: return "http://hl7.org/fhir/action-condition-kind";
240            case NULL: return null;
241            default: return "?";
242          }
243        }
244        public String getDefinition() {
245          switch (this) {
246            case APPLICABILITY: return "The condition describes whether or not a given action is applicable.";
247            case START: return "The condition is a starting condition for the action.";
248            case STOP: return "The condition is a stop, or exit condition for the action.";
249            case NULL: return null;
250            default: return "?";
251          }
252        }
253        public String getDisplay() {
254          switch (this) {
255            case APPLICABILITY: return "Applicability";
256            case START: return "Start";
257            case STOP: return "Stop";
258            case NULL: return null;
259            default: return "?";
260          }
261        }
262    }
263
264  public static class ActionConditionKindEnumFactory implements EnumFactory<ActionConditionKind> {
265    public ActionConditionKind fromCode(String codeString) throws IllegalArgumentException {
266      if (codeString == null || "".equals(codeString))
267            if (codeString == null || "".equals(codeString))
268                return null;
269        if ("applicability".equals(codeString))
270          return ActionConditionKind.APPLICABILITY;
271        if ("start".equals(codeString))
272          return ActionConditionKind.START;
273        if ("stop".equals(codeString))
274          return ActionConditionKind.STOP;
275        throw new IllegalArgumentException("Unknown ActionConditionKind code '"+codeString+"'");
276        }
277
278        public Enumeration<ActionConditionKind> fromType(PrimitiveType<?> code) throws FHIRException {
279          if (code == null)
280            return null;
281          if (code.isEmpty())
282            return new Enumeration<ActionConditionKind>(this, ActionConditionKind.NULL, code);
283          String codeString = ((PrimitiveType) code).asStringValue();
284          if (codeString == null || "".equals(codeString))
285            return new Enumeration<ActionConditionKind>(this, ActionConditionKind.NULL, code);
286        if ("applicability".equals(codeString))
287          return new Enumeration<ActionConditionKind>(this, ActionConditionKind.APPLICABILITY, code);
288        if ("start".equals(codeString))
289          return new Enumeration<ActionConditionKind>(this, ActionConditionKind.START, code);
290        if ("stop".equals(codeString))
291          return new Enumeration<ActionConditionKind>(this, ActionConditionKind.STOP, code);
292        throw new FHIRException("Unknown ActionConditionKind code '"+codeString+"'");
293        }
294    public String toCode(ActionConditionKind code) {
295       if (code == ActionConditionKind.NULL)
296           return null;
297       if (code == ActionConditionKind.APPLICABILITY)
298        return "applicability";
299      if (code == ActionConditionKind.START)
300        return "start";
301      if (code == ActionConditionKind.STOP)
302        return "stop";
303      return "?";
304   }
305    public String toSystem(ActionConditionKind code) {
306      return code.getSystem();
307      }
308    }
309
310    public enum ActionGroupingBehavior {
311        /**
312         * Any group marked with this behavior should be displayed as a visual group to the end user.
313         */
314        VISUALGROUP, 
315        /**
316         * 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.
317         */
318        LOGICALGROUP, 
319        /**
320         * 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".
321         */
322        SENTENCEGROUP, 
323        /**
324         * added to help the parsers
325         */
326        NULL;
327        public static ActionGroupingBehavior fromCode(String codeString) throws FHIRException {
328            if (codeString == null || "".equals(codeString))
329                return null;
330        if ("visual-group".equals(codeString))
331          return VISUALGROUP;
332        if ("logical-group".equals(codeString))
333          return LOGICALGROUP;
334        if ("sentence-group".equals(codeString))
335          return SENTENCEGROUP;
336        throw new FHIRException("Unknown ActionGroupingBehavior code '"+codeString+"'");
337        }
338        public static boolean isValidCode(String codeString) {
339            if (codeString == null || "".equals(codeString))
340                return false;
341          return Utilities.existsInList(codeString, "visual-group", "logical-group", "sentence-group");
342        }
343        public String toCode() {
344          switch (this) {
345            case VISUALGROUP: return "visual-group";
346            case LOGICALGROUP: return "logical-group";
347            case SENTENCEGROUP: return "sentence-group";
348            case NULL: return null;
349            default: return "?";
350          }
351        }
352        public String getSystem() {
353          switch (this) {
354            case VISUALGROUP: return "http://hl7.org/fhir/action-grouping-behavior";
355            case LOGICALGROUP: return "http://hl7.org/fhir/action-grouping-behavior";
356            case SENTENCEGROUP: return "http://hl7.org/fhir/action-grouping-behavior";
357            case NULL: return null;
358            default: return "?";
359          }
360        }
361        public String getDefinition() {
362          switch (this) {
363            case VISUALGROUP: return "Any group marked with this behavior should be displayed as a visual group to the end user.";
364            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.";
365            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\".";
366            case NULL: return null;
367            default: return "?";
368          }
369        }
370        public String getDisplay() {
371          switch (this) {
372            case VISUALGROUP: return "Visual Group";
373            case LOGICALGROUP: return "Logical Group";
374            case SENTENCEGROUP: return "Sentence Group";
375            case NULL: return null;
376            default: return "?";
377          }
378        }
379    }
380
381  public static class ActionGroupingBehaviorEnumFactory implements EnumFactory<ActionGroupingBehavior> {
382    public ActionGroupingBehavior fromCode(String codeString) throws IllegalArgumentException {
383      if (codeString == null || "".equals(codeString))
384            if (codeString == null || "".equals(codeString))
385                return null;
386        if ("visual-group".equals(codeString))
387          return ActionGroupingBehavior.VISUALGROUP;
388        if ("logical-group".equals(codeString))
389          return ActionGroupingBehavior.LOGICALGROUP;
390        if ("sentence-group".equals(codeString))
391          return ActionGroupingBehavior.SENTENCEGROUP;
392        throw new IllegalArgumentException("Unknown ActionGroupingBehavior code '"+codeString+"'");
393        }
394
395        public Enumeration<ActionGroupingBehavior> fromType(PrimitiveType<?> code) throws FHIRException {
396          if (code == null)
397            return null;
398          if (code.isEmpty())
399            return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.NULL, code);
400          String codeString = ((PrimitiveType) code).asStringValue();
401          if (codeString == null || "".equals(codeString))
402            return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.NULL, code);
403        if ("visual-group".equals(codeString))
404          return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.VISUALGROUP, code);
405        if ("logical-group".equals(codeString))
406          return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.LOGICALGROUP, code);
407        if ("sentence-group".equals(codeString))
408          return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.SENTENCEGROUP, code);
409        throw new FHIRException("Unknown ActionGroupingBehavior code '"+codeString+"'");
410        }
411    public String toCode(ActionGroupingBehavior code) {
412       if (code == ActionGroupingBehavior.NULL)
413           return null;
414       if (code == ActionGroupingBehavior.VISUALGROUP)
415        return "visual-group";
416      if (code == ActionGroupingBehavior.LOGICALGROUP)
417        return "logical-group";
418      if (code == ActionGroupingBehavior.SENTENCEGROUP)
419        return "sentence-group";
420      return "?";
421   }
422    public String toSystem(ActionGroupingBehavior code) {
423      return code.getSystem();
424      }
425    }
426
427    public enum ActionParticipantType {
428        /**
429         * The participant is a care team caring for the patient under evaluation.
430         */
431        CARETEAM, 
432        /**
433         * The participant is a system or device used in the care of the patient.
434         */
435        DEVICE, 
436        /**
437         * The participant is a group of participants involved in the care of the patient.
438         */
439        GROUP, 
440        /**
441         * The participant is an institution that can provide the given healthcare service used in the care of the patient.
442         */
443        HEALTHCARESERVICE, 
444        /**
445         * The participant is a location involved in the care of the patient.
446         */
447        LOCATION, 
448        /**
449         * The participant is an organization involved in the care of the patient.
450         */
451        ORGANIZATION, 
452        /**
453         * The participant is the patient under evaluation.
454         */
455        PATIENT, 
456        /**
457         * The participant is a practitioner involved in the patient's care.
458         */
459        PRACTITIONER, 
460        /**
461         * The participant is a particular practitioner role involved in the patient's care.
462         */
463        PRACTITIONERROLE, 
464        /**
465         * The participant is a person related to the patient.
466         */
467        RELATEDPERSON, 
468        /**
469         * added to help the parsers
470         */
471        NULL;
472        public static ActionParticipantType fromCode(String codeString) throws FHIRException {
473            if (codeString == null || "".equals(codeString))
474                return null;
475        if ("careteam".equals(codeString))
476          return CARETEAM;
477        if ("device".equals(codeString))
478          return DEVICE;
479        if ("group".equals(codeString))
480          return GROUP;
481        if ("healthcareservice".equals(codeString))
482          return HEALTHCARESERVICE;
483        if ("location".equals(codeString))
484          return LOCATION;
485        if ("organization".equals(codeString))
486          return ORGANIZATION;
487        if ("patient".equals(codeString))
488          return PATIENT;
489        if ("practitioner".equals(codeString))
490          return PRACTITIONER;
491        if ("practitionerrole".equals(codeString))
492          return PRACTITIONERROLE;
493        if ("relatedperson".equals(codeString))
494          return RELATEDPERSON;
495        throw new FHIRException("Unknown ActionParticipantType code '"+codeString+"'");
496        }
497        public static boolean isValidCode(String codeString) {
498            if (codeString == null || "".equals(codeString))
499                return false;
500          return Utilities.existsInList(codeString, "careteam", "device", "group", "healthcareservice", "location", "organization", "patient", "practitioner", "practitionerrole", "relatedperson");
501        }
502        public String toCode() {
503          switch (this) {
504            case CARETEAM: return "careteam";
505            case DEVICE: return "device";
506            case GROUP: return "group";
507            case HEALTHCARESERVICE: return "healthcareservice";
508            case LOCATION: return "location";
509            case ORGANIZATION: return "organization";
510            case PATIENT: return "patient";
511            case PRACTITIONER: return "practitioner";
512            case PRACTITIONERROLE: return "practitionerrole";
513            case RELATEDPERSON: return "relatedperson";
514            case NULL: return null;
515            default: return "?";
516          }
517        }
518        public String getSystem() {
519          switch (this) {
520            case CARETEAM: return "http://hl7.org/fhir/action-participant-type";
521            case DEVICE: return "http://hl7.org/fhir/action-participant-type";
522            case GROUP: return "http://hl7.org/fhir/action-participant-type";
523            case HEALTHCARESERVICE: return "http://hl7.org/fhir/action-participant-type";
524            case LOCATION: return "http://hl7.org/fhir/action-participant-type";
525            case ORGANIZATION: return "http://hl7.org/fhir/action-participant-type";
526            case PATIENT: return "http://hl7.org/fhir/action-participant-type";
527            case PRACTITIONER: return "http://hl7.org/fhir/action-participant-type";
528            case PRACTITIONERROLE: return "http://hl7.org/fhir/action-participant-type";
529            case RELATEDPERSON: return "http://hl7.org/fhir/action-participant-type";
530            case NULL: return null;
531            default: return "?";
532          }
533        }
534        public String getDefinition() {
535          switch (this) {
536            case CARETEAM: return "The participant is a care team caring for the patient under evaluation.";
537            case DEVICE: return "The participant is a system or device used in the care of the patient.";
538            case GROUP: return "The participant is a group of participants involved in the care of the patient.";
539            case HEALTHCARESERVICE: return "The participant is an institution that can provide the given healthcare service used in the care of the patient.";
540            case LOCATION: return "The participant is a location involved in the care of the patient.";
541            case ORGANIZATION: return "The participant is an organization involved in the care of the patient.";
542            case PATIENT: return "The participant is the patient under evaluation.";
543            case PRACTITIONER: return "The participant is a practitioner involved in the patient's care.";
544            case PRACTITIONERROLE: return "The participant is a particular practitioner role involved in the patient's care.";
545            case RELATEDPERSON: return "The participant is a person related to the patient.";
546            case NULL: return null;
547            default: return "?";
548          }
549        }
550        public String getDisplay() {
551          switch (this) {
552            case CARETEAM: return "CareTeam";
553            case DEVICE: return "Device";
554            case GROUP: return "Group";
555            case HEALTHCARESERVICE: return "HealthcareService";
556            case LOCATION: return "Location";
557            case ORGANIZATION: return "Organization";
558            case PATIENT: return "Patient";
559            case PRACTITIONER: return "Practitioner";
560            case PRACTITIONERROLE: return "PractitionerRole";
561            case RELATEDPERSON: return "RelatedPerson";
562            case NULL: return null;
563            default: return "?";
564          }
565        }
566    }
567
568  public static class ActionParticipantTypeEnumFactory implements EnumFactory<ActionParticipantType> {
569    public ActionParticipantType fromCode(String codeString) throws IllegalArgumentException {
570      if (codeString == null || "".equals(codeString))
571            if (codeString == null || "".equals(codeString))
572                return null;
573        if ("careteam".equals(codeString))
574          return ActionParticipantType.CARETEAM;
575        if ("device".equals(codeString))
576          return ActionParticipantType.DEVICE;
577        if ("group".equals(codeString))
578          return ActionParticipantType.GROUP;
579        if ("healthcareservice".equals(codeString))
580          return ActionParticipantType.HEALTHCARESERVICE;
581        if ("location".equals(codeString))
582          return ActionParticipantType.LOCATION;
583        if ("organization".equals(codeString))
584          return ActionParticipantType.ORGANIZATION;
585        if ("patient".equals(codeString))
586          return ActionParticipantType.PATIENT;
587        if ("practitioner".equals(codeString))
588          return ActionParticipantType.PRACTITIONER;
589        if ("practitionerrole".equals(codeString))
590          return ActionParticipantType.PRACTITIONERROLE;
591        if ("relatedperson".equals(codeString))
592          return ActionParticipantType.RELATEDPERSON;
593        throw new IllegalArgumentException("Unknown ActionParticipantType code '"+codeString+"'");
594        }
595
596        public Enumeration<ActionParticipantType> fromType(PrimitiveType<?> code) throws FHIRException {
597          if (code == null)
598            return null;
599          if (code.isEmpty())
600            return new Enumeration<ActionParticipantType>(this, ActionParticipantType.NULL, code);
601          String codeString = ((PrimitiveType) code).asStringValue();
602          if (codeString == null || "".equals(codeString))
603            return new Enumeration<ActionParticipantType>(this, ActionParticipantType.NULL, code);
604        if ("careteam".equals(codeString))
605          return new Enumeration<ActionParticipantType>(this, ActionParticipantType.CARETEAM, code);
606        if ("device".equals(codeString))
607          return new Enumeration<ActionParticipantType>(this, ActionParticipantType.DEVICE, code);
608        if ("group".equals(codeString))
609          return new Enumeration<ActionParticipantType>(this, ActionParticipantType.GROUP, code);
610        if ("healthcareservice".equals(codeString))
611          return new Enumeration<ActionParticipantType>(this, ActionParticipantType.HEALTHCARESERVICE, code);
612        if ("location".equals(codeString))
613          return new Enumeration<ActionParticipantType>(this, ActionParticipantType.LOCATION, code);
614        if ("organization".equals(codeString))
615          return new Enumeration<ActionParticipantType>(this, ActionParticipantType.ORGANIZATION, code);
616        if ("patient".equals(codeString))
617          return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PATIENT, code);
618        if ("practitioner".equals(codeString))
619          return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PRACTITIONER, code);
620        if ("practitionerrole".equals(codeString))
621          return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PRACTITIONERROLE, code);
622        if ("relatedperson".equals(codeString))
623          return new Enumeration<ActionParticipantType>(this, ActionParticipantType.RELATEDPERSON, code);
624        throw new FHIRException("Unknown ActionParticipantType code '"+codeString+"'");
625        }
626    public String toCode(ActionParticipantType code) {
627       if (code == ActionParticipantType.NULL)
628           return null;
629       if (code == ActionParticipantType.CARETEAM)
630        return "careteam";
631      if (code == ActionParticipantType.DEVICE)
632        return "device";
633      if (code == ActionParticipantType.GROUP)
634        return "group";
635      if (code == ActionParticipantType.HEALTHCARESERVICE)
636        return "healthcareservice";
637      if (code == ActionParticipantType.LOCATION)
638        return "location";
639      if (code == ActionParticipantType.ORGANIZATION)
640        return "organization";
641      if (code == ActionParticipantType.PATIENT)
642        return "patient";
643      if (code == ActionParticipantType.PRACTITIONER)
644        return "practitioner";
645      if (code == ActionParticipantType.PRACTITIONERROLE)
646        return "practitionerrole";
647      if (code == ActionParticipantType.RELATEDPERSON)
648        return "relatedperson";
649      return "?";
650   }
651    public String toSystem(ActionParticipantType code) {
652      return code.getSystem();
653      }
654    }
655
656    public enum ActionPrecheckBehavior {
657        /**
658         * 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.
659         */
660        YES, 
661        /**
662         * 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.
663         */
664        NO, 
665        /**
666         * added to help the parsers
667         */
668        NULL;
669        public static ActionPrecheckBehavior fromCode(String codeString) throws FHIRException {
670            if (codeString == null || "".equals(codeString))
671                return null;
672        if ("yes".equals(codeString))
673          return YES;
674        if ("no".equals(codeString))
675          return NO;
676        throw new FHIRException("Unknown ActionPrecheckBehavior code '"+codeString+"'");
677        }
678        public static boolean isValidCode(String codeString) {
679            if (codeString == null || "".equals(codeString))
680                return false;
681          return Utilities.existsInList(codeString, "yes", "no");
682        }
683        public String toCode() {
684          switch (this) {
685            case YES: return "yes";
686            case NO: return "no";
687            case NULL: return null;
688            default: return "?";
689          }
690        }
691        public String getSystem() {
692          switch (this) {
693            case YES: return "http://hl7.org/fhir/action-precheck-behavior";
694            case NO: return "http://hl7.org/fhir/action-precheck-behavior";
695            case NULL: return null;
696            default: return "?";
697          }
698        }
699        public String getDefinition() {
700          switch (this) {
701            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.";
702            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.";
703            case NULL: return null;
704            default: return "?";
705          }
706        }
707        public String getDisplay() {
708          switch (this) {
709            case YES: return "Yes";
710            case NO: return "No";
711            case NULL: return null;
712            default: return "?";
713          }
714        }
715    }
716
717  public static class ActionPrecheckBehaviorEnumFactory implements EnumFactory<ActionPrecheckBehavior> {
718    public ActionPrecheckBehavior fromCode(String codeString) throws IllegalArgumentException {
719      if (codeString == null || "".equals(codeString))
720            if (codeString == null || "".equals(codeString))
721                return null;
722        if ("yes".equals(codeString))
723          return ActionPrecheckBehavior.YES;
724        if ("no".equals(codeString))
725          return ActionPrecheckBehavior.NO;
726        throw new IllegalArgumentException("Unknown ActionPrecheckBehavior code '"+codeString+"'");
727        }
728
729        public Enumeration<ActionPrecheckBehavior> fromType(PrimitiveType<?> code) throws FHIRException {
730          if (code == null)
731            return null;
732          if (code.isEmpty())
733            return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NULL, code);
734          String codeString = ((PrimitiveType) code).asStringValue();
735          if (codeString == null || "".equals(codeString))
736            return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NULL, code);
737        if ("yes".equals(codeString))
738          return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.YES, code);
739        if ("no".equals(codeString))
740          return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NO, code);
741        throw new FHIRException("Unknown ActionPrecheckBehavior code '"+codeString+"'");
742        }
743    public String toCode(ActionPrecheckBehavior code) {
744       if (code == ActionPrecheckBehavior.NULL)
745           return null;
746       if (code == ActionPrecheckBehavior.YES)
747        return "yes";
748      if (code == ActionPrecheckBehavior.NO)
749        return "no";
750      return "?";
751   }
752    public String toSystem(ActionPrecheckBehavior code) {
753      return code.getSystem();
754      }
755    }
756
757    public enum ActionRelationshipType {
758        /**
759         * The action must be performed before the related action.
760         */
761        BEFORE, 
762        /**
763         * The action must be performed before the start of the related action.
764         */
765        BEFORESTART, 
766        /**
767         * The action must be performed before the end of the related action.
768         */
769        BEFOREEND, 
770        /**
771         * The action must be performed concurrent with the related action.
772         */
773        CONCURRENT, 
774        /**
775         * The action must be performed concurrent with the start of the related action.
776         */
777        CONCURRENTWITHSTART, 
778        /**
779         * The action must be performed concurrent with the end of the related action.
780         */
781        CONCURRENTWITHEND, 
782        /**
783         * The action must be performed after the related action.
784         */
785        AFTER, 
786        /**
787         * The action must be performed after the start of the related action.
788         */
789        AFTERSTART, 
790        /**
791         * The action must be performed after the end of the related action.
792         */
793        AFTEREND, 
794        /**
795         * added to help the parsers
796         */
797        NULL;
798        public static ActionRelationshipType fromCode(String codeString) throws FHIRException {
799            if (codeString == null || "".equals(codeString))
800                return null;
801        if ("before".equals(codeString))
802          return BEFORE;
803        if ("before-start".equals(codeString))
804          return BEFORESTART;
805        if ("before-end".equals(codeString))
806          return BEFOREEND;
807        if ("concurrent".equals(codeString))
808          return CONCURRENT;
809        if ("concurrent-with-start".equals(codeString))
810          return CONCURRENTWITHSTART;
811        if ("concurrent-with-end".equals(codeString))
812          return CONCURRENTWITHEND;
813        if ("after".equals(codeString))
814          return AFTER;
815        if ("after-start".equals(codeString))
816          return AFTERSTART;
817        if ("after-end".equals(codeString))
818          return AFTEREND;
819        throw new FHIRException("Unknown ActionRelationshipType code '"+codeString+"'");
820        }
821        public static boolean isValidCode(String codeString) {
822            if (codeString == null || "".equals(codeString))
823                return false;
824          return Utilities.existsInList(codeString, "before", "before-start", "before-end", "concurrent", "concurrent-with-start", "concurrent-with-end", "after", "after-start", "after-end");
825        }
826        public String toCode() {
827          switch (this) {
828            case BEFORE: return "before";
829            case BEFORESTART: return "before-start";
830            case BEFOREEND: return "before-end";
831            case CONCURRENT: return "concurrent";
832            case CONCURRENTWITHSTART: return "concurrent-with-start";
833            case CONCURRENTWITHEND: return "concurrent-with-end";
834            case AFTER: return "after";
835            case AFTERSTART: return "after-start";
836            case AFTEREND: return "after-end";
837            case NULL: return null;
838            default: return "?";
839          }
840        }
841        public String getSystem() {
842          switch (this) {
843            case BEFORE: return "http://hl7.org/fhir/action-relationship-type";
844            case BEFORESTART: return "http://hl7.org/fhir/action-relationship-type";
845            case BEFOREEND: return "http://hl7.org/fhir/action-relationship-type";
846            case CONCURRENT: return "http://hl7.org/fhir/action-relationship-type";
847            case CONCURRENTWITHSTART: return "http://hl7.org/fhir/action-relationship-type";
848            case CONCURRENTWITHEND: return "http://hl7.org/fhir/action-relationship-type";
849            case AFTER: return "http://hl7.org/fhir/action-relationship-type";
850            case AFTERSTART: return "http://hl7.org/fhir/action-relationship-type";
851            case AFTEREND: return "http://hl7.org/fhir/action-relationship-type";
852            case NULL: return null;
853            default: return "?";
854          }
855        }
856        public String getDefinition() {
857          switch (this) {
858            case BEFORE: return "The action must be performed before the related action.";
859            case BEFORESTART: return "The action must be performed before the start of the related action.";
860            case BEFOREEND: return "The action must be performed before the end of the related action.";
861            case CONCURRENT: return "The action must be performed concurrent with the related action.";
862            case CONCURRENTWITHSTART: return "The action must be performed concurrent with the start of the related action.";
863            case CONCURRENTWITHEND: return "The action must be performed concurrent with the end of the related action.";
864            case AFTER: return "The action must be performed after the related action.";
865            case AFTERSTART: return "The action must be performed after the start of the related action.";
866            case AFTEREND: return "The action must be performed after the end of the related action.";
867            case NULL: return null;
868            default: return "?";
869          }
870        }
871        public String getDisplay() {
872          switch (this) {
873            case BEFORE: return "Before";
874            case BEFORESTART: return "Before Start";
875            case BEFOREEND: return "Before End";
876            case CONCURRENT: return "Concurrent";
877            case CONCURRENTWITHSTART: return "Concurrent With Start";
878            case CONCURRENTWITHEND: return "Concurrent With End";
879            case AFTER: return "After";
880            case AFTERSTART: return "After Start";
881            case AFTEREND: return "After End";
882            case NULL: return null;
883            default: return "?";
884          }
885        }
886    }
887
888  public static class ActionRelationshipTypeEnumFactory implements EnumFactory<ActionRelationshipType> {
889    public ActionRelationshipType fromCode(String codeString) throws IllegalArgumentException {
890      if (codeString == null || "".equals(codeString))
891            if (codeString == null || "".equals(codeString))
892                return null;
893        if ("before".equals(codeString))
894          return ActionRelationshipType.BEFORE;
895        if ("before-start".equals(codeString))
896          return ActionRelationshipType.BEFORESTART;
897        if ("before-end".equals(codeString))
898          return ActionRelationshipType.BEFOREEND;
899        if ("concurrent".equals(codeString))
900          return ActionRelationshipType.CONCURRENT;
901        if ("concurrent-with-start".equals(codeString))
902          return ActionRelationshipType.CONCURRENTWITHSTART;
903        if ("concurrent-with-end".equals(codeString))
904          return ActionRelationshipType.CONCURRENTWITHEND;
905        if ("after".equals(codeString))
906          return ActionRelationshipType.AFTER;
907        if ("after-start".equals(codeString))
908          return ActionRelationshipType.AFTERSTART;
909        if ("after-end".equals(codeString))
910          return ActionRelationshipType.AFTEREND;
911        throw new IllegalArgumentException("Unknown ActionRelationshipType code '"+codeString+"'");
912        }
913
914        public Enumeration<ActionRelationshipType> fromType(PrimitiveType<?> code) throws FHIRException {
915          if (code == null)
916            return null;
917          if (code.isEmpty())
918            return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.NULL, code);
919          String codeString = ((PrimitiveType) code).asStringValue();
920          if (codeString == null || "".equals(codeString))
921            return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.NULL, code);
922        if ("before".equals(codeString))
923          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORE, code);
924        if ("before-start".equals(codeString))
925          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORESTART, code);
926        if ("before-end".equals(codeString))
927          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFOREEND, code);
928        if ("concurrent".equals(codeString))
929          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENT, code);
930        if ("concurrent-with-start".equals(codeString))
931          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHSTART, code);
932        if ("concurrent-with-end".equals(codeString))
933          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHEND, code);
934        if ("after".equals(codeString))
935          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTER, code);
936        if ("after-start".equals(codeString))
937          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTERSTART, code);
938        if ("after-end".equals(codeString))
939          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTEREND, code);
940        throw new FHIRException("Unknown ActionRelationshipType code '"+codeString+"'");
941        }
942    public String toCode(ActionRelationshipType code) {
943       if (code == ActionRelationshipType.NULL)
944           return null;
945       if (code == ActionRelationshipType.BEFORE)
946        return "before";
947      if (code == ActionRelationshipType.BEFORESTART)
948        return "before-start";
949      if (code == ActionRelationshipType.BEFOREEND)
950        return "before-end";
951      if (code == ActionRelationshipType.CONCURRENT)
952        return "concurrent";
953      if (code == ActionRelationshipType.CONCURRENTWITHSTART)
954        return "concurrent-with-start";
955      if (code == ActionRelationshipType.CONCURRENTWITHEND)
956        return "concurrent-with-end";
957      if (code == ActionRelationshipType.AFTER)
958        return "after";
959      if (code == ActionRelationshipType.AFTERSTART)
960        return "after-start";
961      if (code == ActionRelationshipType.AFTEREND)
962        return "after-end";
963      return "?";
964   }
965    public String toSystem(ActionRelationshipType code) {
966      return code.getSystem();
967      }
968    }
969
970    public enum ActionRequiredBehavior {
971        /**
972         * 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.
973         */
974        MUST, 
975        /**
976         * An action with this behavior may be included in the set of actions processed by the end user.
977         */
978        COULD, 
979        /**
980         * 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.
981         */
982        MUSTUNLESSDOCUMENTED, 
983        /**
984         * added to help the parsers
985         */
986        NULL;
987        public static ActionRequiredBehavior fromCode(String codeString) throws FHIRException {
988            if (codeString == null || "".equals(codeString))
989                return null;
990        if ("must".equals(codeString))
991          return MUST;
992        if ("could".equals(codeString))
993          return COULD;
994        if ("must-unless-documented".equals(codeString))
995          return MUSTUNLESSDOCUMENTED;
996        throw new FHIRException("Unknown ActionRequiredBehavior code '"+codeString+"'");
997        }
998        public static boolean isValidCode(String codeString) {
999            if (codeString == null || "".equals(codeString))
1000                return false;
1001          return Utilities.existsInList(codeString, "must", "could", "must-unless-documented");
1002        }
1003        public String toCode() {
1004          switch (this) {
1005            case MUST: return "must";
1006            case COULD: return "could";
1007            case MUSTUNLESSDOCUMENTED: return "must-unless-documented";
1008            case NULL: return null;
1009            default: return "?";
1010          }
1011        }
1012        public String getSystem() {
1013          switch (this) {
1014            case MUST: return "http://hl7.org/fhir/action-required-behavior";
1015            case COULD: return "http://hl7.org/fhir/action-required-behavior";
1016            case MUSTUNLESSDOCUMENTED: return "http://hl7.org/fhir/action-required-behavior";
1017            case NULL: return null;
1018            default: return "?";
1019          }
1020        }
1021        public String getDefinition() {
1022          switch (this) {
1023            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.";
1024            case COULD: return "An action with this behavior may be included in the set of actions processed by the end user.";
1025            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.";
1026            case NULL: return null;
1027            default: return "?";
1028          }
1029        }
1030        public String getDisplay() {
1031          switch (this) {
1032            case MUST: return "Must";
1033            case COULD: return "Could";
1034            case MUSTUNLESSDOCUMENTED: return "Must Unless Documented";
1035            case NULL: return null;
1036            default: return "?";
1037          }
1038        }
1039    }
1040
1041  public static class ActionRequiredBehaviorEnumFactory implements EnumFactory<ActionRequiredBehavior> {
1042    public ActionRequiredBehavior fromCode(String codeString) throws IllegalArgumentException {
1043      if (codeString == null || "".equals(codeString))
1044            if (codeString == null || "".equals(codeString))
1045                return null;
1046        if ("must".equals(codeString))
1047          return ActionRequiredBehavior.MUST;
1048        if ("could".equals(codeString))
1049          return ActionRequiredBehavior.COULD;
1050        if ("must-unless-documented".equals(codeString))
1051          return ActionRequiredBehavior.MUSTUNLESSDOCUMENTED;
1052        throw new IllegalArgumentException("Unknown ActionRequiredBehavior code '"+codeString+"'");
1053        }
1054
1055        public Enumeration<ActionRequiredBehavior> fromType(PrimitiveType<?> code) throws FHIRException {
1056          if (code == null)
1057            return null;
1058          if (code.isEmpty())
1059            return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.NULL, code);
1060          String codeString = ((PrimitiveType) code).asStringValue();
1061          if (codeString == null || "".equals(codeString))
1062            return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.NULL, code);
1063        if ("must".equals(codeString))
1064          return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUST, code);
1065        if ("could".equals(codeString))
1066          return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.COULD, code);
1067        if ("must-unless-documented".equals(codeString))
1068          return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUSTUNLESSDOCUMENTED, code);
1069        throw new FHIRException("Unknown ActionRequiredBehavior code '"+codeString+"'");
1070        }
1071    public String toCode(ActionRequiredBehavior code) {
1072       if (code == ActionRequiredBehavior.NULL)
1073           return null;
1074       if (code == ActionRequiredBehavior.MUST)
1075        return "must";
1076      if (code == ActionRequiredBehavior.COULD)
1077        return "could";
1078      if (code == ActionRequiredBehavior.MUSTUNLESSDOCUMENTED)
1079        return "must-unless-documented";
1080      return "?";
1081   }
1082    public String toSystem(ActionRequiredBehavior code) {
1083      return code.getSystem();
1084      }
1085    }
1086
1087    public enum ActionSelectionBehavior {
1088        /**
1089         * Any number of the actions in the group may be chosen, from zero to all.
1090         */
1091        ANY, 
1092        /**
1093         * All the actions in the group must be selected as a single unit.
1094         */
1095        ALL, 
1096        /**
1097         * 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.
1098         */
1099        ALLORNONE, 
1100        /**
1101         * 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.
1102         */
1103        EXACTLYONE, 
1104        /**
1105         * The end user may choose zero or at most one of the actions in the group.
1106         */
1107        ATMOSTONE, 
1108        /**
1109         * The end user must choose a minimum of one, and as many additional as desired.
1110         */
1111        ONEORMORE, 
1112        /**
1113         * added to help the parsers
1114         */
1115        NULL;
1116        public static ActionSelectionBehavior fromCode(String codeString) throws FHIRException {
1117            if (codeString == null || "".equals(codeString))
1118                return null;
1119        if ("any".equals(codeString))
1120          return ANY;
1121        if ("all".equals(codeString))
1122          return ALL;
1123        if ("all-or-none".equals(codeString))
1124          return ALLORNONE;
1125        if ("exactly-one".equals(codeString))
1126          return EXACTLYONE;
1127        if ("at-most-one".equals(codeString))
1128          return ATMOSTONE;
1129        if ("one-or-more".equals(codeString))
1130          return ONEORMORE;
1131        throw new FHIRException("Unknown ActionSelectionBehavior code '"+codeString+"'");
1132        }
1133        public static boolean isValidCode(String codeString) {
1134            if (codeString == null || "".equals(codeString))
1135                return false;
1136          return Utilities.existsInList(codeString, "any", "all", "all-or-none", "exactly-one", "at-most-one", "one-or-more");
1137        }
1138        public String toCode() {
1139          switch (this) {
1140            case ANY: return "any";
1141            case ALL: return "all";
1142            case ALLORNONE: return "all-or-none";
1143            case EXACTLYONE: return "exactly-one";
1144            case ATMOSTONE: return "at-most-one";
1145            case ONEORMORE: return "one-or-more";
1146            case NULL: return null;
1147            default: return "?";
1148          }
1149        }
1150        public String getSystem() {
1151          switch (this) {
1152            case ANY: return "http://hl7.org/fhir/action-selection-behavior";
1153            case ALL: return "http://hl7.org/fhir/action-selection-behavior";
1154            case ALLORNONE: return "http://hl7.org/fhir/action-selection-behavior";
1155            case EXACTLYONE: return "http://hl7.org/fhir/action-selection-behavior";
1156            case ATMOSTONE: return "http://hl7.org/fhir/action-selection-behavior";
1157            case ONEORMORE: return "http://hl7.org/fhir/action-selection-behavior";
1158            case NULL: return null;
1159            default: return "?";
1160          }
1161        }
1162        public String getDefinition() {
1163          switch (this) {
1164            case ANY: return "Any number of the actions in the group may be chosen, from zero to all.";
1165            case ALL: return "All the actions in the group must be selected as a single unit.";
1166            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.";
1167            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.";
1168            case ATMOSTONE: return "The end user may choose zero or at most one of the actions in the group.";
1169            case ONEORMORE: return "The end user must choose a minimum of one, and as many additional as desired.";
1170            case NULL: return null;
1171            default: return "?";
1172          }
1173        }
1174        public String getDisplay() {
1175          switch (this) {
1176            case ANY: return "Any";
1177            case ALL: return "All";
1178            case ALLORNONE: return "All Or None";
1179            case EXACTLYONE: return "Exactly One";
1180            case ATMOSTONE: return "At Most One";
1181            case ONEORMORE: return "One Or More";
1182            case NULL: return null;
1183            default: return "?";
1184          }
1185        }
1186    }
1187
1188  public static class ActionSelectionBehaviorEnumFactory implements EnumFactory<ActionSelectionBehavior> {
1189    public ActionSelectionBehavior fromCode(String codeString) throws IllegalArgumentException {
1190      if (codeString == null || "".equals(codeString))
1191            if (codeString == null || "".equals(codeString))
1192                return null;
1193        if ("any".equals(codeString))
1194          return ActionSelectionBehavior.ANY;
1195        if ("all".equals(codeString))
1196          return ActionSelectionBehavior.ALL;
1197        if ("all-or-none".equals(codeString))
1198          return ActionSelectionBehavior.ALLORNONE;
1199        if ("exactly-one".equals(codeString))
1200          return ActionSelectionBehavior.EXACTLYONE;
1201        if ("at-most-one".equals(codeString))
1202          return ActionSelectionBehavior.ATMOSTONE;
1203        if ("one-or-more".equals(codeString))
1204          return ActionSelectionBehavior.ONEORMORE;
1205        throw new IllegalArgumentException("Unknown ActionSelectionBehavior code '"+codeString+"'");
1206        }
1207
1208        public Enumeration<ActionSelectionBehavior> fromType(PrimitiveType<?> code) throws FHIRException {
1209          if (code == null)
1210            return null;
1211          if (code.isEmpty())
1212            return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.NULL, code);
1213          String codeString = ((PrimitiveType) code).asStringValue();
1214          if (codeString == null || "".equals(codeString))
1215            return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.NULL, code);
1216        if ("any".equals(codeString))
1217          return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ANY, code);
1218        if ("all".equals(codeString))
1219          return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALL, code);
1220        if ("all-or-none".equals(codeString))
1221          return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALLORNONE, code);
1222        if ("exactly-one".equals(codeString))
1223          return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.EXACTLYONE, code);
1224        if ("at-most-one".equals(codeString))
1225          return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ATMOSTONE, code);
1226        if ("one-or-more".equals(codeString))
1227          return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ONEORMORE, code);
1228        throw new FHIRException("Unknown ActionSelectionBehavior code '"+codeString+"'");
1229        }
1230    public String toCode(ActionSelectionBehavior code) {
1231       if (code == ActionSelectionBehavior.NULL)
1232           return null;
1233       if (code == ActionSelectionBehavior.ANY)
1234        return "any";
1235      if (code == ActionSelectionBehavior.ALL)
1236        return "all";
1237      if (code == ActionSelectionBehavior.ALLORNONE)
1238        return "all-or-none";
1239      if (code == ActionSelectionBehavior.EXACTLYONE)
1240        return "exactly-one";
1241      if (code == ActionSelectionBehavior.ATMOSTONE)
1242        return "at-most-one";
1243      if (code == ActionSelectionBehavior.ONEORMORE)
1244        return "one-or-more";
1245      return "?";
1246   }
1247    public String toSystem(ActionSelectionBehavior code) {
1248      return code.getSystem();
1249      }
1250    }
1251
1252    public enum AdministrativeGender {
1253        /**
1254         * Male.
1255         */
1256        MALE, 
1257        /**
1258         * Female.
1259         */
1260        FEMALE, 
1261        /**
1262         * Other.
1263         */
1264        OTHER, 
1265        /**
1266         * Unknown.
1267         */
1268        UNKNOWN, 
1269        /**
1270         * added to help the parsers
1271         */
1272        NULL;
1273        public static AdministrativeGender fromCode(String codeString) throws FHIRException {
1274            if (codeString == null || "".equals(codeString))
1275                return null;
1276        if ("male".equals(codeString))
1277          return MALE;
1278        if ("female".equals(codeString))
1279          return FEMALE;
1280        if ("other".equals(codeString))
1281          return OTHER;
1282        if ("unknown".equals(codeString))
1283          return UNKNOWN;
1284        throw new FHIRException("Unknown AdministrativeGender code '"+codeString+"'");
1285        }
1286        public static boolean isValidCode(String codeString) {
1287            if (codeString == null || "".equals(codeString))
1288                return false;
1289          return Utilities.existsInList(codeString, "male", "female", "other", "unknown");
1290        }
1291        public String toCode() {
1292          switch (this) {
1293            case MALE: return "male";
1294            case FEMALE: return "female";
1295            case OTHER: return "other";
1296            case UNKNOWN: return "unknown";
1297            case NULL: return null;
1298            default: return "?";
1299          }
1300        }
1301        public String getSystem() {
1302          switch (this) {
1303            case MALE: return "http://hl7.org/fhir/administrative-gender";
1304            case FEMALE: return "http://hl7.org/fhir/administrative-gender";
1305            case OTHER: return "http://hl7.org/fhir/administrative-gender";
1306            case UNKNOWN: return "http://hl7.org/fhir/administrative-gender";
1307            case NULL: return null;
1308            default: return "?";
1309          }
1310        }
1311        public String getDefinition() {
1312          switch (this) {
1313            case MALE: return "Male.";
1314            case FEMALE: return "Female.";
1315            case OTHER: return "Other.";
1316            case UNKNOWN: return "Unknown.";
1317            case NULL: return null;
1318            default: return "?";
1319          }
1320        }
1321        public String getDisplay() {
1322          switch (this) {
1323            case MALE: return "Male";
1324            case FEMALE: return "Female";
1325            case OTHER: return "Other";
1326            case UNKNOWN: return "Unknown";
1327            case NULL: return null;
1328            default: return "?";
1329          }
1330        }
1331    }
1332
1333  public static class AdministrativeGenderEnumFactory implements EnumFactory<AdministrativeGender> {
1334    public AdministrativeGender fromCode(String codeString) throws IllegalArgumentException {
1335      if (codeString == null || "".equals(codeString))
1336            if (codeString == null || "".equals(codeString))
1337                return null;
1338        if ("male".equals(codeString))
1339          return AdministrativeGender.MALE;
1340        if ("female".equals(codeString))
1341          return AdministrativeGender.FEMALE;
1342        if ("other".equals(codeString))
1343          return AdministrativeGender.OTHER;
1344        if ("unknown".equals(codeString))
1345          return AdministrativeGender.UNKNOWN;
1346        throw new IllegalArgumentException("Unknown AdministrativeGender code '"+codeString+"'");
1347        }
1348
1349        public Enumeration<AdministrativeGender> fromType(PrimitiveType<?> code) throws FHIRException {
1350          if (code == null)
1351            return null;
1352          if (code.isEmpty())
1353            return new Enumeration<AdministrativeGender>(this, AdministrativeGender.NULL, code);
1354          String codeString = ((PrimitiveType) code).asStringValue();
1355          if (codeString == null || "".equals(codeString))
1356            return new Enumeration<AdministrativeGender>(this, AdministrativeGender.NULL, code);
1357        if ("male".equals(codeString))
1358          return new Enumeration<AdministrativeGender>(this, AdministrativeGender.MALE, code);
1359        if ("female".equals(codeString))
1360          return new Enumeration<AdministrativeGender>(this, AdministrativeGender.FEMALE, code);
1361        if ("other".equals(codeString))
1362          return new Enumeration<AdministrativeGender>(this, AdministrativeGender.OTHER, code);
1363        if ("unknown".equals(codeString))
1364          return new Enumeration<AdministrativeGender>(this, AdministrativeGender.UNKNOWN, code);
1365        throw new FHIRException("Unknown AdministrativeGender code '"+codeString+"'");
1366        }
1367    public String toCode(AdministrativeGender code) {
1368       if (code == AdministrativeGender.NULL)
1369           return null;
1370       if (code == AdministrativeGender.MALE)
1371        return "male";
1372      if (code == AdministrativeGender.FEMALE)
1373        return "female";
1374      if (code == AdministrativeGender.OTHER)
1375        return "other";
1376      if (code == AdministrativeGender.UNKNOWN)
1377        return "unknown";
1378      return "?";
1379   }
1380    public String toSystem(AdministrativeGender code) {
1381      return code.getSystem();
1382      }
1383    }
1384
1385    public enum AllLanguages {
1386        /**
1387         * added to help the parsers
1388         */
1389        NULL;
1390        public static AllLanguages fromCode(String codeString) throws FHIRException {
1391            if (codeString == null || "".equals(codeString))
1392                return null;
1393        throw new FHIRException("Unknown AllLanguages code '"+codeString+"'");
1394        }
1395        public static boolean isValidCode(String codeString) {
1396            if (codeString == null || "".equals(codeString))
1397                return false;
1398          return Utilities.existsInList(codeString);
1399        }
1400        public String toCode() {
1401          switch (this) {
1402            case NULL: return null;
1403            default: return "?";
1404          }
1405        }
1406        public String getSystem() {
1407          switch (this) {
1408            case NULL: return null;
1409            default: return "?";
1410          }
1411        }
1412        public String getDefinition() {
1413          switch (this) {
1414            case NULL: return null;
1415            default: return "?";
1416          }
1417        }
1418        public String getDisplay() {
1419          switch (this) {
1420            case NULL: return null;
1421            default: return "?";
1422          }
1423        }
1424    }
1425
1426  public static class AllLanguagesEnumFactory implements EnumFactory<AllLanguages> {
1427    public AllLanguages fromCode(String codeString) throws IllegalArgumentException {
1428      if (codeString == null || "".equals(codeString))
1429            if (codeString == null || "".equals(codeString))
1430                return null;
1431        throw new IllegalArgumentException("Unknown AllLanguages code '"+codeString+"'");
1432        }
1433
1434        public Enumeration<AllLanguages> fromType(PrimitiveType<?> code) throws FHIRException {
1435          if (code == null)
1436            return null;
1437          if (code.isEmpty())
1438            return new Enumeration<AllLanguages>(this, AllLanguages.NULL, code);
1439          String codeString = ((PrimitiveType) code).asStringValue();
1440          if (codeString == null || "".equals(codeString))
1441            return new Enumeration<AllLanguages>(this, AllLanguages.NULL, code);
1442        throw new FHIRException("Unknown AllLanguages code '"+codeString+"'");
1443        }
1444    public String toCode(AllLanguages code) {
1445       if (code == AllLanguages.NULL)
1446           return null;
1447       return "?";
1448   }
1449    public String toSystem(AllLanguages code) {
1450      return code.getSystem();
1451      }
1452    }
1453
1454    public enum BindingStrength {
1455        /**
1456         * To be conformant, the concept in this element SHALL be from the specified value set.
1457         */
1458        REQUIRED, 
1459        /**
1460         * 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.
1461         */
1462        EXTENSIBLE, 
1463        /**
1464         * Instances are encouraged to draw from the specified codes for interoperability purposes but are not required to do so to be considered conformant.
1465         */
1466        PREFERRED, 
1467        /**
1468         * 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.
1469         */
1470        EXAMPLE, 
1471        /**
1472         * added to help the parsers
1473         */
1474        NULL;
1475        public static BindingStrength fromCode(String codeString) throws FHIRException {
1476            if (codeString == null || "".equals(codeString))
1477                return null;
1478        if ("required".equals(codeString))
1479          return REQUIRED;
1480        if ("extensible".equals(codeString))
1481          return EXTENSIBLE;
1482        if ("preferred".equals(codeString))
1483          return PREFERRED;
1484        if ("example".equals(codeString))
1485          return EXAMPLE;
1486        throw new FHIRException("Unknown BindingStrength code '"+codeString+"'");
1487        }
1488        public static boolean isValidCode(String codeString) {
1489            if (codeString == null || "".equals(codeString))
1490                return false;
1491          return Utilities.existsInList(codeString, "required", "extensible", "preferred", "example");
1492        }
1493        public String toCode() {
1494          switch (this) {
1495            case REQUIRED: return "required";
1496            case EXTENSIBLE: return "extensible";
1497            case PREFERRED: return "preferred";
1498            case EXAMPLE: return "example";
1499            case NULL: return null;
1500            default: return "?";
1501          }
1502        }
1503        public String getSystem() {
1504          switch (this) {
1505            case REQUIRED: return "http://hl7.org/fhir/binding-strength";
1506            case EXTENSIBLE: return "http://hl7.org/fhir/binding-strength";
1507            case PREFERRED: return "http://hl7.org/fhir/binding-strength";
1508            case EXAMPLE: return "http://hl7.org/fhir/binding-strength";
1509            case NULL: return null;
1510            default: return "?";
1511          }
1512        }
1513        public String getDefinition() {
1514          switch (this) {
1515            case REQUIRED: return "To be conformant, the concept in this element SHALL be from the specified value set.";
1516            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.";
1517            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.";
1518            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.";
1519            case NULL: return null;
1520            default: return "?";
1521          }
1522        }
1523        public String getDisplay() {
1524          switch (this) {
1525            case REQUIRED: return "Required";
1526            case EXTENSIBLE: return "Extensible";
1527            case PREFERRED: return "Preferred";
1528            case EXAMPLE: return "Example";
1529            case NULL: return null;
1530            default: return "?";
1531          }
1532        }
1533    }
1534
1535  public static class BindingStrengthEnumFactory implements EnumFactory<BindingStrength> {
1536    public BindingStrength fromCode(String codeString) throws IllegalArgumentException {
1537      if (codeString == null || "".equals(codeString))
1538            if (codeString == null || "".equals(codeString))
1539                return null;
1540        if ("required".equals(codeString))
1541          return BindingStrength.REQUIRED;
1542        if ("extensible".equals(codeString))
1543          return BindingStrength.EXTENSIBLE;
1544        if ("preferred".equals(codeString))
1545          return BindingStrength.PREFERRED;
1546        if ("example".equals(codeString))
1547          return BindingStrength.EXAMPLE;
1548        throw new IllegalArgumentException("Unknown BindingStrength code '"+codeString+"'");
1549        }
1550
1551        public Enumeration<BindingStrength> fromType(PrimitiveType<?> code) throws FHIRException {
1552          if (code == null)
1553            return null;
1554          if (code.isEmpty())
1555            return new Enumeration<BindingStrength>(this, BindingStrength.NULL, code);
1556          String codeString = ((PrimitiveType) code).asStringValue();
1557          if (codeString == null || "".equals(codeString))
1558            return new Enumeration<BindingStrength>(this, BindingStrength.NULL, code);
1559        if ("required".equals(codeString))
1560          return new Enumeration<BindingStrength>(this, BindingStrength.REQUIRED, code);
1561        if ("extensible".equals(codeString))
1562          return new Enumeration<BindingStrength>(this, BindingStrength.EXTENSIBLE, code);
1563        if ("preferred".equals(codeString))
1564          return new Enumeration<BindingStrength>(this, BindingStrength.PREFERRED, code);
1565        if ("example".equals(codeString))
1566          return new Enumeration<BindingStrength>(this, BindingStrength.EXAMPLE, code);
1567        throw new FHIRException("Unknown BindingStrength code '"+codeString+"'");
1568        }
1569    public String toCode(BindingStrength code) {
1570       if (code == BindingStrength.NULL)
1571           return null;
1572       if (code == BindingStrength.REQUIRED)
1573        return "required";
1574      if (code == BindingStrength.EXTENSIBLE)
1575        return "extensible";
1576      if (code == BindingStrength.PREFERRED)
1577        return "preferred";
1578      if (code == BindingStrength.EXAMPLE)
1579        return "example";
1580      return "?";
1581   }
1582    public String toSystem(BindingStrength code) {
1583      return code.getSystem();
1584      }
1585    }
1586
1587    public enum CapabilityStatementKind {
1588        /**
1589         * 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.
1590         */
1591        INSTANCE, 
1592        /**
1593         * The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation.
1594         */
1595        CAPABILITY, 
1596        /**
1597         * 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'.
1598         */
1599        REQUIREMENTS, 
1600        /**
1601         * added to help the parsers
1602         */
1603        NULL;
1604        public static CapabilityStatementKind fromCode(String codeString) throws FHIRException {
1605            if (codeString == null || "".equals(codeString))
1606                return null;
1607        if ("instance".equals(codeString))
1608          return INSTANCE;
1609        if ("capability".equals(codeString))
1610          return CAPABILITY;
1611        if ("requirements".equals(codeString))
1612          return REQUIREMENTS;
1613        throw new FHIRException("Unknown CapabilityStatementKind code '"+codeString+"'");
1614        }
1615        public static boolean isValidCode(String codeString) {
1616            if (codeString == null || "".equals(codeString))
1617                return false;
1618          return Utilities.existsInList(codeString, "instance", "capability", "requirements");
1619        }
1620        public String toCode() {
1621          switch (this) {
1622            case INSTANCE: return "instance";
1623            case CAPABILITY: return "capability";
1624            case REQUIREMENTS: return "requirements";
1625            case NULL: return null;
1626            default: return "?";
1627          }
1628        }
1629        public String getSystem() {
1630          switch (this) {
1631            case INSTANCE: return "http://hl7.org/fhir/capability-statement-kind";
1632            case CAPABILITY: return "http://hl7.org/fhir/capability-statement-kind";
1633            case REQUIREMENTS: return "http://hl7.org/fhir/capability-statement-kind";
1634            case NULL: return null;
1635            default: return "?";
1636          }
1637        }
1638        public String getDefinition() {
1639          switch (this) {
1640            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.";
1641            case CAPABILITY: return "The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation.";
1642            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'.";
1643            case NULL: return null;
1644            default: return "?";
1645          }
1646        }
1647        public String getDisplay() {
1648          switch (this) {
1649            case INSTANCE: return "Instance";
1650            case CAPABILITY: return "Capability";
1651            case REQUIREMENTS: return "Requirements";
1652            case NULL: return null;
1653            default: return "?";
1654          }
1655        }
1656    }
1657
1658  public static class CapabilityStatementKindEnumFactory implements EnumFactory<CapabilityStatementKind> {
1659    public CapabilityStatementKind fromCode(String codeString) throws IllegalArgumentException {
1660      if (codeString == null || "".equals(codeString))
1661            if (codeString == null || "".equals(codeString))
1662                return null;
1663        if ("instance".equals(codeString))
1664          return CapabilityStatementKind.INSTANCE;
1665        if ("capability".equals(codeString))
1666          return CapabilityStatementKind.CAPABILITY;
1667        if ("requirements".equals(codeString))
1668          return CapabilityStatementKind.REQUIREMENTS;
1669        throw new IllegalArgumentException("Unknown CapabilityStatementKind code '"+codeString+"'");
1670        }
1671
1672        public Enumeration<CapabilityStatementKind> fromType(PrimitiveType<?> code) throws FHIRException {
1673          if (code == null)
1674            return null;
1675          if (code.isEmpty())
1676            return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.NULL, code);
1677          String codeString = ((PrimitiveType) code).asStringValue();
1678          if (codeString == null || "".equals(codeString))
1679            return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.NULL, code);
1680        if ("instance".equals(codeString))
1681          return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.INSTANCE, code);
1682        if ("capability".equals(codeString))
1683          return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.CAPABILITY, code);
1684        if ("requirements".equals(codeString))
1685          return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.REQUIREMENTS, code);
1686        throw new FHIRException("Unknown CapabilityStatementKind code '"+codeString+"'");
1687        }
1688    public String toCode(CapabilityStatementKind code) {
1689       if (code == CapabilityStatementKind.NULL)
1690           return null;
1691       if (code == CapabilityStatementKind.INSTANCE)
1692        return "instance";
1693      if (code == CapabilityStatementKind.CAPABILITY)
1694        return "capability";
1695      if (code == CapabilityStatementKind.REQUIREMENTS)
1696        return "requirements";
1697      return "?";
1698   }
1699    public String toSystem(CapabilityStatementKind code) {
1700      return code.getSystem();
1701      }
1702    }
1703
1704    public enum ClaimProcessingCodes {
1705        /**
1706         * The Claim/Pre-authorization/Pre-determination has been received but processing has not begun.
1707         */
1708        QUEUED, 
1709        /**
1710         * The processing has completed without errors
1711         */
1712        COMPLETE, 
1713        /**
1714         * One or more errors have been detected in the Claim
1715         */
1716        ERROR, 
1717        /**
1718         * No errors have been detected in the Claim and some of the adjudication has been performed.
1719         */
1720        PARTIAL, 
1721        /**
1722         * added to help the parsers
1723         */
1724        NULL;
1725        public static ClaimProcessingCodes fromCode(String codeString) throws FHIRException {
1726            if (codeString == null || "".equals(codeString))
1727                return null;
1728        if ("queued".equals(codeString))
1729          return QUEUED;
1730        if ("complete".equals(codeString))
1731          return COMPLETE;
1732        if ("error".equals(codeString))
1733          return ERROR;
1734        if ("partial".equals(codeString))
1735          return PARTIAL;
1736        throw new FHIRException("Unknown ClaimProcessingCodes code '"+codeString+"'");
1737        }
1738        public static boolean isValidCode(String codeString) {
1739            if (codeString == null || "".equals(codeString))
1740                return false;
1741          return Utilities.existsInList(codeString, "queued", "complete", "error", "partial");
1742        }
1743        public String toCode() {
1744          switch (this) {
1745            case QUEUED: return "queued";
1746            case COMPLETE: return "complete";
1747            case ERROR: return "error";
1748            case PARTIAL: return "partial";
1749            case NULL: return null;
1750            default: return "?";
1751          }
1752        }
1753        public String getSystem() {
1754          switch (this) {
1755            case QUEUED: return "http://hl7.org/fhir/claim-outcome";
1756            case COMPLETE: return "http://hl7.org/fhir/claim-outcome";
1757            case ERROR: return "http://hl7.org/fhir/claim-outcome";
1758            case PARTIAL: return "http://hl7.org/fhir/claim-outcome";
1759            case NULL: return null;
1760            default: return "?";
1761          }
1762        }
1763        public String getDefinition() {
1764          switch (this) {
1765            case QUEUED: return "The Claim/Pre-authorization/Pre-determination has been received but processing has not begun.";
1766            case COMPLETE: return "The processing has completed without errors";
1767            case ERROR: return "One or more errors have been detected in the Claim";
1768            case PARTIAL: return "No errors have been detected in the Claim and some of the adjudication has been performed.";
1769            case NULL: return null;
1770            default: return "?";
1771          }
1772        }
1773        public String getDisplay() {
1774          switch (this) {
1775            case QUEUED: return "Queued";
1776            case COMPLETE: return "Processing Complete";
1777            case ERROR: return "Error";
1778            case PARTIAL: return "Partial Processing";
1779            case NULL: return null;
1780            default: return "?";
1781          }
1782        }
1783    }
1784
1785  public static class ClaimProcessingCodesEnumFactory implements EnumFactory<ClaimProcessingCodes> {
1786    public ClaimProcessingCodes fromCode(String codeString) throws IllegalArgumentException {
1787      if (codeString == null || "".equals(codeString))
1788            if (codeString == null || "".equals(codeString))
1789                return null;
1790        if ("queued".equals(codeString))
1791          return ClaimProcessingCodes.QUEUED;
1792        if ("complete".equals(codeString))
1793          return ClaimProcessingCodes.COMPLETE;
1794        if ("error".equals(codeString))
1795          return ClaimProcessingCodes.ERROR;
1796        if ("partial".equals(codeString))
1797          return ClaimProcessingCodes.PARTIAL;
1798        throw new IllegalArgumentException("Unknown ClaimProcessingCodes code '"+codeString+"'");
1799        }
1800
1801        public Enumeration<ClaimProcessingCodes> fromType(PrimitiveType<?> code) throws FHIRException {
1802          if (code == null)
1803            return null;
1804          if (code.isEmpty())
1805            return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.NULL, code);
1806          String codeString = ((PrimitiveType) code).asStringValue();
1807          if (codeString == null || "".equals(codeString))
1808            return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.NULL, code);
1809        if ("queued".equals(codeString))
1810          return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.QUEUED, code);
1811        if ("complete".equals(codeString))
1812          return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.COMPLETE, code);
1813        if ("error".equals(codeString))
1814          return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.ERROR, code);
1815        if ("partial".equals(codeString))
1816          return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.PARTIAL, code);
1817        throw new FHIRException("Unknown ClaimProcessingCodes code '"+codeString+"'");
1818        }
1819    public String toCode(ClaimProcessingCodes code) {
1820       if (code == ClaimProcessingCodes.NULL)
1821           return null;
1822       if (code == ClaimProcessingCodes.QUEUED)
1823        return "queued";
1824      if (code == ClaimProcessingCodes.COMPLETE)
1825        return "complete";
1826      if (code == ClaimProcessingCodes.ERROR)
1827        return "error";
1828      if (code == ClaimProcessingCodes.PARTIAL)
1829        return "partial";
1830      return "?";
1831   }
1832    public String toSystem(ClaimProcessingCodes code) {
1833      return code.getSystem();
1834      }
1835    }
1836
1837    public enum CodeSystemContentMode {
1838        /**
1839         * None of the concepts defined by the code system are included in the code system resource.
1840         */
1841        NOTPRESENT, 
1842        /**
1843         * A subset of the valid externally defined concepts are included in the code system resource. There is no specific purpose or documented intent other than for illustrative purposes.
1844         */
1845        EXAMPLE, 
1846        /**
1847         * A subset of the code system concepts are included in the code system resource. This is a curated subset released for a specific purpose under the governance of the code system steward, and that the intent, bounds and consequences of the fragmentation are clearly defined in the fragment or the code system documentation. Fragments are also known as partitions.
1848         */
1849        FRAGMENT, 
1850        /**
1851         * All the concepts defined by the code system are included in the code system resource.
1852         */
1853        COMPLETE, 
1854        /**
1855         * The resource doesn't define any new concepts; it just provides additional designations and properties to another code system.
1856         */
1857        SUPPLEMENT, 
1858        /**
1859         * added to help the parsers
1860         */
1861        NULL;
1862        public static CodeSystemContentMode fromCode(String codeString) throws FHIRException {
1863            if (codeString == null || "".equals(codeString))
1864                return null;
1865        if ("not-present".equals(codeString))
1866          return NOTPRESENT;
1867        if ("example".equals(codeString))
1868          return EXAMPLE;
1869        if ("fragment".equals(codeString))
1870          return FRAGMENT;
1871        if ("complete".equals(codeString))
1872          return COMPLETE;
1873        if ("supplement".equals(codeString))
1874          return SUPPLEMENT;
1875        throw new FHIRException("Unknown CodeSystemContentMode code '"+codeString+"'");
1876        }
1877        public static boolean isValidCode(String codeString) {
1878            if (codeString == null || "".equals(codeString))
1879                return false;
1880          return Utilities.existsInList(codeString, "not-present", "example", "fragment", "complete", "supplement");
1881        }
1882        public String toCode() {
1883          switch (this) {
1884            case NOTPRESENT: return "not-present";
1885            case EXAMPLE: return "example";
1886            case FRAGMENT: return "fragment";
1887            case COMPLETE: return "complete";
1888            case SUPPLEMENT: return "supplement";
1889            case NULL: return null;
1890            default: return "?";
1891          }
1892        }
1893        public String getSystem() {
1894          switch (this) {
1895            case NOTPRESENT: return "http://hl7.org/fhir/codesystem-content-mode";
1896            case EXAMPLE: return "http://hl7.org/fhir/codesystem-content-mode";
1897            case FRAGMENT: return "http://hl7.org/fhir/codesystem-content-mode";
1898            case COMPLETE: return "http://hl7.org/fhir/codesystem-content-mode";
1899            case SUPPLEMENT: return "http://hl7.org/fhir/codesystem-content-mode";
1900            case NULL: return null;
1901            default: return "?";
1902          }
1903        }
1904        public String getDefinition() {
1905          switch (this) {
1906            case NOTPRESENT: return "None of the concepts defined by the code system are included in the code system resource.";
1907            case EXAMPLE: return "A subset of the valid externally defined concepts are included in the code system resource. There is no specific purpose or documented intent other than for illustrative purposes.";
1908            case FRAGMENT: return "A subset of the code system concepts are included in the code system resource. This is a curated subset released for a specific purpose under the governance of the code system steward, and that the intent, bounds and consequences of the fragmentation are clearly defined in the fragment or the code system documentation. Fragments are also known as partitions.";
1909            case COMPLETE: return "All the concepts defined by the code system are included in the code system resource.";
1910            case SUPPLEMENT: return "The resource doesn't define any new concepts; it just provides additional designations and properties to another code system.";
1911            case NULL: return null;
1912            default: return "?";
1913          }
1914        }
1915        public String getDisplay() {
1916          switch (this) {
1917            case NOTPRESENT: return "Not Present";
1918            case EXAMPLE: return "Example";
1919            case FRAGMENT: return "Fragment";
1920            case COMPLETE: return "Complete";
1921            case SUPPLEMENT: return "Supplement";
1922            case NULL: return null;
1923            default: return "?";
1924          }
1925        }
1926    }
1927
1928  public static class CodeSystemContentModeEnumFactory implements EnumFactory<CodeSystemContentMode> {
1929    public CodeSystemContentMode fromCode(String codeString) throws IllegalArgumentException {
1930      if (codeString == null || "".equals(codeString))
1931            if (codeString == null || "".equals(codeString))
1932                return null;
1933        if ("not-present".equals(codeString))
1934          return CodeSystemContentMode.NOTPRESENT;
1935        if ("example".equals(codeString))
1936          return CodeSystemContentMode.EXAMPLE;
1937        if ("fragment".equals(codeString))
1938          return CodeSystemContentMode.FRAGMENT;
1939        if ("complete".equals(codeString))
1940          return CodeSystemContentMode.COMPLETE;
1941        if ("supplement".equals(codeString))
1942          return CodeSystemContentMode.SUPPLEMENT;
1943        throw new IllegalArgumentException("Unknown CodeSystemContentMode code '"+codeString+"'");
1944        }
1945
1946        public Enumeration<CodeSystemContentMode> fromType(PrimitiveType<?> code) throws FHIRException {
1947          if (code == null)
1948            return null;
1949          if (code.isEmpty())
1950            return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.NULL, code);
1951          String codeString = ((PrimitiveType) code).asStringValue();
1952          if (codeString == null || "".equals(codeString))
1953            return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.NULL, code);
1954        if ("not-present".equals(codeString))
1955          return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.NOTPRESENT, code);
1956        if ("example".equals(codeString))
1957          return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.EXAMPLE, code);
1958        if ("fragment".equals(codeString))
1959          return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.FRAGMENT, code);
1960        if ("complete".equals(codeString))
1961          return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.COMPLETE, code);
1962        if ("supplement".equals(codeString))
1963          return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.SUPPLEMENT, code);
1964        throw new FHIRException("Unknown CodeSystemContentMode code '"+codeString+"'");
1965        }
1966    public String toCode(CodeSystemContentMode code) {
1967       if (code == CodeSystemContentMode.NULL)
1968           return null;
1969       if (code == CodeSystemContentMode.NOTPRESENT)
1970        return "not-present";
1971      if (code == CodeSystemContentMode.EXAMPLE)
1972        return "example";
1973      if (code == CodeSystemContentMode.FRAGMENT)
1974        return "fragment";
1975      if (code == CodeSystemContentMode.COMPLETE)
1976        return "complete";
1977      if (code == CodeSystemContentMode.SUPPLEMENT)
1978        return "supplement";
1979      return "?";
1980   }
1981    public String toSystem(CodeSystemContentMode code) {
1982      return code.getSystem();
1983      }
1984    }
1985
1986    public enum CommonLanguages {
1987        /**
1988         * null
1989         */
1990        AR, 
1991        /**
1992         * null
1993         */
1994        BG, 
1995        /**
1996         * null
1997         */
1998        BGBG, 
1999        /**
2000         * null
2001         */
2002        BN, 
2003        /**
2004         * null
2005         */
2006        CS, 
2007        /**
2008         * null
2009         */
2010        CSCZ, 
2011        /**
2012         * null
2013         */
2014        BS, 
2015        /**
2016         * null
2017         */
2018        BSBA, 
2019        /**
2020         * null
2021         */
2022        DA, 
2023        /**
2024         * null
2025         */
2026        DADK, 
2027        /**
2028         * null
2029         */
2030        DE, 
2031        /**
2032         * null
2033         */
2034        DEAT, 
2035        /**
2036         * null
2037         */
2038        DECH, 
2039        /**
2040         * null
2041         */
2042        DEDE, 
2043        /**
2044         * null
2045         */
2046        EL, 
2047        /**
2048         * null
2049         */
2050        ELGR, 
2051        /**
2052         * null
2053         */
2054        EN, 
2055        /**
2056         * null
2057         */
2058        ENAU, 
2059        /**
2060         * null
2061         */
2062        ENCA, 
2063        /**
2064         * null
2065         */
2066        ENGB, 
2067        /**
2068         * null
2069         */
2070        ENIN, 
2071        /**
2072         * null
2073         */
2074        ENNZ, 
2075        /**
2076         * null
2077         */
2078        ENSG, 
2079        /**
2080         * null
2081         */
2082        ENUS, 
2083        /**
2084         * null
2085         */
2086        ES, 
2087        /**
2088         * null
2089         */
2090        ESAR, 
2091        /**
2092         * null
2093         */
2094        ESES, 
2095        /**
2096         * null
2097         */
2098        ESUY, 
2099        /**
2100         * null
2101         */
2102        ET, 
2103        /**
2104         * null
2105         */
2106        ETEE, 
2107        /**
2108         * null
2109         */
2110        FI, 
2111        /**
2112         * null
2113         */
2114        FR, 
2115        /**
2116         * null
2117         */
2118        FRBE, 
2119        /**
2120         * null
2121         */
2122        FRCH, 
2123        /**
2124         * null
2125         */
2126        FRFR, 
2127        /**
2128         * null
2129         */
2130        FIFI, 
2131        /**
2132         * null
2133         */
2134        FRCA, 
2135        /**
2136         * null
2137         */
2138        FY, 
2139        /**
2140         * null
2141         */
2142        FYNL, 
2143        /**
2144         * null
2145         */
2146        HI, 
2147        /**
2148         * null
2149         */
2150        HR, 
2151        /**
2152         * null
2153         */
2154        HRHR, 
2155        /**
2156         * null
2157         */
2158        IS, 
2159        /**
2160         * null
2161         */
2162        ISIS, 
2163        /**
2164         * null
2165         */
2166        IT, 
2167        /**
2168         * null
2169         */
2170        ITCH, 
2171        /**
2172         * null
2173         */
2174        ITIT, 
2175        /**
2176         * null
2177         */
2178        JA, 
2179        /**
2180         * null
2181         */
2182        KO, 
2183        /**
2184         * null
2185         */
2186        LT, 
2187        /**
2188         * null
2189         */
2190        LTLT, 
2191        /**
2192         * null
2193         */
2194        LV, 
2195        /**
2196         * null
2197         */
2198        LVLV, 
2199        /**
2200         * null
2201         */
2202        NL, 
2203        /**
2204         * null
2205         */
2206        NLBE, 
2207        /**
2208         * null
2209         */
2210        NLNL, 
2211        /**
2212         * null
2213         */
2214        NO, 
2215        /**
2216         * null
2217         */
2218        NONO, 
2219        /**
2220         * null
2221         */
2222        PA, 
2223        /**
2224         * null
2225         */
2226        PL, 
2227        /**
2228         * null
2229         */
2230        PLPL, 
2231        /**
2232         * null
2233         */
2234        PT, 
2235        /**
2236         * null
2237         */
2238        PTPT, 
2239        /**
2240         * null
2241         */
2242        PTBR, 
2243        /**
2244         * null
2245         */
2246        RO, 
2247        /**
2248         * null
2249         */
2250        RORO, 
2251        /**
2252         * null
2253         */
2254        RU, 
2255        /**
2256         * null
2257         */
2258        RURU, 
2259        /**
2260         * null
2261         */
2262        SK, 
2263        /**
2264         * null
2265         */
2266        SKSK, 
2267        /**
2268         * null
2269         */
2270        SL, 
2271        /**
2272         * null
2273         */
2274        SLSI, 
2275        /**
2276         * null
2277         */
2278        SR, 
2279        /**
2280         * null
2281         */
2282        SRRS, 
2283        /**
2284         * null
2285         */
2286        SV, 
2287        /**
2288         * null
2289         */
2290        SVSE, 
2291        /**
2292         * null
2293         */
2294        TE, 
2295        /**
2296         * null
2297         */
2298        ZH, 
2299        /**
2300         * null
2301         */
2302        ZHCN, 
2303        /**
2304         * null
2305         */
2306        ZHHK, 
2307        /**
2308         * null
2309         */
2310        ZHSG, 
2311        /**
2312         * null
2313         */
2314        ZHTW, 
2315        /**
2316         * added to help the parsers
2317         */
2318        NULL;
2319        public static CommonLanguages fromCode(String codeString) throws FHIRException {
2320            if (codeString == null || "".equals(codeString))
2321                return null;
2322        if ("ar".equals(codeString))
2323          return AR;
2324        if ("bg".equals(codeString))
2325          return BG;
2326        if ("bg-BG".equals(codeString))
2327          return BGBG;
2328        if ("bn".equals(codeString))
2329          return BN;
2330        if ("cs".equals(codeString))
2331          return CS;
2332        if ("cs-CZ".equals(codeString))
2333          return CSCZ;
2334        if ("bs".equals(codeString))
2335          return BS;
2336        if ("bs-BA".equals(codeString))
2337          return BSBA;
2338        if ("da".equals(codeString))
2339          return DA;
2340        if ("da-DK".equals(codeString))
2341          return DADK;
2342        if ("de".equals(codeString))
2343          return DE;
2344        if ("de-AT".equals(codeString))
2345          return DEAT;
2346        if ("de-CH".equals(codeString))
2347          return DECH;
2348        if ("de-DE".equals(codeString))
2349          return DEDE;
2350        if ("el".equals(codeString))
2351          return EL;
2352        if ("el-GR".equals(codeString))
2353          return ELGR;
2354        if ("en".equals(codeString))
2355          return EN;
2356        if ("en-AU".equals(codeString))
2357          return ENAU;
2358        if ("en-CA".equals(codeString))
2359          return ENCA;
2360        if ("en-GB".equals(codeString))
2361          return ENGB;
2362        if ("en-IN".equals(codeString))
2363          return ENIN;
2364        if ("en-NZ".equals(codeString))
2365          return ENNZ;
2366        if ("en-SG".equals(codeString))
2367          return ENSG;
2368        if ("en-US".equals(codeString))
2369          return ENUS;
2370        if ("es".equals(codeString))
2371          return ES;
2372        if ("es-AR".equals(codeString))
2373          return ESAR;
2374        if ("es-ES".equals(codeString))
2375          return ESES;
2376        if ("es-UY".equals(codeString))
2377          return ESUY;
2378        if ("et".equals(codeString))
2379          return ET;
2380        if ("et-EE".equals(codeString))
2381          return ETEE;
2382        if ("fi".equals(codeString))
2383          return FI;
2384        if ("fr".equals(codeString))
2385          return FR;
2386        if ("fr-BE".equals(codeString))
2387          return FRBE;
2388        if ("fr-CH".equals(codeString))
2389          return FRCH;
2390        if ("fr-FR".equals(codeString))
2391          return FRFR;
2392        if ("fi-FI".equals(codeString))
2393          return FIFI;
2394        if ("fr-CA".equals(codeString))
2395          return FRCA;
2396        if ("fy".equals(codeString))
2397          return FY;
2398        if ("fy-NL".equals(codeString))
2399          return FYNL;
2400        if ("hi".equals(codeString))
2401          return HI;
2402        if ("hr".equals(codeString))
2403          return HR;
2404        if ("hr-HR".equals(codeString))
2405          return HRHR;
2406        if ("is".equals(codeString))
2407          return IS;
2408        if ("is-IS".equals(codeString))
2409          return ISIS;
2410        if ("it".equals(codeString))
2411          return IT;
2412        if ("it-CH".equals(codeString))
2413          return ITCH;
2414        if ("it-IT".equals(codeString))
2415          return ITIT;
2416        if ("ja".equals(codeString))
2417          return JA;
2418        if ("ko".equals(codeString))
2419          return KO;
2420        if ("lt".equals(codeString))
2421          return LT;
2422        if ("lt-LT".equals(codeString))
2423          return LTLT;
2424        if ("lv".equals(codeString))
2425          return LV;
2426        if ("lv-LV".equals(codeString))
2427          return LVLV;
2428        if ("nl".equals(codeString))
2429          return NL;
2430        if ("nl-BE".equals(codeString))
2431          return NLBE;
2432        if ("nl-NL".equals(codeString))
2433          return NLNL;
2434        if ("no".equals(codeString))
2435          return NO;
2436        if ("no-NO".equals(codeString))
2437          return NONO;
2438        if ("pa".equals(codeString))
2439          return PA;
2440        if ("pl".equals(codeString))
2441          return PL;
2442        if ("pl-PL".equals(codeString))
2443          return PLPL;
2444        if ("pt".equals(codeString))
2445          return PT;
2446        if ("pt-PT".equals(codeString))
2447          return PTPT;
2448        if ("pt-BR".equals(codeString))
2449          return PTBR;
2450        if ("ro".equals(codeString))
2451          return RO;
2452        if ("ro-RO".equals(codeString))
2453          return RORO;
2454        if ("ru".equals(codeString))
2455          return RU;
2456        if ("ru-RU".equals(codeString))
2457          return RURU;
2458        if ("sk".equals(codeString))
2459          return SK;
2460        if ("sk-SK".equals(codeString))
2461          return SKSK;
2462        if ("sl".equals(codeString))
2463          return SL;
2464        if ("sl-SI".equals(codeString))
2465          return SLSI;
2466        if ("sr".equals(codeString))
2467          return SR;
2468        if ("sr-RS".equals(codeString))
2469          return SRRS;
2470        if ("sv".equals(codeString))
2471          return SV;
2472        if ("sv-SE".equals(codeString))
2473          return SVSE;
2474        if ("te".equals(codeString))
2475          return TE;
2476        if ("zh".equals(codeString))
2477          return ZH;
2478        if ("zh-CN".equals(codeString))
2479          return ZHCN;
2480        if ("zh-HK".equals(codeString))
2481          return ZHHK;
2482        if ("zh-SG".equals(codeString))
2483          return ZHSG;
2484        if ("zh-TW".equals(codeString))
2485          return ZHTW;
2486        throw new FHIRException("Unknown CommonLanguages code '"+codeString+"'");
2487        }
2488        public static boolean isValidCode(String codeString) {
2489            if (codeString == null || "".equals(codeString))
2490                return false;
2491          return Utilities.existsInList(codeString, "ar", "bg", "bg-BG", "bn", "cs", "cs-CZ", "bs", "bs-BA", "da", "da-DK", "de", "de-AT", "de-CH", "de-DE", "el", "el-GR", "en", "en-AU", "en-CA", "en-GB", "en-IN", "en-NZ", "en-SG", "en-US", "es", "es-AR", "es-ES", "es-UY", "et", "et-EE", "fi", "fr", "fr-BE", "fr-CH", "fr-FR", "fi-FI", "fr-CA", "fy", "fy-NL", "hi", "hr", "hr-HR", "is", "is-IS", "it", "it-CH", "it-IT", "ja", "ko", "lt", "lt-LT", "lv", "lv-LV", "nl", "nl-BE", "nl-NL", "no", "no-NO", "pa", "pl", "pl-PL", "pt", "pt-PT", "pt-BR", "ro", "ro-RO", "ru", "ru-RU", "sk", "sk-SK", "sl", "sl-SI", "sr", "sr-RS", "sv", "sv-SE", "te", "zh", "zh-CN", "zh-HK", "zh-SG", "zh-TW");
2492        }
2493        public String toCode() {
2494          switch (this) {
2495            case AR: return "ar";
2496            case BG: return "bg";
2497            case BGBG: return "bg-BG";
2498            case BN: return "bn";
2499            case CS: return "cs";
2500            case CSCZ: return "cs-CZ";
2501            case BS: return "bs";
2502            case BSBA: return "bs-BA";
2503            case DA: return "da";
2504            case DADK: return "da-DK";
2505            case DE: return "de";
2506            case DEAT: return "de-AT";
2507            case DECH: return "de-CH";
2508            case DEDE: return "de-DE";
2509            case EL: return "el";
2510            case ELGR: return "el-GR";
2511            case EN: return "en";
2512            case ENAU: return "en-AU";
2513            case ENCA: return "en-CA";
2514            case ENGB: return "en-GB";
2515            case ENIN: return "en-IN";
2516            case ENNZ: return "en-NZ";
2517            case ENSG: return "en-SG";
2518            case ENUS: return "en-US";
2519            case ES: return "es";
2520            case ESAR: return "es-AR";
2521            case ESES: return "es-ES";
2522            case ESUY: return "es-UY";
2523            case ET: return "et";
2524            case ETEE: return "et-EE";
2525            case FI: return "fi";
2526            case FR: return "fr";
2527            case FRBE: return "fr-BE";
2528            case FRCH: return "fr-CH";
2529            case FRFR: return "fr-FR";
2530            case FIFI: return "fi-FI";
2531            case FRCA: return "fr-CA";
2532            case FY: return "fy";
2533            case FYNL: return "fy-NL";
2534            case HI: return "hi";
2535            case HR: return "hr";
2536            case HRHR: return "hr-HR";
2537            case IS: return "is";
2538            case ISIS: return "is-IS";
2539            case IT: return "it";
2540            case ITCH: return "it-CH";
2541            case ITIT: return "it-IT";
2542            case JA: return "ja";
2543            case KO: return "ko";
2544            case LT: return "lt";
2545            case LTLT: return "lt-LT";
2546            case LV: return "lv";
2547            case LVLV: return "lv-LV";
2548            case NL: return "nl";
2549            case NLBE: return "nl-BE";
2550            case NLNL: return "nl-NL";
2551            case NO: return "no";
2552            case NONO: return "no-NO";
2553            case PA: return "pa";
2554            case PL: return "pl";
2555            case PLPL: return "pl-PL";
2556            case PT: return "pt";
2557            case PTPT: return "pt-PT";
2558            case PTBR: return "pt-BR";
2559            case RO: return "ro";
2560            case RORO: return "ro-RO";
2561            case RU: return "ru";
2562            case RURU: return "ru-RU";
2563            case SK: return "sk";
2564            case SKSK: return "sk-SK";
2565            case SL: return "sl";
2566            case SLSI: return "sl-SI";
2567            case SR: return "sr";
2568            case SRRS: return "sr-RS";
2569            case SV: return "sv";
2570            case SVSE: return "sv-SE";
2571            case TE: return "te";
2572            case ZH: return "zh";
2573            case ZHCN: return "zh-CN";
2574            case ZHHK: return "zh-HK";
2575            case ZHSG: return "zh-SG";
2576            case ZHTW: return "zh-TW";
2577            case NULL: return null;
2578            default: return "?";
2579          }
2580        }
2581        public String getSystem() {
2582          switch (this) {
2583            case AR: return "urn:ietf:bcp:47";
2584            case BG: return "urn:ietf:bcp:47";
2585            case BGBG: return "urn:ietf:bcp:47";
2586            case BN: return "urn:ietf:bcp:47";
2587            case CS: return "urn:ietf:bcp:47";
2588            case CSCZ: return "urn:ietf:bcp:47";
2589            case BS: return "urn:ietf:bcp:47";
2590            case BSBA: return "urn:ietf:bcp:47";
2591            case DA: return "urn:ietf:bcp:47";
2592            case DADK: return "urn:ietf:bcp:47";
2593            case DE: return "urn:ietf:bcp:47";
2594            case DEAT: return "urn:ietf:bcp:47";
2595            case DECH: return "urn:ietf:bcp:47";
2596            case DEDE: return "urn:ietf:bcp:47";
2597            case EL: return "urn:ietf:bcp:47";
2598            case ELGR: return "urn:ietf:bcp:47";
2599            case EN: return "urn:ietf:bcp:47";
2600            case ENAU: return "urn:ietf:bcp:47";
2601            case ENCA: return "urn:ietf:bcp:47";
2602            case ENGB: return "urn:ietf:bcp:47";
2603            case ENIN: return "urn:ietf:bcp:47";
2604            case ENNZ: return "urn:ietf:bcp:47";
2605            case ENSG: return "urn:ietf:bcp:47";
2606            case ENUS: return "urn:ietf:bcp:47";
2607            case ES: return "urn:ietf:bcp:47";
2608            case ESAR: return "urn:ietf:bcp:47";
2609            case ESES: return "urn:ietf:bcp:47";
2610            case ESUY: return "urn:ietf:bcp:47";
2611            case ET: return "urn:ietf:bcp:47";
2612            case ETEE: return "urn:ietf:bcp:47";
2613            case FI: return "urn:ietf:bcp:47";
2614            case FR: return "urn:ietf:bcp:47";
2615            case FRBE: return "urn:ietf:bcp:47";
2616            case FRCH: return "urn:ietf:bcp:47";
2617            case FRFR: return "urn:ietf:bcp:47";
2618            case FIFI: return "urn:ietf:bcp:47";
2619            case FRCA: return "urn:ietf:bcp:47";
2620            case FY: return "urn:ietf:bcp:47";
2621            case FYNL: return "urn:ietf:bcp:47";
2622            case HI: return "urn:ietf:bcp:47";
2623            case HR: return "urn:ietf:bcp:47";
2624            case HRHR: return "urn:ietf:bcp:47";
2625            case IS: return "urn:ietf:bcp:47";
2626            case ISIS: return "urn:ietf:bcp:47";
2627            case IT: return "urn:ietf:bcp:47";
2628            case ITCH: return "urn:ietf:bcp:47";
2629            case ITIT: return "urn:ietf:bcp:47";
2630            case JA: return "urn:ietf:bcp:47";
2631            case KO: return "urn:ietf:bcp:47";
2632            case LT: return "urn:ietf:bcp:47";
2633            case LTLT: return "urn:ietf:bcp:47";
2634            case LV: return "urn:ietf:bcp:47";
2635            case LVLV: return "urn:ietf:bcp:47";
2636            case NL: return "urn:ietf:bcp:47";
2637            case NLBE: return "urn:ietf:bcp:47";
2638            case NLNL: return "urn:ietf:bcp:47";
2639            case NO: return "urn:ietf:bcp:47";
2640            case NONO: return "urn:ietf:bcp:47";
2641            case PA: return "urn:ietf:bcp:47";
2642            case PL: return "urn:ietf:bcp:47";
2643            case PLPL: return "urn:ietf:bcp:47";
2644            case PT: return "urn:ietf:bcp:47";
2645            case PTPT: return "urn:ietf:bcp:47";
2646            case PTBR: return "urn:ietf:bcp:47";
2647            case RO: return "urn:ietf:bcp:47";
2648            case RORO: return "urn:ietf:bcp:47";
2649            case RU: return "urn:ietf:bcp:47";
2650            case RURU: return "urn:ietf:bcp:47";
2651            case SK: return "urn:ietf:bcp:47";
2652            case SKSK: return "urn:ietf:bcp:47";
2653            case SL: return "urn:ietf:bcp:47";
2654            case SLSI: return "urn:ietf:bcp:47";
2655            case SR: return "urn:ietf:bcp:47";
2656            case SRRS: return "urn:ietf:bcp:47";
2657            case SV: return "urn:ietf:bcp:47";
2658            case SVSE: return "urn:ietf:bcp:47";
2659            case TE: return "urn:ietf:bcp:47";
2660            case ZH: return "urn:ietf:bcp:47";
2661            case ZHCN: return "urn:ietf:bcp:47";
2662            case ZHHK: return "urn:ietf:bcp:47";
2663            case ZHSG: return "urn:ietf:bcp:47";
2664            case ZHTW: return "urn:ietf:bcp:47";
2665            case NULL: return null;
2666            default: return "?";
2667          }
2668        }
2669        public String getDefinition() {
2670          switch (this) {
2671            case AR: return "";
2672            case BG: return "";
2673            case BGBG: return "";
2674            case BN: return "";
2675            case CS: return "";
2676            case CSCZ: return "";
2677            case BS: return "";
2678            case BSBA: return "";
2679            case DA: return "";
2680            case DADK: return "";
2681            case DE: return "";
2682            case DEAT: return "";
2683            case DECH: return "";
2684            case DEDE: return "";
2685            case EL: return "";
2686            case ELGR: return "";
2687            case EN: return "";
2688            case ENAU: return "";
2689            case ENCA: return "";
2690            case ENGB: return "";
2691            case ENIN: return "";
2692            case ENNZ: return "";
2693            case ENSG: return "";
2694            case ENUS: return "";
2695            case ES: return "";
2696            case ESAR: return "";
2697            case ESES: return "";
2698            case ESUY: return "";
2699            case ET: return "";
2700            case ETEE: return "";
2701            case FI: return "";
2702            case FR: return "";
2703            case FRBE: return "";
2704            case FRCH: return "";
2705            case FRFR: return "";
2706            case FIFI: return "";
2707            case FRCA: return "";
2708            case FY: return "";
2709            case FYNL: return "";
2710            case HI: return "";
2711            case HR: return "";
2712            case HRHR: return "";
2713            case IS: return "";
2714            case ISIS: return "";
2715            case IT: return "";
2716            case ITCH: return "";
2717            case ITIT: return "";
2718            case JA: return "";
2719            case KO: return "";
2720            case LT: return "";
2721            case LTLT: return "";
2722            case LV: return "";
2723            case LVLV: return "";
2724            case NL: return "";
2725            case NLBE: return "";
2726            case NLNL: return "";
2727            case NO: return "";
2728            case NONO: return "";
2729            case PA: return "";
2730            case PL: return "";
2731            case PLPL: return "";
2732            case PT: return "";
2733            case PTPT: return "";
2734            case PTBR: return "";
2735            case RO: return "";
2736            case RORO: return "";
2737            case RU: return "";
2738            case RURU: return "";
2739            case SK: return "";
2740            case SKSK: return "";
2741            case SL: return "";
2742            case SLSI: return "";
2743            case SR: return "";
2744            case SRRS: return "";
2745            case SV: return "";
2746            case SVSE: return "";
2747            case TE: return "";
2748            case ZH: return "";
2749            case ZHCN: return "";
2750            case ZHHK: return "";
2751            case ZHSG: return "";
2752            case ZHTW: return "";
2753            case NULL: return null;
2754            default: return "?";
2755          }
2756        }
2757        public String getDisplay() {
2758          switch (this) {
2759            case AR: return "Arabisk";
2760            case BG: return "Bulgarian";
2761            case BGBG: return "Bulgarian (Bulgaria)";
2762            case BN: return "Bengali";
2763            case CS: return "Czech";
2764            case CSCZ: return "Czech (Czechia)";
2765            case BS: return "Bosnian";
2766            case BSBA: return "Bosnian (Bosnia and Herzegovina))";
2767            case DA: return "Danish";
2768            case DADK: return "Danish (Denmark)";
2769            case DE: return "German";
2770            case DEAT: return "German (Austria)";
2771            case DECH: return "German (Switzerland)";
2772            case DEDE: return "German (Germany)";
2773            case EL: return "Greek";
2774            case ELGR: return "Greek (Greece)";
2775            case EN: return "English";
2776            case ENAU: return "English (Australia)";
2777            case ENCA: return "English (Canada)";
2778            case ENGB: return "English (Great Britain)";
2779            case ENIN: return "English (India)";
2780            case ENNZ: return "English (New Zealand)";
2781            case ENSG: return "English (Singapore)";
2782            case ENUS: return "English (United States)";
2783            case ES: return "Spanish";
2784            case ESAR: return "Spanish (Argentina)";
2785            case ESES: return "Spanish (Spain)";
2786            case ESUY: return "Spanish (Uruguay)";
2787            case ET: return "Estonian";
2788            case ETEE: return "Estonian (Estonia)";
2789            case FI: return "Finnish";
2790            case FR: return "French";
2791            case FRBE: return "French (Belgium)";
2792            case FRCH: return "French (Switzerland)";
2793            case FRFR: return "French (France)";
2794            case FIFI: return "Finnish (Finland)";
2795            case FRCA: return "French (Canada)";
2796            case FY: return "Frisian";
2797            case FYNL: return "Frisian (Netherlands)";
2798            case HI: return "Hindi";
2799            case HR: return "Croatian";
2800            case HRHR: return "Croatian (Croatia)";
2801            case IS: return "Icelandic";
2802            case ISIS: return "Icelandic (Iceland)";
2803            case IT: return "Italian";
2804            case ITCH: return "Italian (Switzerland)";
2805            case ITIT: return "Italian (Italy)";
2806            case JA: return "Japanese";
2807            case KO: return "Korean";
2808            case LT: return "Lithuanian";
2809            case LTLT: return "Lithuanian (Lithuania)";
2810            case LV: return "Latvian";
2811            case LVLV: return "Latvian (Latvia)";
2812            case NL: return "Dutch";
2813            case NLBE: return "Dutch (Belgium)";
2814            case NLNL: return "Dutch (Netherlands)";
2815            case NO: return "Norwegian";
2816            case NONO: return "Norwegian (Norway)";
2817            case PA: return "Punjabi";
2818            case PL: return "Polskie";
2819            case PLPL: return "Polish (Poland)";
2820            case PT: return "Portuguese";
2821            case PTPT: return "Portuguese (Portugal)";
2822            case PTBR: return "Portuguese (Brazil)";
2823            case RO: return "Romanian";
2824            case RORO: return "Romanian (Romania)";
2825            case RU: return "Russian";
2826            case RURU: return "Russian (Russia)";
2827            case SK: return "Slovakian";
2828            case SKSK: return "Slovakian (Slovakia)";
2829            case SL: return "Slovenian";
2830            case SLSI: return "Slovenian (Slovenia)";
2831            case SR: return "Serbian";
2832            case SRRS: return "Serbian (Serbia)";
2833            case SV: return "Swedish";
2834            case SVSE: return "Swedish (Sweden)";
2835            case TE: return "Telugu";
2836            case ZH: return "Chinese";
2837            case ZHCN: return "Chinese (China)";
2838            case ZHHK: return "Chinese (Hong Kong)";
2839            case ZHSG: return "Chinese (Singapore)";
2840            case ZHTW: return "Chinese (Taiwan)";
2841            case NULL: return null;
2842            default: return "?";
2843          }
2844        }
2845    }
2846
2847  public static class CommonLanguagesEnumFactory implements EnumFactory<CommonLanguages> {
2848    public CommonLanguages fromCode(String codeString) throws IllegalArgumentException {
2849      if (codeString == null || "".equals(codeString))
2850            if (codeString == null || "".equals(codeString))
2851                return null;
2852        if ("ar".equals(codeString))
2853          return CommonLanguages.AR;
2854        if ("bg".equals(codeString))
2855          return CommonLanguages.BG;
2856        if ("bg-BG".equals(codeString))
2857          return CommonLanguages.BGBG;
2858        if ("bn".equals(codeString))
2859          return CommonLanguages.BN;
2860        if ("cs".equals(codeString))
2861          return CommonLanguages.CS;
2862        if ("cs-CZ".equals(codeString))
2863          return CommonLanguages.CSCZ;
2864        if ("bs".equals(codeString))
2865          return CommonLanguages.BS;
2866        if ("bs-BA".equals(codeString))
2867          return CommonLanguages.BSBA;
2868        if ("da".equals(codeString))
2869          return CommonLanguages.DA;
2870        if ("da-DK".equals(codeString))
2871          return CommonLanguages.DADK;
2872        if ("de".equals(codeString))
2873          return CommonLanguages.DE;
2874        if ("de-AT".equals(codeString))
2875          return CommonLanguages.DEAT;
2876        if ("de-CH".equals(codeString))
2877          return CommonLanguages.DECH;
2878        if ("de-DE".equals(codeString))
2879          return CommonLanguages.DEDE;
2880        if ("el".equals(codeString))
2881          return CommonLanguages.EL;
2882        if ("el-GR".equals(codeString))
2883          return CommonLanguages.ELGR;
2884        if ("en".equals(codeString))
2885          return CommonLanguages.EN;
2886        if ("en-AU".equals(codeString))
2887          return CommonLanguages.ENAU;
2888        if ("en-CA".equals(codeString))
2889          return CommonLanguages.ENCA;
2890        if ("en-GB".equals(codeString))
2891          return CommonLanguages.ENGB;
2892        if ("en-IN".equals(codeString))
2893          return CommonLanguages.ENIN;
2894        if ("en-NZ".equals(codeString))
2895          return CommonLanguages.ENNZ;
2896        if ("en-SG".equals(codeString))
2897          return CommonLanguages.ENSG;
2898        if ("en-US".equals(codeString))
2899          return CommonLanguages.ENUS;
2900        if ("es".equals(codeString))
2901          return CommonLanguages.ES;
2902        if ("es-AR".equals(codeString))
2903          return CommonLanguages.ESAR;
2904        if ("es-ES".equals(codeString))
2905          return CommonLanguages.ESES;
2906        if ("es-UY".equals(codeString))
2907          return CommonLanguages.ESUY;
2908        if ("et".equals(codeString))
2909          return CommonLanguages.ET;
2910        if ("et-EE".equals(codeString))
2911          return CommonLanguages.ETEE;
2912        if ("fi".equals(codeString))
2913          return CommonLanguages.FI;
2914        if ("fr".equals(codeString))
2915          return CommonLanguages.FR;
2916        if ("fr-BE".equals(codeString))
2917          return CommonLanguages.FRBE;
2918        if ("fr-CH".equals(codeString))
2919          return CommonLanguages.FRCH;
2920        if ("fr-FR".equals(codeString))
2921          return CommonLanguages.FRFR;
2922        if ("fi-FI".equals(codeString))
2923          return CommonLanguages.FIFI;
2924        if ("fr-CA".equals(codeString))
2925          return CommonLanguages.FRCA;
2926        if ("fy".equals(codeString))
2927          return CommonLanguages.FY;
2928        if ("fy-NL".equals(codeString))
2929          return CommonLanguages.FYNL;
2930        if ("hi".equals(codeString))
2931          return CommonLanguages.HI;
2932        if ("hr".equals(codeString))
2933          return CommonLanguages.HR;
2934        if ("hr-HR".equals(codeString))
2935          return CommonLanguages.HRHR;
2936        if ("is".equals(codeString))
2937          return CommonLanguages.IS;
2938        if ("is-IS".equals(codeString))
2939          return CommonLanguages.ISIS;
2940        if ("it".equals(codeString))
2941          return CommonLanguages.IT;
2942        if ("it-CH".equals(codeString))
2943          return CommonLanguages.ITCH;
2944        if ("it-IT".equals(codeString))
2945          return CommonLanguages.ITIT;
2946        if ("ja".equals(codeString))
2947          return CommonLanguages.JA;
2948        if ("ko".equals(codeString))
2949          return CommonLanguages.KO;
2950        if ("lt".equals(codeString))
2951          return CommonLanguages.LT;
2952        if ("lt-LT".equals(codeString))
2953          return CommonLanguages.LTLT;
2954        if ("lv".equals(codeString))
2955          return CommonLanguages.LV;
2956        if ("lv-LV".equals(codeString))
2957          return CommonLanguages.LVLV;
2958        if ("nl".equals(codeString))
2959          return CommonLanguages.NL;
2960        if ("nl-BE".equals(codeString))
2961          return CommonLanguages.NLBE;
2962        if ("nl-NL".equals(codeString))
2963          return CommonLanguages.NLNL;
2964        if ("no".equals(codeString))
2965          return CommonLanguages.NO;
2966        if ("no-NO".equals(codeString))
2967          return CommonLanguages.NONO;
2968        if ("pa".equals(codeString))
2969          return CommonLanguages.PA;
2970        if ("pl".equals(codeString))
2971          return CommonLanguages.PL;
2972        if ("pl-PL".equals(codeString))
2973          return CommonLanguages.PLPL;
2974        if ("pt".equals(codeString))
2975          return CommonLanguages.PT;
2976        if ("pt-PT".equals(codeString))
2977          return CommonLanguages.PTPT;
2978        if ("pt-BR".equals(codeString))
2979          return CommonLanguages.PTBR;
2980        if ("ro".equals(codeString))
2981          return CommonLanguages.RO;
2982        if ("ro-RO".equals(codeString))
2983          return CommonLanguages.RORO;
2984        if ("ru".equals(codeString))
2985          return CommonLanguages.RU;
2986        if ("ru-RU".equals(codeString))
2987          return CommonLanguages.RURU;
2988        if ("sk".equals(codeString))
2989          return CommonLanguages.SK;
2990        if ("sk-SK".equals(codeString))
2991          return CommonLanguages.SKSK;
2992        if ("sl".equals(codeString))
2993          return CommonLanguages.SL;
2994        if ("sl-SI".equals(codeString))
2995          return CommonLanguages.SLSI;
2996        if ("sr".equals(codeString))
2997          return CommonLanguages.SR;
2998        if ("sr-RS".equals(codeString))
2999          return CommonLanguages.SRRS;
3000        if ("sv".equals(codeString))
3001          return CommonLanguages.SV;
3002        if ("sv-SE".equals(codeString))
3003          return CommonLanguages.SVSE;
3004        if ("te".equals(codeString))
3005          return CommonLanguages.TE;
3006        if ("zh".equals(codeString))
3007          return CommonLanguages.ZH;
3008        if ("zh-CN".equals(codeString))
3009          return CommonLanguages.ZHCN;
3010        if ("zh-HK".equals(codeString))
3011          return CommonLanguages.ZHHK;
3012        if ("zh-SG".equals(codeString))
3013          return CommonLanguages.ZHSG;
3014        if ("zh-TW".equals(codeString))
3015          return CommonLanguages.ZHTW;
3016        throw new IllegalArgumentException("Unknown CommonLanguages code '"+codeString+"'");
3017        }
3018
3019        public Enumeration<CommonLanguages> fromType(PrimitiveType<?> code) throws FHIRException {
3020          if (code == null)
3021            return null;
3022          if (code.isEmpty())
3023            return new Enumeration<CommonLanguages>(this, CommonLanguages.NULL, code);
3024          String codeString = ((PrimitiveType) code).asStringValue();
3025          if (codeString == null || "".equals(codeString))
3026            return new Enumeration<CommonLanguages>(this, CommonLanguages.NULL, code);
3027        if ("ar".equals(codeString))
3028          return new Enumeration<CommonLanguages>(this, CommonLanguages.AR, code);
3029        if ("bg".equals(codeString))
3030          return new Enumeration<CommonLanguages>(this, CommonLanguages.BG, code);
3031        if ("bg-BG".equals(codeString))
3032          return new Enumeration<CommonLanguages>(this, CommonLanguages.BGBG, code);
3033        if ("bn".equals(codeString))
3034          return new Enumeration<CommonLanguages>(this, CommonLanguages.BN, code);
3035        if ("cs".equals(codeString))
3036          return new Enumeration<CommonLanguages>(this, CommonLanguages.CS, code);
3037        if ("cs-CZ".equals(codeString))
3038          return new Enumeration<CommonLanguages>(this, CommonLanguages.CSCZ, code);
3039        if ("bs".equals(codeString))
3040          return new Enumeration<CommonLanguages>(this, CommonLanguages.BS, code);
3041        if ("bs-BA".equals(codeString))
3042          return new Enumeration<CommonLanguages>(this, CommonLanguages.BSBA, code);
3043        if ("da".equals(codeString))
3044          return new Enumeration<CommonLanguages>(this, CommonLanguages.DA, code);
3045        if ("da-DK".equals(codeString))
3046          return new Enumeration<CommonLanguages>(this, CommonLanguages.DADK, code);
3047        if ("de".equals(codeString))
3048          return new Enumeration<CommonLanguages>(this, CommonLanguages.DE, code);
3049        if ("de-AT".equals(codeString))
3050          return new Enumeration<CommonLanguages>(this, CommonLanguages.DEAT, code);
3051        if ("de-CH".equals(codeString))
3052          return new Enumeration<CommonLanguages>(this, CommonLanguages.DECH, code);
3053        if ("de-DE".equals(codeString))
3054          return new Enumeration<CommonLanguages>(this, CommonLanguages.DEDE, code);
3055        if ("el".equals(codeString))
3056          return new Enumeration<CommonLanguages>(this, CommonLanguages.EL, code);
3057        if ("el-GR".equals(codeString))
3058          return new Enumeration<CommonLanguages>(this, CommonLanguages.ELGR, code);
3059        if ("en".equals(codeString))
3060          return new Enumeration<CommonLanguages>(this, CommonLanguages.EN, code);
3061        if ("en-AU".equals(codeString))
3062          return new Enumeration<CommonLanguages>(this, CommonLanguages.ENAU, code);
3063        if ("en-CA".equals(codeString))
3064          return new Enumeration<CommonLanguages>(this, CommonLanguages.ENCA, code);
3065        if ("en-GB".equals(codeString))
3066          return new Enumeration<CommonLanguages>(this, CommonLanguages.ENGB, code);
3067        if ("en-IN".equals(codeString))
3068          return new Enumeration<CommonLanguages>(this, CommonLanguages.ENIN, code);
3069        if ("en-NZ".equals(codeString))
3070          return new Enumeration<CommonLanguages>(this, CommonLanguages.ENNZ, code);
3071        if ("en-SG".equals(codeString))
3072          return new Enumeration<CommonLanguages>(this, CommonLanguages.ENSG, code);
3073        if ("en-US".equals(codeString))
3074          return new Enumeration<CommonLanguages>(this, CommonLanguages.ENUS, code);
3075        if ("es".equals(codeString))
3076          return new Enumeration<CommonLanguages>(this, CommonLanguages.ES, code);
3077        if ("es-AR".equals(codeString))
3078          return new Enumeration<CommonLanguages>(this, CommonLanguages.ESAR, code);
3079        if ("es-ES".equals(codeString))
3080          return new Enumeration<CommonLanguages>(this, CommonLanguages.ESES, code);
3081        if ("es-UY".equals(codeString))
3082          return new Enumeration<CommonLanguages>(this, CommonLanguages.ESUY, code);
3083        if ("et".equals(codeString))
3084          return new Enumeration<CommonLanguages>(this, CommonLanguages.ET, code);
3085        if ("et-EE".equals(codeString))
3086          return new Enumeration<CommonLanguages>(this, CommonLanguages.ETEE, code);
3087        if ("fi".equals(codeString))
3088          return new Enumeration<CommonLanguages>(this, CommonLanguages.FI, code);
3089        if ("fr".equals(codeString))
3090          return new Enumeration<CommonLanguages>(this, CommonLanguages.FR, code);
3091        if ("fr-BE".equals(codeString))
3092          return new Enumeration<CommonLanguages>(this, CommonLanguages.FRBE, code);
3093        if ("fr-CH".equals(codeString))
3094          return new Enumeration<CommonLanguages>(this, CommonLanguages.FRCH, code);
3095        if ("fr-FR".equals(codeString))
3096          return new Enumeration<CommonLanguages>(this, CommonLanguages.FRFR, code);
3097        if ("fi-FI".equals(codeString))
3098          return new Enumeration<CommonLanguages>(this, CommonLanguages.FIFI, code);
3099        if ("fr-CA".equals(codeString))
3100          return new Enumeration<CommonLanguages>(this, CommonLanguages.FRCA, code);
3101        if ("fy".equals(codeString))
3102          return new Enumeration<CommonLanguages>(this, CommonLanguages.FY, code);
3103        if ("fy-NL".equals(codeString))
3104          return new Enumeration<CommonLanguages>(this, CommonLanguages.FYNL, code);
3105        if ("hi".equals(codeString))
3106          return new Enumeration<CommonLanguages>(this, CommonLanguages.HI, code);
3107        if ("hr".equals(codeString))
3108          return new Enumeration<CommonLanguages>(this, CommonLanguages.HR, code);
3109        if ("hr-HR".equals(codeString))
3110          return new Enumeration<CommonLanguages>(this, CommonLanguages.HRHR, code);
3111        if ("is".equals(codeString))
3112          return new Enumeration<CommonLanguages>(this, CommonLanguages.IS, code);
3113        if ("is-IS".equals(codeString))
3114          return new Enumeration<CommonLanguages>(this, CommonLanguages.ISIS, code);
3115        if ("it".equals(codeString))
3116          return new Enumeration<CommonLanguages>(this, CommonLanguages.IT, code);
3117        if ("it-CH".equals(codeString))
3118          return new Enumeration<CommonLanguages>(this, CommonLanguages.ITCH, code);
3119        if ("it-IT".equals(codeString))
3120          return new Enumeration<CommonLanguages>(this, CommonLanguages.ITIT, code);
3121        if ("ja".equals(codeString))
3122          return new Enumeration<CommonLanguages>(this, CommonLanguages.JA, code);
3123        if ("ko".equals(codeString))
3124          return new Enumeration<CommonLanguages>(this, CommonLanguages.KO, code);
3125        if ("lt".equals(codeString))
3126          return new Enumeration<CommonLanguages>(this, CommonLanguages.LT, code);
3127        if ("lt-LT".equals(codeString))
3128          return new Enumeration<CommonLanguages>(this, CommonLanguages.LTLT, code);
3129        if ("lv".equals(codeString))
3130          return new Enumeration<CommonLanguages>(this, CommonLanguages.LV, code);
3131        if ("lv-LV".equals(codeString))
3132          return new Enumeration<CommonLanguages>(this, CommonLanguages.LVLV, code);
3133        if ("nl".equals(codeString))
3134          return new Enumeration<CommonLanguages>(this, CommonLanguages.NL, code);
3135        if ("nl-BE".equals(codeString))
3136          return new Enumeration<CommonLanguages>(this, CommonLanguages.NLBE, code);
3137        if ("nl-NL".equals(codeString))
3138          return new Enumeration<CommonLanguages>(this, CommonLanguages.NLNL, code);
3139        if ("no".equals(codeString))
3140          return new Enumeration<CommonLanguages>(this, CommonLanguages.NO, code);
3141        if ("no-NO".equals(codeString))
3142          return new Enumeration<CommonLanguages>(this, CommonLanguages.NONO, code);
3143        if ("pa".equals(codeString))
3144          return new Enumeration<CommonLanguages>(this, CommonLanguages.PA, code);
3145        if ("pl".equals(codeString))
3146          return new Enumeration<CommonLanguages>(this, CommonLanguages.PL, code);
3147        if ("pl-PL".equals(codeString))
3148          return new Enumeration<CommonLanguages>(this, CommonLanguages.PLPL, code);
3149        if ("pt".equals(codeString))
3150          return new Enumeration<CommonLanguages>(this, CommonLanguages.PT, code);
3151        if ("pt-PT".equals(codeString))
3152          return new Enumeration<CommonLanguages>(this, CommonLanguages.PTPT, code);
3153        if ("pt-BR".equals(codeString))
3154          return new Enumeration<CommonLanguages>(this, CommonLanguages.PTBR, code);
3155        if ("ro".equals(codeString))
3156          return new Enumeration<CommonLanguages>(this, CommonLanguages.RO, code);
3157        if ("ro-RO".equals(codeString))
3158          return new Enumeration<CommonLanguages>(this, CommonLanguages.RORO, code);
3159        if ("ru".equals(codeString))
3160          return new Enumeration<CommonLanguages>(this, CommonLanguages.RU, code);
3161        if ("ru-RU".equals(codeString))
3162          return new Enumeration<CommonLanguages>(this, CommonLanguages.RURU, code);
3163        if ("sk".equals(codeString))
3164          return new Enumeration<CommonLanguages>(this, CommonLanguages.SK, code);
3165        if ("sk-SK".equals(codeString))
3166          return new Enumeration<CommonLanguages>(this, CommonLanguages.SKSK, code);
3167        if ("sl".equals(codeString))
3168          return new Enumeration<CommonLanguages>(this, CommonLanguages.SL, code);
3169        if ("sl-SI".equals(codeString))
3170          return new Enumeration<CommonLanguages>(this, CommonLanguages.SLSI, code);
3171        if ("sr".equals(codeString))
3172          return new Enumeration<CommonLanguages>(this, CommonLanguages.SR, code);
3173        if ("sr-RS".equals(codeString))
3174          return new Enumeration<CommonLanguages>(this, CommonLanguages.SRRS, code);
3175        if ("sv".equals(codeString))
3176          return new Enumeration<CommonLanguages>(this, CommonLanguages.SV, code);
3177        if ("sv-SE".equals(codeString))
3178          return new Enumeration<CommonLanguages>(this, CommonLanguages.SVSE, code);
3179        if ("te".equals(codeString))
3180          return new Enumeration<CommonLanguages>(this, CommonLanguages.TE, code);
3181        if ("zh".equals(codeString))
3182          return new Enumeration<CommonLanguages>(this, CommonLanguages.ZH, code);
3183        if ("zh-CN".equals(codeString))
3184          return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHCN, code);
3185        if ("zh-HK".equals(codeString))
3186          return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHHK, code);
3187        if ("zh-SG".equals(codeString))
3188          return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHSG, code);
3189        if ("zh-TW".equals(codeString))
3190          return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHTW, code);
3191        throw new FHIRException("Unknown CommonLanguages code '"+codeString+"'");
3192        }
3193    public String toCode(CommonLanguages code) {
3194       if (code == CommonLanguages.NULL)
3195           return null;
3196       if (code == CommonLanguages.AR)
3197        return "ar";
3198      if (code == CommonLanguages.BG)
3199        return "bg";
3200      if (code == CommonLanguages.BGBG)
3201        return "bg-BG";
3202      if (code == CommonLanguages.BN)
3203        return "bn";
3204      if (code == CommonLanguages.CS)
3205        return "cs";
3206      if (code == CommonLanguages.CSCZ)
3207        return "cs-CZ";
3208      if (code == CommonLanguages.BS)
3209        return "bs";
3210      if (code == CommonLanguages.BSBA)
3211        return "bs-BA";
3212      if (code == CommonLanguages.DA)
3213        return "da";
3214      if (code == CommonLanguages.DADK)
3215        return "da-DK";
3216      if (code == CommonLanguages.DE)
3217        return "de";
3218      if (code == CommonLanguages.DEAT)
3219        return "de-AT";
3220      if (code == CommonLanguages.DECH)
3221        return "de-CH";
3222      if (code == CommonLanguages.DEDE)
3223        return "de-DE";
3224      if (code == CommonLanguages.EL)
3225        return "el";
3226      if (code == CommonLanguages.ELGR)
3227        return "el-GR";
3228      if (code == CommonLanguages.EN)
3229        return "en";
3230      if (code == CommonLanguages.ENAU)
3231        return "en-AU";
3232      if (code == CommonLanguages.ENCA)
3233        return "en-CA";
3234      if (code == CommonLanguages.ENGB)
3235        return "en-GB";
3236      if (code == CommonLanguages.ENIN)
3237        return "en-IN";
3238      if (code == CommonLanguages.ENNZ)
3239        return "en-NZ";
3240      if (code == CommonLanguages.ENSG)
3241        return "en-SG";
3242      if (code == CommonLanguages.ENUS)
3243        return "en-US";
3244      if (code == CommonLanguages.ES)
3245        return "es";
3246      if (code == CommonLanguages.ESAR)
3247        return "es-AR";
3248      if (code == CommonLanguages.ESES)
3249        return "es-ES";
3250      if (code == CommonLanguages.ESUY)
3251        return "es-UY";
3252      if (code == CommonLanguages.ET)
3253        return "et";
3254      if (code == CommonLanguages.ETEE)
3255        return "et-EE";
3256      if (code == CommonLanguages.FI)
3257        return "fi";
3258      if (code == CommonLanguages.FR)
3259        return "fr";
3260      if (code == CommonLanguages.FRBE)
3261        return "fr-BE";
3262      if (code == CommonLanguages.FRCH)
3263        return "fr-CH";
3264      if (code == CommonLanguages.FRFR)
3265        return "fr-FR";
3266      if (code == CommonLanguages.FIFI)
3267        return "fi-FI";
3268      if (code == CommonLanguages.FRCA)
3269        return "fr-CA";
3270      if (code == CommonLanguages.FY)
3271        return "fy";
3272      if (code == CommonLanguages.FYNL)
3273        return "fy-NL";
3274      if (code == CommonLanguages.HI)
3275        return "hi";
3276      if (code == CommonLanguages.HR)
3277        return "hr";
3278      if (code == CommonLanguages.HRHR)
3279        return "hr-HR";
3280      if (code == CommonLanguages.IS)
3281        return "is";
3282      if (code == CommonLanguages.ISIS)
3283        return "is-IS";
3284      if (code == CommonLanguages.IT)
3285        return "it";
3286      if (code == CommonLanguages.ITCH)
3287        return "it-CH";
3288      if (code == CommonLanguages.ITIT)
3289        return "it-IT";
3290      if (code == CommonLanguages.JA)
3291        return "ja";
3292      if (code == CommonLanguages.KO)
3293        return "ko";
3294      if (code == CommonLanguages.LT)
3295        return "lt";
3296      if (code == CommonLanguages.LTLT)
3297        return "lt-LT";
3298      if (code == CommonLanguages.LV)
3299        return "lv";
3300      if (code == CommonLanguages.LVLV)
3301        return "lv-LV";
3302      if (code == CommonLanguages.NL)
3303        return "nl";
3304      if (code == CommonLanguages.NLBE)
3305        return "nl-BE";
3306      if (code == CommonLanguages.NLNL)
3307        return "nl-NL";
3308      if (code == CommonLanguages.NO)
3309        return "no";
3310      if (code == CommonLanguages.NONO)
3311        return "no-NO";
3312      if (code == CommonLanguages.PA)
3313        return "pa";
3314      if (code == CommonLanguages.PL)
3315        return "pl";
3316      if (code == CommonLanguages.PLPL)
3317        return "pl-PL";
3318      if (code == CommonLanguages.PT)
3319        return "pt";
3320      if (code == CommonLanguages.PTPT)
3321        return "pt-PT";
3322      if (code == CommonLanguages.PTBR)
3323        return "pt-BR";
3324      if (code == CommonLanguages.RO)
3325        return "ro";
3326      if (code == CommonLanguages.RORO)
3327        return "ro-RO";
3328      if (code == CommonLanguages.RU)
3329        return "ru";
3330      if (code == CommonLanguages.RURU)
3331        return "ru-RU";
3332      if (code == CommonLanguages.SK)
3333        return "sk";
3334      if (code == CommonLanguages.SKSK)
3335        return "sk-SK";
3336      if (code == CommonLanguages.SL)
3337        return "sl";
3338      if (code == CommonLanguages.SLSI)
3339        return "sl-SI";
3340      if (code == CommonLanguages.SR)
3341        return "sr";
3342      if (code == CommonLanguages.SRRS)
3343        return "sr-RS";
3344      if (code == CommonLanguages.SV)
3345        return "sv";
3346      if (code == CommonLanguages.SVSE)
3347        return "sv-SE";
3348      if (code == CommonLanguages.TE)
3349        return "te";
3350      if (code == CommonLanguages.ZH)
3351        return "zh";
3352      if (code == CommonLanguages.ZHCN)
3353        return "zh-CN";
3354      if (code == CommonLanguages.ZHHK)
3355        return "zh-HK";
3356      if (code == CommonLanguages.ZHSG)
3357        return "zh-SG";
3358      if (code == CommonLanguages.ZHTW)
3359        return "zh-TW";
3360      return "?";
3361   }
3362    public String toSystem(CommonLanguages code) {
3363      return code.getSystem();
3364      }
3365    }
3366
3367    public enum CompartmentType {
3368        /**
3369         * The compartment definition is for the patient compartment.
3370         */
3371        PATIENT, 
3372        /**
3373         * The compartment definition is for the encounter compartment.
3374         */
3375        ENCOUNTER, 
3376        /**
3377         * The compartment definition is for the related-person compartment.
3378         */
3379        RELATEDPERSON, 
3380        /**
3381         * The compartment definition is for the practitioner compartment.
3382         */
3383        PRACTITIONER, 
3384        /**
3385         * The compartment definition is for the device compartment.
3386         */
3387        DEVICE, 
3388        /**
3389         * The compartment definition is for the episodeofcare compartment.
3390         */
3391        EPISODEOFCARE, 
3392        /**
3393         * added to help the parsers
3394         */
3395        NULL;
3396        public static CompartmentType fromCode(String codeString) throws FHIRException {
3397            if (codeString == null || "".equals(codeString))
3398                return null;
3399        if ("Patient".equals(codeString))
3400          return PATIENT;
3401        if ("Encounter".equals(codeString))
3402          return ENCOUNTER;
3403        if ("RelatedPerson".equals(codeString))
3404          return RELATEDPERSON;
3405        if ("Practitioner".equals(codeString))
3406          return PRACTITIONER;
3407        if ("Device".equals(codeString))
3408          return DEVICE;
3409        if ("EpisodeOfCare".equals(codeString))
3410          return EPISODEOFCARE;
3411        throw new FHIRException("Unknown CompartmentType code '"+codeString+"'");
3412        }
3413        public static boolean isValidCode(String codeString) {
3414            if (codeString == null || "".equals(codeString))
3415                return false;
3416          return Utilities.existsInList(codeString, "Patient", "Encounter", "RelatedPerson", "Practitioner", "Device", "EpisodeOfCare");
3417        }
3418        public String toCode() {
3419          switch (this) {
3420            case PATIENT: return "Patient";
3421            case ENCOUNTER: return "Encounter";
3422            case RELATEDPERSON: return "RelatedPerson";
3423            case PRACTITIONER: return "Practitioner";
3424            case DEVICE: return "Device";
3425            case EPISODEOFCARE: return "EpisodeOfCare";
3426            case NULL: return null;
3427            default: return "?";
3428          }
3429        }
3430        public String getSystem() {
3431          switch (this) {
3432            case PATIENT: return "http://hl7.org/fhir/compartment-type";
3433            case ENCOUNTER: return "http://hl7.org/fhir/compartment-type";
3434            case RELATEDPERSON: return "http://hl7.org/fhir/compartment-type";
3435            case PRACTITIONER: return "http://hl7.org/fhir/compartment-type";
3436            case DEVICE: return "http://hl7.org/fhir/compartment-type";
3437            case EPISODEOFCARE: return "http://hl7.org/fhir/compartment-type";
3438            case NULL: return null;
3439            default: return "?";
3440          }
3441        }
3442        public String getDefinition() {
3443          switch (this) {
3444            case PATIENT: return "The compartment definition is for the patient compartment.";
3445            case ENCOUNTER: return "The compartment definition is for the encounter compartment.";
3446            case RELATEDPERSON: return "The compartment definition is for the related-person compartment.";
3447            case PRACTITIONER: return "The compartment definition is for the practitioner compartment.";
3448            case DEVICE: return "The compartment definition is for the device compartment.";
3449            case EPISODEOFCARE: return "The compartment definition is for the episodeofcare compartment.";
3450            case NULL: return null;
3451            default: return "?";
3452          }
3453        }
3454        public String getDisplay() {
3455          switch (this) {
3456            case PATIENT: return "Patient";
3457            case ENCOUNTER: return "Encounter";
3458            case RELATEDPERSON: return "RelatedPerson";
3459            case PRACTITIONER: return "Practitioner";
3460            case DEVICE: return "Device";
3461            case EPISODEOFCARE: return "EpisodeOfCare";
3462            case NULL: return null;
3463            default: return "?";
3464          }
3465        }
3466    }
3467
3468  public static class CompartmentTypeEnumFactory implements EnumFactory<CompartmentType> {
3469    public CompartmentType fromCode(String codeString) throws IllegalArgumentException {
3470      if (codeString == null || "".equals(codeString))
3471            if (codeString == null || "".equals(codeString))
3472                return null;
3473        if ("Patient".equals(codeString))
3474          return CompartmentType.PATIENT;
3475        if ("Encounter".equals(codeString))
3476          return CompartmentType.ENCOUNTER;
3477        if ("RelatedPerson".equals(codeString))
3478          return CompartmentType.RELATEDPERSON;
3479        if ("Practitioner".equals(codeString))
3480          return CompartmentType.PRACTITIONER;
3481        if ("Device".equals(codeString))
3482          return CompartmentType.DEVICE;
3483        if ("EpisodeOfCare".equals(codeString))
3484          return CompartmentType.EPISODEOFCARE;
3485        throw new IllegalArgumentException("Unknown CompartmentType code '"+codeString+"'");
3486        }
3487
3488        public Enumeration<CompartmentType> fromType(PrimitiveType<?> code) throws FHIRException {
3489          if (code == null)
3490            return null;
3491          if (code.isEmpty())
3492            return new Enumeration<CompartmentType>(this, CompartmentType.NULL, code);
3493          String codeString = ((PrimitiveType) code).asStringValue();
3494          if (codeString == null || "".equals(codeString))
3495            return new Enumeration<CompartmentType>(this, CompartmentType.NULL, code);
3496        if ("Patient".equals(codeString))
3497          return new Enumeration<CompartmentType>(this, CompartmentType.PATIENT, code);
3498        if ("Encounter".equals(codeString))
3499          return new Enumeration<CompartmentType>(this, CompartmentType.ENCOUNTER, code);
3500        if ("RelatedPerson".equals(codeString))
3501          return new Enumeration<CompartmentType>(this, CompartmentType.RELATEDPERSON, code);
3502        if ("Practitioner".equals(codeString))
3503          return new Enumeration<CompartmentType>(this, CompartmentType.PRACTITIONER, code);
3504        if ("Device".equals(codeString))
3505          return new Enumeration<CompartmentType>(this, CompartmentType.DEVICE, code);
3506        if ("EpisodeOfCare".equals(codeString))
3507          return new Enumeration<CompartmentType>(this, CompartmentType.EPISODEOFCARE, code);
3508        throw new FHIRException("Unknown CompartmentType code '"+codeString+"'");
3509        }
3510    public String toCode(CompartmentType code) {
3511       if (code == CompartmentType.NULL)
3512           return null;
3513       if (code == CompartmentType.PATIENT)
3514        return "Patient";
3515      if (code == CompartmentType.ENCOUNTER)
3516        return "Encounter";
3517      if (code == CompartmentType.RELATEDPERSON)
3518        return "RelatedPerson";
3519      if (code == CompartmentType.PRACTITIONER)
3520        return "Practitioner";
3521      if (code == CompartmentType.DEVICE)
3522        return "Device";
3523      if (code == CompartmentType.EPISODEOFCARE)
3524        return "EpisodeOfCare";
3525      return "?";
3526   }
3527    public String toSystem(CompartmentType code) {
3528      return code.getSystem();
3529      }
3530    }
3531
3532    public enum CompositionStatus {
3533        /**
3534         * The existence of the composition is registered, but there is nothing yet available.
3535         */
3536        REGISTERED, 
3537        /**
3538         * This is a partial (e.g. initial, interim or preliminary) composition: data in the composition may be incomplete or unverified.
3539         */
3540        PARTIAL, 
3541        /**
3542         * Verified early results are available, but not all results are final.
3543         */
3544        PRELIMINARY, 
3545        /**
3546         * 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.
3547         */
3548        FINAL, 
3549        /**
3550         * 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.
3551         */
3552        AMENDED, 
3553        /**
3554         * Subsequent to being final, the composition content has been modified to correct an error in the composition or referenced results.
3555         */
3556        CORRECTED, 
3557        /**
3558         * Subsequent to being final, the composition content has been modified by adding new content. The existing content is unchanged.
3559         */
3560        APPENDED, 
3561        /**
3562         * The composition is unavailable because the measurement was not started or not completed (also sometimes called "aborted").
3563         */
3564        CANCELLED, 
3565        /**
3566         * 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.
3567         */
3568        ENTEREDINERROR, 
3569        /**
3570         * This composition has been withdrawn or superseded and should no longer be used.
3571         */
3572        DEPRECATED, 
3573        /**
3574         * 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.
3575         */
3576        UNKNOWN, 
3577        /**
3578         * added to help the parsers
3579         */
3580        NULL;
3581        public static CompositionStatus fromCode(String codeString) throws FHIRException {
3582            if (codeString == null || "".equals(codeString))
3583                return null;
3584        if ("registered".equals(codeString))
3585          return REGISTERED;
3586        if ("partial".equals(codeString))
3587          return PARTIAL;
3588        if ("preliminary".equals(codeString))
3589          return PRELIMINARY;
3590        if ("final".equals(codeString))
3591          return FINAL;
3592        if ("amended".equals(codeString))
3593          return AMENDED;
3594        if ("corrected".equals(codeString))
3595          return CORRECTED;
3596        if ("appended".equals(codeString))
3597          return APPENDED;
3598        if ("cancelled".equals(codeString))
3599          return CANCELLED;
3600        if ("entered-in-error".equals(codeString))
3601          return ENTEREDINERROR;
3602        if ("deprecated".equals(codeString))
3603          return DEPRECATED;
3604        if ("unknown".equals(codeString))
3605          return UNKNOWN;
3606        throw new FHIRException("Unknown CompositionStatus code '"+codeString+"'");
3607        }
3608        public static boolean isValidCode(String codeString) {
3609            if (codeString == null || "".equals(codeString))
3610                return false;
3611          return Utilities.existsInList(codeString, "registered", "partial", "preliminary", "final", "amended", "corrected", "appended", "cancelled", "entered-in-error", "deprecated", "unknown");
3612        }
3613        public String toCode() {
3614          switch (this) {
3615            case REGISTERED: return "registered";
3616            case PARTIAL: return "partial";
3617            case PRELIMINARY: return "preliminary";
3618            case FINAL: return "final";
3619            case AMENDED: return "amended";
3620            case CORRECTED: return "corrected";
3621            case APPENDED: return "appended";
3622            case CANCELLED: return "cancelled";
3623            case ENTEREDINERROR: return "entered-in-error";
3624            case DEPRECATED: return "deprecated";
3625            case UNKNOWN: return "unknown";
3626            case NULL: return null;
3627            default: return "?";
3628          }
3629        }
3630        public String getSystem() {
3631          switch (this) {
3632            case REGISTERED: return "http://hl7.org/fhir/composition-status";
3633            case PARTIAL: return "http://hl7.org/fhir/composition-status";
3634            case PRELIMINARY: return "http://hl7.org/fhir/composition-status";
3635            case FINAL: return "http://hl7.org/fhir/composition-status";
3636            case AMENDED: return "http://hl7.org/fhir/composition-status";
3637            case CORRECTED: return "http://hl7.org/fhir/composition-status";
3638            case APPENDED: return "http://hl7.org/fhir/composition-status";
3639            case CANCELLED: return "http://hl7.org/fhir/composition-status";
3640            case ENTEREDINERROR: return "http://hl7.org/fhir/composition-status";
3641            case DEPRECATED: return "http://hl7.org/fhir/composition-status";
3642            case UNKNOWN: return "http://hl7.org/fhir/composition-status";
3643            case NULL: return null;
3644            default: return "?";
3645          }
3646        }
3647        public String getDefinition() {
3648          switch (this) {
3649            case REGISTERED: return "The existence of the composition is registered, but there is nothing yet available.";
3650            case PARTIAL: return "This is a partial (e.g. initial, interim or preliminary) composition: data in the composition may be incomplete or unverified.";
3651            case PRELIMINARY: return "Verified early results are available, but not all results are final.";
3652            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.";
3653            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.";
3654            case CORRECTED: return "Subsequent to being final, the composition content has been modified to correct an error in the composition or referenced results.";
3655            case APPENDED: return "Subsequent to being final, the composition content has been modified by adding new content. The existing content is unchanged.";
3656            case CANCELLED: return "The composition is unavailable because the measurement was not started or not completed (also sometimes called \"aborted\").";
3657            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.";
3658            case DEPRECATED: return "This composition has been withdrawn or superseded and should no longer be used.";
3659            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.";
3660            case NULL: return null;
3661            default: return "?";
3662          }
3663        }
3664        public String getDisplay() {
3665          switch (this) {
3666            case REGISTERED: return "Registered";
3667            case PARTIAL: return "Partial";
3668            case PRELIMINARY: return "Preliminary";
3669            case FINAL: return "Final";
3670            case AMENDED: return "Amended";
3671            case CORRECTED: return "Corrected";
3672            case APPENDED: return "Appended";
3673            case CANCELLED: return "Cancelled";
3674            case ENTEREDINERROR: return "Entered in Error";
3675            case DEPRECATED: return "Deprecated";
3676            case UNKNOWN: return "Unknown";
3677            case NULL: return null;
3678            default: return "?";
3679          }
3680        }
3681    }
3682
3683  public static class CompositionStatusEnumFactory implements EnumFactory<CompositionStatus> {
3684    public CompositionStatus fromCode(String codeString) throws IllegalArgumentException {
3685      if (codeString == null || "".equals(codeString))
3686            if (codeString == null || "".equals(codeString))
3687                return null;
3688        if ("registered".equals(codeString))
3689          return CompositionStatus.REGISTERED;
3690        if ("partial".equals(codeString))
3691          return CompositionStatus.PARTIAL;
3692        if ("preliminary".equals(codeString))
3693          return CompositionStatus.PRELIMINARY;
3694        if ("final".equals(codeString))
3695          return CompositionStatus.FINAL;
3696        if ("amended".equals(codeString))
3697          return CompositionStatus.AMENDED;
3698        if ("corrected".equals(codeString))
3699          return CompositionStatus.CORRECTED;
3700        if ("appended".equals(codeString))
3701          return CompositionStatus.APPENDED;
3702        if ("cancelled".equals(codeString))
3703          return CompositionStatus.CANCELLED;
3704        if ("entered-in-error".equals(codeString))
3705          return CompositionStatus.ENTEREDINERROR;
3706        if ("deprecated".equals(codeString))
3707          return CompositionStatus.DEPRECATED;
3708        if ("unknown".equals(codeString))
3709          return CompositionStatus.UNKNOWN;
3710        throw new IllegalArgumentException("Unknown CompositionStatus code '"+codeString+"'");
3711        }
3712
3713        public Enumeration<CompositionStatus> fromType(PrimitiveType<?> code) throws FHIRException {
3714          if (code == null)
3715            return null;
3716          if (code.isEmpty())
3717            return new Enumeration<CompositionStatus>(this, CompositionStatus.NULL, code);
3718          String codeString = ((PrimitiveType) code).asStringValue();
3719          if (codeString == null || "".equals(codeString))
3720            return new Enumeration<CompositionStatus>(this, CompositionStatus.NULL, code);
3721        if ("registered".equals(codeString))
3722          return new Enumeration<CompositionStatus>(this, CompositionStatus.REGISTERED, code);
3723        if ("partial".equals(codeString))
3724          return new Enumeration<CompositionStatus>(this, CompositionStatus.PARTIAL, code);
3725        if ("preliminary".equals(codeString))
3726          return new Enumeration<CompositionStatus>(this, CompositionStatus.PRELIMINARY, code);
3727        if ("final".equals(codeString))
3728          return new Enumeration<CompositionStatus>(this, CompositionStatus.FINAL, code);
3729        if ("amended".equals(codeString))
3730          return new Enumeration<CompositionStatus>(this, CompositionStatus.AMENDED, code);
3731        if ("corrected".equals(codeString))
3732          return new Enumeration<CompositionStatus>(this, CompositionStatus.CORRECTED, code);
3733        if ("appended".equals(codeString))
3734          return new Enumeration<CompositionStatus>(this, CompositionStatus.APPENDED, code);
3735        if ("cancelled".equals(codeString))
3736          return new Enumeration<CompositionStatus>(this, CompositionStatus.CANCELLED, code);
3737        if ("entered-in-error".equals(codeString))
3738          return new Enumeration<CompositionStatus>(this, CompositionStatus.ENTEREDINERROR, code);
3739        if ("deprecated".equals(codeString))
3740          return new Enumeration<CompositionStatus>(this, CompositionStatus.DEPRECATED, code);
3741        if ("unknown".equals(codeString))
3742          return new Enumeration<CompositionStatus>(this, CompositionStatus.UNKNOWN, code);
3743        throw new FHIRException("Unknown CompositionStatus code '"+codeString+"'");
3744        }
3745    public String toCode(CompositionStatus code) {
3746       if (code == CompositionStatus.NULL)
3747           return null;
3748       if (code == CompositionStatus.REGISTERED)
3749        return "registered";
3750      if (code == CompositionStatus.PARTIAL)
3751        return "partial";
3752      if (code == CompositionStatus.PRELIMINARY)
3753        return "preliminary";
3754      if (code == CompositionStatus.FINAL)
3755        return "final";
3756      if (code == CompositionStatus.AMENDED)
3757        return "amended";
3758      if (code == CompositionStatus.CORRECTED)
3759        return "corrected";
3760      if (code == CompositionStatus.APPENDED)
3761        return "appended";
3762      if (code == CompositionStatus.CANCELLED)
3763        return "cancelled";
3764      if (code == CompositionStatus.ENTEREDINERROR)
3765        return "entered-in-error";
3766      if (code == CompositionStatus.DEPRECATED)
3767        return "deprecated";
3768      if (code == CompositionStatus.UNKNOWN)
3769        return "unknown";
3770      return "?";
3771   }
3772    public String toSystem(CompositionStatus code) {
3773      return code.getSystem();
3774      }
3775    }
3776
3777    public enum ConceptMapRelationship {
3778        /**
3779         * The concepts are related to each other, but the exact relationship is not known.
3780         */
3781        RELATEDTO, 
3782        /**
3783         * The definitions of the concepts mean the same thing.
3784         */
3785        EQUIVALENT, 
3786        /**
3787         * The source concept is narrower in meaning than the target concept.
3788         */
3789        SOURCEISNARROWERTHANTARGET, 
3790        /**
3791         * The source concept is broader in meaning than the target concept.
3792         */
3793        SOURCEISBROADERTHANTARGET, 
3794        /**
3795         * This is an explicit assertion that the target concept is not related to the source concept.
3796         */
3797        NOTRELATEDTO, 
3798        /**
3799         * added to help the parsers
3800         */
3801        NULL;
3802        public static ConceptMapRelationship fromCode(String codeString) throws FHIRException {
3803            if (codeString == null || "".equals(codeString))
3804                return null;
3805        if ("related-to".equals(codeString))
3806          return RELATEDTO;
3807        if ("equivalent".equals(codeString))
3808          return EQUIVALENT;
3809        if ("source-is-narrower-than-target".equals(codeString))
3810          return SOURCEISNARROWERTHANTARGET;
3811        if ("source-is-broader-than-target".equals(codeString))
3812          return SOURCEISBROADERTHANTARGET;
3813        if ("not-related-to".equals(codeString))
3814          return NOTRELATEDTO;
3815        throw new FHIRException("Unknown ConceptMapRelationship code '"+codeString+"'");
3816        }
3817        public static boolean isValidCode(String codeString) {
3818            if (codeString == null || "".equals(codeString))
3819                return false;
3820          return Utilities.existsInList(codeString, "related-to", "equivalent", "source-is-narrower-than-target", "source-is-broader-than-target", "not-related-to");
3821        }
3822        public String toCode() {
3823          switch (this) {
3824            case RELATEDTO: return "related-to";
3825            case EQUIVALENT: return "equivalent";
3826            case SOURCEISNARROWERTHANTARGET: return "source-is-narrower-than-target";
3827            case SOURCEISBROADERTHANTARGET: return "source-is-broader-than-target";
3828            case NOTRELATEDTO: return "not-related-to";
3829            case NULL: return null;
3830            default: return "?";
3831          }
3832        }
3833        public String getSystem() {
3834          switch (this) {
3835            case RELATEDTO: return "http://hl7.org/fhir/concept-map-relationship";
3836            case EQUIVALENT: return "http://hl7.org/fhir/concept-map-relationship";
3837            case SOURCEISNARROWERTHANTARGET: return "http://hl7.org/fhir/concept-map-relationship";
3838            case SOURCEISBROADERTHANTARGET: return "http://hl7.org/fhir/concept-map-relationship";
3839            case NOTRELATEDTO: return "http://hl7.org/fhir/concept-map-relationship";
3840            case NULL: return null;
3841            default: return "?";
3842          }
3843        }
3844        public String getDefinition() {
3845          switch (this) {
3846            case RELATEDTO: return "The concepts are related to each other, but the exact relationship is not known.";
3847            case EQUIVALENT: return "The definitions of the concepts mean the same thing.";
3848            case SOURCEISNARROWERTHANTARGET: return "The source concept is narrower in meaning than the target concept.";
3849            case SOURCEISBROADERTHANTARGET: return "The source concept is broader in meaning than the target concept.";
3850            case NOTRELATEDTO: return "This is an explicit assertion that the target concept is not related to the source concept.";
3851            case NULL: return null;
3852            default: return "?";
3853          }
3854        }
3855        public String getDisplay() {
3856          switch (this) {
3857            case RELATEDTO: return "Related To";
3858            case EQUIVALENT: return "Equivalent";
3859            case SOURCEISNARROWERTHANTARGET: return "Source Is Narrower Than Target";
3860            case SOURCEISBROADERTHANTARGET: return "Source Is Broader Than Target";
3861            case NOTRELATEDTO: return "Not Related To";
3862            case NULL: return null;
3863            default: return "?";
3864          }
3865        }
3866        public String getSymbol() {
3867          switch (this) {
3868          case RELATEDTO: return "-";
3869          case EQUIVALENT: return "=";
3870          case SOURCEISNARROWERTHANTARGET: return "<";
3871          case SOURCEISBROADERTHANTARGET: return ">";
3872          case NOTRELATEDTO: return "!=";
3873          case NULL: return null;
3874          default: return "?";
3875        }
3876        }
3877    }
3878
3879  public static class ConceptMapRelationshipEnumFactory implements EnumFactory<ConceptMapRelationship> {
3880    public ConceptMapRelationship fromCode(String codeString) throws IllegalArgumentException {
3881      if (codeString == null || "".equals(codeString))
3882            if (codeString == null || "".equals(codeString))
3883                return null;
3884        if ("related-to".equals(codeString))
3885          return ConceptMapRelationship.RELATEDTO;
3886        if ("equivalent".equals(codeString))
3887          return ConceptMapRelationship.EQUIVALENT;
3888        if ("source-is-narrower-than-target".equals(codeString))
3889          return ConceptMapRelationship.SOURCEISNARROWERTHANTARGET;
3890        if ("source-is-broader-than-target".equals(codeString))
3891          return ConceptMapRelationship.SOURCEISBROADERTHANTARGET;
3892        if ("not-related-to".equals(codeString))
3893          return ConceptMapRelationship.NOTRELATEDTO;
3894        throw new IllegalArgumentException("Unknown ConceptMapRelationship code '"+codeString+"'");
3895        }
3896
3897        public Enumeration<ConceptMapRelationship> fromType(PrimitiveType<?> code) throws FHIRException {
3898          if (code == null)
3899            return null;
3900          if (code.isEmpty())
3901            return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NULL, code);
3902          String codeString = ((PrimitiveType) code).asStringValue();
3903          if (codeString == null || "".equals(codeString))
3904            return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NULL, code);
3905        if ("related-to".equals(codeString))
3906          return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.RELATEDTO, code);
3907        if ("equivalent".equals(codeString))
3908          return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.EQUIVALENT, code);
3909        if ("source-is-narrower-than-target".equals(codeString))
3910          return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.SOURCEISNARROWERTHANTARGET, code);
3911        if ("source-is-broader-than-target".equals(codeString))
3912          return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.SOURCEISBROADERTHANTARGET, code);
3913        if ("not-related-to".equals(codeString))
3914          return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NOTRELATEDTO, code);
3915        throw new FHIRException("Unknown ConceptMapRelationship code '"+codeString+"'");
3916        }
3917    public String toCode(ConceptMapRelationship code) {
3918       if (code == ConceptMapRelationship.NULL)
3919           return null;
3920       if (code == ConceptMapRelationship.RELATEDTO)
3921        return "related-to";
3922      if (code == ConceptMapRelationship.EQUIVALENT)
3923        return "equivalent";
3924      if (code == ConceptMapRelationship.SOURCEISNARROWERTHANTARGET)
3925        return "source-is-narrower-than-target";
3926      if (code == ConceptMapRelationship.SOURCEISBROADERTHANTARGET)
3927        return "source-is-broader-than-target";
3928      if (code == ConceptMapRelationship.NOTRELATEDTO)
3929        return "not-related-to";
3930      return "?";
3931   }
3932    public String toSystem(ConceptMapRelationship code) {
3933      return code.getSystem();
3934      }
3935    }
3936
3937    public enum ConsentDataMeaning {
3938        /**
3939         * The consent applies directly to the instance of the resource.
3940         */
3941        INSTANCE, 
3942        /**
3943         * The consent applies directly to the instance of the resource and instances it refers to.
3944         */
3945        RELATED, 
3946        /**
3947         * The consent applies directly to the instance of the resource and instances that refer to it.
3948         */
3949        DEPENDENTS, 
3950        /**
3951         * The consent applies to instances of resources that are authored by.
3952         */
3953        AUTHOREDBY, 
3954        /**
3955         * added to help the parsers
3956         */
3957        NULL;
3958        public static ConsentDataMeaning fromCode(String codeString) throws FHIRException {
3959            if (codeString == null || "".equals(codeString))
3960                return null;
3961        if ("instance".equals(codeString))
3962          return INSTANCE;
3963        if ("related".equals(codeString))
3964          return RELATED;
3965        if ("dependents".equals(codeString))
3966          return DEPENDENTS;
3967        if ("authoredby".equals(codeString))
3968          return AUTHOREDBY;
3969        throw new FHIRException("Unknown ConsentDataMeaning code '"+codeString+"'");
3970        }
3971        public static boolean isValidCode(String codeString) {
3972            if (codeString == null || "".equals(codeString))
3973                return false;
3974          return Utilities.existsInList(codeString, "instance", "related", "dependents", "authoredby");
3975        }
3976        public String toCode() {
3977          switch (this) {
3978            case INSTANCE: return "instance";
3979            case RELATED: return "related";
3980            case DEPENDENTS: return "dependents";
3981            case AUTHOREDBY: return "authoredby";
3982            case NULL: return null;
3983            default: return "?";
3984          }
3985        }
3986        public String getSystem() {
3987          switch (this) {
3988            case INSTANCE: return "http://hl7.org/fhir/consent-data-meaning";
3989            case RELATED: return "http://hl7.org/fhir/consent-data-meaning";
3990            case DEPENDENTS: return "http://hl7.org/fhir/consent-data-meaning";
3991            case AUTHOREDBY: return "http://hl7.org/fhir/consent-data-meaning";
3992            case NULL: return null;
3993            default: return "?";
3994          }
3995        }
3996        public String getDefinition() {
3997          switch (this) {
3998            case INSTANCE: return "The consent applies directly to the instance of the resource.";
3999            case RELATED: return "The consent applies directly to the instance of the resource and instances it refers to.";
4000            case DEPENDENTS: return "The consent applies directly to the instance of the resource and instances that refer to it.";
4001            case AUTHOREDBY: return "The consent applies to instances of resources that are authored by.";
4002            case NULL: return null;
4003            default: return "?";
4004          }
4005        }
4006        public String getDisplay() {
4007          switch (this) {
4008            case INSTANCE: return "Instance";
4009            case RELATED: return "Related";
4010            case DEPENDENTS: return "Dependents";
4011            case AUTHOREDBY: return "AuthoredBy";
4012            case NULL: return null;
4013            default: return "?";
4014          }
4015        }
4016    }
4017
4018  public static class ConsentDataMeaningEnumFactory implements EnumFactory<ConsentDataMeaning> {
4019    public ConsentDataMeaning fromCode(String codeString) throws IllegalArgumentException {
4020      if (codeString == null || "".equals(codeString))
4021            if (codeString == null || "".equals(codeString))
4022                return null;
4023        if ("instance".equals(codeString))
4024          return ConsentDataMeaning.INSTANCE;
4025        if ("related".equals(codeString))
4026          return ConsentDataMeaning.RELATED;
4027        if ("dependents".equals(codeString))
4028          return ConsentDataMeaning.DEPENDENTS;
4029        if ("authoredby".equals(codeString))
4030          return ConsentDataMeaning.AUTHOREDBY;
4031        throw new IllegalArgumentException("Unknown ConsentDataMeaning code '"+codeString+"'");
4032        }
4033
4034        public Enumeration<ConsentDataMeaning> fromType(PrimitiveType<?> code) throws FHIRException {
4035          if (code == null)
4036            return null;
4037          if (code.isEmpty())
4038            return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.NULL, code);
4039          String codeString = ((PrimitiveType) code).asStringValue();
4040          if (codeString == null || "".equals(codeString))
4041            return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.NULL, code);
4042        if ("instance".equals(codeString))
4043          return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.INSTANCE, code);
4044        if ("related".equals(codeString))
4045          return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.RELATED, code);
4046        if ("dependents".equals(codeString))
4047          return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.DEPENDENTS, code);
4048        if ("authoredby".equals(codeString))
4049          return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.AUTHOREDBY, code);
4050        throw new FHIRException("Unknown ConsentDataMeaning code '"+codeString+"'");
4051        }
4052    public String toCode(ConsentDataMeaning code) {
4053       if (code == ConsentDataMeaning.NULL)
4054           return null;
4055       if (code == ConsentDataMeaning.INSTANCE)
4056        return "instance";
4057      if (code == ConsentDataMeaning.RELATED)
4058        return "related";
4059      if (code == ConsentDataMeaning.DEPENDENTS)
4060        return "dependents";
4061      if (code == ConsentDataMeaning.AUTHOREDBY)
4062        return "authoredby";
4063      return "?";
4064   }
4065    public String toSystem(ConsentDataMeaning code) {
4066      return code.getSystem();
4067      }
4068    }
4069
4070    public enum ConsentProvisionType {
4071        /**
4072         * Consent is denied for actions meeting these rules.
4073         */
4074        DENY, 
4075        /**
4076         * Consent is provided for actions meeting these rules.
4077         */
4078        PERMIT, 
4079        /**
4080         * added to help the parsers
4081         */
4082        NULL;
4083        public static ConsentProvisionType fromCode(String codeString) throws FHIRException {
4084            if (codeString == null || "".equals(codeString))
4085                return null;
4086        if ("deny".equals(codeString))
4087          return DENY;
4088        if ("permit".equals(codeString))
4089          return PERMIT;
4090        throw new FHIRException("Unknown ConsentProvisionType code '"+codeString+"'");
4091        }
4092        public static boolean isValidCode(String codeString) {
4093            if (codeString == null || "".equals(codeString))
4094                return false;
4095          return Utilities.existsInList(codeString, "deny", "permit");
4096        }
4097        public String toCode() {
4098          switch (this) {
4099            case DENY: return "deny";
4100            case PERMIT: return "permit";
4101            case NULL: return null;
4102            default: return "?";
4103          }
4104        }
4105        public String getSystem() {
4106          switch (this) {
4107            case DENY: return "http://hl7.org/fhir/consent-provision-type";
4108            case PERMIT: return "http://hl7.org/fhir/consent-provision-type";
4109            case NULL: return null;
4110            default: return "?";
4111          }
4112        }
4113        public String getDefinition() {
4114          switch (this) {
4115            case DENY: return "Consent is denied for actions meeting these rules.";
4116            case PERMIT: return "Consent is provided for actions meeting these rules.";
4117            case NULL: return null;
4118            default: return "?";
4119          }
4120        }
4121        public String getDisplay() {
4122          switch (this) {
4123            case DENY: return "Deny";
4124            case PERMIT: return "Permit";
4125            case NULL: return null;
4126            default: return "?";
4127          }
4128        }
4129    }
4130
4131  public static class ConsentProvisionTypeEnumFactory implements EnumFactory<ConsentProvisionType> {
4132    public ConsentProvisionType fromCode(String codeString) throws IllegalArgumentException {
4133      if (codeString == null || "".equals(codeString))
4134            if (codeString == null || "".equals(codeString))
4135                return null;
4136        if ("deny".equals(codeString))
4137          return ConsentProvisionType.DENY;
4138        if ("permit".equals(codeString))
4139          return ConsentProvisionType.PERMIT;
4140        throw new IllegalArgumentException("Unknown ConsentProvisionType code '"+codeString+"'");
4141        }
4142
4143        public Enumeration<ConsentProvisionType> fromType(PrimitiveType<?> code) throws FHIRException {
4144          if (code == null)
4145            return null;
4146          if (code.isEmpty())
4147            return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.NULL, code);
4148          String codeString = ((PrimitiveType) code).asStringValue();
4149          if (codeString == null || "".equals(codeString))
4150            return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.NULL, code);
4151        if ("deny".equals(codeString))
4152          return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.DENY, code);
4153        if ("permit".equals(codeString))
4154          return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.PERMIT, code);
4155        throw new FHIRException("Unknown ConsentProvisionType code '"+codeString+"'");
4156        }
4157    public String toCode(ConsentProvisionType code) {
4158       if (code == ConsentProvisionType.NULL)
4159           return null;
4160       if (code == ConsentProvisionType.DENY)
4161        return "deny";
4162      if (code == ConsentProvisionType.PERMIT)
4163        return "permit";
4164      return "?";
4165   }
4166    public String toSystem(ConsentProvisionType code) {
4167      return code.getSystem();
4168      }
4169    }
4170
4171    public enum Currencies {
4172        /**
4173         * null
4174         */
4175        AED, 
4176        /**
4177         * null
4178         */
4179        AFN, 
4180        /**
4181         * null
4182         */
4183        ALL, 
4184        /**
4185         * null
4186         */
4187        AMD, 
4188        /**
4189         * null
4190         */
4191        ANG, 
4192        /**
4193         * null
4194         */
4195        AOA, 
4196        /**
4197         * null
4198         */
4199        ARS, 
4200        /**
4201         * null
4202         */
4203        AUD, 
4204        /**
4205         * null
4206         */
4207        AWG, 
4208        /**
4209         * null
4210         */
4211        AZN, 
4212        /**
4213         * null
4214         */
4215        BAM, 
4216        /**
4217         * null
4218         */
4219        BBD, 
4220        /**
4221         * null
4222         */
4223        BDT, 
4224        /**
4225         * null
4226         */
4227        BGN, 
4228        /**
4229         * null
4230         */
4231        BHD, 
4232        /**
4233         * null
4234         */
4235        BIF, 
4236        /**
4237         * null
4238         */
4239        BMD, 
4240        /**
4241         * null
4242         */
4243        BND, 
4244        /**
4245         * null
4246         */
4247        BOB, 
4248        /**
4249         * null
4250         */
4251        BOV, 
4252        /**
4253         * null
4254         */
4255        BRL, 
4256        /**
4257         * null
4258         */
4259        BSD, 
4260        /**
4261         * null
4262         */
4263        BTN, 
4264        /**
4265         * null
4266         */
4267        BWP, 
4268        /**
4269         * null
4270         */
4271        BYN, 
4272        /**
4273         * null
4274         */
4275        BZD, 
4276        /**
4277         * null
4278         */
4279        CAD, 
4280        /**
4281         * null
4282         */
4283        CDF, 
4284        /**
4285         * null
4286         */
4287        CHE, 
4288        /**
4289         * null
4290         */
4291        CHF, 
4292        /**
4293         * null
4294         */
4295        CHW, 
4296        /**
4297         * null
4298         */
4299        CLF, 
4300        /**
4301         * null
4302         */
4303        CLP, 
4304        /**
4305         * null
4306         */
4307        CNY, 
4308        /**
4309         * null
4310         */
4311        COP, 
4312        /**
4313         * null
4314         */
4315        COU, 
4316        /**
4317         * null
4318         */
4319        CRC, 
4320        /**
4321         * null
4322         */
4323        CUC, 
4324        /**
4325         * null
4326         */
4327        CUP, 
4328        /**
4329         * null
4330         */
4331        CVE, 
4332        /**
4333         * null
4334         */
4335        CZK, 
4336        /**
4337         * null
4338         */
4339        DJF, 
4340        /**
4341         * null
4342         */
4343        DKK, 
4344        /**
4345         * null
4346         */
4347        DOP, 
4348        /**
4349         * null
4350         */
4351        DZD, 
4352        /**
4353         * null
4354         */
4355        EGP, 
4356        /**
4357         * null
4358         */
4359        ERN, 
4360        /**
4361         * null
4362         */
4363        ETB, 
4364        /**
4365         * null
4366         */
4367        EUR, 
4368        /**
4369         * null
4370         */
4371        FJD, 
4372        /**
4373         * null
4374         */
4375        FKP, 
4376        /**
4377         * null
4378         */
4379        GBP, 
4380        /**
4381         * null
4382         */
4383        GEL, 
4384        /**
4385         * null
4386         */
4387        GGP, 
4388        /**
4389         * null
4390         */
4391        GHS, 
4392        /**
4393         * null
4394         */
4395        GIP, 
4396        /**
4397         * null
4398         */
4399        GMD, 
4400        /**
4401         * null
4402         */
4403        GNF, 
4404        /**
4405         * null
4406         */
4407        GTQ, 
4408        /**
4409         * null
4410         */
4411        GYD, 
4412        /**
4413         * null
4414         */
4415        HKD, 
4416        /**
4417         * null
4418         */
4419        HNL, 
4420        /**
4421         * null
4422         */
4423        HRK, 
4424        /**
4425         * null
4426         */
4427        HTG, 
4428        /**
4429         * null
4430         */
4431        HUF, 
4432        /**
4433         * null
4434         */
4435        IDR, 
4436        /**
4437         * null
4438         */
4439        ILS, 
4440        /**
4441         * null
4442         */
4443        IMP, 
4444        /**
4445         * null
4446         */
4447        INR, 
4448        /**
4449         * null
4450         */
4451        IQD, 
4452        /**
4453         * null
4454         */
4455        IRR, 
4456        /**
4457         * null
4458         */
4459        ISK, 
4460        /**
4461         * null
4462         */
4463        JEP, 
4464        /**
4465         * null
4466         */
4467        JMD, 
4468        /**
4469         * null
4470         */
4471        JOD, 
4472        /**
4473         * null
4474         */
4475        JPY, 
4476        /**
4477         * null
4478         */
4479        KES, 
4480        /**
4481         * null
4482         */
4483        KGS, 
4484        /**
4485         * null
4486         */
4487        KHR, 
4488        /**
4489         * null
4490         */
4491        KMF, 
4492        /**
4493         * null
4494         */
4495        KPW, 
4496        /**
4497         * null
4498         */
4499        KRW, 
4500        /**
4501         * null
4502         */
4503        KWD, 
4504        /**
4505         * null
4506         */
4507        KYD, 
4508        /**
4509         * null
4510         */
4511        KZT, 
4512        /**
4513         * null
4514         */
4515        LAK, 
4516        /**
4517         * null
4518         */
4519        LBP, 
4520        /**
4521         * null
4522         */
4523        LKR, 
4524        /**
4525         * null
4526         */
4527        LRD, 
4528        /**
4529         * null
4530         */
4531        LSL, 
4532        /**
4533         * null
4534         */
4535        LYD, 
4536        /**
4537         * null
4538         */
4539        MAD, 
4540        /**
4541         * null
4542         */
4543        MDL, 
4544        /**
4545         * null
4546         */
4547        MGA, 
4548        /**
4549         * null
4550         */
4551        MKD, 
4552        /**
4553         * null
4554         */
4555        MMK, 
4556        /**
4557         * null
4558         */
4559        MNT, 
4560        /**
4561         * null
4562         */
4563        MOP, 
4564        /**
4565         * null
4566         */
4567        MRU, 
4568        /**
4569         * null
4570         */
4571        MUR, 
4572        /**
4573         * null
4574         */
4575        MVR, 
4576        /**
4577         * null
4578         */
4579        MWK, 
4580        /**
4581         * null
4582         */
4583        MXN, 
4584        /**
4585         * null
4586         */
4587        MXV, 
4588        /**
4589         * null
4590         */
4591        MYR, 
4592        /**
4593         * null
4594         */
4595        MZN, 
4596        /**
4597         * null
4598         */
4599        NAD, 
4600        /**
4601         * null
4602         */
4603        NGN, 
4604        /**
4605         * null
4606         */
4607        NIO, 
4608        /**
4609         * null
4610         */
4611        NOK, 
4612        /**
4613         * null
4614         */
4615        NPR, 
4616        /**
4617         * null
4618         */
4619        NZD, 
4620        /**
4621         * null
4622         */
4623        OMR, 
4624        /**
4625         * null
4626         */
4627        PAB, 
4628        /**
4629         * null
4630         */
4631        PEN, 
4632        /**
4633         * null
4634         */
4635        PGK, 
4636        /**
4637         * null
4638         */
4639        PHP, 
4640        /**
4641         * null
4642         */
4643        PKR, 
4644        /**
4645         * null
4646         */
4647        PLN, 
4648        /**
4649         * null
4650         */
4651        PYG, 
4652        /**
4653         * null
4654         */
4655        QAR, 
4656        /**
4657         * null
4658         */
4659        RON, 
4660        /**
4661         * null
4662         */
4663        RSD, 
4664        /**
4665         * null
4666         */
4667        RUB, 
4668        /**
4669         * null
4670         */
4671        RWF, 
4672        /**
4673         * null
4674         */
4675        SAR, 
4676        /**
4677         * null
4678         */
4679        SBD, 
4680        /**
4681         * null
4682         */
4683        SCR, 
4684        /**
4685         * null
4686         */
4687        SDG, 
4688        /**
4689         * null
4690         */
4691        SEK, 
4692        /**
4693         * null
4694         */
4695        SGD, 
4696        /**
4697         * null
4698         */
4699        SHP, 
4700        /**
4701         * null
4702         */
4703        SLL, 
4704        /**
4705         * null
4706         */
4707        SOS, 
4708        /**
4709         * null
4710         */
4711        SRD, 
4712        /**
4713         * null
4714         */
4715        SSP, 
4716        /**
4717         * null
4718         */
4719        STN, 
4720        /**
4721         * null
4722         */
4723        SVC, 
4724        /**
4725         * null
4726         */
4727        SYP, 
4728        /**
4729         * null
4730         */
4731        SZL, 
4732        /**
4733         * null
4734         */
4735        THB, 
4736        /**
4737         * null
4738         */
4739        TJS, 
4740        /**
4741         * null
4742         */
4743        TMT, 
4744        /**
4745         * null
4746         */
4747        TND, 
4748        /**
4749         * null
4750         */
4751        TOP, 
4752        /**
4753         * null
4754         */
4755        TRY, 
4756        /**
4757         * null
4758         */
4759        TTD, 
4760        /**
4761         * null
4762         */
4763        TVD, 
4764        /**
4765         * null
4766         */
4767        TWD, 
4768        /**
4769         * null
4770         */
4771        TZS, 
4772        /**
4773         * null
4774         */
4775        UAH, 
4776        /**
4777         * null
4778         */
4779        UGX, 
4780        /**
4781         * null
4782         */
4783        USD, 
4784        /**
4785         * null
4786         */
4787        USN, 
4788        /**
4789         * null
4790         */
4791        UYI, 
4792        /**
4793         * null
4794         */
4795        UYU, 
4796        /**
4797         * null
4798         */
4799        UZS, 
4800        /**
4801         * null
4802         */
4803        VEF, 
4804        /**
4805         * null
4806         */
4807        VND, 
4808        /**
4809         * null
4810         */
4811        VUV, 
4812        /**
4813         * null
4814         */
4815        WST, 
4816        /**
4817         * null
4818         */
4819        XAF, 
4820        /**
4821         * null
4822         */
4823        XAG, 
4824        /**
4825         * null
4826         */
4827        XAU, 
4828        /**
4829         * null
4830         */
4831        XBA, 
4832        /**
4833         * null
4834         */
4835        XBB, 
4836        /**
4837         * null
4838         */
4839        XBC, 
4840        /**
4841         * null
4842         */
4843        XBD, 
4844        /**
4845         * null
4846         */
4847        XCD, 
4848        /**
4849         * null
4850         */
4851        XDR, 
4852        /**
4853         * null
4854         */
4855        XOF, 
4856        /**
4857         * null
4858         */
4859        XPD, 
4860        /**
4861         * null
4862         */
4863        XPF, 
4864        /**
4865         * null
4866         */
4867        XPT, 
4868        /**
4869         * null
4870         */
4871        XSU, 
4872        /**
4873         * null
4874         */
4875        XTS, 
4876        /**
4877         * null
4878         */
4879        XUA, 
4880        /**
4881         * null
4882         */
4883        XXX, 
4884        /**
4885         * null
4886         */
4887        YER, 
4888        /**
4889         * null
4890         */
4891        ZAR, 
4892        /**
4893         * null
4894         */
4895        ZMW, 
4896        /**
4897         * null
4898         */
4899        ZWL, 
4900        /**
4901         * added to help the parsers
4902         */
4903        NULL;
4904        public static Currencies fromCode(String codeString) throws FHIRException {
4905            if (codeString == null || "".equals(codeString))
4906                return null;
4907        if ("AED".equals(codeString))
4908          return AED;
4909        if ("AFN".equals(codeString))
4910          return AFN;
4911        if ("ALL".equals(codeString))
4912          return ALL;
4913        if ("AMD".equals(codeString))
4914          return AMD;
4915        if ("ANG".equals(codeString))
4916          return ANG;
4917        if ("AOA".equals(codeString))
4918          return AOA;
4919        if ("ARS".equals(codeString))
4920          return ARS;
4921        if ("AUD".equals(codeString))
4922          return AUD;
4923        if ("AWG".equals(codeString))
4924          return AWG;
4925        if ("AZN".equals(codeString))
4926          return AZN;
4927        if ("BAM".equals(codeString))
4928          return BAM;
4929        if ("BBD".equals(codeString))
4930          return BBD;
4931        if ("BDT".equals(codeString))
4932          return BDT;
4933        if ("BGN".equals(codeString))
4934          return BGN;
4935        if ("BHD".equals(codeString))
4936          return BHD;
4937        if ("BIF".equals(codeString))
4938          return BIF;
4939        if ("BMD".equals(codeString))
4940          return BMD;
4941        if ("BND".equals(codeString))
4942          return BND;
4943        if ("BOB".equals(codeString))
4944          return BOB;
4945        if ("BOV".equals(codeString))
4946          return BOV;
4947        if ("BRL".equals(codeString))
4948          return BRL;
4949        if ("BSD".equals(codeString))
4950          return BSD;
4951        if ("BTN".equals(codeString))
4952          return BTN;
4953        if ("BWP".equals(codeString))
4954          return BWP;
4955        if ("BYN".equals(codeString))
4956          return BYN;
4957        if ("BZD".equals(codeString))
4958          return BZD;
4959        if ("CAD".equals(codeString))
4960          return CAD;
4961        if ("CDF".equals(codeString))
4962          return CDF;
4963        if ("CHE".equals(codeString))
4964          return CHE;
4965        if ("CHF".equals(codeString))
4966          return CHF;
4967        if ("CHW".equals(codeString))
4968          return CHW;
4969        if ("CLF".equals(codeString))
4970          return CLF;
4971        if ("CLP".equals(codeString))
4972          return CLP;
4973        if ("CNY".equals(codeString))
4974          return CNY;
4975        if ("COP".equals(codeString))
4976          return COP;
4977        if ("COU".equals(codeString))
4978          return COU;
4979        if ("CRC".equals(codeString))
4980          return CRC;
4981        if ("CUC".equals(codeString))
4982          return CUC;
4983        if ("CUP".equals(codeString))
4984          return CUP;
4985        if ("CVE".equals(codeString))
4986          return CVE;
4987        if ("CZK".equals(codeString))
4988          return CZK;
4989        if ("DJF".equals(codeString))
4990          return DJF;
4991        if ("DKK".equals(codeString))
4992          return DKK;
4993        if ("DOP".equals(codeString))
4994          return DOP;
4995        if ("DZD".equals(codeString))
4996          return DZD;
4997        if ("EGP".equals(codeString))
4998          return EGP;
4999        if ("ERN".equals(codeString))
5000          return ERN;
5001        if ("ETB".equals(codeString))
5002          return ETB;
5003        if ("EUR".equals(codeString))
5004          return EUR;
5005        if ("FJD".equals(codeString))
5006          return FJD;
5007        if ("FKP".equals(codeString))
5008          return FKP;
5009        if ("GBP".equals(codeString))
5010          return GBP;
5011        if ("GEL".equals(codeString))
5012          return GEL;
5013        if ("GGP".equals(codeString))
5014          return GGP;
5015        if ("GHS".equals(codeString))
5016          return GHS;
5017        if ("GIP".equals(codeString))
5018          return GIP;
5019        if ("GMD".equals(codeString))
5020          return GMD;
5021        if ("GNF".equals(codeString))
5022          return GNF;
5023        if ("GTQ".equals(codeString))
5024          return GTQ;
5025        if ("GYD".equals(codeString))
5026          return GYD;
5027        if ("HKD".equals(codeString))
5028          return HKD;
5029        if ("HNL".equals(codeString))
5030          return HNL;
5031        if ("HRK".equals(codeString))
5032          return HRK;
5033        if ("HTG".equals(codeString))
5034          return HTG;
5035        if ("HUF".equals(codeString))
5036          return HUF;
5037        if ("IDR".equals(codeString))
5038          return IDR;
5039        if ("ILS".equals(codeString))
5040          return ILS;
5041        if ("IMP".equals(codeString))
5042          return IMP;
5043        if ("INR".equals(codeString))
5044          return INR;
5045        if ("IQD".equals(codeString))
5046          return IQD;
5047        if ("IRR".equals(codeString))
5048          return IRR;
5049        if ("ISK".equals(codeString))
5050          return ISK;
5051        if ("JEP".equals(codeString))
5052          return JEP;
5053        if ("JMD".equals(codeString))
5054          return JMD;
5055        if ("JOD".equals(codeString))
5056          return JOD;
5057        if ("JPY".equals(codeString))
5058          return JPY;
5059        if ("KES".equals(codeString))
5060          return KES;
5061        if ("KGS".equals(codeString))
5062          return KGS;
5063        if ("KHR".equals(codeString))
5064          return KHR;
5065        if ("KMF".equals(codeString))
5066          return KMF;
5067        if ("KPW".equals(codeString))
5068          return KPW;
5069        if ("KRW".equals(codeString))
5070          return KRW;
5071        if ("KWD".equals(codeString))
5072          return KWD;
5073        if ("KYD".equals(codeString))
5074          return KYD;
5075        if ("KZT".equals(codeString))
5076          return KZT;
5077        if ("LAK".equals(codeString))
5078          return LAK;
5079        if ("LBP".equals(codeString))
5080          return LBP;
5081        if ("LKR".equals(codeString))
5082          return LKR;
5083        if ("LRD".equals(codeString))
5084          return LRD;
5085        if ("LSL".equals(codeString))
5086          return LSL;
5087        if ("LYD".equals(codeString))
5088          return LYD;
5089        if ("MAD".equals(codeString))
5090          return MAD;
5091        if ("MDL".equals(codeString))
5092          return MDL;
5093        if ("MGA".equals(codeString))
5094          return MGA;
5095        if ("MKD".equals(codeString))
5096          return MKD;
5097        if ("MMK".equals(codeString))
5098          return MMK;
5099        if ("MNT".equals(codeString))
5100          return MNT;
5101        if ("MOP".equals(codeString))
5102          return MOP;
5103        if ("MRU".equals(codeString))
5104          return MRU;
5105        if ("MUR".equals(codeString))
5106          return MUR;
5107        if ("MVR".equals(codeString))
5108          return MVR;
5109        if ("MWK".equals(codeString))
5110          return MWK;
5111        if ("MXN".equals(codeString))
5112          return MXN;
5113        if ("MXV".equals(codeString))
5114          return MXV;
5115        if ("MYR".equals(codeString))
5116          return MYR;
5117        if ("MZN".equals(codeString))
5118          return MZN;
5119        if ("NAD".equals(codeString))
5120          return NAD;
5121        if ("NGN".equals(codeString))
5122          return NGN;
5123        if ("NIO".equals(codeString))
5124          return NIO;
5125        if ("NOK".equals(codeString))
5126          return NOK;
5127        if ("NPR".equals(codeString))
5128          return NPR;
5129        if ("NZD".equals(codeString))
5130          return NZD;
5131        if ("OMR".equals(codeString))
5132          return OMR;
5133        if ("PAB".equals(codeString))
5134          return PAB;
5135        if ("PEN".equals(codeString))
5136          return PEN;
5137        if ("PGK".equals(codeString))
5138          return PGK;
5139        if ("PHP".equals(codeString))
5140          return PHP;
5141        if ("PKR".equals(codeString))
5142          return PKR;
5143        if ("PLN".equals(codeString))
5144          return PLN;
5145        if ("PYG".equals(codeString))
5146          return PYG;
5147        if ("QAR".equals(codeString))
5148          return QAR;
5149        if ("RON".equals(codeString))
5150          return RON;
5151        if ("RSD".equals(codeString))
5152          return RSD;
5153        if ("RUB".equals(codeString))
5154          return RUB;
5155        if ("RWF".equals(codeString))
5156          return RWF;
5157        if ("SAR".equals(codeString))
5158          return SAR;
5159        if ("SBD".equals(codeString))
5160          return SBD;
5161        if ("SCR".equals(codeString))
5162          return SCR;
5163        if ("SDG".equals(codeString))
5164          return SDG;
5165        if ("SEK".equals(codeString))
5166          return SEK;
5167        if ("SGD".equals(codeString))
5168          return SGD;
5169        if ("SHP".equals(codeString))
5170          return SHP;
5171        if ("SLL".equals(codeString))
5172          return SLL;
5173        if ("SOS".equals(codeString))
5174          return SOS;
5175        if ("SRD".equals(codeString))
5176          return SRD;
5177        if ("SSP".equals(codeString))
5178          return SSP;
5179        if ("STN".equals(codeString))
5180          return STN;
5181        if ("SVC".equals(codeString))
5182          return SVC;
5183        if ("SYP".equals(codeString))
5184          return SYP;
5185        if ("SZL".equals(codeString))
5186          return SZL;
5187        if ("THB".equals(codeString))
5188          return THB;
5189        if ("TJS".equals(codeString))
5190          return TJS;
5191        if ("TMT".equals(codeString))
5192          return TMT;
5193        if ("TND".equals(codeString))
5194          return TND;
5195        if ("TOP".equals(codeString))
5196          return TOP;
5197        if ("TRY".equals(codeString))
5198          return TRY;
5199        if ("TTD".equals(codeString))
5200          return TTD;
5201        if ("TVD".equals(codeString))
5202          return TVD;
5203        if ("TWD".equals(codeString))
5204          return TWD;
5205        if ("TZS".equals(codeString))
5206          return TZS;
5207        if ("UAH".equals(codeString))
5208          return UAH;
5209        if ("UGX".equals(codeString))
5210          return UGX;
5211        if ("USD".equals(codeString))
5212          return USD;
5213        if ("USN".equals(codeString))
5214          return USN;
5215        if ("UYI".equals(codeString))
5216          return UYI;
5217        if ("UYU".equals(codeString))
5218          return UYU;
5219        if ("UZS".equals(codeString))
5220          return UZS;
5221        if ("VEF".equals(codeString))
5222          return VEF;
5223        if ("VND".equals(codeString))
5224          return VND;
5225        if ("VUV".equals(codeString))
5226          return VUV;
5227        if ("WST".equals(codeString))
5228          return WST;
5229        if ("XAF".equals(codeString))
5230          return XAF;
5231        if ("XAG".equals(codeString))
5232          return XAG;
5233        if ("XAU".equals(codeString))
5234          return XAU;
5235        if ("XBA".equals(codeString))
5236          return XBA;
5237        if ("XBB".equals(codeString))
5238          return XBB;
5239        if ("XBC".equals(codeString))
5240          return XBC;
5241        if ("XBD".equals(codeString))
5242          return XBD;
5243        if ("XCD".equals(codeString))
5244          return XCD;
5245        if ("XDR".equals(codeString))
5246          return XDR;
5247        if ("XOF".equals(codeString))
5248          return XOF;
5249        if ("XPD".equals(codeString))
5250          return XPD;
5251        if ("XPF".equals(codeString))
5252          return XPF;
5253        if ("XPT".equals(codeString))
5254          return XPT;
5255        if ("XSU".equals(codeString))
5256          return XSU;
5257        if ("XTS".equals(codeString))
5258          return XTS;
5259        if ("XUA".equals(codeString))
5260          return XUA;
5261        if ("XXX".equals(codeString))
5262          return XXX;
5263        if ("YER".equals(codeString))
5264          return YER;
5265        if ("ZAR".equals(codeString))
5266          return ZAR;
5267        if ("ZMW".equals(codeString))
5268          return ZMW;
5269        if ("ZWL".equals(codeString))
5270          return ZWL;
5271        throw new FHIRException("Unknown Currencies code '"+codeString+"'");
5272        }
5273        public static boolean isValidCode(String codeString) {
5274            if (codeString == null || "".equals(codeString))
5275                return false;
5276          return Utilities.existsInList(codeString, "AED", "AFN", "ALL", "AMD", "ANG", "AOA", "ARS", "AUD", "AWG", "AZN", "BAM", "BBD", "BDT", "BGN", "BHD", "BIF", "BMD", "BND", "BOB", "BOV", "BRL", "BSD", "BTN", "BWP", "BYN", "BZD", "CAD", "CDF", "CHE", "CHF", "CHW", "CLF", "CLP", "CNY", "COP", "COU", "CRC", "CUC", "CUP", "CVE", "CZK", "DJF", "DKK", "DOP", "DZD", "EGP", "ERN", "ETB", "EUR", "FJD", "FKP", "GBP", "GEL", "GGP", "GHS", "GIP", "GMD", "GNF", "GTQ", "GYD", "HKD", "HNL", "HRK", "HTG", "HUF", "IDR", "ILS", "IMP", "INR", "IQD", "IRR", "ISK", "JEP", "JMD", "JOD", "JPY", "KES", "KGS", "KHR", "KMF", "KPW", "KRW", "KWD", "KYD", "KZT", "LAK", "LBP", "LKR", "LRD", "LSL", "LYD", "MAD", "MDL", "MGA", "MKD", "MMK", "MNT", "MOP", "MRU", "MUR", "MVR", "MWK", "MXN", "MXV", "MYR", "MZN", "NAD", "NGN", "NIO", "NOK", "NPR", "NZD", "OMR", "PAB", "PEN", "PGK", "PHP", "PKR", "PLN", "PYG", "QAR", "RON", "RSD", "RUB", "RWF", "SAR", "SBD", "SCR", "SDG", "SEK", "SGD", "SHP", "SLL", "SOS", "SRD", "SSP", "STN", "SVC", "SYP", "SZL", "THB", "TJS", "TMT", "TND", "TOP", "TRY", "TTD", "TVD", "TWD", "TZS", "UAH", "UGX", "USD", "USN", "UYI", "UYU", "UZS", "VEF", "VND", "VUV", "WST", "XAF", "XAG", "XAU", "XBA", "XBB", "XBC", "XBD", "XCD", "XDR", "XOF", "XPD", "XPF", "XPT", "XSU", "XTS", "XUA", "XXX", "YER", "ZAR", "ZMW", "ZWL");
5277        }
5278        public String toCode() {
5279          switch (this) {
5280            case AED: return "AED";
5281            case AFN: return "AFN";
5282            case ALL: return "ALL";
5283            case AMD: return "AMD";
5284            case ANG: return "ANG";
5285            case AOA: return "AOA";
5286            case ARS: return "ARS";
5287            case AUD: return "AUD";
5288            case AWG: return "AWG";
5289            case AZN: return "AZN";
5290            case BAM: return "BAM";
5291            case BBD: return "BBD";
5292            case BDT: return "BDT";
5293            case BGN: return "BGN";
5294            case BHD: return "BHD";
5295            case BIF: return "BIF";
5296            case BMD: return "BMD";
5297            case BND: return "BND";
5298            case BOB: return "BOB";
5299            case BOV: return "BOV";
5300            case BRL: return "BRL";
5301            case BSD: return "BSD";
5302            case BTN: return "BTN";
5303            case BWP: return "BWP";
5304            case BYN: return "BYN";
5305            case BZD: return "BZD";
5306            case CAD: return "CAD";
5307            case CDF: return "CDF";
5308            case CHE: return "CHE";
5309            case CHF: return "CHF";
5310            case CHW: return "CHW";
5311            case CLF: return "CLF";
5312            case CLP: return "CLP";
5313            case CNY: return "CNY";
5314            case COP: return "COP";
5315            case COU: return "COU";
5316            case CRC: return "CRC";
5317            case CUC: return "CUC";
5318            case CUP: return "CUP";
5319            case CVE: return "CVE";
5320            case CZK: return "CZK";
5321            case DJF: return "DJF";
5322            case DKK: return "DKK";
5323            case DOP: return "DOP";
5324            case DZD: return "DZD";
5325            case EGP: return "EGP";
5326            case ERN: return "ERN";
5327            case ETB: return "ETB";
5328            case EUR: return "EUR";
5329            case FJD: return "FJD";
5330            case FKP: return "FKP";
5331            case GBP: return "GBP";
5332            case GEL: return "GEL";
5333            case GGP: return "GGP";
5334            case GHS: return "GHS";
5335            case GIP: return "GIP";
5336            case GMD: return "GMD";
5337            case GNF: return "GNF";
5338            case GTQ: return "GTQ";
5339            case GYD: return "GYD";
5340            case HKD: return "HKD";
5341            case HNL: return "HNL";
5342            case HRK: return "HRK";
5343            case HTG: return "HTG";
5344            case HUF: return "HUF";
5345            case IDR: return "IDR";
5346            case ILS: return "ILS";
5347            case IMP: return "IMP";
5348            case INR: return "INR";
5349            case IQD: return "IQD";
5350            case IRR: return "IRR";
5351            case ISK: return "ISK";
5352            case JEP: return "JEP";
5353            case JMD: return "JMD";
5354            case JOD: return "JOD";
5355            case JPY: return "JPY";
5356            case KES: return "KES";
5357            case KGS: return "KGS";
5358            case KHR: return "KHR";
5359            case KMF: return "KMF";
5360            case KPW: return "KPW";
5361            case KRW: return "KRW";
5362            case KWD: return "KWD";
5363            case KYD: return "KYD";
5364            case KZT: return "KZT";
5365            case LAK: return "LAK";
5366            case LBP: return "LBP";
5367            case LKR: return "LKR";
5368            case LRD: return "LRD";
5369            case LSL: return "LSL";
5370            case LYD: return "LYD";
5371            case MAD: return "MAD";
5372            case MDL: return "MDL";
5373            case MGA: return "MGA";
5374            case MKD: return "MKD";
5375            case MMK: return "MMK";
5376            case MNT: return "MNT";
5377            case MOP: return "MOP";
5378            case MRU: return "MRU";
5379            case MUR: return "MUR";
5380            case MVR: return "MVR";
5381            case MWK: return "MWK";
5382            case MXN: return "MXN";
5383            case MXV: return "MXV";
5384            case MYR: return "MYR";
5385            case MZN: return "MZN";
5386            case NAD: return "NAD";
5387            case NGN: return "NGN";
5388            case NIO: return "NIO";
5389            case NOK: return "NOK";
5390            case NPR: return "NPR";
5391            case NZD: return "NZD";
5392            case OMR: return "OMR";
5393            case PAB: return "PAB";
5394            case PEN: return "PEN";
5395            case PGK: return "PGK";
5396            case PHP: return "PHP";
5397            case PKR: return "PKR";
5398            case PLN: return "PLN";
5399            case PYG: return "PYG";
5400            case QAR: return "QAR";
5401            case RON: return "RON";
5402            case RSD: return "RSD";
5403            case RUB: return "RUB";
5404            case RWF: return "RWF";
5405            case SAR: return "SAR";
5406            case SBD: return "SBD";
5407            case SCR: return "SCR";
5408            case SDG: return "SDG";
5409            case SEK: return "SEK";
5410            case SGD: return "SGD";
5411            case SHP: return "SHP";
5412            case SLL: return "SLL";
5413            case SOS: return "SOS";
5414            case SRD: return "SRD";
5415            case SSP: return "SSP";
5416            case STN: return "STN";
5417            case SVC: return "SVC";
5418            case SYP: return "SYP";
5419            case SZL: return "SZL";
5420            case THB: return "THB";
5421            case TJS: return "TJS";
5422            case TMT: return "TMT";
5423            case TND: return "TND";
5424            case TOP: return "TOP";
5425            case TRY: return "TRY";
5426            case TTD: return "TTD";
5427            case TVD: return "TVD";
5428            case TWD: return "TWD";
5429            case TZS: return "TZS";
5430            case UAH: return "UAH";
5431            case UGX: return "UGX";
5432            case USD: return "USD";
5433            case USN: return "USN";
5434            case UYI: return "UYI";
5435            case UYU: return "UYU";
5436            case UZS: return "UZS";
5437            case VEF: return "VEF";
5438            case VND: return "VND";
5439            case VUV: return "VUV";
5440            case WST: return "WST";
5441            case XAF: return "XAF";
5442            case XAG: return "XAG";
5443            case XAU: return "XAU";
5444            case XBA: return "XBA";
5445            case XBB: return "XBB";
5446            case XBC: return "XBC";
5447            case XBD: return "XBD";
5448            case XCD: return "XCD";
5449            case XDR: return "XDR";
5450            case XOF: return "XOF";
5451            case XPD: return "XPD";
5452            case XPF: return "XPF";
5453            case XPT: return "XPT";
5454            case XSU: return "XSU";
5455            case XTS: return "XTS";
5456            case XUA: return "XUA";
5457            case XXX: return "XXX";
5458            case YER: return "YER";
5459            case ZAR: return "ZAR";
5460            case ZMW: return "ZMW";
5461            case ZWL: return "ZWL";
5462            case NULL: return null;
5463            default: return "?";
5464          }
5465        }
5466        public String getSystem() {
5467          switch (this) {
5468            case AED: return "urn:iso:std:iso:4217";
5469            case AFN: return "urn:iso:std:iso:4217";
5470            case ALL: return "urn:iso:std:iso:4217";
5471            case AMD: return "urn:iso:std:iso:4217";
5472            case ANG: return "urn:iso:std:iso:4217";
5473            case AOA: return "urn:iso:std:iso:4217";
5474            case ARS: return "urn:iso:std:iso:4217";
5475            case AUD: return "urn:iso:std:iso:4217";
5476            case AWG: return "urn:iso:std:iso:4217";
5477            case AZN: return "urn:iso:std:iso:4217";
5478            case BAM: return "urn:iso:std:iso:4217";
5479            case BBD: return "urn:iso:std:iso:4217";
5480            case BDT: return "urn:iso:std:iso:4217";
5481            case BGN: return "urn:iso:std:iso:4217";
5482            case BHD: return "urn:iso:std:iso:4217";
5483            case BIF: return "urn:iso:std:iso:4217";
5484            case BMD: return "urn:iso:std:iso:4217";
5485            case BND: return "urn:iso:std:iso:4217";
5486            case BOB: return "urn:iso:std:iso:4217";
5487            case BOV: return "urn:iso:std:iso:4217";
5488            case BRL: return "urn:iso:std:iso:4217";
5489            case BSD: return "urn:iso:std:iso:4217";
5490            case BTN: return "urn:iso:std:iso:4217";
5491            case BWP: return "urn:iso:std:iso:4217";
5492            case BYN: return "urn:iso:std:iso:4217";
5493            case BZD: return "urn:iso:std:iso:4217";
5494            case CAD: return "urn:iso:std:iso:4217";
5495            case CDF: return "urn:iso:std:iso:4217";
5496            case CHE: return "urn:iso:std:iso:4217";
5497            case CHF: return "urn:iso:std:iso:4217";
5498            case CHW: return "urn:iso:std:iso:4217";
5499            case CLF: return "urn:iso:std:iso:4217";
5500            case CLP: return "urn:iso:std:iso:4217";
5501            case CNY: return "urn:iso:std:iso:4217";
5502            case COP: return "urn:iso:std:iso:4217";
5503            case COU: return "urn:iso:std:iso:4217";
5504            case CRC: return "urn:iso:std:iso:4217";
5505            case CUC: return "urn:iso:std:iso:4217";
5506            case CUP: return "urn:iso:std:iso:4217";
5507            case CVE: return "urn:iso:std:iso:4217";
5508            case CZK: return "urn:iso:std:iso:4217";
5509            case DJF: return "urn:iso:std:iso:4217";
5510            case DKK: return "urn:iso:std:iso:4217";
5511            case DOP: return "urn:iso:std:iso:4217";
5512            case DZD: return "urn:iso:std:iso:4217";
5513            case EGP: return "urn:iso:std:iso:4217";
5514            case ERN: return "urn:iso:std:iso:4217";
5515            case ETB: return "urn:iso:std:iso:4217";
5516            case EUR: return "urn:iso:std:iso:4217";
5517            case FJD: return "urn:iso:std:iso:4217";
5518            case FKP: return "urn:iso:std:iso:4217";
5519            case GBP: return "urn:iso:std:iso:4217";
5520            case GEL: return "urn:iso:std:iso:4217";
5521            case GGP: return "urn:iso:std:iso:4217";
5522            case GHS: return "urn:iso:std:iso:4217";
5523            case GIP: return "urn:iso:std:iso:4217";
5524            case GMD: return "urn:iso:std:iso:4217";
5525            case GNF: return "urn:iso:std:iso:4217";
5526            case GTQ: return "urn:iso:std:iso:4217";
5527            case GYD: return "urn:iso:std:iso:4217";
5528            case HKD: return "urn:iso:std:iso:4217";
5529            case HNL: return "urn:iso:std:iso:4217";
5530            case HRK: return "urn:iso:std:iso:4217";
5531            case HTG: return "urn:iso:std:iso:4217";
5532            case HUF: return "urn:iso:std:iso:4217";
5533            case IDR: return "urn:iso:std:iso:4217";
5534            case ILS: return "urn:iso:std:iso:4217";
5535            case IMP: return "urn:iso:std:iso:4217";
5536            case INR: return "urn:iso:std:iso:4217";
5537            case IQD: return "urn:iso:std:iso:4217";
5538            case IRR: return "urn:iso:std:iso:4217";
5539            case ISK: return "urn:iso:std:iso:4217";
5540            case JEP: return "urn:iso:std:iso:4217";
5541            case JMD: return "urn:iso:std:iso:4217";
5542            case JOD: return "urn:iso:std:iso:4217";
5543            case JPY: return "urn:iso:std:iso:4217";
5544            case KES: return "urn:iso:std:iso:4217";
5545            case KGS: return "urn:iso:std:iso:4217";
5546            case KHR: return "urn:iso:std:iso:4217";
5547            case KMF: return "urn:iso:std:iso:4217";
5548            case KPW: return "urn:iso:std:iso:4217";
5549            case KRW: return "urn:iso:std:iso:4217";
5550            case KWD: return "urn:iso:std:iso:4217";
5551            case KYD: return "urn:iso:std:iso:4217";
5552            case KZT: return "urn:iso:std:iso:4217";
5553            case LAK: return "urn:iso:std:iso:4217";
5554            case LBP: return "urn:iso:std:iso:4217";
5555            case LKR: return "urn:iso:std:iso:4217";
5556            case LRD: return "urn:iso:std:iso:4217";
5557            case LSL: return "urn:iso:std:iso:4217";
5558            case LYD: return "urn:iso:std:iso:4217";
5559            case MAD: return "urn:iso:std:iso:4217";
5560            case MDL: return "urn:iso:std:iso:4217";
5561            case MGA: return "urn:iso:std:iso:4217";
5562            case MKD: return "urn:iso:std:iso:4217";
5563            case MMK: return "urn:iso:std:iso:4217";
5564            case MNT: return "urn:iso:std:iso:4217";
5565            case MOP: return "urn:iso:std:iso:4217";
5566            case MRU: return "urn:iso:std:iso:4217";
5567            case MUR: return "urn:iso:std:iso:4217";
5568            case MVR: return "urn:iso:std:iso:4217";
5569            case MWK: return "urn:iso:std:iso:4217";
5570            case MXN: return "urn:iso:std:iso:4217";
5571            case MXV: return "urn:iso:std:iso:4217";
5572            case MYR: return "urn:iso:std:iso:4217";
5573            case MZN: return "urn:iso:std:iso:4217";
5574            case NAD: return "urn:iso:std:iso:4217";
5575            case NGN: return "urn:iso:std:iso:4217";
5576            case NIO: return "urn:iso:std:iso:4217";
5577            case NOK: return "urn:iso:std:iso:4217";
5578            case NPR: return "urn:iso:std:iso:4217";
5579            case NZD: return "urn:iso:std:iso:4217";
5580            case OMR: return "urn:iso:std:iso:4217";
5581            case PAB: return "urn:iso:std:iso:4217";
5582            case PEN: return "urn:iso:std:iso:4217";
5583            case PGK: return "urn:iso:std:iso:4217";
5584            case PHP: return "urn:iso:std:iso:4217";
5585            case PKR: return "urn:iso:std:iso:4217";
5586            case PLN: return "urn:iso:std:iso:4217";
5587            case PYG: return "urn:iso:std:iso:4217";
5588            case QAR: return "urn:iso:std:iso:4217";
5589            case RON: return "urn:iso:std:iso:4217";
5590            case RSD: return "urn:iso:std:iso:4217";
5591            case RUB: return "urn:iso:std:iso:4217";
5592            case RWF: return "urn:iso:std:iso:4217";
5593            case SAR: return "urn:iso:std:iso:4217";
5594            case SBD: return "urn:iso:std:iso:4217";
5595            case SCR: return "urn:iso:std:iso:4217";
5596            case SDG: return "urn:iso:std:iso:4217";
5597            case SEK: return "urn:iso:std:iso:4217";
5598            case SGD: return "urn:iso:std:iso:4217";
5599            case SHP: return "urn:iso:std:iso:4217";
5600            case SLL: return "urn:iso:std:iso:4217";
5601            case SOS: return "urn:iso:std:iso:4217";
5602            case SRD: return "urn:iso:std:iso:4217";
5603            case SSP: return "urn:iso:std:iso:4217";
5604            case STN: return "urn:iso:std:iso:4217";
5605            case SVC: return "urn:iso:std:iso:4217";
5606            case SYP: return "urn:iso:std:iso:4217";
5607            case SZL: return "urn:iso:std:iso:4217";
5608            case THB: return "urn:iso:std:iso:4217";
5609            case TJS: return "urn:iso:std:iso:4217";
5610            case TMT: return "urn:iso:std:iso:4217";
5611            case TND: return "urn:iso:std:iso:4217";
5612            case TOP: return "urn:iso:std:iso:4217";
5613            case TRY: return "urn:iso:std:iso:4217";
5614            case TTD: return "urn:iso:std:iso:4217";
5615            case TVD: return "urn:iso:std:iso:4217";
5616            case TWD: return "urn:iso:std:iso:4217";
5617            case TZS: return "urn:iso:std:iso:4217";
5618            case UAH: return "urn:iso:std:iso:4217";
5619            case UGX: return "urn:iso:std:iso:4217";
5620            case USD: return "urn:iso:std:iso:4217";
5621            case USN: return "urn:iso:std:iso:4217";
5622            case UYI: return "urn:iso:std:iso:4217";
5623            case UYU: return "urn:iso:std:iso:4217";
5624            case UZS: return "urn:iso:std:iso:4217";
5625            case VEF: return "urn:iso:std:iso:4217";
5626            case VND: return "urn:iso:std:iso:4217";
5627            case VUV: return "urn:iso:std:iso:4217";
5628            case WST: return "urn:iso:std:iso:4217";
5629            case XAF: return "urn:iso:std:iso:4217";
5630            case XAG: return "urn:iso:std:iso:4217";
5631            case XAU: return "urn:iso:std:iso:4217";
5632            case XBA: return "urn:iso:std:iso:4217";
5633            case XBB: return "urn:iso:std:iso:4217";
5634            case XBC: return "urn:iso:std:iso:4217";
5635            case XBD: return "urn:iso:std:iso:4217";
5636            case XCD: return "urn:iso:std:iso:4217";
5637            case XDR: return "urn:iso:std:iso:4217";
5638            case XOF: return "urn:iso:std:iso:4217";
5639            case XPD: return "urn:iso:std:iso:4217";
5640            case XPF: return "urn:iso:std:iso:4217";
5641            case XPT: return "urn:iso:std:iso:4217";
5642            case XSU: return "urn:iso:std:iso:4217";
5643            case XTS: return "urn:iso:std:iso:4217";
5644            case XUA: return "urn:iso:std:iso:4217";
5645            case XXX: return "urn:iso:std:iso:4217";
5646            case YER: return "urn:iso:std:iso:4217";
5647            case ZAR: return "urn:iso:std:iso:4217";
5648            case ZMW: return "urn:iso:std:iso:4217";
5649            case ZWL: return "urn:iso:std:iso:4217";
5650            case NULL: return null;
5651            default: return "?";
5652          }
5653        }
5654        public String getDefinition() {
5655          switch (this) {
5656            case AED: return "";
5657            case AFN: return "";
5658            case ALL: return "";
5659            case AMD: return "";
5660            case ANG: return "";
5661            case AOA: return "";
5662            case ARS: return "";
5663            case AUD: return "";
5664            case AWG: return "";
5665            case AZN: return "";
5666            case BAM: return "";
5667            case BBD: return "";
5668            case BDT: return "";
5669            case BGN: return "";
5670            case BHD: return "";
5671            case BIF: return "";
5672            case BMD: return "";
5673            case BND: return "";
5674            case BOB: return "";
5675            case BOV: return "";
5676            case BRL: return "";
5677            case BSD: return "";
5678            case BTN: return "";
5679            case BWP: return "";
5680            case BYN: return "";
5681            case BZD: return "";
5682            case CAD: return "";
5683            case CDF: return "";
5684            case CHE: return "";
5685            case CHF: return "";
5686            case CHW: return "";
5687            case CLF: return "";
5688            case CLP: return "";
5689            case CNY: return "";
5690            case COP: return "";
5691            case COU: return "";
5692            case CRC: return "";
5693            case CUC: return "";
5694            case CUP: return "";
5695            case CVE: return "";
5696            case CZK: return "";
5697            case DJF: return "";
5698            case DKK: return "";
5699            case DOP: return "";
5700            case DZD: return "";
5701            case EGP: return "";
5702            case ERN: return "";
5703            case ETB: return "";
5704            case EUR: return "";
5705            case FJD: return "";
5706            case FKP: return "";
5707            case GBP: return "";
5708            case GEL: return "";
5709            case GGP: return "";
5710            case GHS: return "";
5711            case GIP: return "";
5712            case GMD: return "";
5713            case GNF: return "";
5714            case GTQ: return "";
5715            case GYD: return "";
5716            case HKD: return "";
5717            case HNL: return "";
5718            case HRK: return "";
5719            case HTG: return "";
5720            case HUF: return "";
5721            case IDR: return "";
5722            case ILS: return "";
5723            case IMP: return "";
5724            case INR: return "";
5725            case IQD: return "";
5726            case IRR: return "";
5727            case ISK: return "";
5728            case JEP: return "";
5729            case JMD: return "";
5730            case JOD: return "";
5731            case JPY: return "";
5732            case KES: return "";
5733            case KGS: return "";
5734            case KHR: return "";
5735            case KMF: return "";
5736            case KPW: return "";
5737            case KRW: return "";
5738            case KWD: return "";
5739            case KYD: return "";
5740            case KZT: return "";
5741            case LAK: return "";
5742            case LBP: return "";
5743            case LKR: return "";
5744            case LRD: return "";
5745            case LSL: return "";
5746            case LYD: return "";
5747            case MAD: return "";
5748            case MDL: return "";
5749            case MGA: return "";
5750            case MKD: return "";
5751            case MMK: return "";
5752            case MNT: return "";
5753            case MOP: return "";
5754            case MRU: return "";
5755            case MUR: return "";
5756            case MVR: return "";
5757            case MWK: return "";
5758            case MXN: return "";
5759            case MXV: return "";
5760            case MYR: return "";
5761            case MZN: return "";
5762            case NAD: return "";
5763            case NGN: return "";
5764            case NIO: return "";
5765            case NOK: return "";
5766            case NPR: return "";
5767            case NZD: return "";
5768            case OMR: return "";
5769            case PAB: return "";
5770            case PEN: return "";
5771            case PGK: return "";
5772            case PHP: return "";
5773            case PKR: return "";
5774            case PLN: return "";
5775            case PYG: return "";
5776            case QAR: return "";
5777            case RON: return "";
5778            case RSD: return "";
5779            case RUB: return "";
5780            case RWF: return "";
5781            case SAR: return "";
5782            case SBD: return "";
5783            case SCR: return "";
5784            case SDG: return "";
5785            case SEK: return "";
5786            case SGD: return "";
5787            case SHP: return "";
5788            case SLL: return "";
5789            case SOS: return "";
5790            case SRD: return "";
5791            case SSP: return "";
5792            case STN: return "";
5793            case SVC: return "";
5794            case SYP: return "";
5795            case SZL: return "";
5796            case THB: return "";
5797            case TJS: return "";
5798            case TMT: return "";
5799            case TND: return "";
5800            case TOP: return "";
5801            case TRY: return "";
5802            case TTD: return "";
5803            case TVD: return "";
5804            case TWD: return "";
5805            case TZS: return "";
5806            case UAH: return "";
5807            case UGX: return "";
5808            case USD: return "";
5809            case USN: return "";
5810            case UYI: return "";
5811            case UYU: return "";
5812            case UZS: return "";
5813            case VEF: return "";
5814            case VND: return "";
5815            case VUV: return "";
5816            case WST: return "";
5817            case XAF: return "";
5818            case XAG: return "";
5819            case XAU: return "";
5820            case XBA: return "";
5821            case XBB: return "";
5822            case XBC: return "";
5823            case XBD: return "";
5824            case XCD: return "";
5825            case XDR: return "";
5826            case XOF: return "";
5827            case XPD: return "";
5828            case XPF: return "";
5829            case XPT: return "";
5830            case XSU: return "";
5831            case XTS: return "";
5832            case XUA: return "";
5833            case XXX: return "";
5834            case YER: return "";
5835            case ZAR: return "";
5836            case ZMW: return "";
5837            case ZWL: return "";
5838            case NULL: return null;
5839            default: return "?";
5840          }
5841        }
5842        public String getDisplay() {
5843          switch (this) {
5844            case AED: return "United Arab Emirates dirham";
5845            case AFN: return "Afghan afghani";
5846            case ALL: return "Albanian lek";
5847            case AMD: return "Armenian dram";
5848            case ANG: return "Netherlands Antillean guilder";
5849            case AOA: return "Angolan kwanza";
5850            case ARS: return "Argentine peso";
5851            case AUD: return "Australian dollar";
5852            case AWG: return "Aruban florin";
5853            case AZN: return "Azerbaijani manat";
5854            case BAM: return "Bosnia and Herzegovina convertible mark";
5855            case BBD: return "Barbados dollar";
5856            case BDT: return "Bangladeshi taka";
5857            case BGN: return "Bulgarian lev";
5858            case BHD: return "Bahraini dinar";
5859            case BIF: return "Burundian franc";
5860            case BMD: return "Bermudian dollar";
5861            case BND: return "Brunei dollar";
5862            case BOB: return "Boliviano";
5863            case BOV: return "Bolivian Mvdol (funds code)";
5864            case BRL: return "Brazilian real";
5865            case BSD: return "Bahamian dollar";
5866            case BTN: return "Bhutanese ngultrum";
5867            case BWP: return "Botswana pula";
5868            case BYN: return "Belarusian ruble";
5869            case BZD: return "Belize dollar";
5870            case CAD: return "Canadian dollar";
5871            case CDF: return "Congolese franc";
5872            case CHE: return "WIR Euro (complementary currency)";
5873            case CHF: return "Swiss franc";
5874            case CHW: return "WIR Franc (complementary currency)";
5875            case CLF: return "Unidad de Fomento (funds code)";
5876            case CLP: return "Chilean peso";
5877            case CNY: return "Renminbi (Chinese) yuan[8]";
5878            case COP: return "Colombian peso";
5879            case COU: return "Unidad de Valor Real (UVR) (funds code)[9]";
5880            case CRC: return "Costa Rican colon";
5881            case CUC: return "Cuban convertible peso";
5882            case CUP: return "Cuban peso";
5883            case CVE: return "Cape Verde escudo";
5884            case CZK: return "Czech koruna";
5885            case DJF: return "Djiboutian franc";
5886            case DKK: return "Danish krone";
5887            case DOP: return "Dominican peso";
5888            case DZD: return "Algerian dinar";
5889            case EGP: return "Egyptian pound";
5890            case ERN: return "Eritrean nakfa";
5891            case ETB: return "Ethiopian birr";
5892            case EUR: return "Euro";
5893            case FJD: return "Fiji dollar";
5894            case FKP: return "Falkland Islands pound";
5895            case GBP: return "Pound sterling";
5896            case GEL: return "Georgian lari";
5897            case GGP: return "Guernsey Pound";
5898            case GHS: return "Ghanaian cedi";
5899            case GIP: return "Gibraltar pound";
5900            case GMD: return "Gambian dalasi";
5901            case GNF: return "Guinean franc";
5902            case GTQ: return "Guatemalan quetzal";
5903            case GYD: return "Guyanese dollar";
5904            case HKD: return "Hong Kong dollar";
5905            case HNL: return "Honduran lempira";
5906            case HRK: return "Croatian kuna";
5907            case HTG: return "Haitian gourde";
5908            case HUF: return "Hungarian forint";
5909            case IDR: return "Indonesian rupiah";
5910            case ILS: return "Israeli new shekel";
5911            case IMP: return "Isle of Man Pound";
5912            case INR: return "Indian rupee";
5913            case IQD: return "Iraqi dinar";
5914            case IRR: return "Iranian rial";
5915            case ISK: return "Icelandic króna";
5916            case JEP: return "Jersey Pound";
5917            case JMD: return "Jamaican dollar";
5918            case JOD: return "Jordanian dinar";
5919            case JPY: return "Japanese yen";
5920            case KES: return "Kenyan shilling";
5921            case KGS: return "Kyrgyzstani som";
5922            case KHR: return "Cambodian riel";
5923            case KMF: return "Comoro franc";
5924            case KPW: return "North Korean won";
5925            case KRW: return "South Korean won";
5926            case KWD: return "Kuwaiti dinar";
5927            case KYD: return "Cayman Islands dollar";
5928            case KZT: return "Kazakhstani tenge";
5929            case LAK: return "Lao kip";
5930            case LBP: return "Lebanese pound";
5931            case LKR: return "Sri Lankan rupee";
5932            case LRD: return "Liberian dollar";
5933            case LSL: return "Lesotho loti";
5934            case LYD: return "Libyan dinar";
5935            case MAD: return "Moroccan dirham";
5936            case MDL: return "Moldovan leu";
5937            case MGA: return "Malagasy ariary";
5938            case MKD: return "Macedonian denar";
5939            case MMK: return "Myanmar kyat";
5940            case MNT: return "Mongolian tögrög";
5941            case MOP: return "Macanese pataca";
5942            case MRU: return "Mauritanian ouguiya";
5943            case MUR: return "Mauritian rupee";
5944            case MVR: return "Maldivian rufiyaa";
5945            case MWK: return "Malawian kwacha";
5946            case MXN: return "Mexican peso";
5947            case MXV: return "Mexican Unidad de Inversion (UDI) (funds code)";
5948            case MYR: return "Malaysian ringgit";
5949            case MZN: return "Mozambican metical";
5950            case NAD: return "Namibian dollar";
5951            case NGN: return "Nigerian naira";
5952            case NIO: return "Nicaraguan córdoba";
5953            case NOK: return "Norwegian krone";
5954            case NPR: return "Nepalese rupee";
5955            case NZD: return "New Zealand dollar";
5956            case OMR: return "Omani rial";
5957            case PAB: return "Panamanian balboa";
5958            case PEN: return "Peruvian Sol";
5959            case PGK: return "Papua New Guinean kina";
5960            case PHP: return "Philippine piso[13]";
5961            case PKR: return "Pakistani rupee";
5962            case PLN: return "Polish z?oty";
5963            case PYG: return "Paraguayan guaraní";
5964            case QAR: return "Qatari riyal";
5965            case RON: return "Romanian leu";
5966            case RSD: return "Serbian dinar";
5967            case RUB: return "Russian ruble";
5968            case RWF: return "Rwandan franc";
5969            case SAR: return "Saudi riyal";
5970            case SBD: return "Solomon Islands dollar";
5971            case SCR: return "Seychelles rupee";
5972            case SDG: return "Sudanese pound";
5973            case SEK: return "Swedish krona/kronor";
5974            case SGD: return "Singapore dollar";
5975            case SHP: return "Saint Helena pound";
5976            case SLL: return "Sierra Leonean leone";
5977            case SOS: return "Somali shilling";
5978            case SRD: return "Surinamese dollar";
5979            case SSP: return "South Sudanese pound";
5980            case STN: return "São Tomé and Príncipe dobra";
5981            case SVC: return "Salvadoran colón";
5982            case SYP: return "Syrian pound";
5983            case SZL: return "Swazi lilangeni";
5984            case THB: return "Thai baht";
5985            case TJS: return "Tajikistani somoni";
5986            case TMT: return "Turkmenistan manat";
5987            case TND: return "Tunisian dinar";
5988            case TOP: return "Tongan pa?anga";
5989            case TRY: return "Turkish lira";
5990            case TTD: return "Trinidad and Tobago dollar";
5991            case TVD: return "Tuvalu Dollar";
5992            case TWD: return "New Taiwan dollar";
5993            case TZS: return "Tanzanian shilling";
5994            case UAH: return "Ukrainian hryvnia";
5995            case UGX: return "Ugandan shilling";
5996            case USD: return "United States dollar";
5997            case USN: return "United States dollar (next day) (funds code)";
5998            case UYI: return "Uruguay Peso en Unidades Indexadas (URUIURUI) (funds code)";
5999            case UYU: return "Uruguayan peso";
6000            case UZS: return "Uzbekistan som";
6001            case VEF: return "Venezuelan bolívar";
6002            case VND: return "Vietnamese ??ng";
6003            case VUV: return "Vanuatu vatu";
6004            case WST: return "Samoan tala";
6005            case XAF: return "CFA franc BEAC";
6006            case XAG: return "Silver (one troy ounce)";
6007            case XAU: return "Gold (one troy ounce)";
6008            case XBA: return "European Composite Unit (EURCO) (bond market unit)";
6009            case XBB: return "European Monetary Unit (E.M.U.-6) (bond market unit)";
6010            case XBC: return "European Unit of Account 9 (E.U.A.-9) (bond market unit)";
6011            case XBD: return "European Unit of Account 17 (E.U.A.-17) (bond market unit)";
6012            case XCD: return "East Caribbean dollar";
6013            case XDR: return "Special drawing rights";
6014            case XOF: return "CFA franc BCEAO";
6015            case XPD: return "Palladium (one troy ounce)";
6016            case XPF: return "CFP franc (franc Pacifique)";
6017            case XPT: return "Platinum (one troy ounce)";
6018            case XSU: return "SUCRE";
6019            case XTS: return "Code reserved for testing purposes";
6020            case XUA: return "ADB Unit of Account";
6021            case XXX: return "No currency";
6022            case YER: return "Yemeni rial";
6023            case ZAR: return "South African rand";
6024            case ZMW: return "Zambian kwacha";
6025            case ZWL: return "Zimbabwean dollar A/10";
6026            case NULL: return null;
6027            default: return "?";
6028          }
6029        }
6030    }
6031
6032  public static class CurrenciesEnumFactory implements EnumFactory<Currencies> {
6033    public Currencies fromCode(String codeString) throws IllegalArgumentException {
6034      if (codeString == null || "".equals(codeString))
6035            if (codeString == null || "".equals(codeString))
6036                return null;
6037        if ("AED".equals(codeString))
6038          return Currencies.AED;
6039        if ("AFN".equals(codeString))
6040          return Currencies.AFN;
6041        if ("ALL".equals(codeString))
6042          return Currencies.ALL;
6043        if ("AMD".equals(codeString))
6044          return Currencies.AMD;
6045        if ("ANG".equals(codeString))
6046          return Currencies.ANG;
6047        if ("AOA".equals(codeString))
6048          return Currencies.AOA;
6049        if ("ARS".equals(codeString))
6050          return Currencies.ARS;
6051        if ("AUD".equals(codeString))
6052          return Currencies.AUD;
6053        if ("AWG".equals(codeString))
6054          return Currencies.AWG;
6055        if ("AZN".equals(codeString))
6056          return Currencies.AZN;
6057        if ("BAM".equals(codeString))
6058          return Currencies.BAM;
6059        if ("BBD".equals(codeString))
6060          return Currencies.BBD;
6061        if ("BDT".equals(codeString))
6062          return Currencies.BDT;
6063        if ("BGN".equals(codeString))
6064          return Currencies.BGN;
6065        if ("BHD".equals(codeString))
6066          return Currencies.BHD;
6067        if ("BIF".equals(codeString))
6068          return Currencies.BIF;
6069        if ("BMD".equals(codeString))
6070          return Currencies.BMD;
6071        if ("BND".equals(codeString))
6072          return Currencies.BND;
6073        if ("BOB".equals(codeString))
6074          return Currencies.BOB;
6075        if ("BOV".equals(codeString))
6076          return Currencies.BOV;
6077        if ("BRL".equals(codeString))
6078          return Currencies.BRL;
6079        if ("BSD".equals(codeString))
6080          return Currencies.BSD;
6081        if ("BTN".equals(codeString))
6082          return Currencies.BTN;
6083        if ("BWP".equals(codeString))
6084          return Currencies.BWP;
6085        if ("BYN".equals(codeString))
6086          return Currencies.BYN;
6087        if ("BZD".equals(codeString))
6088          return Currencies.BZD;
6089        if ("CAD".equals(codeString))
6090          return Currencies.CAD;
6091        if ("CDF".equals(codeString))
6092          return Currencies.CDF;
6093        if ("CHE".equals(codeString))
6094          return Currencies.CHE;
6095        if ("CHF".equals(codeString))
6096          return Currencies.CHF;
6097        if ("CHW".equals(codeString))
6098          return Currencies.CHW;
6099        if ("CLF".equals(codeString))
6100          return Currencies.CLF;
6101        if ("CLP".equals(codeString))
6102          return Currencies.CLP;
6103        if ("CNY".equals(codeString))
6104          return Currencies.CNY;
6105        if ("COP".equals(codeString))
6106          return Currencies.COP;
6107        if ("COU".equals(codeString))
6108          return Currencies.COU;
6109        if ("CRC".equals(codeString))
6110          return Currencies.CRC;
6111        if ("CUC".equals(codeString))
6112          return Currencies.CUC;
6113        if ("CUP".equals(codeString))
6114          return Currencies.CUP;
6115        if ("CVE".equals(codeString))
6116          return Currencies.CVE;
6117        if ("CZK".equals(codeString))
6118          return Currencies.CZK;
6119        if ("DJF".equals(codeString))
6120          return Currencies.DJF;
6121        if ("DKK".equals(codeString))
6122          return Currencies.DKK;
6123        if ("DOP".equals(codeString))
6124          return Currencies.DOP;
6125        if ("DZD".equals(codeString))
6126          return Currencies.DZD;
6127        if ("EGP".equals(codeString))
6128          return Currencies.EGP;
6129        if ("ERN".equals(codeString))
6130          return Currencies.ERN;
6131        if ("ETB".equals(codeString))
6132          return Currencies.ETB;
6133        if ("EUR".equals(codeString))
6134          return Currencies.EUR;
6135        if ("FJD".equals(codeString))
6136          return Currencies.FJD;
6137        if ("FKP".equals(codeString))
6138          return Currencies.FKP;
6139        if ("GBP".equals(codeString))
6140          return Currencies.GBP;
6141        if ("GEL".equals(codeString))
6142          return Currencies.GEL;
6143        if ("GGP".equals(codeString))
6144          return Currencies.GGP;
6145        if ("GHS".equals(codeString))
6146          return Currencies.GHS;
6147        if ("GIP".equals(codeString))
6148          return Currencies.GIP;
6149        if ("GMD".equals(codeString))
6150          return Currencies.GMD;
6151        if ("GNF".equals(codeString))
6152          return Currencies.GNF;
6153        if ("GTQ".equals(codeString))
6154          return Currencies.GTQ;
6155        if ("GYD".equals(codeString))
6156          return Currencies.GYD;
6157        if ("HKD".equals(codeString))
6158          return Currencies.HKD;
6159        if ("HNL".equals(codeString))
6160          return Currencies.HNL;
6161        if ("HRK".equals(codeString))
6162          return Currencies.HRK;
6163        if ("HTG".equals(codeString))
6164          return Currencies.HTG;
6165        if ("HUF".equals(codeString))
6166          return Currencies.HUF;
6167        if ("IDR".equals(codeString))
6168          return Currencies.IDR;
6169        if ("ILS".equals(codeString))
6170          return Currencies.ILS;
6171        if ("IMP".equals(codeString))
6172          return Currencies.IMP;
6173        if ("INR".equals(codeString))
6174          return Currencies.INR;
6175        if ("IQD".equals(codeString))
6176          return Currencies.IQD;
6177        if ("IRR".equals(codeString))
6178          return Currencies.IRR;
6179        if ("ISK".equals(codeString))
6180          return Currencies.ISK;
6181        if ("JEP".equals(codeString))
6182          return Currencies.JEP;
6183        if ("JMD".equals(codeString))
6184          return Currencies.JMD;
6185        if ("JOD".equals(codeString))
6186          return Currencies.JOD;
6187        if ("JPY".equals(codeString))
6188          return Currencies.JPY;
6189        if ("KES".equals(codeString))
6190          return Currencies.KES;
6191        if ("KGS".equals(codeString))
6192          return Currencies.KGS;
6193        if ("KHR".equals(codeString))
6194          return Currencies.KHR;
6195        if ("KMF".equals(codeString))
6196          return Currencies.KMF;
6197        if ("KPW".equals(codeString))
6198          return Currencies.KPW;
6199        if ("KRW".equals(codeString))
6200          return Currencies.KRW;
6201        if ("KWD".equals(codeString))
6202          return Currencies.KWD;
6203        if ("KYD".equals(codeString))
6204          return Currencies.KYD;
6205        if ("KZT".equals(codeString))
6206          return Currencies.KZT;
6207        if ("LAK".equals(codeString))
6208          return Currencies.LAK;
6209        if ("LBP".equals(codeString))
6210          return Currencies.LBP;
6211        if ("LKR".equals(codeString))
6212          return Currencies.LKR;
6213        if ("LRD".equals(codeString))
6214          return Currencies.LRD;
6215        if ("LSL".equals(codeString))
6216          return Currencies.LSL;
6217        if ("LYD".equals(codeString))
6218          return Currencies.LYD;
6219        if ("MAD".equals(codeString))
6220          return Currencies.MAD;
6221        if ("MDL".equals(codeString))
6222          return Currencies.MDL;
6223        if ("MGA".equals(codeString))
6224          return Currencies.MGA;
6225        if ("MKD".equals(codeString))
6226          return Currencies.MKD;
6227        if ("MMK".equals(codeString))
6228          return Currencies.MMK;
6229        if ("MNT".equals(codeString))
6230          return Currencies.MNT;
6231        if ("MOP".equals(codeString))
6232          return Currencies.MOP;
6233        if ("MRU".equals(codeString))
6234          return Currencies.MRU;
6235        if ("MUR".equals(codeString))
6236          return Currencies.MUR;
6237        if ("MVR".equals(codeString))
6238          return Currencies.MVR;
6239        if ("MWK".equals(codeString))
6240          return Currencies.MWK;
6241        if ("MXN".equals(codeString))
6242          return Currencies.MXN;
6243        if ("MXV".equals(codeString))
6244          return Currencies.MXV;
6245        if ("MYR".equals(codeString))
6246          return Currencies.MYR;
6247        if ("MZN".equals(codeString))
6248          return Currencies.MZN;
6249        if ("NAD".equals(codeString))
6250          return Currencies.NAD;
6251        if ("NGN".equals(codeString))
6252          return Currencies.NGN;
6253        if ("NIO".equals(codeString))
6254          return Currencies.NIO;
6255        if ("NOK".equals(codeString))
6256          return Currencies.NOK;
6257        if ("NPR".equals(codeString))
6258          return Currencies.NPR;
6259        if ("NZD".equals(codeString))
6260          return Currencies.NZD;
6261        if ("OMR".equals(codeString))
6262          return Currencies.OMR;
6263        if ("PAB".equals(codeString))
6264          return Currencies.PAB;
6265        if ("PEN".equals(codeString))
6266          return Currencies.PEN;
6267        if ("PGK".equals(codeString))
6268          return Currencies.PGK;
6269        if ("PHP".equals(codeString))
6270          return Currencies.PHP;
6271        if ("PKR".equals(codeString))
6272          return Currencies.PKR;
6273        if ("PLN".equals(codeString))
6274          return Currencies.PLN;
6275        if ("PYG".equals(codeString))
6276          return Currencies.PYG;
6277        if ("QAR".equals(codeString))
6278          return Currencies.QAR;
6279        if ("RON".equals(codeString))
6280          return Currencies.RON;
6281        if ("RSD".equals(codeString))
6282          return Currencies.RSD;
6283        if ("RUB".equals(codeString))
6284          return Currencies.RUB;
6285        if ("RWF".equals(codeString))
6286          return Currencies.RWF;
6287        if ("SAR".equals(codeString))
6288          return Currencies.SAR;
6289        if ("SBD".equals(codeString))
6290          return Currencies.SBD;
6291        if ("SCR".equals(codeString))
6292          return Currencies.SCR;
6293        if ("SDG".equals(codeString))
6294          return Currencies.SDG;
6295        if ("SEK".equals(codeString))
6296          return Currencies.SEK;
6297        if ("SGD".equals(codeString))
6298          return Currencies.SGD;
6299        if ("SHP".equals(codeString))
6300          return Currencies.SHP;
6301        if ("SLL".equals(codeString))
6302          return Currencies.SLL;
6303        if ("SOS".equals(codeString))
6304          return Currencies.SOS;
6305        if ("SRD".equals(codeString))
6306          return Currencies.SRD;
6307        if ("SSP".equals(codeString))
6308          return Currencies.SSP;
6309        if ("STN".equals(codeString))
6310          return Currencies.STN;
6311        if ("SVC".equals(codeString))
6312          return Currencies.SVC;
6313        if ("SYP".equals(codeString))
6314          return Currencies.SYP;
6315        if ("SZL".equals(codeString))
6316          return Currencies.SZL;
6317        if ("THB".equals(codeString))
6318          return Currencies.THB;
6319        if ("TJS".equals(codeString))
6320          return Currencies.TJS;
6321        if ("TMT".equals(codeString))
6322          return Currencies.TMT;
6323        if ("TND".equals(codeString))
6324          return Currencies.TND;
6325        if ("TOP".equals(codeString))
6326          return Currencies.TOP;
6327        if ("TRY".equals(codeString))
6328          return Currencies.TRY;
6329        if ("TTD".equals(codeString))
6330          return Currencies.TTD;
6331        if ("TVD".equals(codeString))
6332          return Currencies.TVD;
6333        if ("TWD".equals(codeString))
6334          return Currencies.TWD;
6335        if ("TZS".equals(codeString))
6336          return Currencies.TZS;
6337        if ("UAH".equals(codeString))
6338          return Currencies.UAH;
6339        if ("UGX".equals(codeString))
6340          return Currencies.UGX;
6341        if ("USD".equals(codeString))
6342          return Currencies.USD;
6343        if ("USN".equals(codeString))
6344          return Currencies.USN;
6345        if ("UYI".equals(codeString))
6346          return Currencies.UYI;
6347        if ("UYU".equals(codeString))
6348          return Currencies.UYU;
6349        if ("UZS".equals(codeString))
6350          return Currencies.UZS;
6351        if ("VEF".equals(codeString))
6352          return Currencies.VEF;
6353        if ("VND".equals(codeString))
6354          return Currencies.VND;
6355        if ("VUV".equals(codeString))
6356          return Currencies.VUV;
6357        if ("WST".equals(codeString))
6358          return Currencies.WST;
6359        if ("XAF".equals(codeString))
6360          return Currencies.XAF;
6361        if ("XAG".equals(codeString))
6362          return Currencies.XAG;
6363        if ("XAU".equals(codeString))
6364          return Currencies.XAU;
6365        if ("XBA".equals(codeString))
6366          return Currencies.XBA;
6367        if ("XBB".equals(codeString))
6368          return Currencies.XBB;
6369        if ("XBC".equals(codeString))
6370          return Currencies.XBC;
6371        if ("XBD".equals(codeString))
6372          return Currencies.XBD;
6373        if ("XCD".equals(codeString))
6374          return Currencies.XCD;
6375        if ("XDR".equals(codeString))
6376          return Currencies.XDR;
6377        if ("XOF".equals(codeString))
6378          return Currencies.XOF;
6379        if ("XPD".equals(codeString))
6380          return Currencies.XPD;
6381        if ("XPF".equals(codeString))
6382          return Currencies.XPF;
6383        if ("XPT".equals(codeString))
6384          return Currencies.XPT;
6385        if ("XSU".equals(codeString))
6386          return Currencies.XSU;
6387        if ("XTS".equals(codeString))
6388          return Currencies.XTS;
6389        if ("XUA".equals(codeString))
6390          return Currencies.XUA;
6391        if ("XXX".equals(codeString))
6392          return Currencies.XXX;
6393        if ("YER".equals(codeString))
6394          return Currencies.YER;
6395        if ("ZAR".equals(codeString))
6396          return Currencies.ZAR;
6397        if ("ZMW".equals(codeString))
6398          return Currencies.ZMW;
6399        if ("ZWL".equals(codeString))
6400          return Currencies.ZWL;
6401        throw new IllegalArgumentException("Unknown Currencies code '"+codeString+"'");
6402        }
6403
6404        public Enumeration<Currencies> fromType(PrimitiveType<?> code) throws FHIRException {
6405          if (code == null)
6406            return null;
6407          if (code.isEmpty())
6408            return new Enumeration<Currencies>(this, Currencies.NULL, code);
6409          String codeString = ((PrimitiveType) code).asStringValue();
6410          if (codeString == null || "".equals(codeString))
6411            return new Enumeration<Currencies>(this, Currencies.NULL, code);
6412        if ("AED".equals(codeString))
6413          return new Enumeration<Currencies>(this, Currencies.AED, code);
6414        if ("AFN".equals(codeString))
6415          return new Enumeration<Currencies>(this, Currencies.AFN, code);
6416        if ("ALL".equals(codeString))
6417          return new Enumeration<Currencies>(this, Currencies.ALL, code);
6418        if ("AMD".equals(codeString))
6419          return new Enumeration<Currencies>(this, Currencies.AMD, code);
6420        if ("ANG".equals(codeString))
6421          return new Enumeration<Currencies>(this, Currencies.ANG, code);
6422        if ("AOA".equals(codeString))
6423          return new Enumeration<Currencies>(this, Currencies.AOA, code);
6424        if ("ARS".equals(codeString))
6425          return new Enumeration<Currencies>(this, Currencies.ARS, code);
6426        if ("AUD".equals(codeString))
6427          return new Enumeration<Currencies>(this, Currencies.AUD, code);
6428        if ("AWG".equals(codeString))
6429          return new Enumeration<Currencies>(this, Currencies.AWG, code);
6430        if ("AZN".equals(codeString))
6431          return new Enumeration<Currencies>(this, Currencies.AZN, code);
6432        if ("BAM".equals(codeString))
6433          return new Enumeration<Currencies>(this, Currencies.BAM, code);
6434        if ("BBD".equals(codeString))
6435          return new Enumeration<Currencies>(this, Currencies.BBD, code);
6436        if ("BDT".equals(codeString))
6437          return new Enumeration<Currencies>(this, Currencies.BDT, code);
6438        if ("BGN".equals(codeString))
6439          return new Enumeration<Currencies>(this, Currencies.BGN, code);
6440        if ("BHD".equals(codeString))
6441          return new Enumeration<Currencies>(this, Currencies.BHD, code);
6442        if ("BIF".equals(codeString))
6443          return new Enumeration<Currencies>(this, Currencies.BIF, code);
6444        if ("BMD".equals(codeString))
6445          return new Enumeration<Currencies>(this, Currencies.BMD, code);
6446        if ("BND".equals(codeString))
6447          return new Enumeration<Currencies>(this, Currencies.BND, code);
6448        if ("BOB".equals(codeString))
6449          return new Enumeration<Currencies>(this, Currencies.BOB, code);
6450        if ("BOV".equals(codeString))
6451          return new Enumeration<Currencies>(this, Currencies.BOV, code);
6452        if ("BRL".equals(codeString))
6453          return new Enumeration<Currencies>(this, Currencies.BRL, code);
6454        if ("BSD".equals(codeString))
6455          return new Enumeration<Currencies>(this, Currencies.BSD, code);
6456        if ("BTN".equals(codeString))
6457          return new Enumeration<Currencies>(this, Currencies.BTN, code);
6458        if ("BWP".equals(codeString))
6459          return new Enumeration<Currencies>(this, Currencies.BWP, code);
6460        if ("BYN".equals(codeString))
6461          return new Enumeration<Currencies>(this, Currencies.BYN, code);
6462        if ("BZD".equals(codeString))
6463          return new Enumeration<Currencies>(this, Currencies.BZD, code);
6464        if ("CAD".equals(codeString))
6465          return new Enumeration<Currencies>(this, Currencies.CAD, code);
6466        if ("CDF".equals(codeString))
6467          return new Enumeration<Currencies>(this, Currencies.CDF, code);
6468        if ("CHE".equals(codeString))
6469          return new Enumeration<Currencies>(this, Currencies.CHE, code);
6470        if ("CHF".equals(codeString))
6471          return new Enumeration<Currencies>(this, Currencies.CHF, code);
6472        if ("CHW".equals(codeString))
6473          return new Enumeration<Currencies>(this, Currencies.CHW, code);
6474        if ("CLF".equals(codeString))
6475          return new Enumeration<Currencies>(this, Currencies.CLF, code);
6476        if ("CLP".equals(codeString))
6477          return new Enumeration<Currencies>(this, Currencies.CLP, code);
6478        if ("CNY".equals(codeString))
6479          return new Enumeration<Currencies>(this, Currencies.CNY, code);
6480        if ("COP".equals(codeString))
6481          return new Enumeration<Currencies>(this, Currencies.COP, code);
6482        if ("COU".equals(codeString))
6483          return new Enumeration<Currencies>(this, Currencies.COU, code);
6484        if ("CRC".equals(codeString))
6485          return new Enumeration<Currencies>(this, Currencies.CRC, code);
6486        if ("CUC".equals(codeString))
6487          return new Enumeration<Currencies>(this, Currencies.CUC, code);
6488        if ("CUP".equals(codeString))
6489          return new Enumeration<Currencies>(this, Currencies.CUP, code);
6490        if ("CVE".equals(codeString))
6491          return new Enumeration<Currencies>(this, Currencies.CVE, code);
6492        if ("CZK".equals(codeString))
6493          return new Enumeration<Currencies>(this, Currencies.CZK, code);
6494        if ("DJF".equals(codeString))
6495          return new Enumeration<Currencies>(this, Currencies.DJF, code);
6496        if ("DKK".equals(codeString))
6497          return new Enumeration<Currencies>(this, Currencies.DKK, code);
6498        if ("DOP".equals(codeString))
6499          return new Enumeration<Currencies>(this, Currencies.DOP, code);
6500        if ("DZD".equals(codeString))
6501          return new Enumeration<Currencies>(this, Currencies.DZD, code);
6502        if ("EGP".equals(codeString))
6503          return new Enumeration<Currencies>(this, Currencies.EGP, code);
6504        if ("ERN".equals(codeString))
6505          return new Enumeration<Currencies>(this, Currencies.ERN, code);
6506        if ("ETB".equals(codeString))
6507          return new Enumeration<Currencies>(this, Currencies.ETB, code);
6508        if ("EUR".equals(codeString))
6509          return new Enumeration<Currencies>(this, Currencies.EUR, code);
6510        if ("FJD".equals(codeString))
6511          return new Enumeration<Currencies>(this, Currencies.FJD, code);
6512        if ("FKP".equals(codeString))
6513          return new Enumeration<Currencies>(this, Currencies.FKP, code);
6514        if ("GBP".equals(codeString))
6515          return new Enumeration<Currencies>(this, Currencies.GBP, code);
6516        if ("GEL".equals(codeString))
6517          return new Enumeration<Currencies>(this, Currencies.GEL, code);
6518        if ("GGP".equals(codeString))
6519          return new Enumeration<Currencies>(this, Currencies.GGP, code);
6520        if ("GHS".equals(codeString))
6521          return new Enumeration<Currencies>(this, Currencies.GHS, code);
6522        if ("GIP".equals(codeString))
6523          return new Enumeration<Currencies>(this, Currencies.GIP, code);
6524        if ("GMD".equals(codeString))
6525          return new Enumeration<Currencies>(this, Currencies.GMD, code);
6526        if ("GNF".equals(codeString))
6527          return new Enumeration<Currencies>(this, Currencies.GNF, code);
6528        if ("GTQ".equals(codeString))
6529          return new Enumeration<Currencies>(this, Currencies.GTQ, code);
6530        if ("GYD".equals(codeString))
6531          return new Enumeration<Currencies>(this, Currencies.GYD, code);
6532        if ("HKD".equals(codeString))
6533          return new Enumeration<Currencies>(this, Currencies.HKD, code);
6534        if ("HNL".equals(codeString))
6535          return new Enumeration<Currencies>(this, Currencies.HNL, code);
6536        if ("HRK".equals(codeString))
6537          return new Enumeration<Currencies>(this, Currencies.HRK, code);
6538        if ("HTG".equals(codeString))
6539          return new Enumeration<Currencies>(this, Currencies.HTG, code);
6540        if ("HUF".equals(codeString))
6541          return new Enumeration<Currencies>(this, Currencies.HUF, code);
6542        if ("IDR".equals(codeString))
6543          return new Enumeration<Currencies>(this, Currencies.IDR, code);
6544        if ("ILS".equals(codeString))
6545          return new Enumeration<Currencies>(this, Currencies.ILS, code);
6546        if ("IMP".equals(codeString))
6547          return new Enumeration<Currencies>(this, Currencies.IMP, code);
6548        if ("INR".equals(codeString))
6549          return new Enumeration<Currencies>(this, Currencies.INR, code);
6550        if ("IQD".equals(codeString))
6551          return new Enumeration<Currencies>(this, Currencies.IQD, code);
6552        if ("IRR".equals(codeString))
6553          return new Enumeration<Currencies>(this, Currencies.IRR, code);
6554        if ("ISK".equals(codeString))
6555          return new Enumeration<Currencies>(this, Currencies.ISK, code);
6556        if ("JEP".equals(codeString))
6557          return new Enumeration<Currencies>(this, Currencies.JEP, code);
6558        if ("JMD".equals(codeString))
6559          return new Enumeration<Currencies>(this, Currencies.JMD, code);
6560        if ("JOD".equals(codeString))
6561          return new Enumeration<Currencies>(this, Currencies.JOD, code);
6562        if ("JPY".equals(codeString))
6563          return new Enumeration<Currencies>(this, Currencies.JPY, code);
6564        if ("KES".equals(codeString))
6565          return new Enumeration<Currencies>(this, Currencies.KES, code);
6566        if ("KGS".equals(codeString))
6567          return new Enumeration<Currencies>(this, Currencies.KGS, code);
6568        if ("KHR".equals(codeString))
6569          return new Enumeration<Currencies>(this, Currencies.KHR, code);
6570        if ("KMF".equals(codeString))
6571          return new Enumeration<Currencies>(this, Currencies.KMF, code);
6572        if ("KPW".equals(codeString))
6573          return new Enumeration<Currencies>(this, Currencies.KPW, code);
6574        if ("KRW".equals(codeString))
6575          return new Enumeration<Currencies>(this, Currencies.KRW, code);
6576        if ("KWD".equals(codeString))
6577          return new Enumeration<Currencies>(this, Currencies.KWD, code);
6578        if ("KYD".equals(codeString))
6579          return new Enumeration<Currencies>(this, Currencies.KYD, code);
6580        if ("KZT".equals(codeString))
6581          return new Enumeration<Currencies>(this, Currencies.KZT, code);
6582        if ("LAK".equals(codeString))
6583          return new Enumeration<Currencies>(this, Currencies.LAK, code);
6584        if ("LBP".equals(codeString))
6585          return new Enumeration<Currencies>(this, Currencies.LBP, code);
6586        if ("LKR".equals(codeString))
6587          return new Enumeration<Currencies>(this, Currencies.LKR, code);
6588        if ("LRD".equals(codeString))
6589          return new Enumeration<Currencies>(this, Currencies.LRD, code);
6590        if ("LSL".equals(codeString))
6591          return new Enumeration<Currencies>(this, Currencies.LSL, code);
6592        if ("LYD".equals(codeString))
6593          return new Enumeration<Currencies>(this, Currencies.LYD, code);
6594        if ("MAD".equals(codeString))
6595          return new Enumeration<Currencies>(this, Currencies.MAD, code);
6596        if ("MDL".equals(codeString))
6597          return new Enumeration<Currencies>(this, Currencies.MDL, code);
6598        if ("MGA".equals(codeString))
6599          return new Enumeration<Currencies>(this, Currencies.MGA, code);
6600        if ("MKD".equals(codeString))
6601          return new Enumeration<Currencies>(this, Currencies.MKD, code);
6602        if ("MMK".equals(codeString))
6603          return new Enumeration<Currencies>(this, Currencies.MMK, code);
6604        if ("MNT".equals(codeString))
6605          return new Enumeration<Currencies>(this, Currencies.MNT, code);
6606        if ("MOP".equals(codeString))
6607          return new Enumeration<Currencies>(this, Currencies.MOP, code);
6608        if ("MRU".equals(codeString))
6609          return new Enumeration<Currencies>(this, Currencies.MRU, code);
6610        if ("MUR".equals(codeString))
6611          return new Enumeration<Currencies>(this, Currencies.MUR, code);
6612        if ("MVR".equals(codeString))
6613          return new Enumeration<Currencies>(this, Currencies.MVR, code);
6614        if ("MWK".equals(codeString))
6615          return new Enumeration<Currencies>(this, Currencies.MWK, code);
6616        if ("MXN".equals(codeString))
6617          return new Enumeration<Currencies>(this, Currencies.MXN, code);
6618        if ("MXV".equals(codeString))
6619          return new Enumeration<Currencies>(this, Currencies.MXV, code);
6620        if ("MYR".equals(codeString))
6621          return new Enumeration<Currencies>(this, Currencies.MYR, code);
6622        if ("MZN".equals(codeString))
6623          return new Enumeration<Currencies>(this, Currencies.MZN, code);
6624        if ("NAD".equals(codeString))
6625          return new Enumeration<Currencies>(this, Currencies.NAD, code);
6626        if ("NGN".equals(codeString))
6627          return new Enumeration<Currencies>(this, Currencies.NGN, code);
6628        if ("NIO".equals(codeString))
6629          return new Enumeration<Currencies>(this, Currencies.NIO, code);
6630        if ("NOK".equals(codeString))
6631          return new Enumeration<Currencies>(this, Currencies.NOK, code);
6632        if ("NPR".equals(codeString))
6633          return new Enumeration<Currencies>(this, Currencies.NPR, code);
6634        if ("NZD".equals(codeString))
6635          return new Enumeration<Currencies>(this, Currencies.NZD, code);
6636        if ("OMR".equals(codeString))
6637          return new Enumeration<Currencies>(this, Currencies.OMR, code);
6638        if ("PAB".equals(codeString))
6639          return new Enumeration<Currencies>(this, Currencies.PAB, code);
6640        if ("PEN".equals(codeString))
6641          return new Enumeration<Currencies>(this, Currencies.PEN, code);
6642        if ("PGK".equals(codeString))
6643          return new Enumeration<Currencies>(this, Currencies.PGK, code);
6644        if ("PHP".equals(codeString))
6645          return new Enumeration<Currencies>(this, Currencies.PHP, code);
6646        if ("PKR".equals(codeString))
6647          return new Enumeration<Currencies>(this, Currencies.PKR, code);
6648        if ("PLN".equals(codeString))
6649          return new Enumeration<Currencies>(this, Currencies.PLN, code);
6650        if ("PYG".equals(codeString))
6651          return new Enumeration<Currencies>(this, Currencies.PYG, code);
6652        if ("QAR".equals(codeString))
6653          return new Enumeration<Currencies>(this, Currencies.QAR, code);
6654        if ("RON".equals(codeString))
6655          return new Enumeration<Currencies>(this, Currencies.RON, code);
6656        if ("RSD".equals(codeString))
6657          return new Enumeration<Currencies>(this, Currencies.RSD, code);
6658        if ("RUB".equals(codeString))
6659          return new Enumeration<Currencies>(this, Currencies.RUB, code);
6660        if ("RWF".equals(codeString))
6661          return new Enumeration<Currencies>(this, Currencies.RWF, code);
6662        if ("SAR".equals(codeString))
6663          return new Enumeration<Currencies>(this, Currencies.SAR, code);
6664        if ("SBD".equals(codeString))
6665          return new Enumeration<Currencies>(this, Currencies.SBD, code);
6666        if ("SCR".equals(codeString))
6667          return new Enumeration<Currencies>(this, Currencies.SCR, code);
6668        if ("SDG".equals(codeString))
6669          return new Enumeration<Currencies>(this, Currencies.SDG, code);
6670        if ("SEK".equals(codeString))
6671          return new Enumeration<Currencies>(this, Currencies.SEK, code);
6672        if ("SGD".equals(codeString))
6673          return new Enumeration<Currencies>(this, Currencies.SGD, code);
6674        if ("SHP".equals(codeString))
6675          return new Enumeration<Currencies>(this, Currencies.SHP, code);
6676        if ("SLL".equals(codeString))
6677          return new Enumeration<Currencies>(this, Currencies.SLL, code);
6678        if ("SOS".equals(codeString))
6679          return new Enumeration<Currencies>(this, Currencies.SOS, code);
6680        if ("SRD".equals(codeString))
6681          return new Enumeration<Currencies>(this, Currencies.SRD, code);
6682        if ("SSP".equals(codeString))
6683          return new Enumeration<Currencies>(this, Currencies.SSP, code);
6684        if ("STN".equals(codeString))
6685          return new Enumeration<Currencies>(this, Currencies.STN, code);
6686        if ("SVC".equals(codeString))
6687          return new Enumeration<Currencies>(this, Currencies.SVC, code);
6688        if ("SYP".equals(codeString))
6689          return new Enumeration<Currencies>(this, Currencies.SYP, code);
6690        if ("SZL".equals(codeString))
6691          return new Enumeration<Currencies>(this, Currencies.SZL, code);
6692        if ("THB".equals(codeString))
6693          return new Enumeration<Currencies>(this, Currencies.THB, code);
6694        if ("TJS".equals(codeString))
6695          return new Enumeration<Currencies>(this, Currencies.TJS, code);
6696        if ("TMT".equals(codeString))
6697          return new Enumeration<Currencies>(this, Currencies.TMT, code);
6698        if ("TND".equals(codeString))
6699          return new Enumeration<Currencies>(this, Currencies.TND, code);
6700        if ("TOP".equals(codeString))
6701          return new Enumeration<Currencies>(this, Currencies.TOP, code);
6702        if ("TRY".equals(codeString))
6703          return new Enumeration<Currencies>(this, Currencies.TRY, code);
6704        if ("TTD".equals(codeString))
6705          return new Enumeration<Currencies>(this, Currencies.TTD, code);
6706        if ("TVD".equals(codeString))
6707          return new Enumeration<Currencies>(this, Currencies.TVD, code);
6708        if ("TWD".equals(codeString))
6709          return new Enumeration<Currencies>(this, Currencies.TWD, code);
6710        if ("TZS".equals(codeString))
6711          return new Enumeration<Currencies>(this, Currencies.TZS, code);
6712        if ("UAH".equals(codeString))
6713          return new Enumeration<Currencies>(this, Currencies.UAH, code);
6714        if ("UGX".equals(codeString))
6715          return new Enumeration<Currencies>(this, Currencies.UGX, code);
6716        if ("USD".equals(codeString))
6717          return new Enumeration<Currencies>(this, Currencies.USD, code);
6718        if ("USN".equals(codeString))
6719          return new Enumeration<Currencies>(this, Currencies.USN, code);
6720        if ("UYI".equals(codeString))
6721          return new Enumeration<Currencies>(this, Currencies.UYI, code);
6722        if ("UYU".equals(codeString))
6723          return new Enumeration<Currencies>(this, Currencies.UYU, code);
6724        if ("UZS".equals(codeString))
6725          return new Enumeration<Currencies>(this, Currencies.UZS, code);
6726        if ("VEF".equals(codeString))
6727          return new Enumeration<Currencies>(this, Currencies.VEF, code);
6728        if ("VND".equals(codeString))
6729          return new Enumeration<Currencies>(this, Currencies.VND, code);
6730        if ("VUV".equals(codeString))
6731          return new Enumeration<Currencies>(this, Currencies.VUV, code);
6732        if ("WST".equals(codeString))
6733          return new Enumeration<Currencies>(this, Currencies.WST, code);
6734        if ("XAF".equals(codeString))
6735          return new Enumeration<Currencies>(this, Currencies.XAF, code);
6736        if ("XAG".equals(codeString))
6737          return new Enumeration<Currencies>(this, Currencies.XAG, code);
6738        if ("XAU".equals(codeString))
6739          return new Enumeration<Currencies>(this, Currencies.XAU, code);
6740        if ("XBA".equals(codeString))
6741          return new Enumeration<Currencies>(this, Currencies.XBA, code);
6742        if ("XBB".equals(codeString))
6743          return new Enumeration<Currencies>(this, Currencies.XBB, code);
6744        if ("XBC".equals(codeString))
6745          return new Enumeration<Currencies>(this, Currencies.XBC, code);
6746        if ("XBD".equals(codeString))
6747          return new Enumeration<Currencies>(this, Currencies.XBD, code);
6748        if ("XCD".equals(codeString))
6749          return new Enumeration<Currencies>(this, Currencies.XCD, code);
6750        if ("XDR".equals(codeString))
6751          return new Enumeration<Currencies>(this, Currencies.XDR, code);
6752        if ("XOF".equals(codeString))
6753          return new Enumeration<Currencies>(this, Currencies.XOF, code);
6754        if ("XPD".equals(codeString))
6755          return new Enumeration<Currencies>(this, Currencies.XPD, code);
6756        if ("XPF".equals(codeString))
6757          return new Enumeration<Currencies>(this, Currencies.XPF, code);
6758        if ("XPT".equals(codeString))
6759          return new Enumeration<Currencies>(this, Currencies.XPT, code);
6760        if ("XSU".equals(codeString))
6761          return new Enumeration<Currencies>(this, Currencies.XSU, code);
6762        if ("XTS".equals(codeString))
6763          return new Enumeration<Currencies>(this, Currencies.XTS, code);
6764        if ("XUA".equals(codeString))
6765          return new Enumeration<Currencies>(this, Currencies.XUA, code);
6766        if ("XXX".equals(codeString))
6767          return new Enumeration<Currencies>(this, Currencies.XXX, code);
6768        if ("YER".equals(codeString))
6769          return new Enumeration<Currencies>(this, Currencies.YER, code);
6770        if ("ZAR".equals(codeString))
6771          return new Enumeration<Currencies>(this, Currencies.ZAR, code);
6772        if ("ZMW".equals(codeString))
6773          return new Enumeration<Currencies>(this, Currencies.ZMW, code);
6774        if ("ZWL".equals(codeString))
6775          return new Enumeration<Currencies>(this, Currencies.ZWL, code);
6776        throw new FHIRException("Unknown Currencies code '"+codeString+"'");
6777        }
6778    public String toCode(Currencies code) {
6779       if (code == Currencies.NULL)
6780           return null;
6781       if (code == Currencies.AED)
6782        return "AED";
6783      if (code == Currencies.AFN)
6784        return "AFN";
6785      if (code == Currencies.ALL)
6786        return "ALL";
6787      if (code == Currencies.AMD)
6788        return "AMD";
6789      if (code == Currencies.ANG)
6790        return "ANG";
6791      if (code == Currencies.AOA)
6792        return "AOA";
6793      if (code == Currencies.ARS)
6794        return "ARS";
6795      if (code == Currencies.AUD)
6796        return "AUD";
6797      if (code == Currencies.AWG)
6798        return "AWG";
6799      if (code == Currencies.AZN)
6800        return "AZN";
6801      if (code == Currencies.BAM)
6802        return "BAM";
6803      if (code == Currencies.BBD)
6804        return "BBD";
6805      if (code == Currencies.BDT)
6806        return "BDT";
6807      if (code == Currencies.BGN)
6808        return "BGN";
6809      if (code == Currencies.BHD)
6810        return "BHD";
6811      if (code == Currencies.BIF)
6812        return "BIF";
6813      if (code == Currencies.BMD)
6814        return "BMD";
6815      if (code == Currencies.BND)
6816        return "BND";
6817      if (code == Currencies.BOB)
6818        return "BOB";
6819      if (code == Currencies.BOV)
6820        return "BOV";
6821      if (code == Currencies.BRL)
6822        return "BRL";
6823      if (code == Currencies.BSD)
6824        return "BSD";
6825      if (code == Currencies.BTN)
6826        return "BTN";
6827      if (code == Currencies.BWP)
6828        return "BWP";
6829      if (code == Currencies.BYN)
6830        return "BYN";
6831      if (code == Currencies.BZD)
6832        return "BZD";
6833      if (code == Currencies.CAD)
6834        return "CAD";
6835      if (code == Currencies.CDF)
6836        return "CDF";
6837      if (code == Currencies.CHE)
6838        return "CHE";
6839      if (code == Currencies.CHF)
6840        return "CHF";
6841      if (code == Currencies.CHW)
6842        return "CHW";
6843      if (code == Currencies.CLF)
6844        return "CLF";
6845      if (code == Currencies.CLP)
6846        return "CLP";
6847      if (code == Currencies.CNY)
6848        return "CNY";
6849      if (code == Currencies.COP)
6850        return "COP";
6851      if (code == Currencies.COU)
6852        return "COU";
6853      if (code == Currencies.CRC)
6854        return "CRC";
6855      if (code == Currencies.CUC)
6856        return "CUC";
6857      if (code == Currencies.CUP)
6858        return "CUP";
6859      if (code == Currencies.CVE)
6860        return "CVE";
6861      if (code == Currencies.CZK)
6862        return "CZK";
6863      if (code == Currencies.DJF)
6864        return "DJF";
6865      if (code == Currencies.DKK)
6866        return "DKK";
6867      if (code == Currencies.DOP)
6868        return "DOP";
6869      if (code == Currencies.DZD)
6870        return "DZD";
6871      if (code == Currencies.EGP)
6872        return "EGP";
6873      if (code == Currencies.ERN)
6874        return "ERN";
6875      if (code == Currencies.ETB)
6876        return "ETB";
6877      if (code == Currencies.EUR)
6878        return "EUR";
6879      if (code == Currencies.FJD)
6880        return "FJD";
6881      if (code == Currencies.FKP)
6882        return "FKP";
6883      if (code == Currencies.GBP)
6884        return "GBP";
6885      if (code == Currencies.GEL)
6886        return "GEL";
6887      if (code == Currencies.GGP)
6888        return "GGP";
6889      if (code == Currencies.GHS)
6890        return "GHS";
6891      if (code == Currencies.GIP)
6892        return "GIP";
6893      if (code == Currencies.GMD)
6894        return "GMD";
6895      if (code == Currencies.GNF)
6896        return "GNF";
6897      if (code == Currencies.GTQ)
6898        return "GTQ";
6899      if (code == Currencies.GYD)
6900        return "GYD";
6901      if (code == Currencies.HKD)
6902        return "HKD";
6903      if (code == Currencies.HNL)
6904        return "HNL";
6905      if (code == Currencies.HRK)
6906        return "HRK";
6907      if (code == Currencies.HTG)
6908        return "HTG";
6909      if (code == Currencies.HUF)
6910        return "HUF";
6911      if (code == Currencies.IDR)
6912        return "IDR";
6913      if (code == Currencies.ILS)
6914        return "ILS";
6915      if (code == Currencies.IMP)
6916        return "IMP";
6917      if (code == Currencies.INR)
6918        return "INR";
6919      if (code == Currencies.IQD)
6920        return "IQD";
6921      if (code == Currencies.IRR)
6922        return "IRR";
6923      if (code == Currencies.ISK)
6924        return "ISK";
6925      if (code == Currencies.JEP)
6926        return "JEP";
6927      if (code == Currencies.JMD)
6928        return "JMD";
6929      if (code == Currencies.JOD)
6930        return "JOD";
6931      if (code == Currencies.JPY)
6932        return "JPY";
6933      if (code == Currencies.KES)
6934        return "KES";
6935      if (code == Currencies.KGS)
6936        return "KGS";
6937      if (code == Currencies.KHR)
6938        return "KHR";
6939      if (code == Currencies.KMF)
6940        return "KMF";
6941      if (code == Currencies.KPW)
6942        return "KPW";
6943      if (code == Currencies.KRW)
6944        return "KRW";
6945      if (code == Currencies.KWD)
6946        return "KWD";
6947      if (code == Currencies.KYD)
6948        return "KYD";
6949      if (code == Currencies.KZT)
6950        return "KZT";
6951      if (code == Currencies.LAK)
6952        return "LAK";
6953      if (code == Currencies.LBP)
6954        return "LBP";
6955      if (code == Currencies.LKR)
6956        return "LKR";
6957      if (code == Currencies.LRD)
6958        return "LRD";
6959      if (code == Currencies.LSL)
6960        return "LSL";
6961      if (code == Currencies.LYD)
6962        return "LYD";
6963      if (code == Currencies.MAD)
6964        return "MAD";
6965      if (code == Currencies.MDL)
6966        return "MDL";
6967      if (code == Currencies.MGA)
6968        return "MGA";
6969      if (code == Currencies.MKD)
6970        return "MKD";
6971      if (code == Currencies.MMK)
6972        return "MMK";
6973      if (code == Currencies.MNT)
6974        return "MNT";
6975      if (code == Currencies.MOP)
6976        return "MOP";
6977      if (code == Currencies.MRU)
6978        return "MRU";
6979      if (code == Currencies.MUR)
6980        return "MUR";
6981      if (code == Currencies.MVR)
6982        return "MVR";
6983      if (code == Currencies.MWK)
6984        return "MWK";
6985      if (code == Currencies.MXN)
6986        return "MXN";
6987      if (code == Currencies.MXV)
6988        return "MXV";
6989      if (code == Currencies.MYR)
6990        return "MYR";
6991      if (code == Currencies.MZN)
6992        return "MZN";
6993      if (code == Currencies.NAD)
6994        return "NAD";
6995      if (code == Currencies.NGN)
6996        return "NGN";
6997      if (code == Currencies.NIO)
6998        return "NIO";
6999      if (code == Currencies.NOK)
7000        return "NOK";
7001      if (code == Currencies.NPR)
7002        return "NPR";
7003      if (code == Currencies.NZD)
7004        return "NZD";
7005      if (code == Currencies.OMR)
7006        return "OMR";
7007      if (code == Currencies.PAB)
7008        return "PAB";
7009      if (code == Currencies.PEN)
7010        return "PEN";
7011      if (code == Currencies.PGK)
7012        return "PGK";
7013      if (code == Currencies.PHP)
7014        return "PHP";
7015      if (code == Currencies.PKR)
7016        return "PKR";
7017      if (code == Currencies.PLN)
7018        return "PLN";
7019      if (code == Currencies.PYG)
7020        return "PYG";
7021      if (code == Currencies.QAR)
7022        return "QAR";
7023      if (code == Currencies.RON)
7024        return "RON";
7025      if (code == Currencies.RSD)
7026        return "RSD";
7027      if (code == Currencies.RUB)
7028        return "RUB";
7029      if (code == Currencies.RWF)
7030        return "RWF";
7031      if (code == Currencies.SAR)
7032        return "SAR";
7033      if (code == Currencies.SBD)
7034        return "SBD";
7035      if (code == Currencies.SCR)
7036        return "SCR";
7037      if (code == Currencies.SDG)
7038        return "SDG";
7039      if (code == Currencies.SEK)
7040        return "SEK";
7041      if (code == Currencies.SGD)
7042        return "SGD";
7043      if (code == Currencies.SHP)
7044        return "SHP";
7045      if (code == Currencies.SLL)
7046        return "SLL";
7047      if (code == Currencies.SOS)
7048        return "SOS";
7049      if (code == Currencies.SRD)
7050        return "SRD";
7051      if (code == Currencies.SSP)
7052        return "SSP";
7053      if (code == Currencies.STN)
7054        return "STN";
7055      if (code == Currencies.SVC)
7056        return "SVC";
7057      if (code == Currencies.SYP)
7058        return "SYP";
7059      if (code == Currencies.SZL)
7060        return "SZL";
7061      if (code == Currencies.THB)
7062        return "THB";
7063      if (code == Currencies.TJS)
7064        return "TJS";
7065      if (code == Currencies.TMT)
7066        return "TMT";
7067      if (code == Currencies.TND)
7068        return "TND";
7069      if (code == Currencies.TOP)
7070        return "TOP";
7071      if (code == Currencies.TRY)
7072        return "TRY";
7073      if (code == Currencies.TTD)
7074        return "TTD";
7075      if (code == Currencies.TVD)
7076        return "TVD";
7077      if (code == Currencies.TWD)
7078        return "TWD";
7079      if (code == Currencies.TZS)
7080        return "TZS";
7081      if (code == Currencies.UAH)
7082        return "UAH";
7083      if (code == Currencies.UGX)
7084        return "UGX";
7085      if (code == Currencies.USD)
7086        return "USD";
7087      if (code == Currencies.USN)
7088        return "USN";
7089      if (code == Currencies.UYI)
7090        return "UYI";
7091      if (code == Currencies.UYU)
7092        return "UYU";
7093      if (code == Currencies.UZS)
7094        return "UZS";
7095      if (code == Currencies.VEF)
7096        return "VEF";
7097      if (code == Currencies.VND)
7098        return "VND";
7099      if (code == Currencies.VUV)
7100        return "VUV";
7101      if (code == Currencies.WST)
7102        return "WST";
7103      if (code == Currencies.XAF)
7104        return "XAF";
7105      if (code == Currencies.XAG)
7106        return "XAG";
7107      if (code == Currencies.XAU)
7108        return "XAU";
7109      if (code == Currencies.XBA)
7110        return "XBA";
7111      if (code == Currencies.XBB)
7112        return "XBB";
7113      if (code == Currencies.XBC)
7114        return "XBC";
7115      if (code == Currencies.XBD)
7116        return "XBD";
7117      if (code == Currencies.XCD)
7118        return "XCD";
7119      if (code == Currencies.XDR)
7120        return "XDR";
7121      if (code == Currencies.XOF)
7122        return "XOF";
7123      if (code == Currencies.XPD)
7124        return "XPD";
7125      if (code == Currencies.XPF)
7126        return "XPF";
7127      if (code == Currencies.XPT)
7128        return "XPT";
7129      if (code == Currencies.XSU)
7130        return "XSU";
7131      if (code == Currencies.XTS)
7132        return "XTS";
7133      if (code == Currencies.XUA)
7134        return "XUA";
7135      if (code == Currencies.XXX)
7136        return "XXX";
7137      if (code == Currencies.YER)
7138        return "YER";
7139      if (code == Currencies.ZAR)
7140        return "ZAR";
7141      if (code == Currencies.ZMW)
7142        return "ZMW";
7143      if (code == Currencies.ZWL)
7144        return "ZWL";
7145      return "?";
7146   }
7147    public String toSystem(Currencies code) {
7148      return code.getSystem();
7149      }
7150    }
7151
7152    public enum DaysOfWeek {
7153        /**
7154         * Monday.
7155         */
7156        MON, 
7157        /**
7158         * Tuesday.
7159         */
7160        TUE, 
7161        /**
7162         * Wednesday.
7163         */
7164        WED, 
7165        /**
7166         * Thursday.
7167         */
7168        THU, 
7169        /**
7170         * Friday.
7171         */
7172        FRI, 
7173        /**
7174         * Saturday.
7175         */
7176        SAT, 
7177        /**
7178         * Sunday.
7179         */
7180        SUN, 
7181        /**
7182         * added to help the parsers
7183         */
7184        NULL;
7185        public static DaysOfWeek fromCode(String codeString) throws FHIRException {
7186            if (codeString == null || "".equals(codeString))
7187                return null;
7188        if ("mon".equals(codeString))
7189          return MON;
7190        if ("tue".equals(codeString))
7191          return TUE;
7192        if ("wed".equals(codeString))
7193          return WED;
7194        if ("thu".equals(codeString))
7195          return THU;
7196        if ("fri".equals(codeString))
7197          return FRI;
7198        if ("sat".equals(codeString))
7199          return SAT;
7200        if ("sun".equals(codeString))
7201          return SUN;
7202        throw new FHIRException("Unknown DaysOfWeek code '"+codeString+"'");
7203        }
7204        public static boolean isValidCode(String codeString) {
7205            if (codeString == null || "".equals(codeString))
7206                return false;
7207          return Utilities.existsInList(codeString, "mon", "tue", "wed", "thu", "fri", "sat", "sun");
7208        }
7209        public String toCode() {
7210          switch (this) {
7211            case MON: return "mon";
7212            case TUE: return "tue";
7213            case WED: return "wed";
7214            case THU: return "thu";
7215            case FRI: return "fri";
7216            case SAT: return "sat";
7217            case SUN: return "sun";
7218            case NULL: return null;
7219            default: return "?";
7220          }
7221        }
7222        public String getSystem() {
7223          switch (this) {
7224            case MON: return "http://hl7.org/fhir/days-of-week";
7225            case TUE: return "http://hl7.org/fhir/days-of-week";
7226            case WED: return "http://hl7.org/fhir/days-of-week";
7227            case THU: return "http://hl7.org/fhir/days-of-week";
7228            case FRI: return "http://hl7.org/fhir/days-of-week";
7229            case SAT: return "http://hl7.org/fhir/days-of-week";
7230            case SUN: return "http://hl7.org/fhir/days-of-week";
7231            case NULL: return null;
7232            default: return "?";
7233          }
7234        }
7235        public String getDefinition() {
7236          switch (this) {
7237            case MON: return "Monday.";
7238            case TUE: return "Tuesday.";
7239            case WED: return "Wednesday.";
7240            case THU: return "Thursday.";
7241            case FRI: return "Friday.";
7242            case SAT: return "Saturday.";
7243            case SUN: return "Sunday.";
7244            case NULL: return null;
7245            default: return "?";
7246          }
7247        }
7248        public String getDisplay() {
7249          switch (this) {
7250            case MON: return "Monday";
7251            case TUE: return "Tuesday";
7252            case WED: return "Wednesday";
7253            case THU: return "Thursday";
7254            case FRI: return "Friday";
7255            case SAT: return "Saturday";
7256            case SUN: return "Sunday";
7257            case NULL: return null;
7258            default: return "?";
7259          }
7260        }
7261    }
7262
7263  public static class DaysOfWeekEnumFactory implements EnumFactory<DaysOfWeek> {
7264    public DaysOfWeek fromCode(String codeString) throws IllegalArgumentException {
7265      if (codeString == null || "".equals(codeString))
7266            if (codeString == null || "".equals(codeString))
7267                return null;
7268        if ("mon".equals(codeString))
7269          return DaysOfWeek.MON;
7270        if ("tue".equals(codeString))
7271          return DaysOfWeek.TUE;
7272        if ("wed".equals(codeString))
7273          return DaysOfWeek.WED;
7274        if ("thu".equals(codeString))
7275          return DaysOfWeek.THU;
7276        if ("fri".equals(codeString))
7277          return DaysOfWeek.FRI;
7278        if ("sat".equals(codeString))
7279          return DaysOfWeek.SAT;
7280        if ("sun".equals(codeString))
7281          return DaysOfWeek.SUN;
7282        throw new IllegalArgumentException("Unknown DaysOfWeek code '"+codeString+"'");
7283        }
7284
7285        public Enumeration<DaysOfWeek> fromType(PrimitiveType<?> code) throws FHIRException {
7286          if (code == null)
7287            return null;
7288          if (code.isEmpty())
7289            return new Enumeration<DaysOfWeek>(this, DaysOfWeek.NULL, code);
7290          String codeString = ((PrimitiveType) code).asStringValue();
7291          if (codeString == null || "".equals(codeString))
7292            return new Enumeration<DaysOfWeek>(this, DaysOfWeek.NULL, code);
7293        if ("mon".equals(codeString))
7294          return new Enumeration<DaysOfWeek>(this, DaysOfWeek.MON, code);
7295        if ("tue".equals(codeString))
7296          return new Enumeration<DaysOfWeek>(this, DaysOfWeek.TUE, code);
7297        if ("wed".equals(codeString))
7298          return new Enumeration<DaysOfWeek>(this, DaysOfWeek.WED, code);
7299        if ("thu".equals(codeString))
7300          return new Enumeration<DaysOfWeek>(this, DaysOfWeek.THU, code);
7301        if ("fri".equals(codeString))
7302          return new Enumeration<DaysOfWeek>(this, DaysOfWeek.FRI, code);
7303        if ("sat".equals(codeString))
7304          return new Enumeration<DaysOfWeek>(this, DaysOfWeek.SAT, code);
7305        if ("sun".equals(codeString))
7306          return new Enumeration<DaysOfWeek>(this, DaysOfWeek.SUN, code);
7307        throw new FHIRException("Unknown DaysOfWeek code '"+codeString+"'");
7308        }
7309    public String toCode(DaysOfWeek code) {
7310       if (code == DaysOfWeek.NULL)
7311           return null;
7312       if (code == DaysOfWeek.MON)
7313        return "mon";
7314      if (code == DaysOfWeek.TUE)
7315        return "tue";
7316      if (code == DaysOfWeek.WED)
7317        return "wed";
7318      if (code == DaysOfWeek.THU)
7319        return "thu";
7320      if (code == DaysOfWeek.FRI)
7321        return "fri";
7322      if (code == DaysOfWeek.SAT)
7323        return "sat";
7324      if (code == DaysOfWeek.SUN)
7325        return "sun";
7326      return "?";
7327   }
7328    public String toSystem(DaysOfWeek code) {
7329      return code.getSystem();
7330      }
7331    }
7332
7333    public enum DeviceNameType {
7334        /**
7335         * The term assigned to a medical device by the entity who registers or submits information about it to a jurisdiction or its databases. This may be considered the manufacturer assigned name (e.g., brand name assigned by the labeler or manufacturer in US, or device name assigned by the manufacturer in EU) and may also be synonymous with proprietary name or trade name of the device.
7336         */
7337        REGISTEREDNAME, 
7338        /**
7339         * The term that generically describes the device by a name as assigned by the manufacturer that is recognized by lay person.  This common or generic name may be printed on the package it came in or some combination of that name with the model number, serial number, or other attribute that makes the name easy to understand for the user of that device. It is often exposed in communicating devices transport protocols. It is provided to help users identify the device when reported in discovery operations.
7340         */
7341        USERFRIENDLYNAME, 
7342        /**
7343         * the term used by the patient associated with the device when describing the device, for example 'knee implant', when documented as a self-reported device.
7344         */
7345        PATIENTREPORTEDNAME, 
7346        /**
7347         * added to help the parsers
7348         */
7349        NULL;
7350        public static DeviceNameType fromCode(String codeString) throws FHIRException {
7351            if (codeString == null || "".equals(codeString))
7352                return null;
7353        if ("registered-name".equals(codeString))
7354          return REGISTEREDNAME;
7355        if ("user-friendly-name".equals(codeString))
7356          return USERFRIENDLYNAME;
7357        if ("patient-reported-name".equals(codeString))
7358          return PATIENTREPORTEDNAME;
7359        throw new FHIRException("Unknown DeviceNameType code '"+codeString+"'");
7360        }
7361        public static boolean isValidCode(String codeString) {
7362            if (codeString == null || "".equals(codeString))
7363                return false;
7364          return Utilities.existsInList(codeString, "registered-name", "user-friendly-name", "patient-reported-name");
7365        }
7366        public String toCode() {
7367          switch (this) {
7368            case REGISTEREDNAME: return "registered-name";
7369            case USERFRIENDLYNAME: return "user-friendly-name";
7370            case PATIENTREPORTEDNAME: return "patient-reported-name";
7371            case NULL: return null;
7372            default: return "?";
7373          }
7374        }
7375        public String getSystem() {
7376          switch (this) {
7377            case REGISTEREDNAME: return "http://hl7.org/fhir/device-nametype";
7378            case USERFRIENDLYNAME: return "http://hl7.org/fhir/device-nametype";
7379            case PATIENTREPORTEDNAME: return "http://hl7.org/fhir/device-nametype";
7380            case NULL: return null;
7381            default: return "?";
7382          }
7383        }
7384        public String getDefinition() {
7385          switch (this) {
7386            case REGISTEREDNAME: return "The term assigned to a medical device by the entity who registers or submits information about it to a jurisdiction or its databases. This may be considered the manufacturer assigned name (e.g., brand name assigned by the labeler or manufacturer in US, or device name assigned by the manufacturer in EU) and may also be synonymous with proprietary name or trade name of the device.";
7387            case USERFRIENDLYNAME: return "The term that generically describes the device by a name as assigned by the manufacturer that is recognized by lay person.  This common or generic name may be printed on the package it came in or some combination of that name with the model number, serial number, or other attribute that makes the name easy to understand for the user of that device. It is often exposed in communicating devices transport protocols. It is provided to help users identify the device when reported in discovery operations.";
7388            case PATIENTREPORTEDNAME: return "the term used by the patient associated with the device when describing the device, for example 'knee implant', when documented as a self-reported device.";
7389            case NULL: return null;
7390            default: return "?";
7391          }
7392        }
7393        public String getDisplay() {
7394          switch (this) {
7395            case REGISTEREDNAME: return "Registered name";
7396            case USERFRIENDLYNAME: return "User Friendly name";
7397            case PATIENTREPORTEDNAME: return "Patient Reported name";
7398            case NULL: return null;
7399            default: return "?";
7400          }
7401        }
7402    }
7403
7404  public static class DeviceNameTypeEnumFactory implements EnumFactory<DeviceNameType> {
7405    public DeviceNameType fromCode(String codeString) throws IllegalArgumentException {
7406      if (codeString == null || "".equals(codeString))
7407            if (codeString == null || "".equals(codeString))
7408                return null;
7409        if ("registered-name".equals(codeString))
7410          return DeviceNameType.REGISTEREDNAME;
7411        if ("user-friendly-name".equals(codeString))
7412          return DeviceNameType.USERFRIENDLYNAME;
7413        if ("patient-reported-name".equals(codeString))
7414          return DeviceNameType.PATIENTREPORTEDNAME;
7415        throw new IllegalArgumentException("Unknown DeviceNameType code '"+codeString+"'");
7416        }
7417
7418        public Enumeration<DeviceNameType> fromType(PrimitiveType<?> code) throws FHIRException {
7419          if (code == null)
7420            return null;
7421          if (code.isEmpty())
7422            return new Enumeration<DeviceNameType>(this, DeviceNameType.NULL, code);
7423          String codeString = ((PrimitiveType) code).asStringValue();
7424          if (codeString == null || "".equals(codeString))
7425            return new Enumeration<DeviceNameType>(this, DeviceNameType.NULL, code);
7426        if ("registered-name".equals(codeString))
7427          return new Enumeration<DeviceNameType>(this, DeviceNameType.REGISTEREDNAME, code);
7428        if ("user-friendly-name".equals(codeString))
7429          return new Enumeration<DeviceNameType>(this, DeviceNameType.USERFRIENDLYNAME, code);
7430        if ("patient-reported-name".equals(codeString))
7431          return new Enumeration<DeviceNameType>(this, DeviceNameType.PATIENTREPORTEDNAME, code);
7432        throw new FHIRException("Unknown DeviceNameType code '"+codeString+"'");
7433        }
7434    public String toCode(DeviceNameType code) {
7435       if (code == DeviceNameType.NULL)
7436           return null;
7437       if (code == DeviceNameType.REGISTEREDNAME)
7438        return "registered-name";
7439      if (code == DeviceNameType.USERFRIENDLYNAME)
7440        return "user-friendly-name";
7441      if (code == DeviceNameType.PATIENTREPORTEDNAME)
7442        return "patient-reported-name";
7443      return "?";
7444   }
7445    public String toSystem(DeviceNameType code) {
7446      return code.getSystem();
7447      }
7448    }
7449
7450    public enum EncounterStatus {
7451        /**
7452         * The Encounter has not yet started.
7453         */
7454        PLANNED, 
7455        /**
7456         * The Encounter has begun and the patient is present / the practitioner and the patient are meeting.
7457         */
7458        INPROGRESS, 
7459        /**
7460         * The Encounter has begun, but is currently on hold, e.g. because the patient is temporarily on leave.
7461         */
7462        ONHOLD, 
7463        /**
7464         * The Encounter has been clinically completed, the patient has been discharged from the facility or the visit has ended, and the patient may have departed (refer to subjectStatus). While the encounter is in this status, administrative activities are usually performed, collating all required documentation and charge information before being released for billing, at which point the status will move to completed.
7465         */
7466        DISCHARGED, 
7467        /**
7468         * The Encounter has ended.
7469         */
7470        COMPLETED, 
7471        /**
7472         * The Encounter has ended before it has begun.
7473         */
7474        CANCELLED, 
7475        /**
7476         * The Encounter has started, but was not able to be completed. Further action may need to be performed, such as rescheduling appointments related to this encounter.
7477         */
7478        DISCONTINUED, 
7479        /**
7480         * This instance should not have been part of this patient's medical record.
7481         */
7482        ENTEREDINERROR, 
7483        /**
7484         * The encounter status is unknown. Note that "unknown" is a value of last resort and every attempt should be made to provide a meaningful value other than "unknown".
7485         */
7486        UNKNOWN, 
7487        /**
7488         * added to help the parsers
7489         */
7490        NULL;
7491        public static EncounterStatus fromCode(String codeString) throws FHIRException {
7492            if (codeString == null || "".equals(codeString))
7493                return null;
7494        if ("planned".equals(codeString))
7495          return PLANNED;
7496        if ("in-progress".equals(codeString))
7497          return INPROGRESS;
7498        if ("on-hold".equals(codeString))
7499          return ONHOLD;
7500        if ("discharged".equals(codeString))
7501          return DISCHARGED;
7502        if ("completed".equals(codeString))
7503          return COMPLETED;
7504        if ("cancelled".equals(codeString))
7505          return CANCELLED;
7506        if ("discontinued".equals(codeString))
7507          return DISCONTINUED;
7508        if ("entered-in-error".equals(codeString))
7509          return ENTEREDINERROR;
7510        if ("unknown".equals(codeString))
7511          return UNKNOWN;
7512        throw new FHIRException("Unknown EncounterStatus code '"+codeString+"'");
7513        }
7514        public static boolean isValidCode(String codeString) {
7515            if (codeString == null || "".equals(codeString))
7516                return false;
7517          return Utilities.existsInList(codeString, "planned", "in-progress", "on-hold", "discharged", "completed", "cancelled", "discontinued", "entered-in-error", "unknown");
7518        }
7519        public String toCode() {
7520          switch (this) {
7521            case PLANNED: return "planned";
7522            case INPROGRESS: return "in-progress";
7523            case ONHOLD: return "on-hold";
7524            case DISCHARGED: return "discharged";
7525            case COMPLETED: return "completed";
7526            case CANCELLED: return "cancelled";
7527            case DISCONTINUED: return "discontinued";
7528            case ENTEREDINERROR: return "entered-in-error";
7529            case UNKNOWN: return "unknown";
7530            case NULL: return null;
7531            default: return "?";
7532          }
7533        }
7534        public String getSystem() {
7535          switch (this) {
7536            case PLANNED: return "http://hl7.org/fhir/encounter-status";
7537            case INPROGRESS: return "http://hl7.org/fhir/encounter-status";
7538            case ONHOLD: return "http://hl7.org/fhir/encounter-status";
7539            case DISCHARGED: return "http://hl7.org/fhir/encounter-status";
7540            case COMPLETED: return "http://hl7.org/fhir/encounter-status";
7541            case CANCELLED: return "http://hl7.org/fhir/encounter-status";
7542            case DISCONTINUED: return "http://hl7.org/fhir/encounter-status";
7543            case ENTEREDINERROR: return "http://hl7.org/fhir/encounter-status";
7544            case UNKNOWN: return "http://hl7.org/fhir/encounter-status";
7545            case NULL: return null;
7546            default: return "?";
7547          }
7548        }
7549        public String getDefinition() {
7550          switch (this) {
7551            case PLANNED: return "The Encounter has not yet started.";
7552            case INPROGRESS: return "The Encounter has begun and the patient is present / the practitioner and the patient are meeting.";
7553            case ONHOLD: return "The Encounter has begun, but is currently on hold, e.g. because the patient is temporarily on leave.";
7554            case DISCHARGED: return "The Encounter has been clinically completed, the patient has been discharged from the facility or the visit has ended, and the patient may have departed (refer to subjectStatus). While the encounter is in this status, administrative activities are usually performed, collating all required documentation and charge information before being released for billing, at which point the status will move to completed.";
7555            case COMPLETED: return "The Encounter has ended.";
7556            case CANCELLED: return "The Encounter has ended before it has begun.";
7557            case DISCONTINUED: return "The Encounter has started, but was not able to be completed. Further action may need to be performed, such as rescheduling appointments related to this encounter.";
7558            case ENTEREDINERROR: return "This instance should not have been part of this patient's medical record.";
7559            case UNKNOWN: return "The encounter status is unknown. Note that \"unknown\" is a value of last resort and every attempt should be made to provide a meaningful value other than \"unknown\".";
7560            case NULL: return null;
7561            default: return "?";
7562          }
7563        }
7564        public String getDisplay() {
7565          switch (this) {
7566            case PLANNED: return "Planned";
7567            case INPROGRESS: return "In Progress";
7568            case ONHOLD: return "On Hold";
7569            case DISCHARGED: return "Discharged";
7570            case COMPLETED: return "Completed";
7571            case CANCELLED: return "Cancelled";
7572            case DISCONTINUED: return "Discontinued";
7573            case ENTEREDINERROR: return "Entered in Error";
7574            case UNKNOWN: return "Unknown";
7575            case NULL: return null;
7576            default: return "?";
7577          }
7578        }
7579    }
7580
7581  public static class EncounterStatusEnumFactory implements EnumFactory<EncounterStatus> {
7582    public EncounterStatus fromCode(String codeString) throws IllegalArgumentException {
7583      if (codeString == null || "".equals(codeString))
7584            if (codeString == null || "".equals(codeString))
7585                return null;
7586        if ("planned".equals(codeString))
7587          return EncounterStatus.PLANNED;
7588        if ("in-progress".equals(codeString))
7589          return EncounterStatus.INPROGRESS;
7590        if ("on-hold".equals(codeString))
7591          return EncounterStatus.ONHOLD;
7592        if ("discharged".equals(codeString))
7593          return EncounterStatus.DISCHARGED;
7594        if ("completed".equals(codeString))
7595          return EncounterStatus.COMPLETED;
7596        if ("cancelled".equals(codeString))
7597          return EncounterStatus.CANCELLED;
7598        if ("discontinued".equals(codeString))
7599          return EncounterStatus.DISCONTINUED;
7600        if ("entered-in-error".equals(codeString))
7601          return EncounterStatus.ENTEREDINERROR;
7602        if ("unknown".equals(codeString))
7603          return EncounterStatus.UNKNOWN;
7604        throw new IllegalArgumentException("Unknown EncounterStatus code '"+codeString+"'");
7605        }
7606
7607        public Enumeration<EncounterStatus> fromType(PrimitiveType<?> code) throws FHIRException {
7608          if (code == null)
7609            return null;
7610          if (code.isEmpty())
7611            return new Enumeration<EncounterStatus>(this, EncounterStatus.NULL, code);
7612          String codeString = ((PrimitiveType) code).asStringValue();
7613          if (codeString == null || "".equals(codeString))
7614            return new Enumeration<EncounterStatus>(this, EncounterStatus.NULL, code);
7615        if ("planned".equals(codeString))
7616          return new Enumeration<EncounterStatus>(this, EncounterStatus.PLANNED, code);
7617        if ("in-progress".equals(codeString))
7618          return new Enumeration<EncounterStatus>(this, EncounterStatus.INPROGRESS, code);
7619        if ("on-hold".equals(codeString))
7620          return new Enumeration<EncounterStatus>(this, EncounterStatus.ONHOLD, code);
7621        if ("discharged".equals(codeString))
7622          return new Enumeration<EncounterStatus>(this, EncounterStatus.DISCHARGED, code);
7623        if ("completed".equals(codeString))
7624          return new Enumeration<EncounterStatus>(this, EncounterStatus.COMPLETED, code);
7625        if ("cancelled".equals(codeString))
7626          return new Enumeration<EncounterStatus>(this, EncounterStatus.CANCELLED, code);
7627        if ("discontinued".equals(codeString))
7628          return new Enumeration<EncounterStatus>(this, EncounterStatus.DISCONTINUED, code);
7629        if ("entered-in-error".equals(codeString))
7630          return new Enumeration<EncounterStatus>(this, EncounterStatus.ENTEREDINERROR, code);
7631        if ("unknown".equals(codeString))
7632          return new Enumeration<EncounterStatus>(this, EncounterStatus.UNKNOWN, code);
7633        throw new FHIRException("Unknown EncounterStatus code '"+codeString+"'");
7634        }
7635    public String toCode(EncounterStatus code) {
7636       if (code == EncounterStatus.NULL)
7637           return null;
7638       if (code == EncounterStatus.PLANNED)
7639        return "planned";
7640      if (code == EncounterStatus.INPROGRESS)
7641        return "in-progress";
7642      if (code == EncounterStatus.ONHOLD)
7643        return "on-hold";
7644      if (code == EncounterStatus.DISCHARGED)
7645        return "discharged";
7646      if (code == EncounterStatus.COMPLETED)
7647        return "completed";
7648      if (code == EncounterStatus.CANCELLED)
7649        return "cancelled";
7650      if (code == EncounterStatus.DISCONTINUED)
7651        return "discontinued";
7652      if (code == EncounterStatus.ENTEREDINERROR)
7653        return "entered-in-error";
7654      if (code == EncounterStatus.UNKNOWN)
7655        return "unknown";
7656      return "?";
7657   }
7658    public String toSystem(EncounterStatus code) {
7659      return code.getSystem();
7660      }
7661    }
7662
7663    public enum EventStatus {
7664        /**
7665         * 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.
7666         */
7667        PREPARATION, 
7668        /**
7669         * The event is currently occurring.
7670         */
7671        INPROGRESS, 
7672        /**
7673         * 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.
7674         */
7675        NOTDONE, 
7676        /**
7677         * The event has been temporarily stopped but is expected to resume in the future.
7678         */
7679        ONHOLD, 
7680        /**
7681         * 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.
7682         */
7683        STOPPED, 
7684        /**
7685         * The event has now concluded.
7686         */
7687        COMPLETED, 
7688        /**
7689         * 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".).
7690         */
7691        ENTEREDINERROR, 
7692        /**
7693         * 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.
7694         */
7695        UNKNOWN, 
7696        /**
7697         * added to help the parsers
7698         */
7699        NULL;
7700        public static EventStatus fromCode(String codeString) throws FHIRException {
7701            if (codeString == null || "".equals(codeString))
7702                return null;
7703        if ("preparation".equals(codeString))
7704          return PREPARATION;
7705        if ("in-progress".equals(codeString))
7706          return INPROGRESS;
7707        if ("not-done".equals(codeString))
7708          return NOTDONE;
7709        if ("on-hold".equals(codeString))
7710          return ONHOLD;
7711        if ("stopped".equals(codeString))
7712          return STOPPED;
7713        if ("completed".equals(codeString))
7714          return COMPLETED;
7715        if ("entered-in-error".equals(codeString))
7716          return ENTEREDINERROR;
7717        if ("unknown".equals(codeString))
7718          return UNKNOWN;
7719        throw new FHIRException("Unknown EventStatus code '"+codeString+"'");
7720        }
7721        public static boolean isValidCode(String codeString) {
7722            if (codeString == null || "".equals(codeString))
7723                return false;
7724          return Utilities.existsInList(codeString, "preparation", "in-progress", "not-done", "on-hold", "stopped", "completed", "entered-in-error", "unknown");
7725        }
7726        public String toCode() {
7727          switch (this) {
7728            case PREPARATION: return "preparation";
7729            case INPROGRESS: return "in-progress";
7730            case NOTDONE: return "not-done";
7731            case ONHOLD: return "on-hold";
7732            case STOPPED: return "stopped";
7733            case COMPLETED: return "completed";
7734            case ENTEREDINERROR: return "entered-in-error";
7735            case UNKNOWN: return "unknown";
7736            case NULL: return null;
7737            default: return "?";
7738          }
7739        }
7740        public String getSystem() {
7741          switch (this) {
7742            case PREPARATION: return "http://hl7.org/fhir/event-status";
7743            case INPROGRESS: return "http://hl7.org/fhir/event-status";
7744            case NOTDONE: return "http://hl7.org/fhir/event-status";
7745            case ONHOLD: return "http://hl7.org/fhir/event-status";
7746            case STOPPED: return "http://hl7.org/fhir/event-status";
7747            case COMPLETED: return "http://hl7.org/fhir/event-status";
7748            case ENTEREDINERROR: return "http://hl7.org/fhir/event-status";
7749            case UNKNOWN: return "http://hl7.org/fhir/event-status";
7750            case NULL: return null;
7751            default: return "?";
7752          }
7753        }
7754        public String getDefinition() {
7755          switch (this) {
7756            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.";
7757            case INPROGRESS: return "The event is currently occurring.";
7758            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.";
7759            case ONHOLD: return "The event has been temporarily stopped but is expected to resume in the future.";
7760            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.";
7761            case COMPLETED: return "The event has now concluded.";
7762            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\".).";
7763            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.";
7764            case NULL: return null;
7765            default: return "?";
7766          }
7767        }
7768        public String getDisplay() {
7769          switch (this) {
7770            case PREPARATION: return "Preparation";
7771            case INPROGRESS: return "In Progress";
7772            case NOTDONE: return "Not Done";
7773            case ONHOLD: return "On Hold";
7774            case STOPPED: return "Stopped";
7775            case COMPLETED: return "Completed";
7776            case ENTEREDINERROR: return "Entered in Error";
7777            case UNKNOWN: return "Unknown";
7778            case NULL: return null;
7779            default: return "?";
7780          }
7781        }
7782    }
7783
7784  public static class EventStatusEnumFactory implements EnumFactory<EventStatus> {
7785    public EventStatus fromCode(String codeString) throws IllegalArgumentException {
7786      if (codeString == null || "".equals(codeString))
7787            if (codeString == null || "".equals(codeString))
7788                return null;
7789        if ("preparation".equals(codeString))
7790          return EventStatus.PREPARATION;
7791        if ("in-progress".equals(codeString))
7792          return EventStatus.INPROGRESS;
7793        if ("not-done".equals(codeString))
7794          return EventStatus.NOTDONE;
7795        if ("on-hold".equals(codeString))
7796          return EventStatus.ONHOLD;
7797        if ("stopped".equals(codeString))
7798          return EventStatus.STOPPED;
7799        if ("completed".equals(codeString))
7800          return EventStatus.COMPLETED;
7801        if ("entered-in-error".equals(codeString))
7802          return EventStatus.ENTEREDINERROR;
7803        if ("unknown".equals(codeString))
7804          return EventStatus.UNKNOWN;
7805        throw new IllegalArgumentException("Unknown EventStatus code '"+codeString+"'");
7806        }
7807
7808        public Enumeration<EventStatus> fromType(PrimitiveType<?> code) throws FHIRException {
7809          if (code == null)
7810            return null;
7811          if (code.isEmpty())
7812            return new Enumeration<EventStatus>(this, EventStatus.NULL, code);
7813          String codeString = ((PrimitiveType) code).asStringValue();
7814          if (codeString == null || "".equals(codeString))
7815            return new Enumeration<EventStatus>(this, EventStatus.NULL, code);
7816        if ("preparation".equals(codeString))
7817          return new Enumeration<EventStatus>(this, EventStatus.PREPARATION, code);
7818        if ("in-progress".equals(codeString))
7819          return new Enumeration<EventStatus>(this, EventStatus.INPROGRESS, code);
7820        if ("not-done".equals(codeString))
7821          return new Enumeration<EventStatus>(this, EventStatus.NOTDONE, code);
7822        if ("on-hold".equals(codeString))
7823          return new Enumeration<EventStatus>(this, EventStatus.ONHOLD, code);
7824        if ("stopped".equals(codeString))
7825          return new Enumeration<EventStatus>(this, EventStatus.STOPPED, code);
7826        if ("completed".equals(codeString))
7827          return new Enumeration<EventStatus>(this, EventStatus.COMPLETED, code);
7828        if ("entered-in-error".equals(codeString))
7829          return new Enumeration<EventStatus>(this, EventStatus.ENTEREDINERROR, code);
7830        if ("unknown".equals(codeString))
7831          return new Enumeration<EventStatus>(this, EventStatus.UNKNOWN, code);
7832        throw new FHIRException("Unknown EventStatus code '"+codeString+"'");
7833        }
7834    public String toCode(EventStatus code) {
7835       if (code == EventStatus.NULL)
7836           return null;
7837       if (code == EventStatus.PREPARATION)
7838        return "preparation";
7839      if (code == EventStatus.INPROGRESS)
7840        return "in-progress";
7841      if (code == EventStatus.NOTDONE)
7842        return "not-done";
7843      if (code == EventStatus.ONHOLD)
7844        return "on-hold";
7845      if (code == EventStatus.STOPPED)
7846        return "stopped";
7847      if (code == EventStatus.COMPLETED)
7848        return "completed";
7849      if (code == EventStatus.ENTEREDINERROR)
7850        return "entered-in-error";
7851      if (code == EventStatus.UNKNOWN)
7852        return "unknown";
7853      return "?";
7854   }
7855    public String toSystem(EventStatus code) {
7856      return code.getSystem();
7857      }
7858    }
7859
7860    public enum EvidenceVariableHandling {
7861        /**
7862         * A continuous variable is one for which, within the limits the variable ranges, any value is possible (from STATO http://purl.obolibrary.org/obo/STATO_0000251).
7863         */
7864        CONTINUOUS, 
7865        /**
7866         * A dichotomous variable is a categorical variable which is defined to have only 2 categories or possible values (from STATO http://purl.obolibrary.org/obo/STATO_0000090).
7867         */
7868        DICHOTOMOUS, 
7869        /**
7870         * An ordinal variable is a categorical variable where the discrete possible values are ordered or correspond to an implicit ranking (from STATO http://purl.obolibrary.org/obo/STATO_0000228).
7871         */
7872        ORDINAL, 
7873        /**
7874         * A polychotomous variable is a categorical variable which is defined to have minimally 2 categories or possible values. (from STATO  http://purl.obolibrary.org/obo/STATO_0000087).  Suggestion to limit code use to situations when neither dichotomous nor ordinal variables apply.
7875         */
7876        POLYCHOTOMOUS, 
7877        /**
7878         * added to help the parsers
7879         */
7880        NULL;
7881        public static EvidenceVariableHandling fromCode(String codeString) throws FHIRException {
7882            if (codeString == null || "".equals(codeString))
7883                return null;
7884        if ("continuous".equals(codeString))
7885          return CONTINUOUS;
7886        if ("dichotomous".equals(codeString))
7887          return DICHOTOMOUS;
7888        if ("ordinal".equals(codeString))
7889          return ORDINAL;
7890        if ("polychotomous".equals(codeString))
7891          return POLYCHOTOMOUS;
7892        throw new FHIRException("Unknown EvidenceVariableHandling code '"+codeString+"'");
7893        }
7894        public static boolean isValidCode(String codeString) {
7895            if (codeString == null || "".equals(codeString))
7896                return false;
7897          return Utilities.existsInList(codeString, "continuous", "dichotomous", "ordinal", "polychotomous");
7898        }
7899        public String toCode() {
7900          switch (this) {
7901            case CONTINUOUS: return "continuous";
7902            case DICHOTOMOUS: return "dichotomous";
7903            case ORDINAL: return "ordinal";
7904            case POLYCHOTOMOUS: return "polychotomous";
7905            case NULL: return null;
7906            default: return "?";
7907          }
7908        }
7909        public String getSystem() {
7910          switch (this) {
7911            case CONTINUOUS: return "http://hl7.org/fhir/variable-handling";
7912            case DICHOTOMOUS: return "http://hl7.org/fhir/variable-handling";
7913            case ORDINAL: return "http://hl7.org/fhir/variable-handling";
7914            case POLYCHOTOMOUS: return "http://hl7.org/fhir/variable-handling";
7915            case NULL: return null;
7916            default: return "?";
7917          }
7918        }
7919        public String getDefinition() {
7920          switch (this) {
7921            case CONTINUOUS: return "A continuous variable is one for which, within the limits the variable ranges, any value is possible (from STATO http://purl.obolibrary.org/obo/STATO_0000251).";
7922            case DICHOTOMOUS: return "A dichotomous variable is a categorical variable which is defined to have only 2 categories or possible values (from STATO http://purl.obolibrary.org/obo/STATO_0000090).";
7923            case ORDINAL: return "An ordinal variable is a categorical variable where the discrete possible values are ordered or correspond to an implicit ranking (from STATO http://purl.obolibrary.org/obo/STATO_0000228).";
7924            case POLYCHOTOMOUS: return "A polychotomous variable is a categorical variable which is defined to have minimally 2 categories or possible values. (from STATO  http://purl.obolibrary.org/obo/STATO_0000087).  Suggestion to limit code use to situations when neither dichotomous nor ordinal variables apply.";
7925            case NULL: return null;
7926            default: return "?";
7927          }
7928        }
7929        public String getDisplay() {
7930          switch (this) {
7931            case CONTINUOUS: return "continuous variable";
7932            case DICHOTOMOUS: return "dichotomous variable";
7933            case ORDINAL: return "ordinal variable";
7934            case POLYCHOTOMOUS: return "polychotomous variable";
7935            case NULL: return null;
7936            default: return "?";
7937          }
7938        }
7939    }
7940
7941  public static class EvidenceVariableHandlingEnumFactory implements EnumFactory<EvidenceVariableHandling> {
7942    public EvidenceVariableHandling fromCode(String codeString) throws IllegalArgumentException {
7943      if (codeString == null || "".equals(codeString))
7944            if (codeString == null || "".equals(codeString))
7945                return null;
7946        if ("continuous".equals(codeString))
7947          return EvidenceVariableHandling.CONTINUOUS;
7948        if ("dichotomous".equals(codeString))
7949          return EvidenceVariableHandling.DICHOTOMOUS;
7950        if ("ordinal".equals(codeString))
7951          return EvidenceVariableHandling.ORDINAL;
7952        if ("polychotomous".equals(codeString))
7953          return EvidenceVariableHandling.POLYCHOTOMOUS;
7954        throw new IllegalArgumentException("Unknown EvidenceVariableHandling code '"+codeString+"'");
7955        }
7956
7957        public Enumeration<EvidenceVariableHandling> fromType(PrimitiveType<?> code) throws FHIRException {
7958          if (code == null)
7959            return null;
7960          if (code.isEmpty())
7961            return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.NULL, code);
7962          String codeString = ((PrimitiveType) code).asStringValue();
7963          if (codeString == null || "".equals(codeString))
7964            return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.NULL, code);
7965        if ("continuous".equals(codeString))
7966          return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.CONTINUOUS, code);
7967        if ("dichotomous".equals(codeString))
7968          return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.DICHOTOMOUS, code);
7969        if ("ordinal".equals(codeString))
7970          return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.ORDINAL, code);
7971        if ("polychotomous".equals(codeString))
7972          return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.POLYCHOTOMOUS, code);
7973        throw new FHIRException("Unknown EvidenceVariableHandling code '"+codeString+"'");
7974        }
7975    public String toCode(EvidenceVariableHandling code) {
7976       if (code == EvidenceVariableHandling.NULL)
7977           return null;
7978       if (code == EvidenceVariableHandling.CONTINUOUS)
7979        return "continuous";
7980      if (code == EvidenceVariableHandling.DICHOTOMOUS)
7981        return "dichotomous";
7982      if (code == EvidenceVariableHandling.ORDINAL)
7983        return "ordinal";
7984      if (code == EvidenceVariableHandling.POLYCHOTOMOUS)
7985        return "polychotomous";
7986      return "?";
7987   }
7988    public String toSystem(EvidenceVariableHandling code) {
7989      return code.getSystem();
7990      }
7991    }
7992
7993    public enum ExampleScenarioActorType {
7994        /**
7995         * A human actor
7996         */
7997        PERSON, 
7998        /**
7999         * A software application or other system
8000         */
8001        SYSTEM, 
8002        /**
8003         * added to help the parsers
8004         */
8005        NULL;
8006        public static ExampleScenarioActorType fromCode(String codeString) throws FHIRException {
8007            if (codeString == null || "".equals(codeString))
8008                return null;
8009        if ("person".equals(codeString))
8010          return PERSON;
8011        if ("system".equals(codeString))
8012          return SYSTEM;
8013        throw new FHIRException("Unknown ExampleScenarioActorType code '"+codeString+"'");
8014        }
8015        public static boolean isValidCode(String codeString) {
8016            if (codeString == null || "".equals(codeString))
8017                return false;
8018          return Utilities.existsInList(codeString, "person", "system");
8019        }
8020        public String toCode() {
8021          switch (this) {
8022            case PERSON: return "person";
8023            case SYSTEM: return "system";
8024            case NULL: return null;
8025            default: return "?";
8026          }
8027        }
8028        public String getSystem() {
8029          switch (this) {
8030            case PERSON: return "http://hl7.org/fhir/examplescenario-actor-type";
8031            case SYSTEM: return "http://hl7.org/fhir/examplescenario-actor-type";
8032            case NULL: return null;
8033            default: return "?";
8034          }
8035        }
8036        public String getDefinition() {
8037          switch (this) {
8038            case PERSON: return "A human actor";
8039            case SYSTEM: return "A software application or other system";
8040            case NULL: return null;
8041            default: return "?";
8042          }
8043        }
8044        public String getDisplay() {
8045          switch (this) {
8046            case PERSON: return "Person";
8047            case SYSTEM: return "System";
8048            case NULL: return null;
8049            default: return "?";
8050          }
8051        }
8052    }
8053
8054  public static class ExampleScenarioActorTypeEnumFactory implements EnumFactory<ExampleScenarioActorType> {
8055    public ExampleScenarioActorType fromCode(String codeString) throws IllegalArgumentException {
8056      if (codeString == null || "".equals(codeString))
8057            if (codeString == null || "".equals(codeString))
8058                return null;
8059        if ("person".equals(codeString))
8060          return ExampleScenarioActorType.PERSON;
8061        if ("system".equals(codeString))
8062          return ExampleScenarioActorType.SYSTEM;
8063        throw new IllegalArgumentException("Unknown ExampleScenarioActorType code '"+codeString+"'");
8064        }
8065
8066        public Enumeration<ExampleScenarioActorType> fromType(PrimitiveType<?> code) throws FHIRException {
8067          if (code == null)
8068            return null;
8069          if (code.isEmpty())
8070            return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.NULL, code);
8071          String codeString = ((PrimitiveType) code).asStringValue();
8072          if (codeString == null || "".equals(codeString))
8073            return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.NULL, code);
8074        if ("person".equals(codeString))
8075          return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.PERSON, code);
8076        if ("system".equals(codeString))
8077          return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.SYSTEM, code);
8078        throw new FHIRException("Unknown ExampleScenarioActorType code '"+codeString+"'");
8079        }
8080    public String toCode(ExampleScenarioActorType code) {
8081       if (code == ExampleScenarioActorType.NULL)
8082           return null;
8083       if (code == ExampleScenarioActorType.PERSON)
8084        return "person";
8085      if (code == ExampleScenarioActorType.SYSTEM)
8086        return "system";
8087      return "?";
8088   }
8089    public String toSystem(ExampleScenarioActorType code) {
8090      return code.getSystem();
8091      }
8092    }
8093
8094    public enum FHIRTypes {
8095        /**
8096         * Base Type: Base definition for all types defined in FHIR type system.
8097         */
8098        BASE, 
8099        /**
8100         * Element Type: Base definition for all elements in a resource.
8101         */
8102        ELEMENT, 
8103        /**
8104         * BackboneElement Type: Base definition for all elements that are defined inside a resource - but not those in a data type.
8105         */
8106        BACKBONEELEMENT, 
8107        /**
8108         * DataType Type: The base class for all re-useable types defined as part of the FHIR Specification.
8109         */
8110        DATATYPE, 
8111        /**
8112         * Address Type: 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.
8113The ISO21090-codedString may be used to provide a coded representation of the contents of strings in an Address.
8114         */
8115        ADDRESS, 
8116        /**
8117         * Annotation Type: A  text note which also  contains information about who made the statement and when.
8118         */
8119        ANNOTATION, 
8120        /**
8121         * Attachment Type: For referring to data content defined in other formats.
8122         */
8123        ATTACHMENT, 
8124        /**
8125         * Availability Type: Availability data for an {item}.
8126         */
8127        AVAILABILITY, 
8128        /**
8129         * BackboneType Type: Base definition for the few data types that are allowed to carry modifier extensions.
8130         */
8131        BACKBONETYPE, 
8132        /**
8133         * Dosage Type: Indicates how the medication is/was taken or should be taken by the patient.
8134         */
8135        DOSAGE, 
8136        /**
8137         * ElementDefinition Type: Captures constraints on each element within the resource, profile, or extension.
8138         */
8139        ELEMENTDEFINITION, 
8140        /**
8141         * MarketingStatus Type: 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.
8142         */
8143        MARKETINGSTATUS, 
8144        /**
8145         * ProductShelfLife Type: The shelf-life and storage information for a medicinal product item or container can be described using this class.
8146         */
8147        PRODUCTSHELFLIFE, 
8148        /**
8149         * Timing Type: 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.
8150         */
8151        TIMING, 
8152        /**
8153         * CodeableConcept Type: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text.
8154         */
8155        CODEABLECONCEPT, 
8156        /**
8157         * CodeableReference Type: A reference to a resource (by instance), or instead, a reference to a concept defined in a terminology or ontology (by class).
8158         */
8159        CODEABLEREFERENCE, 
8160        /**
8161         * Coding Type: A reference to a code defined by a terminology system.
8162         */
8163        CODING, 
8164        /**
8165         * ContactDetail Type: Specifies contact information for a person or organization.
8166         */
8167        CONTACTDETAIL, 
8168        /**
8169         * ContactPoint Type: Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc.
8170         */
8171        CONTACTPOINT, 
8172        /**
8173         * Contributor Type: A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers.
8174         */
8175        CONTRIBUTOR, 
8176        /**
8177         * DataRequirement Type: Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data.
8178         */
8179        DATAREQUIREMENT, 
8180        /**
8181         * Expression Type: 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.
8182         */
8183        EXPRESSION, 
8184        /**
8185         * ExtendedContactDetail Type: Specifies contact information for a specific purpose over a period of time, might be handled/monitored by a specific named person or organization.
8186         */
8187        EXTENDEDCONTACTDETAIL, 
8188        /**
8189         * Extension Type: Optional Extension Element - found in all resources.
8190         */
8191        EXTENSION, 
8192        /**
8193         * HumanName Type: A name, normally of a human, that can be used for other living entities (e.g. animals but not organizations) that have been assigned names by a human and may need the use of name parts or the need for usage information.
8194         */
8195        HUMANNAME, 
8196        /**
8197         * Identifier Type: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers.
8198         */
8199        IDENTIFIER, 
8200        /**
8201         * Meta Type: 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.
8202         */
8203        META, 
8204        /**
8205         * MonetaryComponent Type: Availability data for an {item}.
8206         */
8207        MONETARYCOMPONENT, 
8208        /**
8209         * Money Type: An amount of economic utility in some recognized currency.
8210         */
8211        MONEY, 
8212        /**
8213         * Narrative Type: A human-readable summary of the resource conveying the essential clinical and business information for the resource.
8214         */
8215        NARRATIVE, 
8216        /**
8217         * ParameterDefinition Type: 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.
8218         */
8219        PARAMETERDEFINITION, 
8220        /**
8221         * Period Type: A time period defined by a start and end date and optionally time.
8222         */
8223        PERIOD, 
8224        /**
8225         * PrimitiveType Type: The base type for all re-useable types defined that have a simple property.
8226         */
8227        PRIMITIVETYPE, 
8228        /**
8229         * base64Binary Type: A stream of bytes
8230         */
8231        BASE64BINARY, 
8232        /**
8233         * boolean Type: Value of "true" or "false"
8234         */
8235        BOOLEAN, 
8236        /**
8237         * date Type: A date or partial date (e.g. just year or year + month). There is no UTC offset. The format is a union of the schema types gYear, gYearMonth and date.  Dates SHALL be valid dates.
8238         */
8239        DATE, 
8240        /**
8241         * dateTime Type: A date, date-time or partial date (e.g. just year or year + month).  If hours and minutes are specified, a UTC offset 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.
8242         */
8243        DATETIME, 
8244        /**
8245         * decimal Type: A rational number with implicit precision
8246         */
8247        DECIMAL, 
8248        /**
8249         * instant Type: An instant in time - known at least to the second
8250         */
8251        INSTANT, 
8252        /**
8253         * integer Type: A whole number
8254         */
8255        INTEGER, 
8256        /**
8257         * positiveInt type: An integer with a value that is positive (e.g. >0)
8258         */
8259        POSITIVEINT, 
8260        /**
8261         * unsignedInt type: An integer with a value that is not negative (e.g. >= 0)
8262         */
8263        UNSIGNEDINT, 
8264        /**
8265         * integer64 Type: A very large whole number
8266         */
8267        INTEGER64, 
8268        /**
8269         * string Type: A sequence of Unicode characters
8270         */
8271        STRING, 
8272        /**
8273         * code type: 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
8274         */
8275        CODE, 
8276        /**
8277         * id type: 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.
8278         */
8279        ID, 
8280        /**
8281         * markdown type: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine
8282         */
8283        MARKDOWN, 
8284        /**
8285         * time Type: A time during the day, with no date specified
8286         */
8287        TIME, 
8288        /**
8289         * uri Type: String of characters used to identify a name or a resource
8290         */
8291        URI, 
8292        /**
8293         * canonical type: A URI that is a reference to a canonical URL on a FHIR resource
8294         */
8295        CANONICAL, 
8296        /**
8297         * oid type: An OID represented as a URI
8298         */
8299        OID, 
8300        /**
8301         * url type: A URI that is a literal reference
8302         */
8303        URL, 
8304        /**
8305         * uuid type: A UUID, represented as a URI
8306         */
8307        UUID, 
8308        /**
8309         * Quantity Type: 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.
8310         */
8311        QUANTITY, 
8312        /**
8313         * Age Type: A duration of time during which an organism (or a process) has existed.
8314         */
8315        AGE, 
8316        /**
8317         * Count Type: 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.
8318         */
8319        COUNT, 
8320        /**
8321         * Distance Type: A length - a value with a unit that is a physical distance.
8322         */
8323        DISTANCE, 
8324        /**
8325         * Duration Type: A length of time.
8326         */
8327        DURATION, 
8328        /**
8329         * Range Type: A set of ordered Quantities defined by a low and high limit.
8330         */
8331        RANGE, 
8332        /**
8333         * Ratio Type: A relationship of two Quantity values - expressed as a numerator and a denominator.
8334         */
8335        RATIO, 
8336        /**
8337         * RatioRange Type: A range of ratios expressed as a low and high numerator and a denominator.
8338         */
8339        RATIORANGE, 
8340        /**
8341         * Reference Type: A reference from one resource to another.
8342         */
8343        REFERENCE, 
8344        /**
8345         * RelatedArtifact Type: Related artifacts such as additional documentation, justification, or bibliographic references.
8346         */
8347        RELATEDARTIFACT, 
8348        /**
8349         * SampledData Type: A series of measurements taken by a device, with upper and lower limits. There may be more than one dimension in the data.
8350         */
8351        SAMPLEDDATA, 
8352        /**
8353         * Signature Type: 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.
8354         */
8355        SIGNATURE, 
8356        /**
8357         * TriggerDefinition Type: A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element.
8358         */
8359        TRIGGERDEFINITION, 
8360        /**
8361         * UsageContext Type: 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).
8362         */
8363        USAGECONTEXT, 
8364        /**
8365         * VirtualServiceDetail Type: Virtual Service Contact Details.
8366         */
8367        VIRTUALSERVICEDETAIL, 
8368        /**
8369         * xhtml Type definition
8370         */
8371        XHTML, 
8372        /**
8373         * This is the base resource type for everything.
8374         */
8375        RESOURCE, 
8376        /**
8377         * 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.
8378         */
8379        BINARY, 
8380        /**
8381         * A container for a collection of resources.
8382         */
8383        BUNDLE, 
8384        /**
8385         * A resource that includes narrative, extensions, and contained resources.
8386         */
8387        DOMAINRESOURCE, 
8388        /**
8389         * 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.
8390         */
8391        ACCOUNT, 
8392        /**
8393         * This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context.
8394         */
8395        ACTIVITYDEFINITION, 
8396        /**
8397         * The ActorDefinition resource is used to describe an actor - a human or an application that plays a role in data exchange, and that may have obligations associated with the role the actor plays.
8398         */
8399        ACTORDEFINITION, 
8400        /**
8401         * A medicinal product in the final form which is suitable for administering to a patient (after any mixing of multiple components, dissolution etc. has been performed).
8402         */
8403        ADMINISTRABLEPRODUCTDEFINITION, 
8404        /**
8405         * An event (i.e. any change to current patient status) that may be related to unintended effects on a patient or research participant. The unintended effects may require additional monitoring, treatment, hospitalization, or may result in death. The AdverseEvent resource also extends to potential or avoided events that could have had such effects. There are two major domains where the AdverseEvent resource is expected to be used. One is in clinical care reported adverse events and the other is in reporting adverse events in clinical  research trial management.  Adverse events can be reported by healthcare providers, patients, caregivers or by medical products manufacturers.  Given the differences between these two concepts, we recommend consulting the domain specific implementation guides when implementing the AdverseEvent Resource. The implementation guides include specific extensions, value sets and constraints.
8406         */
8407        ADVERSEEVENT, 
8408        /**
8409         * Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance.
8410         */
8411        ALLERGYINTOLERANCE, 
8412        /**
8413         * 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).
8414         */
8415        APPOINTMENT, 
8416        /**
8417         * A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection.
8418         */
8419        APPOINTMENTRESPONSE, 
8420        /**
8421         * This Resource provides one or more comments, classifiers or ratings about a Resource and supports attribution and rights management metadata for the added content.
8422         */
8423        ARTIFACTASSESSMENT, 
8424        /**
8425         * A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis.
8426         */
8427        AUDITEVENT, 
8428        /**
8429         * 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.
8430         */
8431        BASIC, 
8432        /**
8433         * A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity.
8434         */
8435        BIOLOGICALLYDERIVEDPRODUCT, 
8436        /**
8437         * A record of dispensation of a biologically derived product.
8438         */
8439        BIOLOGICALLYDERIVEDPRODUCTDISPENSE, 
8440        /**
8441         * 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.
8442         */
8443        BODYSTRUCTURE, 
8444        /**
8445         * Common Interface declaration for conformance and knowledge artifact resources.
8446         */
8447        CANONICALRESOURCE, 
8448        /**
8449         * A Capability Statement documents a set of capabilities (behaviors) of a FHIR Server or Client 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.
8450         */
8451        CAPABILITYSTATEMENT, 
8452        /**
8453         * 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.
8454         */
8455        CAREPLAN, 
8456        /**
8457         * The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care.
8458         */
8459        CARETEAM, 
8460        /**
8461         * 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.
8462         */
8463        CHARGEITEM, 
8464        /**
8465         * 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.
8466         */
8467        CHARGEITEMDEFINITION, 
8468        /**
8469         * The Citation Resource enables reference to any knowledge artifact for purposes of identification and attribution. The Citation Resource supports existing reference structures and developing publication practices such as versioning, expressing complex contributorship roles, and referencing computable resources.
8470         */
8471        CITATION, 
8472        /**
8473         * 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.
8474         */
8475        CLAIM, 
8476        /**
8477         * This resource provides the adjudication details from the processing of a Claim resource.
8478         */
8479        CLAIMRESPONSE, 
8480        /**
8481         * 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.
8482         */
8483        CLINICALIMPRESSION, 
8484        /**
8485         * A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure.
8486         */
8487        CLINICALUSEDEFINITION, 
8488        /**
8489         * 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.
8490         */
8491        CODESYSTEM, 
8492        /**
8493         * A clinical or business level record of information being transmitted or shared; 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.
8494         */
8495        COMMUNICATION, 
8496        /**
8497         * 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.
8498         */
8499        COMMUNICATIONREQUEST, 
8500        /**
8501         * A compartment definition that defines how resources are accessed on a server.
8502         */
8503        COMPARTMENTDEFINITION, 
8504        /**
8505         * 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.).
8506         */
8507        COMPOSITION, 
8508        /**
8509         * 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.
8510         */
8511        CONCEPTMAP, 
8512        /**
8513         * A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern.
8514         */
8515        CONDITION, 
8516        /**
8517         * A definition of a condition and information relevant to managing it.
8518         */
8519        CONDITIONDEFINITION, 
8520        /**
8521         * 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.
8522         */
8523        CONSENT, 
8524        /**
8525         * Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement.
8526         */
8527        CONTRACT, 
8528        /**
8529         * Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment.
8530         */
8531        COVERAGE, 
8532        /**
8533         * 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.
8534         */
8535        COVERAGEELIGIBILITYREQUEST, 
8536        /**
8537         * This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource.
8538         */
8539        COVERAGEELIGIBILITYRESPONSE, 
8540        /**
8541         * 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, gaps in care, etc.
8542         */
8543        DETECTEDISSUE, 
8544        /**
8545         * This resource describes the properties (regulated, has real time clock, etc.), adminstrative (manufacturer name, model number, serial number, firmware, etc.), and type (knee replacement, blood pressure cuff, MRI, etc.) of a physical unit (these values do not change much within a given module, for example the serail number, manufacturer name, and model number). An actual unit may consist of several modules in a distinct hierarchy and these are represented by multiple Device resources and bound through the 'parent' element.
8546         */
8547        DEVICE, 
8548        /**
8549         * A record of association of a device.
8550         */
8551        DEVICEASSOCIATION, 
8552        /**
8553         * This is a specialized resource that defines the characteristics and capabilities of a device.
8554         */
8555        DEVICEDEFINITION, 
8556        /**
8557         * Indicates that a device is to be or has been dispensed for a named person/patient.  This includes a description of the product (supply) provided and the instructions for using the device.
8558         */
8559        DEVICEDISPENSE, 
8560        /**
8561         * Describes a measurement, calculation or setting capability of a device.  The DeviceMetric resource is derived from the ISO/IEEE 11073-10201 Domain Information Model standard, but is more widely applicable. 
8562         */
8563        DEVICEMETRIC, 
8564        /**
8565         * Represents a request a device to be provided to a specific patient. The device may be an implantable device to be subsequently implanted, or an external assistive device, such as a walker, to be delivered and subsequently be used.
8566         */
8567        DEVICEREQUEST, 
8568        /**
8569         * A record of a device being used by a patient where the record is the result of a report from the patient or a clinician.
8570         */
8571        DEVICEUSAGE, 
8572        /**
8573         * The findings and interpretation of diagnostic tests performed on patients, groups of patients, products, substances, devices, and locations, and/or specimens derived from these. The report includes clinical context such as requesting provider information, and some mix of atomic results, images, textual and coded interpretations, and formatted representation of diagnostic reports. The report also includes non-clinical context such as batch analysis and stability reporting of products and substances.
8574         */
8575        DIAGNOSTICREPORT, 
8576        /**
8577         * 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.
8578         */
8579        DOCUMENTREFERENCE, 
8580        /**
8581         * An interaction between healthcare provider(s), and/or patient(s) for the purpose of providing healthcare service(s) or assessing the health status of patient(s).
8582         */
8583        ENCOUNTER, 
8584        /**
8585         * A record of significant events/milestones key data throughout the history of an Encounter
8586         */
8587        ENCOUNTERHISTORY, 
8588        /**
8589         * The technical details of an endpoint that can be used for electronic services, such as for web services providing XDS.b, a REST endpoint for another FHIR server, or a s/Mime email address. This may include any security context information.
8590         */
8591        ENDPOINT, 
8592        /**
8593         * This resource provides the insurance enrollment details to the insurer regarding a specified coverage.
8594         */
8595        ENROLLMENTREQUEST, 
8596        /**
8597         * This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource.
8598         */
8599        ENROLLMENTRESPONSE, 
8600        /**
8601         * 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.
8602         */
8603        EPISODEOFCARE, 
8604        /**
8605         * The EventDefinition resource provides a reusable description of when a particular event can occur.
8606         */
8607        EVENTDEFINITION, 
8608        /**
8609         * The Evidence Resource provides a machine-interpretable expression of an evidence concept including the evidence variables (e.g., population, exposures/interventions, comparators, outcomes, measured variables, confounding variables), the statistics, and the certainty of this evidence.
8610         */
8611        EVIDENCE, 
8612        /**
8613         * The EvidenceReport Resource is a specialized container for a collection of resources and codeable concepts, adapted to support compositions of Evidence, EvidenceVariable, and Citation resources and related concepts.
8614         */
8615        EVIDENCEREPORT, 
8616        /**
8617         * The EvidenceVariable resource describes an element that knowledge (Evidence) is about.
8618         */
8619        EVIDENCEVARIABLE, 
8620        /**
8621         * A walkthrough of a workflow showing the interaction between systems and the instances shared, possibly including the evolution of instances over time.
8622         */
8623        EXAMPLESCENARIO, 
8624        /**
8625         * 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.
8626         */
8627        EXPLANATIONOFBENEFIT, 
8628        /**
8629         * Significant health conditions for a person related to the patient relevant in the context of care for the patient.
8630         */
8631        FAMILYMEMBERHISTORY, 
8632        /**
8633         * Prospective warnings of potential issues when providing care to the patient.
8634         */
8635        FLAG, 
8636        /**
8637         * This resource describes a product or service that is available through a program and includes the conditions and constraints of availability.  All of the information in this resource is specific to the inclusion of the item in the formulary and is not inherent to the item itself.
8638         */
8639        FORMULARYITEM, 
8640        /**
8641         * A set of analyses performed to analyze and generate genomic data.
8642         */
8643        GENOMICSTUDY, 
8644        /**
8645         * 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.
8646         */
8647        GOAL, 
8648        /**
8649         * 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.
8650         */
8651        GRAPHDEFINITION, 
8652        /**
8653         * 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.
8654         */
8655        GROUP, 
8656        /**
8657         * 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.
8658         */
8659        GUIDANCERESPONSE, 
8660        /**
8661         * The details of a healthcare service available at a location or in a catalog.  In the case where there is a hierarchy of services (for example, Lab -> Pathology -> Wound Cultures), this can be represented using a set of linked HealthcareServices.
8662         */
8663        HEALTHCARESERVICE, 
8664        /**
8665         * A selection of DICOM SOP instances and/or frames within a single Study and Series. This might include additional specifics such as an image region, an Observation UID or a Segmentation Number, allowing linkage to an Observation Resource or transferring this information along with the ImagingStudy Resource.
8666         */
8667        IMAGINGSELECTION, 
8668        /**
8669         * 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.
8670         */
8671        IMAGINGSTUDY, 
8672        /**
8673         * 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.
8674         */
8675        IMMUNIZATION, 
8676        /**
8677         * Describes a comparison of an immunization event against published recommendations to determine if the administration is "valid" in relation to those  recommendations.
8678         */
8679        IMMUNIZATIONEVALUATION, 
8680        /**
8681         * A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification.
8682         */
8683        IMMUNIZATIONRECOMMENDATION, 
8684        /**
8685         * 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.
8686         */
8687        IMPLEMENTATIONGUIDE, 
8688        /**
8689         * An ingredient of a manufactured item or pharmaceutical product.
8690         */
8691        INGREDIENT, 
8692        /**
8693         * Details of a Health Insurance product/plan provided by an organization.
8694         */
8695        INSURANCEPLAN, 
8696        /**
8697         * functional description of an inventory item used in inventory and supply-related workflows.
8698         */
8699        INVENTORYITEM, 
8700        /**
8701         * A report of inventory or stock items.
8702         */
8703        INVENTORYREPORT, 
8704        /**
8705         * Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose.
8706         */
8707        INVOICE, 
8708        /**
8709         * 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.
8710         */
8711        LIBRARY, 
8712        /**
8713         * Identifies two or more records (resource instances) that refer to the same real-world "occurrence".
8714         */
8715        LINKAGE, 
8716        /**
8717         * A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc.
8718         */
8719        LIST, 
8720        /**
8721         * Details and position information for a place where services are provided and resources and participants may be stored, found, contained, or accommodated.
8722         */
8723        LOCATION, 
8724        /**
8725         * The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product.
8726         */
8727        MANUFACTUREDITEMDEFINITION, 
8728        /**
8729         * The Measure resource provides the definition of a quality measure.
8730         */
8731        MEASURE, 
8732        /**
8733         * The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation.
8734         */
8735        MEASUREREPORT, 
8736        /**
8737         * This resource is primarily used for the identification and definition of a medication, including ingredients, for the purposes of prescribing, dispensing, and administering a medication as well as for making statements about medication use.
8738         */
8739        MEDICATION, 
8740        /**
8741         * 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. This event can also be used to record waste using a status of not-done and the appropriate statusReason.
8742         */
8743        MEDICATIONADMINISTRATION, 
8744        /**
8745         * 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.
8746         */
8747        MEDICATIONDISPENSE, 
8748        /**
8749         * Information about a medication that is used to support knowledge.
8750         */
8751        MEDICATIONKNOWLEDGE, 
8752        /**
8753         * 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.
8754         */
8755        MEDICATIONREQUEST, 
8756        /**
8757         * A record of a medication that is being consumed by a patient.   A MedicationStatement may indicate that the patient may be taking the medication now or has taken the medication in the past or will be taking the medication in the future.  The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician.  A common scenario where this information is captured is during the history taking process during a patient visit or stay.   The medication information may come from sources such as the patient's memory, from a prescription bottle,  or from a list of medications the patient, clinician or other party maintains. 
8758
8759The primary difference between a medicationstatement 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 medicationstatement is often, if not always, less specific.  There is no required date/time when the medication was administered, in fact we only know that a source has reported the patient is taking this medication, where details such as time, quantity, or rate or even medication product may be incomplete or missing or less precise.  As stated earlier, the Medication Statement information may come from the patient's memory, from a prescription bottle or from a list of medications the patient, clinician or other party maintains.  Medication administration is more formal and is not missing detailed information.
8760         */
8761        MEDICATIONSTATEMENT, 
8762        /**
8763         * Detailed definition of a medicinal product, typically for uses other than direct patient care (e.g. regulatory use, drug catalogs, to support prescribing, adverse events management etc.).
8764         */
8765        MEDICINALPRODUCTDEFINITION, 
8766        /**
8767         * 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.
8768         */
8769        MESSAGEDEFINITION, 
8770        /**
8771         * 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.
8772         */
8773        MESSAGEHEADER, 
8774        /**
8775         * Common Interface declaration for conformance and knowledge artifact resources.
8776         */
8777        METADATARESOURCE, 
8778        /**
8779         * Representation of a molecular sequence.
8780         */
8781        MOLECULARSEQUENCE, 
8782        /**
8783         * 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.
8784         */
8785        NAMINGSYSTEM, 
8786        /**
8787         * 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.
8788         */
8789        NUTRITIONINTAKE, 
8790        /**
8791         * A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident.
8792         */
8793        NUTRITIONORDER, 
8794        /**
8795         * A food or supplement that is consumed by patients.
8796         */
8797        NUTRITIONPRODUCT, 
8798        /**
8799         * Measurements and simple assertions made about a patient, device or other subject.
8800         */
8801        OBSERVATION, 
8802        /**
8803         * Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service.
8804         */
8805        OBSERVATIONDEFINITION, 
8806        /**
8807         * A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction).
8808         */
8809        OPERATIONDEFINITION, 
8810        /**
8811         * A collection of error, warning, or information messages that result from a system action.
8812         */
8813        OPERATIONOUTCOME, 
8814        /**
8815         * 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.
8816         */
8817        ORGANIZATION, 
8818        /**
8819         * Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship.
8820         */
8821        ORGANIZATIONAFFILIATION, 
8822        /**
8823         * A medically related item or items, in a container or package.
8824         */
8825        PACKAGEDPRODUCTDEFINITION, 
8826        /**
8827         * Demographics and other administrative information about an individual or animal receiving care or other health-related services.
8828         */
8829        PATIENT, 
8830        /**
8831         * This resource provides the status of the payment for goods and services rendered, and the request and response resource references.
8832         */
8833        PAYMENTNOTICE, 
8834        /**
8835         * This resource provides the details including amount of a payment and allocates the payment items being paid.
8836         */
8837        PAYMENTRECONCILIATION, 
8838        /**
8839         * Permission resource holds access rules for a given data and context.
8840         */
8841        PERMISSION, 
8842        /**
8843         * Demographics and administrative information about a person independent of a specific health-related context.
8844         */
8845        PERSON, 
8846        /**
8847         * 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 and non-clinical artifacts such as clinical decision support rules, order sets, protocols, and drug quality specifications.
8848         */
8849        PLANDEFINITION, 
8850        /**
8851         * A person who is directly or indirectly involved in the provisioning of healthcare or related services.
8852         */
8853        PRACTITIONER, 
8854        /**
8855         * A specific set of Roles/Locations/specialties/services that a practitioner may perform, or has performed at an organization during a period of time.
8856         */
8857        PRACTITIONERROLE, 
8858        /**
8859         * An action that is or was performed on or for a patient, practitioner, device, organization, or location. For example, this can be a physical intervention on a patient like an operation, or less invasive like long term services, counseling, or hypnotherapy.  This can be a quality or safety inspection for a location, organization, or device.  This can be an accreditation procedure on a practitioner for licensing.
8860         */
8861        PROCEDURE, 
8862        /**
8863         * 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.
8864         */
8865        PROVENANCE, 
8866        /**
8867         * 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.
8868         */
8869        QUESTIONNAIRE, 
8870        /**
8871         * 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.
8872         */
8873        QUESTIONNAIRERESPONSE, 
8874        /**
8875         * Regulatory approval, clearance or licencing related to a regulated product, treatment, facility or activity that is cited in a guidance, regulation, rule or legislative act. An example is Market Authorization relating to a Medicinal Product.
8876         */
8877        REGULATEDAUTHORIZATION, 
8878        /**
8879         * Information about a person that is involved in a patient's health or the care for a patient, but who is not the target of healthcare, nor has a formal responsibility in the care process.
8880         */
8881        RELATEDPERSON, 
8882        /**
8883         * A set of related requests that can be used to capture intended activities that have inter-dependencies such as "give this medication after that one".
8884         */
8885        REQUESTORCHESTRATION, 
8886        /**
8887         * The Requirements resource is used to describe an actor - a human or an application that plays a role in data exchange, and that may have obligations associated with the role the actor plays.
8888         */
8889        REQUIREMENTS, 
8890        /**
8891         * A scientific study of nature that sometimes includes processes involved in health and disease. For example, clinical trials are research studies that involve people. These studies may be related to new ways to screen, prevent, diagnose, and treat disease. They may also study certain outcomes and certain groups of people by looking at data collected in the past or future.
8892         */
8893        RESEARCHSTUDY, 
8894        /**
8895         * A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study.
8896         */
8897        RESEARCHSUBJECT, 
8898        /**
8899         * An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome.
8900         */
8901        RISKASSESSMENT, 
8902        /**
8903         * A container for slots of time that may be available for booking appointments.
8904         */
8905        SCHEDULE, 
8906        /**
8907         * A search parameter that defines a named search item that can be used to search/filter on a resource.
8908         */
8909        SEARCHPARAMETER, 
8910        /**
8911         * A record of a request for service such as diagnostic investigations, treatments, or operations to be performed.
8912         */
8913        SERVICEREQUEST, 
8914        /**
8915         * A slot of time on a schedule that may be available for booking appointments.
8916         */
8917        SLOT, 
8918        /**
8919         * A sample to be used for analysis.
8920         */
8921        SPECIMEN, 
8922        /**
8923         * A kind of specimen with associated set of requirements.
8924         */
8925        SPECIMENDEFINITION, 
8926        /**
8927         * 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.
8928         */
8929        STRUCTUREDEFINITION, 
8930        /**
8931         * A Map of relationships between 2 structures that can be used to transform data.
8932         */
8933        STRUCTUREMAP, 
8934        /**
8935         * The subscription resource describes a particular client's request to be notified about a SubscriptionTopic.
8936         */
8937        SUBSCRIPTION, 
8938        /**
8939         * The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted.
8940         */
8941        SUBSCRIPTIONSTATUS, 
8942        /**
8943         * Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic.
8944         */
8945        SUBSCRIPTIONTOPIC, 
8946        /**
8947         * A homogeneous material with a definite composition.
8948         */
8949        SUBSTANCE, 
8950        /**
8951         * The detailed description of a substance, typically at a level beyond what is used for prescribing.
8952         */
8953        SUBSTANCEDEFINITION, 
8954        /**
8955         * 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.
8956         */
8957        SUBSTANCENUCLEICACID, 
8958        /**
8959         * Properties of a substance specific to it being a polymer.
8960         */
8961        SUBSTANCEPOLYMER, 
8962        /**
8963         * 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.
8964         */
8965        SUBSTANCEPROTEIN, 
8966        /**
8967         * Todo.
8968         */
8969        SUBSTANCEREFERENCEINFORMATION, 
8970        /**
8971         * 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.
8972         */
8973        SUBSTANCESOURCEMATERIAL, 
8974        /**
8975         * Record of delivery of what is supplied.
8976         */
8977        SUPPLYDELIVERY, 
8978        /**
8979         * A record of a non-patient specific request for a medication, substance, device, certain types of biologically derived product, and nutrition product used in the healthcare setting.
8980         */
8981        SUPPLYREQUEST, 
8982        /**
8983         * A task to be performed.
8984         */
8985        TASK, 
8986        /**
8987         * 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.
8988         */
8989        TERMINOLOGYCAPABILITIES, 
8990        /**
8991         * A plan for executing testing on an artifact or specifications
8992         */
8993        TESTPLAN, 
8994        /**
8995         * A summary of information based on the results of executing a TestScript.
8996         */
8997        TESTREPORT, 
8998        /**
8999         * A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification.
9000         */
9001        TESTSCRIPT, 
9002        /**
9003         * Record of transport.
9004         */
9005        TRANSPORT, 
9006        /**
9007         * 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).
9008         */
9009        VALUESET, 
9010        /**
9011         * Describes validation requirements, source(s), status and dates for one or more elements.
9012         */
9013        VERIFICATIONRESULT, 
9014        /**
9015         * An authorization for the provision of glasses and/or contact lenses to a patient.
9016         */
9017        VISIONPRESCRIPTION, 
9018        /**
9019         * This resource is used to pass information into and back from an operation (whether invoked directly from REST or within a messaging environment).  It is not persisted or allowed to be referenced by other resources except as described in the definition of the Parameters resource.
9020         */
9021        PARAMETERS, 
9022        /**
9023         * added to help the parsers
9024         */
9025        NULL;
9026        public static FHIRTypes fromCode(String codeString) throws FHIRException {
9027            if (codeString == null || "".equals(codeString))
9028                return null;
9029        if ("Base".equals(codeString))
9030          return BASE;
9031        if ("Element".equals(codeString))
9032          return ELEMENT;
9033        if ("BackboneElement".equals(codeString))
9034          return BACKBONEELEMENT;
9035        if ("DataType".equals(codeString))
9036          return DATATYPE;
9037        if ("Address".equals(codeString))
9038          return ADDRESS;
9039        if ("Annotation".equals(codeString))
9040          return ANNOTATION;
9041        if ("Attachment".equals(codeString))
9042          return ATTACHMENT;
9043        if ("Availability".equals(codeString))
9044          return AVAILABILITY;
9045        if ("BackboneType".equals(codeString))
9046          return BACKBONETYPE;
9047        if ("Dosage".equals(codeString))
9048          return DOSAGE;
9049        if ("ElementDefinition".equals(codeString))
9050          return ELEMENTDEFINITION;
9051        if ("MarketingStatus".equals(codeString))
9052          return MARKETINGSTATUS;
9053        if ("ProductShelfLife".equals(codeString))
9054          return PRODUCTSHELFLIFE;
9055        if ("Timing".equals(codeString))
9056          return TIMING;
9057        if ("CodeableConcept".equals(codeString))
9058          return CODEABLECONCEPT;
9059        if ("CodeableReference".equals(codeString))
9060          return CODEABLEREFERENCE;
9061        if ("Coding".equals(codeString))
9062          return CODING;
9063        if ("ContactDetail".equals(codeString))
9064          return CONTACTDETAIL;
9065        if ("ContactPoint".equals(codeString))
9066          return CONTACTPOINT;
9067        if ("Contributor".equals(codeString))
9068          return CONTRIBUTOR;
9069        if ("DataRequirement".equals(codeString))
9070          return DATAREQUIREMENT;
9071        if ("Expression".equals(codeString))
9072          return EXPRESSION;
9073        if ("ExtendedContactDetail".equals(codeString))
9074          return EXTENDEDCONTACTDETAIL;
9075        if ("Extension".equals(codeString))
9076          return EXTENSION;
9077        if ("HumanName".equals(codeString))
9078          return HUMANNAME;
9079        if ("Identifier".equals(codeString))
9080          return IDENTIFIER;
9081        if ("Meta".equals(codeString))
9082          return META;
9083        if ("MonetaryComponent".equals(codeString))
9084          return MONETARYCOMPONENT;
9085        if ("Money".equals(codeString))
9086          return MONEY;
9087        if ("Narrative".equals(codeString))
9088          return NARRATIVE;
9089        if ("ParameterDefinition".equals(codeString))
9090          return PARAMETERDEFINITION;
9091        if ("Period".equals(codeString))
9092          return PERIOD;
9093        if ("PrimitiveType".equals(codeString))
9094          return PRIMITIVETYPE;
9095        if ("base64Binary".equals(codeString))
9096          return BASE64BINARY;
9097        if ("boolean".equals(codeString))
9098          return BOOLEAN;
9099        if ("date".equals(codeString))
9100          return DATE;
9101        if ("dateTime".equals(codeString))
9102          return DATETIME;
9103        if ("decimal".equals(codeString))
9104          return DECIMAL;
9105        if ("instant".equals(codeString))
9106          return INSTANT;
9107        if ("integer".equals(codeString))
9108          return INTEGER;
9109        if ("positiveInt".equals(codeString))
9110          return POSITIVEINT;
9111        if ("unsignedInt".equals(codeString))
9112          return UNSIGNEDINT;
9113        if ("integer64".equals(codeString))
9114          return INTEGER64;
9115        if ("string".equals(codeString))
9116          return STRING;
9117        if ("code".equals(codeString))
9118          return CODE;
9119        if ("id".equals(codeString))
9120          return ID;
9121        if ("markdown".equals(codeString))
9122          return MARKDOWN;
9123        if ("time".equals(codeString))
9124          return TIME;
9125        if ("uri".equals(codeString))
9126          return URI;
9127        if ("canonical".equals(codeString))
9128          return CANONICAL;
9129        if ("oid".equals(codeString))
9130          return OID;
9131        if ("url".equals(codeString))
9132          return URL;
9133        if ("uuid".equals(codeString))
9134          return UUID;
9135        if ("Quantity".equals(codeString))
9136          return QUANTITY;
9137        if ("Age".equals(codeString))
9138          return AGE;
9139        if ("Count".equals(codeString))
9140          return COUNT;
9141        if ("Distance".equals(codeString))
9142          return DISTANCE;
9143        if ("Duration".equals(codeString))
9144          return DURATION;
9145        if ("Range".equals(codeString))
9146          return RANGE;
9147        if ("Ratio".equals(codeString))
9148          return RATIO;
9149        if ("RatioRange".equals(codeString))
9150          return RATIORANGE;
9151        if ("Reference".equals(codeString))
9152          return REFERENCE;
9153        if ("RelatedArtifact".equals(codeString))
9154          return RELATEDARTIFACT;
9155        if ("SampledData".equals(codeString))
9156          return SAMPLEDDATA;
9157        if ("Signature".equals(codeString))
9158          return SIGNATURE;
9159        if ("TriggerDefinition".equals(codeString))
9160          return TRIGGERDEFINITION;
9161        if ("UsageContext".equals(codeString))
9162          return USAGECONTEXT;
9163        if ("VirtualServiceDetail".equals(codeString))
9164          return VIRTUALSERVICEDETAIL;
9165        if ("xhtml".equals(codeString))
9166          return XHTML;
9167        if ("Resource".equals(codeString) || "Any".equals(codeString))
9168          return RESOURCE;
9169        if ("Binary".equals(codeString))
9170          return BINARY;
9171        if ("Bundle".equals(codeString))
9172          return BUNDLE;
9173        if ("DomainResource".equals(codeString))
9174          return DOMAINRESOURCE;
9175        if ("Account".equals(codeString))
9176          return ACCOUNT;
9177        if ("ActivityDefinition".equals(codeString))
9178          return ACTIVITYDEFINITION;
9179        if ("ActorDefinition".equals(codeString))
9180          return ACTORDEFINITION;
9181        if ("AdministrableProductDefinition".equals(codeString))
9182          return ADMINISTRABLEPRODUCTDEFINITION;
9183        if ("AdverseEvent".equals(codeString))
9184          return ADVERSEEVENT;
9185        if ("AllergyIntolerance".equals(codeString))
9186          return ALLERGYINTOLERANCE;
9187        if ("Appointment".equals(codeString))
9188          return APPOINTMENT;
9189        if ("AppointmentResponse".equals(codeString))
9190          return APPOINTMENTRESPONSE;
9191        if ("ArtifactAssessment".equals(codeString))
9192          return ARTIFACTASSESSMENT;
9193        if ("AuditEvent".equals(codeString))
9194          return AUDITEVENT;
9195        if ("Basic".equals(codeString))
9196          return BASIC;
9197        if ("BiologicallyDerivedProduct".equals(codeString))
9198          return BIOLOGICALLYDERIVEDPRODUCT;
9199        if ("BiologicallyDerivedProductDispense".equals(codeString))
9200          return BIOLOGICALLYDERIVEDPRODUCTDISPENSE;
9201        if ("BodyStructure".equals(codeString))
9202          return BODYSTRUCTURE;
9203        if ("CanonicalResource".equals(codeString))
9204          return CANONICALRESOURCE;
9205        if ("CapabilityStatement".equals(codeString))
9206          return CAPABILITYSTATEMENT;
9207        if ("CarePlan".equals(codeString))
9208          return CAREPLAN;
9209        if ("CareTeam".equals(codeString))
9210          return CARETEAM;
9211        if ("ChargeItem".equals(codeString))
9212          return CHARGEITEM;
9213        if ("ChargeItemDefinition".equals(codeString))
9214          return CHARGEITEMDEFINITION;
9215        if ("Citation".equals(codeString))
9216          return CITATION;
9217        if ("Claim".equals(codeString))
9218          return CLAIM;
9219        if ("ClaimResponse".equals(codeString))
9220          return CLAIMRESPONSE;
9221        if ("ClinicalImpression".equals(codeString))
9222          return CLINICALIMPRESSION;
9223        if ("ClinicalUseDefinition".equals(codeString))
9224          return CLINICALUSEDEFINITION;
9225        if ("CodeSystem".equals(codeString))
9226          return CODESYSTEM;
9227        if ("Communication".equals(codeString))
9228          return COMMUNICATION;
9229        if ("CommunicationRequest".equals(codeString))
9230          return COMMUNICATIONREQUEST;
9231        if ("CompartmentDefinition".equals(codeString))
9232          return COMPARTMENTDEFINITION;
9233        if ("Composition".equals(codeString))
9234          return COMPOSITION;
9235        if ("ConceptMap".equals(codeString))
9236          return CONCEPTMAP;
9237        if ("Condition".equals(codeString))
9238          return CONDITION;
9239        if ("ConditionDefinition".equals(codeString))
9240          return CONDITIONDEFINITION;
9241        if ("Consent".equals(codeString))
9242          return CONSENT;
9243        if ("Contract".equals(codeString))
9244          return CONTRACT;
9245        if ("Coverage".equals(codeString))
9246          return COVERAGE;
9247        if ("CoverageEligibilityRequest".equals(codeString))
9248          return COVERAGEELIGIBILITYREQUEST;
9249        if ("CoverageEligibilityResponse".equals(codeString))
9250          return COVERAGEELIGIBILITYRESPONSE;
9251        if ("DetectedIssue".equals(codeString))
9252          return DETECTEDISSUE;
9253        if ("Device".equals(codeString))
9254          return DEVICE;
9255        if ("DeviceAssociation".equals(codeString))
9256          return DEVICEASSOCIATION;
9257        if ("DeviceDefinition".equals(codeString))
9258          return DEVICEDEFINITION;
9259        if ("DeviceDispense".equals(codeString))
9260          return DEVICEDISPENSE;
9261        if ("DeviceMetric".equals(codeString))
9262          return DEVICEMETRIC;
9263        if ("DeviceRequest".equals(codeString))
9264          return DEVICEREQUEST;
9265        if ("DeviceUsage".equals(codeString))
9266          return DEVICEUSAGE;
9267        if ("DiagnosticReport".equals(codeString))
9268          return DIAGNOSTICREPORT;
9269        if ("DocumentReference".equals(codeString))
9270          return DOCUMENTREFERENCE;
9271        if ("Encounter".equals(codeString))
9272          return ENCOUNTER;
9273        if ("EncounterHistory".equals(codeString))
9274          return ENCOUNTERHISTORY;
9275        if ("Endpoint".equals(codeString))
9276          return ENDPOINT;
9277        if ("EnrollmentRequest".equals(codeString))
9278          return ENROLLMENTREQUEST;
9279        if ("EnrollmentResponse".equals(codeString))
9280          return ENROLLMENTRESPONSE;
9281        if ("EpisodeOfCare".equals(codeString))
9282          return EPISODEOFCARE;
9283        if ("EventDefinition".equals(codeString))
9284          return EVENTDEFINITION;
9285        if ("Evidence".equals(codeString))
9286          return EVIDENCE;
9287        if ("EvidenceReport".equals(codeString))
9288          return EVIDENCEREPORT;
9289        if ("EvidenceVariable".equals(codeString))
9290          return EVIDENCEVARIABLE;
9291        if ("ExampleScenario".equals(codeString))
9292          return EXAMPLESCENARIO;
9293        if ("ExplanationOfBenefit".equals(codeString))
9294          return EXPLANATIONOFBENEFIT;
9295        if ("FamilyMemberHistory".equals(codeString))
9296          return FAMILYMEMBERHISTORY;
9297        if ("Flag".equals(codeString))
9298          return FLAG;
9299        if ("FormularyItem".equals(codeString))
9300          return FORMULARYITEM;
9301        if ("GenomicStudy".equals(codeString))
9302          return GENOMICSTUDY;
9303        if ("Goal".equals(codeString))
9304          return GOAL;
9305        if ("GraphDefinition".equals(codeString))
9306          return GRAPHDEFINITION;
9307        if ("Group".equals(codeString))
9308          return GROUP;
9309        if ("GuidanceResponse".equals(codeString))
9310          return GUIDANCERESPONSE;
9311        if ("HealthcareService".equals(codeString))
9312          return HEALTHCARESERVICE;
9313        if ("ImagingSelection".equals(codeString))
9314          return IMAGINGSELECTION;
9315        if ("ImagingStudy".equals(codeString))
9316          return IMAGINGSTUDY;
9317        if ("Immunization".equals(codeString))
9318          return IMMUNIZATION;
9319        if ("ImmunizationEvaluation".equals(codeString))
9320          return IMMUNIZATIONEVALUATION;
9321        if ("ImmunizationRecommendation".equals(codeString))
9322          return IMMUNIZATIONRECOMMENDATION;
9323        if ("ImplementationGuide".equals(codeString))
9324          return IMPLEMENTATIONGUIDE;
9325        if ("Ingredient".equals(codeString))
9326          return INGREDIENT;
9327        if ("InsurancePlan".equals(codeString))
9328          return INSURANCEPLAN;
9329        if ("InventoryItem".equals(codeString))
9330          return INVENTORYITEM;
9331        if ("InventoryReport".equals(codeString))
9332          return INVENTORYREPORT;
9333        if ("Invoice".equals(codeString))
9334          return INVOICE;
9335        if ("Library".equals(codeString))
9336          return LIBRARY;
9337        if ("Linkage".equals(codeString))
9338          return LINKAGE;
9339        if ("List".equals(codeString))
9340          return LIST;
9341        if ("Location".equals(codeString))
9342          return LOCATION;
9343        if ("ManufacturedItemDefinition".equals(codeString))
9344          return MANUFACTUREDITEMDEFINITION;
9345        if ("Measure".equals(codeString))
9346          return MEASURE;
9347        if ("MeasureReport".equals(codeString))
9348          return MEASUREREPORT;
9349        if ("Medication".equals(codeString))
9350          return MEDICATION;
9351        if ("MedicationAdministration".equals(codeString))
9352          return MEDICATIONADMINISTRATION;
9353        if ("MedicationDispense".equals(codeString))
9354          return MEDICATIONDISPENSE;
9355        if ("MedicationKnowledge".equals(codeString))
9356          return MEDICATIONKNOWLEDGE;
9357        if ("MedicationRequest".equals(codeString))
9358          return MEDICATIONREQUEST;
9359        if ("MedicationStatement".equals(codeString))
9360          return MEDICATIONSTATEMENT;
9361        if ("MedicinalProductDefinition".equals(codeString))
9362          return MEDICINALPRODUCTDEFINITION;
9363        if ("MessageDefinition".equals(codeString))
9364          return MESSAGEDEFINITION;
9365        if ("MessageHeader".equals(codeString))
9366          return MESSAGEHEADER;
9367        if ("MetadataResource".equals(codeString))
9368          return METADATARESOURCE;
9369        if ("MolecularSequence".equals(codeString))
9370          return MOLECULARSEQUENCE;
9371        if ("NamingSystem".equals(codeString))
9372          return NAMINGSYSTEM;
9373        if ("NutritionIntake".equals(codeString))
9374          return NUTRITIONINTAKE;
9375        if ("NutritionOrder".equals(codeString))
9376          return NUTRITIONORDER;
9377        if ("NutritionProduct".equals(codeString))
9378          return NUTRITIONPRODUCT;
9379        if ("Observation".equals(codeString))
9380          return OBSERVATION;
9381        if ("ObservationDefinition".equals(codeString))
9382          return OBSERVATIONDEFINITION;
9383        if ("OperationDefinition".equals(codeString))
9384          return OPERATIONDEFINITION;
9385        if ("OperationOutcome".equals(codeString))
9386          return OPERATIONOUTCOME;
9387        if ("Organization".equals(codeString))
9388          return ORGANIZATION;
9389        if ("OrganizationAffiliation".equals(codeString))
9390          return ORGANIZATIONAFFILIATION;
9391        if ("PackagedProductDefinition".equals(codeString))
9392          return PACKAGEDPRODUCTDEFINITION;
9393        if ("Patient".equals(codeString))
9394          return PATIENT;
9395        if ("PaymentNotice".equals(codeString))
9396          return PAYMENTNOTICE;
9397        if ("PaymentReconciliation".equals(codeString))
9398          return PAYMENTRECONCILIATION;
9399        if ("Permission".equals(codeString))
9400          return PERMISSION;
9401        if ("Person".equals(codeString))
9402          return PERSON;
9403        if ("PlanDefinition".equals(codeString))
9404          return PLANDEFINITION;
9405        if ("Practitioner".equals(codeString))
9406          return PRACTITIONER;
9407        if ("PractitionerRole".equals(codeString))
9408          return PRACTITIONERROLE;
9409        if ("Procedure".equals(codeString))
9410          return PROCEDURE;
9411        if ("Provenance".equals(codeString))
9412          return PROVENANCE;
9413        if ("Questionnaire".equals(codeString))
9414          return QUESTIONNAIRE;
9415        if ("QuestionnaireResponse".equals(codeString))
9416          return QUESTIONNAIRERESPONSE;
9417        if ("RegulatedAuthorization".equals(codeString))
9418          return REGULATEDAUTHORIZATION;
9419        if ("RelatedPerson".equals(codeString))
9420          return RELATEDPERSON;
9421        if ("RequestOrchestration".equals(codeString))
9422          return REQUESTORCHESTRATION;
9423        if ("Requirements".equals(codeString))
9424          return REQUIREMENTS;
9425        if ("ResearchStudy".equals(codeString))
9426          return RESEARCHSTUDY;
9427        if ("ResearchSubject".equals(codeString))
9428          return RESEARCHSUBJECT;
9429        if ("RiskAssessment".equals(codeString))
9430          return RISKASSESSMENT;
9431        if ("Schedule".equals(codeString))
9432          return SCHEDULE;
9433        if ("SearchParameter".equals(codeString))
9434          return SEARCHPARAMETER;
9435        if ("ServiceRequest".equals(codeString))
9436          return SERVICEREQUEST;
9437        if ("Slot".equals(codeString))
9438          return SLOT;
9439        if ("Specimen".equals(codeString))
9440          return SPECIMEN;
9441        if ("SpecimenDefinition".equals(codeString))
9442          return SPECIMENDEFINITION;
9443        if ("StructureDefinition".equals(codeString))
9444          return STRUCTUREDEFINITION;
9445        if ("StructureMap".equals(codeString))
9446          return STRUCTUREMAP;
9447        if ("Subscription".equals(codeString))
9448          return SUBSCRIPTION;
9449        if ("SubscriptionStatus".equals(codeString))
9450          return SUBSCRIPTIONSTATUS;
9451        if ("SubscriptionTopic".equals(codeString))
9452          return SUBSCRIPTIONTOPIC;
9453        if ("Substance".equals(codeString))
9454          return SUBSTANCE;
9455        if ("SubstanceDefinition".equals(codeString))
9456          return SUBSTANCEDEFINITION;
9457        if ("SubstanceNucleicAcid".equals(codeString))
9458          return SUBSTANCENUCLEICACID;
9459        if ("SubstancePolymer".equals(codeString))
9460          return SUBSTANCEPOLYMER;
9461        if ("SubstanceProtein".equals(codeString))
9462          return SUBSTANCEPROTEIN;
9463        if ("SubstanceReferenceInformation".equals(codeString))
9464          return SUBSTANCEREFERENCEINFORMATION;
9465        if ("SubstanceSourceMaterial".equals(codeString))
9466          return SUBSTANCESOURCEMATERIAL;
9467        if ("SupplyDelivery".equals(codeString))
9468          return SUPPLYDELIVERY;
9469        if ("SupplyRequest".equals(codeString))
9470          return SUPPLYREQUEST;
9471        if ("Task".equals(codeString))
9472          return TASK;
9473        if ("TerminologyCapabilities".equals(codeString))
9474          return TERMINOLOGYCAPABILITIES;
9475        if ("TestPlan".equals(codeString))
9476          return TESTPLAN;
9477        if ("TestReport".equals(codeString))
9478          return TESTREPORT;
9479        if ("TestScript".equals(codeString))
9480          return TESTSCRIPT;
9481        if ("Transport".equals(codeString))
9482          return TRANSPORT;
9483        if ("ValueSet".equals(codeString))
9484          return VALUESET;
9485        if ("VerificationResult".equals(codeString))
9486          return VERIFICATIONRESULT;
9487        if ("VisionPrescription".equals(codeString))
9488          return VISIONPRESCRIPTION;
9489        if ("Parameters".equals(codeString))
9490          return PARAMETERS;
9491        throw new FHIRException("Unknown FHIRTypes code '"+codeString+"'");
9492        }
9493        public static boolean isValidCode(String codeString) {
9494            if (codeString == null || "".equals(codeString))
9495                return false;
9496          return Utilities.existsInList(codeString, "Base", "Element", "BackboneElement", "DataType", "Address", "Annotation", "Attachment", "Availability", "BackboneType", "Dosage", "ElementDefinition", "MarketingStatus", "ProductShelfLife", "Timing", "CodeableConcept", "CodeableReference", "Coding", "ContactDetail", "ContactPoint", "Contributor", "DataRequirement", "Expression", "Extended