![](/hapi-fhir/images/logos/raccoon-forwards.png)
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.SINGLE) 181 return "single"; 182 if (code == ActionCardinalityBehavior.MULTIPLE) 183 return "multiple"; 184 return "?"; 185 } 186 public String toSystem(ActionCardinalityBehavior code) { 187 return code.getSystem(); 188 } 189 } 190 191 public enum ActionConditionKind { 192 /** 193 * The condition describes whether or not a given action is applicable. 194 */ 195 APPLICABILITY, 196 /** 197 * The condition is a starting condition for the action. 198 */ 199 START, 200 /** 201 * The condition is a stop, or exit condition for the action. 202 */ 203 STOP, 204 /** 205 * added to help the parsers 206 */ 207 NULL; 208 public static ActionConditionKind fromCode(String codeString) throws FHIRException { 209 if (codeString == null || "".equals(codeString)) 210 return null; 211 if ("applicability".equals(codeString)) 212 return APPLICABILITY; 213 if ("start".equals(codeString)) 214 return START; 215 if ("stop".equals(codeString)) 216 return STOP; 217 throw new FHIRException("Unknown ActionConditionKind code '"+codeString+"'"); 218 } 219 public static boolean isValidCode(String codeString) { 220 if (codeString == null || "".equals(codeString)) 221 return false; 222 return Utilities.existsInList(codeString, "applicability", "start", "stop"); 223 } 224 public String toCode() { 225 switch (this) { 226 case APPLICABILITY: return "applicability"; 227 case START: return "start"; 228 case STOP: return "stop"; 229 case NULL: return null; 230 default: return "?"; 231 } 232 } 233 public String getSystem() { 234 switch (this) { 235 case APPLICABILITY: return "http://hl7.org/fhir/action-condition-kind"; 236 case START: return "http://hl7.org/fhir/action-condition-kind"; 237 case STOP: return "http://hl7.org/fhir/action-condition-kind"; 238 case NULL: return null; 239 default: return "?"; 240 } 241 } 242 public String getDefinition() { 243 switch (this) { 244 case APPLICABILITY: return "The condition describes whether or not a given action is applicable."; 245 case START: return "The condition is a starting condition for the action."; 246 case STOP: return "The condition is a stop, or exit condition for the action."; 247 case NULL: return null; 248 default: return "?"; 249 } 250 } 251 public String getDisplay() { 252 switch (this) { 253 case APPLICABILITY: return "Applicability"; 254 case START: return "Start"; 255 case STOP: return "Stop"; 256 case NULL: return null; 257 default: return "?"; 258 } 259 } 260 } 261 262 public static class ActionConditionKindEnumFactory implements EnumFactory<ActionConditionKind> { 263 public ActionConditionKind fromCode(String codeString) throws IllegalArgumentException { 264 if (codeString == null || "".equals(codeString)) 265 if (codeString == null || "".equals(codeString)) 266 return null; 267 if ("applicability".equals(codeString)) 268 return ActionConditionKind.APPLICABILITY; 269 if ("start".equals(codeString)) 270 return ActionConditionKind.START; 271 if ("stop".equals(codeString)) 272 return ActionConditionKind.STOP; 273 throw new IllegalArgumentException("Unknown ActionConditionKind code '"+codeString+"'"); 274 } 275 276 public Enumeration<ActionConditionKind> fromType(PrimitiveType<?> code) throws FHIRException { 277 if (code == null) 278 return null; 279 if (code.isEmpty()) 280 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.NULL, code); 281 String codeString = ((PrimitiveType) code).asStringValue(); 282 if (codeString == null || "".equals(codeString)) 283 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.NULL, code); 284 if ("applicability".equals(codeString)) 285 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.APPLICABILITY, code); 286 if ("start".equals(codeString)) 287 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.START, code); 288 if ("stop".equals(codeString)) 289 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.STOP, code); 290 throw new FHIRException("Unknown ActionConditionKind code '"+codeString+"'"); 291 } 292 public String toCode(ActionConditionKind code) { 293 if (code == ActionConditionKind.APPLICABILITY) 294 return "applicability"; 295 if (code == ActionConditionKind.START) 296 return "start"; 297 if (code == ActionConditionKind.STOP) 298 return "stop"; 299 return "?"; 300 } 301 public String toSystem(ActionConditionKind code) { 302 return code.getSystem(); 303 } 304 } 305 306 public enum ActionGroupingBehavior { 307 /** 308 * Any group marked with this behavior should be displayed as a visual group to the end user. 309 */ 310 VISUALGROUP, 311 /** 312 * 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. 313 */ 314 LOGICALGROUP, 315 /** 316 * 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". 317 */ 318 SENTENCEGROUP, 319 /** 320 * added to help the parsers 321 */ 322 NULL; 323 public static ActionGroupingBehavior fromCode(String codeString) throws FHIRException { 324 if (codeString == null || "".equals(codeString)) 325 return null; 326 if ("visual-group".equals(codeString)) 327 return VISUALGROUP; 328 if ("logical-group".equals(codeString)) 329 return LOGICALGROUP; 330 if ("sentence-group".equals(codeString)) 331 return SENTENCEGROUP; 332 throw new FHIRException("Unknown ActionGroupingBehavior code '"+codeString+"'"); 333 } 334 public static boolean isValidCode(String codeString) { 335 if (codeString == null || "".equals(codeString)) 336 return false; 337 return Utilities.existsInList(codeString, "visual-group", "logical-group", "sentence-group"); 338 } 339 public String toCode() { 340 switch (this) { 341 case VISUALGROUP: return "visual-group"; 342 case LOGICALGROUP: return "logical-group"; 343 case SENTENCEGROUP: return "sentence-group"; 344 case NULL: return null; 345 default: return "?"; 346 } 347 } 348 public String getSystem() { 349 switch (this) { 350 case VISUALGROUP: return "http://hl7.org/fhir/action-grouping-behavior"; 351 case LOGICALGROUP: return "http://hl7.org/fhir/action-grouping-behavior"; 352 case SENTENCEGROUP: return "http://hl7.org/fhir/action-grouping-behavior"; 353 case NULL: return null; 354 default: return "?"; 355 } 356 } 357 public String getDefinition() { 358 switch (this) { 359 case VISUALGROUP: return "Any group marked with this behavior should be displayed as a visual group to the end user."; 360 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."; 361 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\"."; 362 case NULL: return null; 363 default: return "?"; 364 } 365 } 366 public String getDisplay() { 367 switch (this) { 368 case VISUALGROUP: return "Visual Group"; 369 case LOGICALGROUP: return "Logical Group"; 370 case SENTENCEGROUP: return "Sentence Group"; 371 case NULL: return null; 372 default: return "?"; 373 } 374 } 375 } 376 377 public static class ActionGroupingBehaviorEnumFactory implements EnumFactory<ActionGroupingBehavior> { 378 public ActionGroupingBehavior fromCode(String codeString) throws IllegalArgumentException { 379 if (codeString == null || "".equals(codeString)) 380 if (codeString == null || "".equals(codeString)) 381 return null; 382 if ("visual-group".equals(codeString)) 383 return ActionGroupingBehavior.VISUALGROUP; 384 if ("logical-group".equals(codeString)) 385 return ActionGroupingBehavior.LOGICALGROUP; 386 if ("sentence-group".equals(codeString)) 387 return ActionGroupingBehavior.SENTENCEGROUP; 388 throw new IllegalArgumentException("Unknown ActionGroupingBehavior code '"+codeString+"'"); 389 } 390 391 public Enumeration<ActionGroupingBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 392 if (code == null) 393 return null; 394 if (code.isEmpty()) 395 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.NULL, code); 396 String codeString = ((PrimitiveType) code).asStringValue(); 397 if (codeString == null || "".equals(codeString)) 398 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.NULL, code); 399 if ("visual-group".equals(codeString)) 400 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.VISUALGROUP, code); 401 if ("logical-group".equals(codeString)) 402 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.LOGICALGROUP, code); 403 if ("sentence-group".equals(codeString)) 404 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.SENTENCEGROUP, code); 405 throw new FHIRException("Unknown ActionGroupingBehavior code '"+codeString+"'"); 406 } 407 public String toCode(ActionGroupingBehavior code) { 408 if (code == ActionGroupingBehavior.VISUALGROUP) 409 return "visual-group"; 410 if (code == ActionGroupingBehavior.LOGICALGROUP) 411 return "logical-group"; 412 if (code == ActionGroupingBehavior.SENTENCEGROUP) 413 return "sentence-group"; 414 return "?"; 415 } 416 public String toSystem(ActionGroupingBehavior code) { 417 return code.getSystem(); 418 } 419 } 420 421 public enum ActionParticipantType { 422 /** 423 * The participant is a care team caring for the patient under evaluation. 424 */ 425 CARETEAM, 426 /** 427 * The participant is a system or device used in the care of the patient. 428 */ 429 DEVICE, 430 /** 431 * The participant is a group of participants involved in the care of the patient. 432 */ 433 GROUP, 434 /** 435 * The participant is an institution that can provide the given healthcare service used in the care of the patient. 436 */ 437 HEALTHCARESERVICE, 438 /** 439 * The participant is a location involved in the care of the patient. 440 */ 441 LOCATION, 442 /** 443 * The participant is an organization involved in the care of the patient. 444 */ 445 ORGANIZATION, 446 /** 447 * The participant is the patient under evaluation. 448 */ 449 PATIENT, 450 /** 451 * The participant is a practitioner involved in the patient's care. 452 */ 453 PRACTITIONER, 454 /** 455 * The participant is a particular practitioner role involved in the patient's care. 456 */ 457 PRACTITIONERROLE, 458 /** 459 * The participant is a person related to the patient. 460 */ 461 RELATEDPERSON, 462 /** 463 * added to help the parsers 464 */ 465 NULL; 466 public static ActionParticipantType fromCode(String codeString) throws FHIRException { 467 if (codeString == null || "".equals(codeString)) 468 return null; 469 if ("careteam".equals(codeString)) 470 return CARETEAM; 471 if ("device".equals(codeString)) 472 return DEVICE; 473 if ("group".equals(codeString)) 474 return GROUP; 475 if ("healthcareservice".equals(codeString)) 476 return HEALTHCARESERVICE; 477 if ("location".equals(codeString)) 478 return LOCATION; 479 if ("organization".equals(codeString)) 480 return ORGANIZATION; 481 if ("patient".equals(codeString)) 482 return PATIENT; 483 if ("practitioner".equals(codeString)) 484 return PRACTITIONER; 485 if ("practitionerrole".equals(codeString)) 486 return PRACTITIONERROLE; 487 if ("relatedperson".equals(codeString)) 488 return RELATEDPERSON; 489 throw new FHIRException("Unknown ActionParticipantType code '"+codeString+"'"); 490 } 491 public static boolean isValidCode(String codeString) { 492 if (codeString == null || "".equals(codeString)) 493 return false; 494 return Utilities.existsInList(codeString, "careteam", "device", "group", "healthcareservice", "location", "organization", "patient", "practitioner", "practitionerrole", "relatedperson"); 495 } 496 public String toCode() { 497 switch (this) { 498 case CARETEAM: return "careteam"; 499 case DEVICE: return "device"; 500 case GROUP: return "group"; 501 case HEALTHCARESERVICE: return "healthcareservice"; 502 case LOCATION: return "location"; 503 case ORGANIZATION: return "organization"; 504 case PATIENT: return "patient"; 505 case PRACTITIONER: return "practitioner"; 506 case PRACTITIONERROLE: return "practitionerrole"; 507 case RELATEDPERSON: return "relatedperson"; 508 case NULL: return null; 509 default: return "?"; 510 } 511 } 512 public String getSystem() { 513 switch (this) { 514 case CARETEAM: return "http://hl7.org/fhir/action-participant-type"; 515 case DEVICE: return "http://hl7.org/fhir/action-participant-type"; 516 case GROUP: return "http://hl7.org/fhir/action-participant-type"; 517 case HEALTHCARESERVICE: return "http://hl7.org/fhir/action-participant-type"; 518 case LOCATION: return "http://hl7.org/fhir/action-participant-type"; 519 case ORGANIZATION: return "http://hl7.org/fhir/action-participant-type"; 520 case PATIENT: return "http://hl7.org/fhir/action-participant-type"; 521 case PRACTITIONER: return "http://hl7.org/fhir/action-participant-type"; 522 case PRACTITIONERROLE: return "http://hl7.org/fhir/action-participant-type"; 523 case RELATEDPERSON: return "http://hl7.org/fhir/action-participant-type"; 524 case NULL: return null; 525 default: return "?"; 526 } 527 } 528 public String getDefinition() { 529 switch (this) { 530 case CARETEAM: return "The participant is a care team caring for the patient under evaluation."; 531 case DEVICE: return "The participant is a system or device used in the care of the patient."; 532 case GROUP: return "The participant is a group of participants involved in the care of the patient."; 533 case HEALTHCARESERVICE: return "The participant is an institution that can provide the given healthcare service used in the care of the patient."; 534 case LOCATION: return "The participant is a location involved in the care of the patient."; 535 case ORGANIZATION: return "The participant is an organization involved in the care of the patient."; 536 case PATIENT: return "The participant is the patient under evaluation."; 537 case PRACTITIONER: return "The participant is a practitioner involved in the patient's care."; 538 case PRACTITIONERROLE: return "The participant is a particular practitioner role involved in the patient's care."; 539 case RELATEDPERSON: return "The participant is a person related to the patient."; 540 case NULL: return null; 541 default: return "?"; 542 } 543 } 544 public String getDisplay() { 545 switch (this) { 546 case CARETEAM: return "CareTeam"; 547 case DEVICE: return "Device"; 548 case GROUP: return "Group"; 549 case HEALTHCARESERVICE: return "HealthcareService"; 550 case LOCATION: return "Location"; 551 case ORGANIZATION: return "Organization"; 552 case PATIENT: return "Patient"; 553 case PRACTITIONER: return "Practitioner"; 554 case PRACTITIONERROLE: return "PractitionerRole"; 555 case RELATEDPERSON: return "RelatedPerson"; 556 case NULL: return null; 557 default: return "?"; 558 } 559 } 560 } 561 562 public static class ActionParticipantTypeEnumFactory implements EnumFactory<ActionParticipantType> { 563 public ActionParticipantType fromCode(String codeString) throws IllegalArgumentException { 564 if (codeString == null || "".equals(codeString)) 565 if (codeString == null || "".equals(codeString)) 566 return null; 567 if ("careteam".equals(codeString)) 568 return ActionParticipantType.CARETEAM; 569 if ("device".equals(codeString)) 570 return ActionParticipantType.DEVICE; 571 if ("group".equals(codeString)) 572 return ActionParticipantType.GROUP; 573 if ("healthcareservice".equals(codeString)) 574 return ActionParticipantType.HEALTHCARESERVICE; 575 if ("location".equals(codeString)) 576 return ActionParticipantType.LOCATION; 577 if ("organization".equals(codeString)) 578 return ActionParticipantType.ORGANIZATION; 579 if ("patient".equals(codeString)) 580 return ActionParticipantType.PATIENT; 581 if ("practitioner".equals(codeString)) 582 return ActionParticipantType.PRACTITIONER; 583 if ("practitionerrole".equals(codeString)) 584 return ActionParticipantType.PRACTITIONERROLE; 585 if ("relatedperson".equals(codeString)) 586 return ActionParticipantType.RELATEDPERSON; 587 throw new IllegalArgumentException("Unknown ActionParticipantType code '"+codeString+"'"); 588 } 589 590 public Enumeration<ActionParticipantType> fromType(PrimitiveType<?> code) throws FHIRException { 591 if (code == null) 592 return null; 593 if (code.isEmpty()) 594 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.NULL, code); 595 String codeString = ((PrimitiveType) code).asStringValue(); 596 if (codeString == null || "".equals(codeString)) 597 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.NULL, code); 598 if ("careteam".equals(codeString)) 599 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.CARETEAM, code); 600 if ("device".equals(codeString)) 601 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.DEVICE, code); 602 if ("group".equals(codeString)) 603 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.GROUP, code); 604 if ("healthcareservice".equals(codeString)) 605 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.HEALTHCARESERVICE, code); 606 if ("location".equals(codeString)) 607 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.LOCATION, code); 608 if ("organization".equals(codeString)) 609 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.ORGANIZATION, code); 610 if ("patient".equals(codeString)) 611 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PATIENT, code); 612 if ("practitioner".equals(codeString)) 613 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PRACTITIONER, code); 614 if ("practitionerrole".equals(codeString)) 615 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PRACTITIONERROLE, code); 616 if ("relatedperson".equals(codeString)) 617 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.RELATEDPERSON, code); 618 throw new FHIRException("Unknown ActionParticipantType code '"+codeString+"'"); 619 } 620 public String toCode(ActionParticipantType code) { 621 if (code == ActionParticipantType.CARETEAM) 622 return "careteam"; 623 if (code == ActionParticipantType.DEVICE) 624 return "device"; 625 if (code == ActionParticipantType.GROUP) 626 return "group"; 627 if (code == ActionParticipantType.HEALTHCARESERVICE) 628 return "healthcareservice"; 629 if (code == ActionParticipantType.LOCATION) 630 return "location"; 631 if (code == ActionParticipantType.ORGANIZATION) 632 return "organization"; 633 if (code == ActionParticipantType.PATIENT) 634 return "patient"; 635 if (code == ActionParticipantType.PRACTITIONER) 636 return "practitioner"; 637 if (code == ActionParticipantType.PRACTITIONERROLE) 638 return "practitionerrole"; 639 if (code == ActionParticipantType.RELATEDPERSON) 640 return "relatedperson"; 641 return "?"; 642 } 643 public String toSystem(ActionParticipantType code) { 644 return code.getSystem(); 645 } 646 } 647 648 public enum ActionPrecheckBehavior { 649 /** 650 * 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. 651 */ 652 YES, 653 /** 654 * 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. 655 */ 656 NO, 657 /** 658 * added to help the parsers 659 */ 660 NULL; 661 public static ActionPrecheckBehavior fromCode(String codeString) throws FHIRException { 662 if (codeString == null || "".equals(codeString)) 663 return null; 664 if ("yes".equals(codeString)) 665 return YES; 666 if ("no".equals(codeString)) 667 return NO; 668 throw new FHIRException("Unknown ActionPrecheckBehavior code '"+codeString+"'"); 669 } 670 public static boolean isValidCode(String codeString) { 671 if (codeString == null || "".equals(codeString)) 672 return false; 673 return Utilities.existsInList(codeString, "yes", "no"); 674 } 675 public String toCode() { 676 switch (this) { 677 case YES: return "yes"; 678 case NO: return "no"; 679 case NULL: return null; 680 default: return "?"; 681 } 682 } 683 public String getSystem() { 684 switch (this) { 685 case YES: return "http://hl7.org/fhir/action-precheck-behavior"; 686 case NO: return "http://hl7.org/fhir/action-precheck-behavior"; 687 case NULL: return null; 688 default: return "?"; 689 } 690 } 691 public String getDefinition() { 692 switch (this) { 693 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."; 694 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."; 695 case NULL: return null; 696 default: return "?"; 697 } 698 } 699 public String getDisplay() { 700 switch (this) { 701 case YES: return "Yes"; 702 case NO: return "No"; 703 case NULL: return null; 704 default: return "?"; 705 } 706 } 707 } 708 709 public static class ActionPrecheckBehaviorEnumFactory implements EnumFactory<ActionPrecheckBehavior> { 710 public ActionPrecheckBehavior fromCode(String codeString) throws IllegalArgumentException { 711 if (codeString == null || "".equals(codeString)) 712 if (codeString == null || "".equals(codeString)) 713 return null; 714 if ("yes".equals(codeString)) 715 return ActionPrecheckBehavior.YES; 716 if ("no".equals(codeString)) 717 return ActionPrecheckBehavior.NO; 718 throw new IllegalArgumentException("Unknown ActionPrecheckBehavior code '"+codeString+"'"); 719 } 720 721 public Enumeration<ActionPrecheckBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 722 if (code == null) 723 return null; 724 if (code.isEmpty()) 725 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NULL, code); 726 String codeString = ((PrimitiveType) code).asStringValue(); 727 if (codeString == null || "".equals(codeString)) 728 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NULL, code); 729 if ("yes".equals(codeString)) 730 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.YES, code); 731 if ("no".equals(codeString)) 732 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NO, code); 733 throw new FHIRException("Unknown ActionPrecheckBehavior code '"+codeString+"'"); 734 } 735 public String toCode(ActionPrecheckBehavior code) { 736 if (code == ActionPrecheckBehavior.YES) 737 return "yes"; 738 if (code == ActionPrecheckBehavior.NO) 739 return "no"; 740 return "?"; 741 } 742 public String toSystem(ActionPrecheckBehavior code) { 743 return code.getSystem(); 744 } 745 } 746 747 public enum ActionRelationshipType { 748 /** 749 * The action must be performed before the related action. 750 */ 751 BEFORE, 752 /** 753 * The action must be performed before the start of the related action. 754 */ 755 BEFORESTART, 756 /** 757 * The action must be performed before the end of the related action. 758 */ 759 BEFOREEND, 760 /** 761 * The action must be performed concurrent with the related action. 762 */ 763 CONCURRENT, 764 /** 765 * The action must be performed concurrent with the start of the related action. 766 */ 767 CONCURRENTWITHSTART, 768 /** 769 * The action must be performed concurrent with the end of the related action. 770 */ 771 CONCURRENTWITHEND, 772 /** 773 * The action must be performed after the related action. 774 */ 775 AFTER, 776 /** 777 * The action must be performed after the start of the related action. 778 */ 779 AFTERSTART, 780 /** 781 * The action must be performed after the end of the related action. 782 */ 783 AFTEREND, 784 /** 785 * added to help the parsers 786 */ 787 NULL; 788 public static ActionRelationshipType fromCode(String codeString) throws FHIRException { 789 if (codeString == null || "".equals(codeString)) 790 return null; 791 if ("before".equals(codeString)) 792 return BEFORE; 793 if ("before-start".equals(codeString)) 794 return BEFORESTART; 795 if ("before-end".equals(codeString)) 796 return BEFOREEND; 797 if ("concurrent".equals(codeString)) 798 return CONCURRENT; 799 if ("concurrent-with-start".equals(codeString)) 800 return CONCURRENTWITHSTART; 801 if ("concurrent-with-end".equals(codeString)) 802 return CONCURRENTWITHEND; 803 if ("after".equals(codeString)) 804 return AFTER; 805 if ("after-start".equals(codeString)) 806 return AFTERSTART; 807 if ("after-end".equals(codeString)) 808 return AFTEREND; 809 throw new FHIRException("Unknown ActionRelationshipType code '"+codeString+"'"); 810 } 811 public static boolean isValidCode(String codeString) { 812 if (codeString == null || "".equals(codeString)) 813 return false; 814 return Utilities.existsInList(codeString, "before", "before-start", "before-end", "concurrent", "concurrent-with-start", "concurrent-with-end", "after", "after-start", "after-end"); 815 } 816 public String toCode() { 817 switch (this) { 818 case BEFORE: return "before"; 819 case BEFORESTART: return "before-start"; 820 case BEFOREEND: return "before-end"; 821 case CONCURRENT: return "concurrent"; 822 case CONCURRENTWITHSTART: return "concurrent-with-start"; 823 case CONCURRENTWITHEND: return "concurrent-with-end"; 824 case AFTER: return "after"; 825 case AFTERSTART: return "after-start"; 826 case AFTEREND: return "after-end"; 827 case NULL: return null; 828 default: return "?"; 829 } 830 } 831 public String getSystem() { 832 switch (this) { 833 case BEFORE: return "http://hl7.org/fhir/action-relationship-type"; 834 case BEFORESTART: return "http://hl7.org/fhir/action-relationship-type"; 835 case BEFOREEND: return "http://hl7.org/fhir/action-relationship-type"; 836 case CONCURRENT: return "http://hl7.org/fhir/action-relationship-type"; 837 case CONCURRENTWITHSTART: return "http://hl7.org/fhir/action-relationship-type"; 838 case CONCURRENTWITHEND: return "http://hl7.org/fhir/action-relationship-type"; 839 case AFTER: return "http://hl7.org/fhir/action-relationship-type"; 840 case AFTERSTART: return "http://hl7.org/fhir/action-relationship-type"; 841 case AFTEREND: return "http://hl7.org/fhir/action-relationship-type"; 842 case NULL: return null; 843 default: return "?"; 844 } 845 } 846 public String getDefinition() { 847 switch (this) { 848 case BEFORE: return "The action must be performed before the related action."; 849 case BEFORESTART: return "The action must be performed before the start of the related action."; 850 case BEFOREEND: return "The action must be performed before the end of the related action."; 851 case CONCURRENT: return "The action must be performed concurrent with the related action."; 852 case CONCURRENTWITHSTART: return "The action must be performed concurrent with the start of the related action."; 853 case CONCURRENTWITHEND: return "The action must be performed concurrent with the end of the related action."; 854 case AFTER: return "The action must be performed after the related action."; 855 case AFTERSTART: return "The action must be performed after the start of the related action."; 856 case AFTEREND: return "The action must be performed after the end of the related action."; 857 case NULL: return null; 858 default: return "?"; 859 } 860 } 861 public String getDisplay() { 862 switch (this) { 863 case BEFORE: return "Before"; 864 case BEFORESTART: return "Before Start"; 865 case BEFOREEND: return "Before End"; 866 case CONCURRENT: return "Concurrent"; 867 case CONCURRENTWITHSTART: return "Concurrent With Start"; 868 case CONCURRENTWITHEND: return "Concurrent With End"; 869 case AFTER: return "After"; 870 case AFTERSTART: return "After Start"; 871 case AFTEREND: return "After End"; 872 case NULL: return null; 873 default: return "?"; 874 } 875 } 876 } 877 878 public static class ActionRelationshipTypeEnumFactory implements EnumFactory<ActionRelationshipType> { 879 public ActionRelationshipType fromCode(String codeString) throws IllegalArgumentException { 880 if (codeString == null || "".equals(codeString)) 881 if (codeString == null || "".equals(codeString)) 882 return null; 883 if ("before".equals(codeString)) 884 return ActionRelationshipType.BEFORE; 885 if ("before-start".equals(codeString)) 886 return ActionRelationshipType.BEFORESTART; 887 if ("before-end".equals(codeString)) 888 return ActionRelationshipType.BEFOREEND; 889 if ("concurrent".equals(codeString)) 890 return ActionRelationshipType.CONCURRENT; 891 if ("concurrent-with-start".equals(codeString)) 892 return ActionRelationshipType.CONCURRENTWITHSTART; 893 if ("concurrent-with-end".equals(codeString)) 894 return ActionRelationshipType.CONCURRENTWITHEND; 895 if ("after".equals(codeString)) 896 return ActionRelationshipType.AFTER; 897 if ("after-start".equals(codeString)) 898 return ActionRelationshipType.AFTERSTART; 899 if ("after-end".equals(codeString)) 900 return ActionRelationshipType.AFTEREND; 901 throw new IllegalArgumentException("Unknown ActionRelationshipType code '"+codeString+"'"); 902 } 903 904 public Enumeration<ActionRelationshipType> fromType(PrimitiveType<?> code) throws FHIRException { 905 if (code == null) 906 return null; 907 if (code.isEmpty()) 908 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.NULL, code); 909 String codeString = ((PrimitiveType) code).asStringValue(); 910 if (codeString == null || "".equals(codeString)) 911 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.NULL, code); 912 if ("before".equals(codeString)) 913 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORE, code); 914 if ("before-start".equals(codeString)) 915 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORESTART, code); 916 if ("before-end".equals(codeString)) 917 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFOREEND, code); 918 if ("concurrent".equals(codeString)) 919 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENT, code); 920 if ("concurrent-with-start".equals(codeString)) 921 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHSTART, code); 922 if ("concurrent-with-end".equals(codeString)) 923 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHEND, code); 924 if ("after".equals(codeString)) 925 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTER, code); 926 if ("after-start".equals(codeString)) 927 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTERSTART, code); 928 if ("after-end".equals(codeString)) 929 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTEREND, code); 930 throw new FHIRException("Unknown ActionRelationshipType code '"+codeString+"'"); 931 } 932 public String toCode(ActionRelationshipType code) { 933 if (code == ActionRelationshipType.BEFORE) 934 return "before"; 935 if (code == ActionRelationshipType.BEFORESTART) 936 return "before-start"; 937 if (code == ActionRelationshipType.BEFOREEND) 938 return "before-end"; 939 if (code == ActionRelationshipType.CONCURRENT) 940 return "concurrent"; 941 if (code == ActionRelationshipType.CONCURRENTWITHSTART) 942 return "concurrent-with-start"; 943 if (code == ActionRelationshipType.CONCURRENTWITHEND) 944 return "concurrent-with-end"; 945 if (code == ActionRelationshipType.AFTER) 946 return "after"; 947 if (code == ActionRelationshipType.AFTERSTART) 948 return "after-start"; 949 if (code == ActionRelationshipType.AFTEREND) 950 return "after-end"; 951 return "?"; 952 } 953 public String toSystem(ActionRelationshipType code) { 954 return code.getSystem(); 955 } 956 } 957 958 public enum ActionRequiredBehavior { 959 /** 960 * 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. 961 */ 962 MUST, 963 /** 964 * An action with this behavior may be included in the set of actions processed by the end user. 965 */ 966 COULD, 967 /** 968 * 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. 969 */ 970 MUSTUNLESSDOCUMENTED, 971 /** 972 * added to help the parsers 973 */ 974 NULL; 975 public static ActionRequiredBehavior fromCode(String codeString) throws FHIRException { 976 if (codeString == null || "".equals(codeString)) 977 return null; 978 if ("must".equals(codeString)) 979 return MUST; 980 if ("could".equals(codeString)) 981 return COULD; 982 if ("must-unless-documented".equals(codeString)) 983 return MUSTUNLESSDOCUMENTED; 984 throw new FHIRException("Unknown ActionRequiredBehavior code '"+codeString+"'"); 985 } 986 public static boolean isValidCode(String codeString) { 987 if (codeString == null || "".equals(codeString)) 988 return false; 989 return Utilities.existsInList(codeString, "must", "could", "must-unless-documented"); 990 } 991 public String toCode() { 992 switch (this) { 993 case MUST: return "must"; 994 case COULD: return "could"; 995 case MUSTUNLESSDOCUMENTED: return "must-unless-documented"; 996 case NULL: return null; 997 default: return "?"; 998 } 999 } 1000 public String getSystem() { 1001 switch (this) { 1002 case MUST: return "http://hl7.org/fhir/action-required-behavior"; 1003 case COULD: return "http://hl7.org/fhir/action-required-behavior"; 1004 case MUSTUNLESSDOCUMENTED: return "http://hl7.org/fhir/action-required-behavior"; 1005 case NULL: return null; 1006 default: return "?"; 1007 } 1008 } 1009 public String getDefinition() { 1010 switch (this) { 1011 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."; 1012 case COULD: return "An action with this behavior may be included in the set of actions processed by the end user."; 1013 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."; 1014 case NULL: return null; 1015 default: return "?"; 1016 } 1017 } 1018 public String getDisplay() { 1019 switch (this) { 1020 case MUST: return "Must"; 1021 case COULD: return "Could"; 1022 case MUSTUNLESSDOCUMENTED: return "Must Unless Documented"; 1023 case NULL: return null; 1024 default: return "?"; 1025 } 1026 } 1027 } 1028 1029 public static class ActionRequiredBehaviorEnumFactory implements EnumFactory<ActionRequiredBehavior> { 1030 public ActionRequiredBehavior fromCode(String codeString) throws IllegalArgumentException { 1031 if (codeString == null || "".equals(codeString)) 1032 if (codeString == null || "".equals(codeString)) 1033 return null; 1034 if ("must".equals(codeString)) 1035 return ActionRequiredBehavior.MUST; 1036 if ("could".equals(codeString)) 1037 return ActionRequiredBehavior.COULD; 1038 if ("must-unless-documented".equals(codeString)) 1039 return ActionRequiredBehavior.MUSTUNLESSDOCUMENTED; 1040 throw new IllegalArgumentException("Unknown ActionRequiredBehavior code '"+codeString+"'"); 1041 } 1042 1043 public Enumeration<ActionRequiredBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1044 if (code == null) 1045 return null; 1046 if (code.isEmpty()) 1047 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.NULL, code); 1048 String codeString = ((PrimitiveType) code).asStringValue(); 1049 if (codeString == null || "".equals(codeString)) 1050 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.NULL, code); 1051 if ("must".equals(codeString)) 1052 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUST, code); 1053 if ("could".equals(codeString)) 1054 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.COULD, code); 1055 if ("must-unless-documented".equals(codeString)) 1056 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUSTUNLESSDOCUMENTED, code); 1057 throw new FHIRException("Unknown ActionRequiredBehavior code '"+codeString+"'"); 1058 } 1059 public String toCode(ActionRequiredBehavior code) { 1060 if (code == ActionRequiredBehavior.MUST) 1061 return "must"; 1062 if (code == ActionRequiredBehavior.COULD) 1063 return "could"; 1064 if (code == ActionRequiredBehavior.MUSTUNLESSDOCUMENTED) 1065 return "must-unless-documented"; 1066 return "?"; 1067 } 1068 public String toSystem(ActionRequiredBehavior code) { 1069 return code.getSystem(); 1070 } 1071 } 1072 1073 public enum ActionSelectionBehavior { 1074 /** 1075 * Any number of the actions in the group may be chosen, from zero to all. 1076 */ 1077 ANY, 1078 /** 1079 * All the actions in the group must be selected as a single unit. 1080 */ 1081 ALL, 1082 /** 1083 * 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. 1084 */ 1085 ALLORNONE, 1086 /** 1087 * 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. 1088 */ 1089 EXACTLYONE, 1090 /** 1091 * The end user may choose zero or at most one of the actions in the group. 1092 */ 1093 ATMOSTONE, 1094 /** 1095 * The end user must choose a minimum of one, and as many additional as desired. 1096 */ 1097 ONEORMORE, 1098 /** 1099 * added to help the parsers 1100 */ 1101 NULL; 1102 public static ActionSelectionBehavior fromCode(String codeString) throws FHIRException { 1103 if (codeString == null || "".equals(codeString)) 1104 return null; 1105 if ("any".equals(codeString)) 1106 return ANY; 1107 if ("all".equals(codeString)) 1108 return ALL; 1109 if ("all-or-none".equals(codeString)) 1110 return ALLORNONE; 1111 if ("exactly-one".equals(codeString)) 1112 return EXACTLYONE; 1113 if ("at-most-one".equals(codeString)) 1114 return ATMOSTONE; 1115 if ("one-or-more".equals(codeString)) 1116 return ONEORMORE; 1117 throw new FHIRException("Unknown ActionSelectionBehavior code '"+codeString+"'"); 1118 } 1119 public static boolean isValidCode(String codeString) { 1120 if (codeString == null || "".equals(codeString)) 1121 return false; 1122 return Utilities.existsInList(codeString, "any", "all", "all-or-none", "exactly-one", "at-most-one", "one-or-more"); 1123 } 1124 public String toCode() { 1125 switch (this) { 1126 case ANY: return "any"; 1127 case ALL: return "all"; 1128 case ALLORNONE: return "all-or-none"; 1129 case EXACTLYONE: return "exactly-one"; 1130 case ATMOSTONE: return "at-most-one"; 1131 case ONEORMORE: return "one-or-more"; 1132 case NULL: return null; 1133 default: return "?"; 1134 } 1135 } 1136 public String getSystem() { 1137 switch (this) { 1138 case ANY: return "http://hl7.org/fhir/action-selection-behavior"; 1139 case ALL: return "http://hl7.org/fhir/action-selection-behavior"; 1140 case ALLORNONE: return "http://hl7.org/fhir/action-selection-behavior"; 1141 case EXACTLYONE: return "http://hl7.org/fhir/action-selection-behavior"; 1142 case ATMOSTONE: return "http://hl7.org/fhir/action-selection-behavior"; 1143 case ONEORMORE: return "http://hl7.org/fhir/action-selection-behavior"; 1144 case NULL: return null; 1145 default: return "?"; 1146 } 1147 } 1148 public String getDefinition() { 1149 switch (this) { 1150 case ANY: return "Any number of the actions in the group may be chosen, from zero to all."; 1151 case ALL: return "All the actions in the group must be selected as a single unit."; 1152 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."; 1153 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."; 1154 case ATMOSTONE: return "The end user may choose zero or at most one of the actions in the group."; 1155 case ONEORMORE: return "The end user must choose a minimum of one, and as many additional as desired."; 1156 case NULL: return null; 1157 default: return "?"; 1158 } 1159 } 1160 public String getDisplay() { 1161 switch (this) { 1162 case ANY: return "Any"; 1163 case ALL: return "All"; 1164 case ALLORNONE: return "All Or None"; 1165 case EXACTLYONE: return "Exactly One"; 1166 case ATMOSTONE: return "At Most One"; 1167 case ONEORMORE: return "One Or More"; 1168 case NULL: return null; 1169 default: return "?"; 1170 } 1171 } 1172 } 1173 1174 public static class ActionSelectionBehaviorEnumFactory implements EnumFactory<ActionSelectionBehavior> { 1175 public ActionSelectionBehavior fromCode(String codeString) throws IllegalArgumentException { 1176 if (codeString == null || "".equals(codeString)) 1177 if (codeString == null || "".equals(codeString)) 1178 return null; 1179 if ("any".equals(codeString)) 1180 return ActionSelectionBehavior.ANY; 1181 if ("all".equals(codeString)) 1182 return ActionSelectionBehavior.ALL; 1183 if ("all-or-none".equals(codeString)) 1184 return ActionSelectionBehavior.ALLORNONE; 1185 if ("exactly-one".equals(codeString)) 1186 return ActionSelectionBehavior.EXACTLYONE; 1187 if ("at-most-one".equals(codeString)) 1188 return ActionSelectionBehavior.ATMOSTONE; 1189 if ("one-or-more".equals(codeString)) 1190 return ActionSelectionBehavior.ONEORMORE; 1191 throw new IllegalArgumentException("Unknown ActionSelectionBehavior code '"+codeString+"'"); 1192 } 1193 1194 public Enumeration<ActionSelectionBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1195 if (code == null) 1196 return null; 1197 if (code.isEmpty()) 1198 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.NULL, code); 1199 String codeString = ((PrimitiveType) code).asStringValue(); 1200 if (codeString == null || "".equals(codeString)) 1201 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.NULL, code); 1202 if ("any".equals(codeString)) 1203 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ANY, code); 1204 if ("all".equals(codeString)) 1205 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALL, code); 1206 if ("all-or-none".equals(codeString)) 1207 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALLORNONE, code); 1208 if ("exactly-one".equals(codeString)) 1209 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.EXACTLYONE, code); 1210 if ("at-most-one".equals(codeString)) 1211 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ATMOSTONE, code); 1212 if ("one-or-more".equals(codeString)) 1213 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ONEORMORE, code); 1214 throw new FHIRException("Unknown ActionSelectionBehavior code '"+codeString+"'"); 1215 } 1216 public String toCode(ActionSelectionBehavior code) { 1217 if (code == ActionSelectionBehavior.ANY) 1218 return "any"; 1219 if (code == ActionSelectionBehavior.ALL) 1220 return "all"; 1221 if (code == ActionSelectionBehavior.ALLORNONE) 1222 return "all-or-none"; 1223 if (code == ActionSelectionBehavior.EXACTLYONE) 1224 return "exactly-one"; 1225 if (code == ActionSelectionBehavior.ATMOSTONE) 1226 return "at-most-one"; 1227 if (code == ActionSelectionBehavior.ONEORMORE) 1228 return "one-or-more"; 1229 return "?"; 1230 } 1231 public String toSystem(ActionSelectionBehavior code) { 1232 return code.getSystem(); 1233 } 1234 } 1235 1236 public enum AdministrativeGender { 1237 /** 1238 * Male. 1239 */ 1240 MALE, 1241 /** 1242 * Female. 1243 */ 1244 FEMALE, 1245 /** 1246 * Other. 1247 */ 1248 OTHER, 1249 /** 1250 * Unknown. 1251 */ 1252 UNKNOWN, 1253 /** 1254 * added to help the parsers 1255 */ 1256 NULL; 1257 public static AdministrativeGender fromCode(String codeString) throws FHIRException { 1258 if (codeString == null || "".equals(codeString)) 1259 return null; 1260 if ("male".equals(codeString)) 1261 return MALE; 1262 if ("female".equals(codeString)) 1263 return FEMALE; 1264 if ("other".equals(codeString)) 1265 return OTHER; 1266 if ("unknown".equals(codeString)) 1267 return UNKNOWN; 1268 throw new FHIRException("Unknown AdministrativeGender code '"+codeString+"'"); 1269 } 1270 public static boolean isValidCode(String codeString) { 1271 if (codeString == null || "".equals(codeString)) 1272 return false; 1273 return Utilities.existsInList(codeString, "male", "female", "other", "unknown"); 1274 } 1275 public String toCode() { 1276 switch (this) { 1277 case MALE: return "male"; 1278 case FEMALE: return "female"; 1279 case OTHER: return "other"; 1280 case UNKNOWN: return "unknown"; 1281 case NULL: return null; 1282 default: return "?"; 1283 } 1284 } 1285 public String getSystem() { 1286 switch (this) { 1287 case MALE: return "http://hl7.org/fhir/administrative-gender"; 1288 case FEMALE: return "http://hl7.org/fhir/administrative-gender"; 1289 case OTHER: return "http://hl7.org/fhir/administrative-gender"; 1290 case UNKNOWN: return "http://hl7.org/fhir/administrative-gender"; 1291 case NULL: return null; 1292 default: return "?"; 1293 } 1294 } 1295 public String getDefinition() { 1296 switch (this) { 1297 case MALE: return "Male."; 1298 case FEMALE: return "Female."; 1299 case OTHER: return "Other."; 1300 case UNKNOWN: return "Unknown."; 1301 case NULL: return null; 1302 default: return "?"; 1303 } 1304 } 1305 public String getDisplay() { 1306 switch (this) { 1307 case MALE: return "Male"; 1308 case FEMALE: return "Female"; 1309 case OTHER: return "Other"; 1310 case UNKNOWN: return "Unknown"; 1311 case NULL: return null; 1312 default: return "?"; 1313 } 1314 } 1315 } 1316 1317 public static class AdministrativeGenderEnumFactory implements EnumFactory<AdministrativeGender> { 1318 public AdministrativeGender fromCode(String codeString) throws IllegalArgumentException { 1319 if (codeString == null || "".equals(codeString)) 1320 if (codeString == null || "".equals(codeString)) 1321 return null; 1322 if ("male".equals(codeString)) 1323 return AdministrativeGender.MALE; 1324 if ("female".equals(codeString)) 1325 return AdministrativeGender.FEMALE; 1326 if ("other".equals(codeString)) 1327 return AdministrativeGender.OTHER; 1328 if ("unknown".equals(codeString)) 1329 return AdministrativeGender.UNKNOWN; 1330 throw new IllegalArgumentException("Unknown AdministrativeGender code '"+codeString+"'"); 1331 } 1332 1333 public Enumeration<AdministrativeGender> fromType(PrimitiveType<?> code) throws FHIRException { 1334 if (code == null) 1335 return null; 1336 if (code.isEmpty()) 1337 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.NULL, code); 1338 String codeString = ((PrimitiveType) code).asStringValue(); 1339 if (codeString == null || "".equals(codeString)) 1340 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.NULL, code); 1341 if ("male".equals(codeString)) 1342 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.MALE, code); 1343 if ("female".equals(codeString)) 1344 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.FEMALE, code); 1345 if ("other".equals(codeString)) 1346 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.OTHER, code); 1347 if ("unknown".equals(codeString)) 1348 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.UNKNOWN, code); 1349 throw new FHIRException("Unknown AdministrativeGender code '"+codeString+"'"); 1350 } 1351 public String toCode(AdministrativeGender code) { 1352 if (code == AdministrativeGender.MALE) 1353 return "male"; 1354 if (code == AdministrativeGender.FEMALE) 1355 return "female"; 1356 if (code == AdministrativeGender.OTHER) 1357 return "other"; 1358 if (code == AdministrativeGender.UNKNOWN) 1359 return "unknown"; 1360 return "?"; 1361 } 1362 public String toSystem(AdministrativeGender code) { 1363 return code.getSystem(); 1364 } 1365 } 1366 1367 public enum AllLanguages { 1368 /** 1369 * added to help the parsers 1370 */ 1371 NULL; 1372 public static AllLanguages fromCode(String codeString) throws FHIRException { 1373 if (codeString == null || "".equals(codeString)) 1374 return null; 1375 throw new FHIRException("Unknown AllLanguages code '"+codeString+"'"); 1376 } 1377 public static boolean isValidCode(String codeString) { 1378 if (codeString == null || "".equals(codeString)) 1379 return false; 1380 return Utilities.existsInList(codeString); 1381 } 1382 public String toCode() { 1383 switch (this) { 1384 case NULL: return null; 1385 default: return "?"; 1386 } 1387 } 1388 public String getSystem() { 1389 switch (this) { 1390 case NULL: return null; 1391 default: return "?"; 1392 } 1393 } 1394 public String getDefinition() { 1395 switch (this) { 1396 case NULL: return null; 1397 default: return "?"; 1398 } 1399 } 1400 public String getDisplay() { 1401 switch (this) { 1402 case NULL: return null; 1403 default: return "?"; 1404 } 1405 } 1406 } 1407 1408 public static class AllLanguagesEnumFactory implements EnumFactory<AllLanguages> { 1409 public AllLanguages fromCode(String codeString) throws IllegalArgumentException { 1410 if (codeString == null || "".equals(codeString)) 1411 if (codeString == null || "".equals(codeString)) 1412 return null; 1413 throw new IllegalArgumentException("Unknown AllLanguages code '"+codeString+"'"); 1414 } 1415 1416 public Enumeration<AllLanguages> fromType(PrimitiveType<?> code) throws FHIRException { 1417 if (code == null) 1418 return null; 1419 if (code.isEmpty()) 1420 return new Enumeration<AllLanguages>(this, AllLanguages.NULL, code); 1421 String codeString = ((PrimitiveType) code).asStringValue(); 1422 if (codeString == null || "".equals(codeString)) 1423 return new Enumeration<AllLanguages>(this, AllLanguages.NULL, code); 1424 throw new FHIRException("Unknown AllLanguages code '"+codeString+"'"); 1425 } 1426 public String toCode(AllLanguages code) { 1427 return "?"; 1428 } 1429 public String toSystem(AllLanguages code) { 1430 return code.getSystem(); 1431 } 1432 } 1433 1434 public enum BindingStrength { 1435 /** 1436 * To be conformant, the concept in this element SHALL be from the specified value set. 1437 */ 1438 REQUIRED, 1439 /** 1440 * 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. 1441 */ 1442 EXTENSIBLE, 1443 /** 1444 * Instances are encouraged to draw from the specified codes for interoperability purposes but are not required to do so to be considered conformant. 1445 */ 1446 PREFERRED, 1447 /** 1448 * 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. 1449 */ 1450 EXAMPLE, 1451 /** 1452 * added to help the parsers 1453 */ 1454 NULL; 1455 public static BindingStrength fromCode(String codeString) throws FHIRException { 1456 if (codeString == null || "".equals(codeString)) 1457 return null; 1458 if ("required".equals(codeString)) 1459 return REQUIRED; 1460 if ("extensible".equals(codeString)) 1461 return EXTENSIBLE; 1462 if ("preferred".equals(codeString)) 1463 return PREFERRED; 1464 if ("example".equals(codeString)) 1465 return EXAMPLE; 1466 throw new FHIRException("Unknown BindingStrength code '"+codeString+"'"); 1467 } 1468 public static boolean isValidCode(String codeString) { 1469 if (codeString == null || "".equals(codeString)) 1470 return false; 1471 return Utilities.existsInList(codeString, "required", "extensible", "preferred", "example"); 1472 } 1473 public String toCode() { 1474 switch (this) { 1475 case REQUIRED: return "required"; 1476 case EXTENSIBLE: return "extensible"; 1477 case PREFERRED: return "preferred"; 1478 case EXAMPLE: return "example"; 1479 case NULL: return null; 1480 default: return "?"; 1481 } 1482 } 1483 public String getSystem() { 1484 switch (this) { 1485 case REQUIRED: return "http://hl7.org/fhir/binding-strength"; 1486 case EXTENSIBLE: return "http://hl7.org/fhir/binding-strength"; 1487 case PREFERRED: return "http://hl7.org/fhir/binding-strength"; 1488 case EXAMPLE: return "http://hl7.org/fhir/binding-strength"; 1489 case NULL: return null; 1490 default: return "?"; 1491 } 1492 } 1493 public String getDefinition() { 1494 switch (this) { 1495 case REQUIRED: return "To be conformant, the concept in this element SHALL be from the specified value set."; 1496 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."; 1497 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."; 1498 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."; 1499 case NULL: return null; 1500 default: return "?"; 1501 } 1502 } 1503 public String getDisplay() { 1504 switch (this) { 1505 case REQUIRED: return "Required"; 1506 case EXTENSIBLE: return "Extensible"; 1507 case PREFERRED: return "Preferred"; 1508 case EXAMPLE: return "Example"; 1509 case NULL: return null; 1510 default: return "?"; 1511 } 1512 } 1513 } 1514 1515 public static class BindingStrengthEnumFactory implements EnumFactory<BindingStrength> { 1516 public BindingStrength fromCode(String codeString) throws IllegalArgumentException { 1517 if (codeString == null || "".equals(codeString)) 1518 if (codeString == null || "".equals(codeString)) 1519 return null; 1520 if ("required".equals(codeString)) 1521 return BindingStrength.REQUIRED; 1522 if ("extensible".equals(codeString)) 1523 return BindingStrength.EXTENSIBLE; 1524 if ("preferred".equals(codeString)) 1525 return BindingStrength.PREFERRED; 1526 if ("example".equals(codeString)) 1527 return BindingStrength.EXAMPLE; 1528 throw new IllegalArgumentException("Unknown BindingStrength code '"+codeString+"'"); 1529 } 1530 1531 public Enumeration<BindingStrength> fromType(PrimitiveType<?> code) throws FHIRException { 1532 if (code == null) 1533 return null; 1534 if (code.isEmpty()) 1535 return new Enumeration<BindingStrength>(this, BindingStrength.NULL, code); 1536 String codeString = ((PrimitiveType) code).asStringValue(); 1537 if (codeString == null || "".equals(codeString)) 1538 return new Enumeration<BindingStrength>(this, BindingStrength.NULL, code); 1539 if ("required".equals(codeString)) 1540 return new Enumeration<BindingStrength>(this, BindingStrength.REQUIRED, code); 1541 if ("extensible".equals(codeString)) 1542 return new Enumeration<BindingStrength>(this, BindingStrength.EXTENSIBLE, code); 1543 if ("preferred".equals(codeString)) 1544 return new Enumeration<BindingStrength>(this, BindingStrength.PREFERRED, code); 1545 if ("example".equals(codeString)) 1546 return new Enumeration<BindingStrength>(this, BindingStrength.EXAMPLE, code); 1547 throw new FHIRException("Unknown BindingStrength code '"+codeString+"'"); 1548 } 1549 public String toCode(BindingStrength code) { 1550 if (code == BindingStrength.REQUIRED) 1551 return "required"; 1552 if (code == BindingStrength.EXTENSIBLE) 1553 return "extensible"; 1554 if (code == BindingStrength.PREFERRED) 1555 return "preferred"; 1556 if (code == BindingStrength.EXAMPLE) 1557 return "example"; 1558 return "?"; 1559 } 1560 public String toSystem(BindingStrength code) { 1561 return code.getSystem(); 1562 } 1563 } 1564 1565 public enum CapabilityStatementKind { 1566 /** 1567 * 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. 1568 */ 1569 INSTANCE, 1570 /** 1571 * The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation. 1572 */ 1573 CAPABILITY, 1574 /** 1575 * 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'. 1576 */ 1577 REQUIREMENTS, 1578 /** 1579 * added to help the parsers 1580 */ 1581 NULL; 1582 public static CapabilityStatementKind fromCode(String codeString) throws FHIRException { 1583 if (codeString == null || "".equals(codeString)) 1584 return null; 1585 if ("instance".equals(codeString)) 1586 return INSTANCE; 1587 if ("capability".equals(codeString)) 1588 return CAPABILITY; 1589 if ("requirements".equals(codeString)) 1590 return REQUIREMENTS; 1591 throw new FHIRException("Unknown CapabilityStatementKind code '"+codeString+"'"); 1592 } 1593 public static boolean isValidCode(String codeString) { 1594 if (codeString == null || "".equals(codeString)) 1595 return false; 1596 return Utilities.existsInList(codeString, "instance", "capability", "requirements"); 1597 } 1598 public String toCode() { 1599 switch (this) { 1600 case INSTANCE: return "instance"; 1601 case CAPABILITY: return "capability"; 1602 case REQUIREMENTS: return "requirements"; 1603 case NULL: return null; 1604 default: return "?"; 1605 } 1606 } 1607 public String getSystem() { 1608 switch (this) { 1609 case INSTANCE: return "http://hl7.org/fhir/capability-statement-kind"; 1610 case CAPABILITY: return "http://hl7.org/fhir/capability-statement-kind"; 1611 case REQUIREMENTS: return "http://hl7.org/fhir/capability-statement-kind"; 1612 case NULL: return null; 1613 default: return "?"; 1614 } 1615 } 1616 public String getDefinition() { 1617 switch (this) { 1618 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."; 1619 case CAPABILITY: return "The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation."; 1620 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'."; 1621 case NULL: return null; 1622 default: return "?"; 1623 } 1624 } 1625 public String getDisplay() { 1626 switch (this) { 1627 case INSTANCE: return "Instance"; 1628 case CAPABILITY: return "Capability"; 1629 case REQUIREMENTS: return "Requirements"; 1630 case NULL: return null; 1631 default: return "?"; 1632 } 1633 } 1634 } 1635 1636 public static class CapabilityStatementKindEnumFactory implements EnumFactory<CapabilityStatementKind> { 1637 public CapabilityStatementKind fromCode(String codeString) throws IllegalArgumentException { 1638 if (codeString == null || "".equals(codeString)) 1639 if (codeString == null || "".equals(codeString)) 1640 return null; 1641 if ("instance".equals(codeString)) 1642 return CapabilityStatementKind.INSTANCE; 1643 if ("capability".equals(codeString)) 1644 return CapabilityStatementKind.CAPABILITY; 1645 if ("requirements".equals(codeString)) 1646 return CapabilityStatementKind.REQUIREMENTS; 1647 throw new IllegalArgumentException("Unknown CapabilityStatementKind code '"+codeString+"'"); 1648 } 1649 1650 public Enumeration<CapabilityStatementKind> fromType(PrimitiveType<?> code) throws FHIRException { 1651 if (code == null) 1652 return null; 1653 if (code.isEmpty()) 1654 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.NULL, code); 1655 String codeString = ((PrimitiveType) code).asStringValue(); 1656 if (codeString == null || "".equals(codeString)) 1657 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.NULL, code); 1658 if ("instance".equals(codeString)) 1659 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.INSTANCE, code); 1660 if ("capability".equals(codeString)) 1661 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.CAPABILITY, code); 1662 if ("requirements".equals(codeString)) 1663 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.REQUIREMENTS, code); 1664 throw new FHIRException("Unknown CapabilityStatementKind code '"+codeString+"'"); 1665 } 1666 public String toCode(CapabilityStatementKind code) { 1667 if (code == CapabilityStatementKind.INSTANCE) 1668 return "instance"; 1669 if (code == CapabilityStatementKind.CAPABILITY) 1670 return "capability"; 1671 if (code == CapabilityStatementKind.REQUIREMENTS) 1672 return "requirements"; 1673 return "?"; 1674 } 1675 public String toSystem(CapabilityStatementKind code) { 1676 return code.getSystem(); 1677 } 1678 } 1679 1680 public enum ClaimProcessingCodes { 1681 /** 1682 * The Claim/Pre-authorization/Pre-determination has been received but processing has not begun. 1683 */ 1684 QUEUED, 1685 /** 1686 * The processing has completed without errors 1687 */ 1688 COMPLETE, 1689 /** 1690 * One or more errors have been detected in the Claim 1691 */ 1692 ERROR, 1693 /** 1694 * No errors have been detected in the Claim and some of the adjudication has been performed. 1695 */ 1696 PARTIAL, 1697 /** 1698 * added to help the parsers 1699 */ 1700 NULL; 1701 public static ClaimProcessingCodes fromCode(String codeString) throws FHIRException { 1702 if (codeString == null || "".equals(codeString)) 1703 return null; 1704 if ("queued".equals(codeString)) 1705 return QUEUED; 1706 if ("complete".equals(codeString)) 1707 return COMPLETE; 1708 if ("error".equals(codeString)) 1709 return ERROR; 1710 if ("partial".equals(codeString)) 1711 return PARTIAL; 1712 throw new FHIRException("Unknown ClaimProcessingCodes code '"+codeString+"'"); 1713 } 1714 public static boolean isValidCode(String codeString) { 1715 if (codeString == null || "".equals(codeString)) 1716 return false; 1717 return Utilities.existsInList(codeString, "queued", "complete", "error", "partial"); 1718 } 1719 public String toCode() { 1720 switch (this) { 1721 case QUEUED: return "queued"; 1722 case COMPLETE: return "complete"; 1723 case ERROR: return "error"; 1724 case PARTIAL: return "partial"; 1725 case NULL: return null; 1726 default: return "?"; 1727 } 1728 } 1729 public String getSystem() { 1730 switch (this) { 1731 case QUEUED: return "http://hl7.org/fhir/claim-outcome"; 1732 case COMPLETE: return "http://hl7.org/fhir/claim-outcome"; 1733 case ERROR: return "http://hl7.org/fhir/claim-outcome"; 1734 case PARTIAL: return "http://hl7.org/fhir/claim-outcome"; 1735 case NULL: return null; 1736 default: return "?"; 1737 } 1738 } 1739 public String getDefinition() { 1740 switch (this) { 1741 case QUEUED: return "The Claim/Pre-authorization/Pre-determination has been received but processing has not begun."; 1742 case COMPLETE: return "The processing has completed without errors"; 1743 case ERROR: return "One or more errors have been detected in the Claim"; 1744 case PARTIAL: return "No errors have been detected in the Claim and some of the adjudication has been performed."; 1745 case NULL: return null; 1746 default: return "?"; 1747 } 1748 } 1749 public String getDisplay() { 1750 switch (this) { 1751 case QUEUED: return "Queued"; 1752 case COMPLETE: return "Processing Complete"; 1753 case ERROR: return "Error"; 1754 case PARTIAL: return "Partial Processing"; 1755 case NULL: return null; 1756 default: return "?"; 1757 } 1758 } 1759 } 1760 1761 public static class ClaimProcessingCodesEnumFactory implements EnumFactory<ClaimProcessingCodes> { 1762 public ClaimProcessingCodes fromCode(String codeString) throws IllegalArgumentException { 1763 if (codeString == null || "".equals(codeString)) 1764 if (codeString == null || "".equals(codeString)) 1765 return null; 1766 if ("queued".equals(codeString)) 1767 return ClaimProcessingCodes.QUEUED; 1768 if ("complete".equals(codeString)) 1769 return ClaimProcessingCodes.COMPLETE; 1770 if ("error".equals(codeString)) 1771 return ClaimProcessingCodes.ERROR; 1772 if ("partial".equals(codeString)) 1773 return ClaimProcessingCodes.PARTIAL; 1774 throw new IllegalArgumentException("Unknown ClaimProcessingCodes code '"+codeString+"'"); 1775 } 1776 1777 public Enumeration<ClaimProcessingCodes> fromType(PrimitiveType<?> code) throws FHIRException { 1778 if (code == null) 1779 return null; 1780 if (code.isEmpty()) 1781 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.NULL, code); 1782 String codeString = ((PrimitiveType) code).asStringValue(); 1783 if (codeString == null || "".equals(codeString)) 1784 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.NULL, code); 1785 if ("queued".equals(codeString)) 1786 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.QUEUED, code); 1787 if ("complete".equals(codeString)) 1788 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.COMPLETE, code); 1789 if ("error".equals(codeString)) 1790 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.ERROR, code); 1791 if ("partial".equals(codeString)) 1792 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.PARTIAL, code); 1793 throw new FHIRException("Unknown ClaimProcessingCodes code '"+codeString+"'"); 1794 } 1795 public String toCode(ClaimProcessingCodes code) { 1796 if (code == ClaimProcessingCodes.QUEUED) 1797 return "queued"; 1798 if (code == ClaimProcessingCodes.COMPLETE) 1799 return "complete"; 1800 if (code == ClaimProcessingCodes.ERROR) 1801 return "error"; 1802 if (code == ClaimProcessingCodes.PARTIAL) 1803 return "partial"; 1804 return "?"; 1805 } 1806 public String toSystem(ClaimProcessingCodes code) { 1807 return code.getSystem(); 1808 } 1809 } 1810 1811 public enum CodeSystemContentMode { 1812 /** 1813 * None of the concepts defined by the code system are included in the code system resource. 1814 */ 1815 NOTPRESENT, 1816 /** 1817 * 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. 1818 */ 1819 EXAMPLE, 1820 /** 1821 * 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. 1822 */ 1823 FRAGMENT, 1824 /** 1825 * All the concepts defined by the code system are included in the code system resource. 1826 */ 1827 COMPLETE, 1828 /** 1829 * The resource doesn't define any new concepts; it just provides additional designations and properties to another code system. 1830 */ 1831 SUPPLEMENT, 1832 /** 1833 * added to help the parsers 1834 */ 1835 NULL; 1836 public static CodeSystemContentMode fromCode(String codeString) throws FHIRException { 1837 if (codeString == null || "".equals(codeString)) 1838 return null; 1839 if ("not-present".equals(codeString)) 1840 return NOTPRESENT; 1841 if ("example".equals(codeString)) 1842 return EXAMPLE; 1843 if ("fragment".equals(codeString)) 1844 return FRAGMENT; 1845 if ("complete".equals(codeString)) 1846 return COMPLETE; 1847 if ("supplement".equals(codeString)) 1848 return SUPPLEMENT; 1849 throw new FHIRException("Unknown CodeSystemContentMode code '"+codeString+"'"); 1850 } 1851 public static boolean isValidCode(String codeString) { 1852 if (codeString == null || "".equals(codeString)) 1853 return false; 1854 return Utilities.existsInList(codeString, "not-present", "example", "fragment", "complete", "supplement"); 1855 } 1856 public String toCode() { 1857 switch (this) { 1858 case NOTPRESENT: return "not-present"; 1859 case EXAMPLE: return "example"; 1860 case FRAGMENT: return "fragment"; 1861 case COMPLETE: return "complete"; 1862 case SUPPLEMENT: return "supplement"; 1863 case NULL: return null; 1864 default: return "?"; 1865 } 1866 } 1867 public String getSystem() { 1868 switch (this) { 1869 case NOTPRESENT: return "http://hl7.org/fhir/codesystem-content-mode"; 1870 case EXAMPLE: return "http://hl7.org/fhir/codesystem-content-mode"; 1871 case FRAGMENT: return "http://hl7.org/fhir/codesystem-content-mode"; 1872 case COMPLETE: return "http://hl7.org/fhir/codesystem-content-mode"; 1873 case SUPPLEMENT: return "http://hl7.org/fhir/codesystem-content-mode"; 1874 case NULL: return null; 1875 default: return "?"; 1876 } 1877 } 1878 public String getDefinition() { 1879 switch (this) { 1880 case NOTPRESENT: return "None of the concepts defined by the code system are included in the code system resource."; 1881 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."; 1882 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."; 1883 case COMPLETE: return "All the concepts defined by the code system are included in the code system resource."; 1884 case SUPPLEMENT: return "The resource doesn't define any new concepts; it just provides additional designations and properties to another code system."; 1885 case NULL: return null; 1886 default: return "?"; 1887 } 1888 } 1889 public String getDisplay() { 1890 switch (this) { 1891 case NOTPRESENT: return "Not Present"; 1892 case EXAMPLE: return "Example"; 1893 case FRAGMENT: return "Fragment"; 1894 case COMPLETE: return "Complete"; 1895 case SUPPLEMENT: return "Supplement"; 1896 case NULL: return null; 1897 default: return "?"; 1898 } 1899 } 1900 } 1901 1902 public static class CodeSystemContentModeEnumFactory implements EnumFactory<CodeSystemContentMode> { 1903 public CodeSystemContentMode fromCode(String codeString) throws IllegalArgumentException { 1904 if (codeString == null || "".equals(codeString)) 1905 if (codeString == null || "".equals(codeString)) 1906 return null; 1907 if ("not-present".equals(codeString)) 1908 return CodeSystemContentMode.NOTPRESENT; 1909 if ("example".equals(codeString)) 1910 return CodeSystemContentMode.EXAMPLE; 1911 if ("fragment".equals(codeString)) 1912 return CodeSystemContentMode.FRAGMENT; 1913 if ("complete".equals(codeString)) 1914 return CodeSystemContentMode.COMPLETE; 1915 if ("supplement".equals(codeString)) 1916 return CodeSystemContentMode.SUPPLEMENT; 1917 throw new IllegalArgumentException("Unknown CodeSystemContentMode code '"+codeString+"'"); 1918 } 1919 1920 public Enumeration<CodeSystemContentMode> fromType(PrimitiveType<?> code) throws FHIRException { 1921 if (code == null) 1922 return null; 1923 if (code.isEmpty()) 1924 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.NULL, code); 1925 String codeString = ((PrimitiveType) code).asStringValue(); 1926 if (codeString == null || "".equals(codeString)) 1927 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.NULL, code); 1928 if ("not-present".equals(codeString)) 1929 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.NOTPRESENT, code); 1930 if ("example".equals(codeString)) 1931 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.EXAMPLE, code); 1932 if ("fragment".equals(codeString)) 1933 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.FRAGMENT, code); 1934 if ("complete".equals(codeString)) 1935 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.COMPLETE, code); 1936 if ("supplement".equals(codeString)) 1937 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.SUPPLEMENT, code); 1938 throw new FHIRException("Unknown CodeSystemContentMode code '"+codeString+"'"); 1939 } 1940 public String toCode(CodeSystemContentMode code) { 1941 if (code == CodeSystemContentMode.NOTPRESENT) 1942 return "not-present"; 1943 if (code == CodeSystemContentMode.EXAMPLE) 1944 return "example"; 1945 if (code == CodeSystemContentMode.FRAGMENT) 1946 return "fragment"; 1947 if (code == CodeSystemContentMode.COMPLETE) 1948 return "complete"; 1949 if (code == CodeSystemContentMode.SUPPLEMENT) 1950 return "supplement"; 1951 return "?"; 1952 } 1953 public String toSystem(CodeSystemContentMode code) { 1954 return code.getSystem(); 1955 } 1956 } 1957 1958 public enum CommonLanguages { 1959 /** 1960 * null 1961 */ 1962 AR, 1963 /** 1964 * null 1965 */ 1966 BG, 1967 /** 1968 * null 1969 */ 1970 BGBG, 1971 /** 1972 * null 1973 */ 1974 BN, 1975 /** 1976 * null 1977 */ 1978 CS, 1979 /** 1980 * null 1981 */ 1982 CSCZ, 1983 /** 1984 * null 1985 */ 1986 BS, 1987 /** 1988 * null 1989 */ 1990 BSBA, 1991 /** 1992 * null 1993 */ 1994 DA, 1995 /** 1996 * null 1997 */ 1998 DADK, 1999 /** 2000 * null 2001 */ 2002 DE, 2003 /** 2004 * null 2005 */ 2006 DEAT, 2007 /** 2008 * null 2009 */ 2010 DECH, 2011 /** 2012 * null 2013 */ 2014 DEDE, 2015 /** 2016 * null 2017 */ 2018 EL, 2019 /** 2020 * null 2021 */ 2022 ELGR, 2023 /** 2024 * null 2025 */ 2026 EN, 2027 /** 2028 * null 2029 */ 2030 ENAU, 2031 /** 2032 * null 2033 */ 2034 ENCA, 2035 /** 2036 * null 2037 */ 2038 ENGB, 2039 /** 2040 * null 2041 */ 2042 ENIN, 2043 /** 2044 * null 2045 */ 2046 ENNZ, 2047 /** 2048 * null 2049 */ 2050 ENSG, 2051 /** 2052 * null 2053 */ 2054 ENUS, 2055 /** 2056 * null 2057 */ 2058 ES, 2059 /** 2060 * null 2061 */ 2062 ESAR, 2063 /** 2064 * null 2065 */ 2066 ESES, 2067 /** 2068 * null 2069 */ 2070 ESUY, 2071 /** 2072 * null 2073 */ 2074 ET, 2075 /** 2076 * null 2077 */ 2078 ETEE, 2079 /** 2080 * null 2081 */ 2082 FI, 2083 /** 2084 * null 2085 */ 2086 FR, 2087 /** 2088 * null 2089 */ 2090 FRBE, 2091 /** 2092 * null 2093 */ 2094 FRCH, 2095 /** 2096 * null 2097 */ 2098 FRFR, 2099 /** 2100 * null 2101 */ 2102 FIFI, 2103 /** 2104 * null 2105 */ 2106 FRCA, 2107 /** 2108 * null 2109 */ 2110 FY, 2111 /** 2112 * null 2113 */ 2114 FYNL, 2115 /** 2116 * null 2117 */ 2118 HI, 2119 /** 2120 * null 2121 */ 2122 HR, 2123 /** 2124 * null 2125 */ 2126 HRHR, 2127 /** 2128 * null 2129 */ 2130 IS, 2131 /** 2132 * null 2133 */ 2134 ISIS, 2135 /** 2136 * null 2137 */ 2138 IT, 2139 /** 2140 * null 2141 */ 2142 ITCH, 2143 /** 2144 * null 2145 */ 2146 ITIT, 2147 /** 2148 * null 2149 */ 2150 JA, 2151 /** 2152 * null 2153 */ 2154 KO, 2155 /** 2156 * null 2157 */ 2158 LT, 2159 /** 2160 * null 2161 */ 2162 LTLT, 2163 /** 2164 * null 2165 */ 2166 LV, 2167 /** 2168 * null 2169 */ 2170 LVLV, 2171 /** 2172 * null 2173 */ 2174 NL, 2175 /** 2176 * null 2177 */ 2178 NLBE, 2179 /** 2180 * null 2181 */ 2182 NLNL, 2183 /** 2184 * null 2185 */ 2186 NO, 2187 /** 2188 * null 2189 */ 2190 NONO, 2191 /** 2192 * null 2193 */ 2194 PA, 2195 /** 2196 * null 2197 */ 2198 PL, 2199 /** 2200 * null 2201 */ 2202 PLPL, 2203 /** 2204 * null 2205 */ 2206 PT, 2207 /** 2208 * null 2209 */ 2210 PTPT, 2211 /** 2212 * null 2213 */ 2214 PTBR, 2215 /** 2216 * null 2217 */ 2218 RO, 2219 /** 2220 * null 2221 */ 2222 RORO, 2223 /** 2224 * null 2225 */ 2226 RU, 2227 /** 2228 * null 2229 */ 2230 RURU, 2231 /** 2232 * null 2233 */ 2234 SK, 2235 /** 2236 * null 2237 */ 2238 SKSK, 2239 /** 2240 * null 2241 */ 2242 SL, 2243 /** 2244 * null 2245 */ 2246 SLSI, 2247 /** 2248 * null 2249 */ 2250 SR, 2251 /** 2252 * null 2253 */ 2254 SRRS, 2255 /** 2256 * null 2257 */ 2258 SV, 2259 /** 2260 * null 2261 */ 2262 SVSE, 2263 /** 2264 * null 2265 */ 2266 TE, 2267 /** 2268 * null 2269 */ 2270 ZH, 2271 /** 2272 * null 2273 */ 2274 ZHCN, 2275 /** 2276 * null 2277 */ 2278 ZHHK, 2279 /** 2280 * null 2281 */ 2282 ZHSG, 2283 /** 2284 * null 2285 */ 2286 ZHTW, 2287 /** 2288 * added to help the parsers 2289 */ 2290 NULL; 2291 public static CommonLanguages fromCode(String codeString) throws FHIRException { 2292 if (codeString == null || "".equals(codeString)) 2293 return null; 2294 if ("ar".equals(codeString)) 2295 return AR; 2296 if ("bg".equals(codeString)) 2297 return BG; 2298 if ("bg-BG".equals(codeString)) 2299 return BGBG; 2300 if ("bn".equals(codeString)) 2301 return BN; 2302 if ("cs".equals(codeString)) 2303 return CS; 2304 if ("cs-CZ".equals(codeString)) 2305 return CSCZ; 2306 if ("bs".equals(codeString)) 2307 return BS; 2308 if ("bs-BA".equals(codeString)) 2309 return BSBA; 2310 if ("da".equals(codeString)) 2311 return DA; 2312 if ("da-DK".equals(codeString)) 2313 return DADK; 2314 if ("de".equals(codeString)) 2315 return DE; 2316 if ("de-AT".equals(codeString)) 2317 return DEAT; 2318 if ("de-CH".equals(codeString)) 2319 return DECH; 2320 if ("de-DE".equals(codeString)) 2321 return DEDE; 2322 if ("el".equals(codeString)) 2323 return EL; 2324 if ("el-GR".equals(codeString)) 2325 return ELGR; 2326 if ("en".equals(codeString)) 2327 return EN; 2328 if ("en-AU".equals(codeString)) 2329 return ENAU; 2330 if ("en-CA".equals(codeString)) 2331 return ENCA; 2332 if ("en-GB".equals(codeString)) 2333 return ENGB; 2334 if ("en-IN".equals(codeString)) 2335 return ENIN; 2336 if ("en-NZ".equals(codeString)) 2337 return ENNZ; 2338 if ("en-SG".equals(codeString)) 2339 return ENSG; 2340 if ("en-US".equals(codeString)) 2341 return ENUS; 2342 if ("es".equals(codeString)) 2343 return ES; 2344 if ("es-AR".equals(codeString)) 2345 return ESAR; 2346 if ("es-ES".equals(codeString)) 2347 return ESES; 2348 if ("es-UY".equals(codeString)) 2349 return ESUY; 2350 if ("et".equals(codeString)) 2351 return ET; 2352 if ("et-EE".equals(codeString)) 2353 return ETEE; 2354 if ("fi".equals(codeString)) 2355 return FI; 2356 if ("fr".equals(codeString)) 2357 return FR; 2358 if ("fr-BE".equals(codeString)) 2359 return FRBE; 2360 if ("fr-CH".equals(codeString)) 2361 return FRCH; 2362 if ("fr-FR".equals(codeString)) 2363 return FRFR; 2364 if ("fi-FI".equals(codeString)) 2365 return FIFI; 2366 if ("fr-CA".equals(codeString)) 2367 return FRCA; 2368 if ("fy".equals(codeString)) 2369 return FY; 2370 if ("fy-NL".equals(codeString)) 2371 return FYNL; 2372 if ("hi".equals(codeString)) 2373 return HI; 2374 if ("hr".equals(codeString)) 2375 return HR; 2376 if ("hr-HR".equals(codeString)) 2377 return HRHR; 2378 if ("is".equals(codeString)) 2379 return IS; 2380 if ("is-IS".equals(codeString)) 2381 return ISIS; 2382 if ("it".equals(codeString)) 2383 return IT; 2384 if ("it-CH".equals(codeString)) 2385 return ITCH; 2386 if ("it-IT".equals(codeString)) 2387 return ITIT; 2388 if ("ja".equals(codeString)) 2389 return JA; 2390 if ("ko".equals(codeString)) 2391 return KO; 2392 if ("lt".equals(codeString)) 2393 return LT; 2394 if ("lt-LT".equals(codeString)) 2395 return LTLT; 2396 if ("lv".equals(codeString)) 2397 return LV; 2398 if ("lv-LV".equals(codeString)) 2399 return LVLV; 2400 if ("nl".equals(codeString)) 2401 return NL; 2402 if ("nl-BE".equals(codeString)) 2403 return NLBE; 2404 if ("nl-NL".equals(codeString)) 2405 return NLNL; 2406 if ("no".equals(codeString)) 2407 return NO; 2408 if ("no-NO".equals(codeString)) 2409 return NONO; 2410 if ("pa".equals(codeString)) 2411 return PA; 2412 if ("pl".equals(codeString)) 2413 return PL; 2414 if ("pl-PL".equals(codeString)) 2415 return PLPL; 2416 if ("pt".equals(codeString)) 2417 return PT; 2418 if ("pt-PT".equals(codeString)) 2419 return PTPT; 2420 if ("pt-BR".equals(codeString)) 2421 return PTBR; 2422 if ("ro".equals(codeString)) 2423 return RO; 2424 if ("ro-RO".equals(codeString)) 2425 return RORO; 2426 if ("ru".equals(codeString)) 2427 return RU; 2428 if ("ru-RU".equals(codeString)) 2429 return RURU; 2430 if ("sk".equals(codeString)) 2431 return SK; 2432 if ("sk-SK".equals(codeString)) 2433 return SKSK; 2434 if ("sl".equals(codeString)) 2435 return SL; 2436 if ("sl-SI".equals(codeString)) 2437 return SLSI; 2438 if ("sr".equals(codeString)) 2439 return SR; 2440 if ("sr-RS".equals(codeString)) 2441 return SRRS; 2442 if ("sv".equals(codeString)) 2443 return SV; 2444 if ("sv-SE".equals(codeString)) 2445 return SVSE; 2446 if ("te".equals(codeString)) 2447 return TE; 2448 if ("zh".equals(codeString)) 2449 return ZH; 2450 if ("zh-CN".equals(codeString)) 2451 return ZHCN; 2452 if ("zh-HK".equals(codeString)) 2453 return ZHHK; 2454 if ("zh-SG".equals(codeString)) 2455 return ZHSG; 2456 if ("zh-TW".equals(codeString)) 2457 return ZHTW; 2458 throw new FHIRException("Unknown CommonLanguages code '"+codeString+"'"); 2459 } 2460 public static boolean isValidCode(String codeString) { 2461 if (codeString == null || "".equals(codeString)) 2462 return false; 2463 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"); 2464 } 2465 public String toCode() { 2466 switch (this) { 2467 case AR: return "ar"; 2468 case BG: return "bg"; 2469 case BGBG: return "bg-BG"; 2470 case BN: return "bn"; 2471 case CS: return "cs"; 2472 case CSCZ: return "cs-CZ"; 2473 case BS: return "bs"; 2474 case BSBA: return "bs-BA"; 2475 case DA: return "da"; 2476 case DADK: return "da-DK"; 2477 case DE: return "de"; 2478 case DEAT: return "de-AT"; 2479 case DECH: return "de-CH"; 2480 case DEDE: return "de-DE"; 2481 case EL: return "el"; 2482 case ELGR: return "el-GR"; 2483 case EN: return "en"; 2484 case ENAU: return "en-AU"; 2485 case ENCA: return "en-CA"; 2486 case ENGB: return "en-GB"; 2487 case ENIN: return "en-IN"; 2488 case ENNZ: return "en-NZ"; 2489 case ENSG: return "en-SG"; 2490 case ENUS: return "en-US"; 2491 case ES: return "es"; 2492 case ESAR: return "es-AR"; 2493 case ESES: return "es-ES"; 2494 case ESUY: return "es-UY"; 2495 case ET: return "et"; 2496 case ETEE: return "et-EE"; 2497 case FI: return "fi"; 2498 case FR: return "fr"; 2499 case FRBE: return "fr-BE"; 2500 case FRCH: return "fr-CH"; 2501 case FRFR: return "fr-FR"; 2502 case FIFI: return "fi-FI"; 2503 case FRCA: return "fr-CA"; 2504 case FY: return "fy"; 2505 case FYNL: return "fy-NL"; 2506 case HI: return "hi"; 2507 case HR: return "hr"; 2508 case HRHR: return "hr-HR"; 2509 case IS: return "is"; 2510 case ISIS: return "is-IS"; 2511 case IT: return "it"; 2512 case ITCH: return "it-CH"; 2513 case ITIT: return "it-IT"; 2514 case JA: return "ja"; 2515 case KO: return "ko"; 2516 case LT: return "lt"; 2517 case LTLT: return "lt-LT"; 2518 case LV: return "lv"; 2519 case LVLV: return "lv-LV"; 2520 case NL: return "nl"; 2521 case NLBE: return "nl-BE"; 2522 case NLNL: return "nl-NL"; 2523 case NO: return "no"; 2524 case NONO: return "no-NO"; 2525 case PA: return "pa"; 2526 case PL: return "pl"; 2527 case PLPL: return "pl-PL"; 2528 case PT: return "pt"; 2529 case PTPT: return "pt-PT"; 2530 case PTBR: return "pt-BR"; 2531 case RO: return "ro"; 2532 case RORO: return "ro-RO"; 2533 case RU: return "ru"; 2534 case RURU: return "ru-RU"; 2535 case SK: return "sk"; 2536 case SKSK: return "sk-SK"; 2537 case SL: return "sl"; 2538 case SLSI: return "sl-SI"; 2539 case SR: return "sr"; 2540 case SRRS: return "sr-RS"; 2541 case SV: return "sv"; 2542 case SVSE: return "sv-SE"; 2543 case TE: return "te"; 2544 case ZH: return "zh"; 2545 case ZHCN: return "zh-CN"; 2546 case ZHHK: return "zh-HK"; 2547 case ZHSG: return "zh-SG"; 2548 case ZHTW: return "zh-TW"; 2549 case NULL: return null; 2550 default: return "?"; 2551 } 2552 } 2553 public String getSystem() { 2554 switch (this) { 2555 case AR: return "urn:ietf:bcp:47"; 2556 case BG: return "urn:ietf:bcp:47"; 2557 case BGBG: return "urn:ietf:bcp:47"; 2558 case BN: return "urn:ietf:bcp:47"; 2559 case CS: return "urn:ietf:bcp:47"; 2560 case CSCZ: return "urn:ietf:bcp:47"; 2561 case BS: return "urn:ietf:bcp:47"; 2562 case BSBA: return "urn:ietf:bcp:47"; 2563 case DA: return "urn:ietf:bcp:47"; 2564 case DADK: return "urn:ietf:bcp:47"; 2565 case DE: return "urn:ietf:bcp:47"; 2566 case DEAT: return "urn:ietf:bcp:47"; 2567 case DECH: return "urn:ietf:bcp:47"; 2568 case DEDE: return "urn:ietf:bcp:47"; 2569 case EL: return "urn:ietf:bcp:47"; 2570 case ELGR: return "urn:ietf:bcp:47"; 2571 case EN: return "urn:ietf:bcp:47"; 2572 case ENAU: return "urn:ietf:bcp:47"; 2573 case ENCA: return "urn:ietf:bcp:47"; 2574 case ENGB: return "urn:ietf:bcp:47"; 2575 case ENIN: return "urn:ietf:bcp:47"; 2576 case ENNZ: return "urn:ietf:bcp:47"; 2577 case ENSG: return "urn:ietf:bcp:47"; 2578 case ENUS: return "urn:ietf:bcp:47"; 2579 case ES: return "urn:ietf:bcp:47"; 2580 case ESAR: return "urn:ietf:bcp:47"; 2581 case ESES: return "urn:ietf:bcp:47"; 2582 case ESUY: return "urn:ietf:bcp:47"; 2583 case ET: return "urn:ietf:bcp:47"; 2584 case ETEE: return "urn:ietf:bcp:47"; 2585 case FI: return "urn:ietf:bcp:47"; 2586 case FR: return "urn:ietf:bcp:47"; 2587 case FRBE: return "urn:ietf:bcp:47"; 2588 case FRCH: return "urn:ietf:bcp:47"; 2589 case FRFR: return "urn:ietf:bcp:47"; 2590 case FIFI: return "urn:ietf:bcp:47"; 2591 case FRCA: return "urn:ietf:bcp:47"; 2592 case FY: return "urn:ietf:bcp:47"; 2593 case FYNL: return "urn:ietf:bcp:47"; 2594 case HI: return "urn:ietf:bcp:47"; 2595 case HR: return "urn:ietf:bcp:47"; 2596 case HRHR: return "urn:ietf:bcp:47"; 2597 case IS: return "urn:ietf:bcp:47"; 2598 case ISIS: return "urn:ietf:bcp:47"; 2599 case IT: return "urn:ietf:bcp:47"; 2600 case ITCH: return "urn:ietf:bcp:47"; 2601 case ITIT: return "urn:ietf:bcp:47"; 2602 case JA: return "urn:ietf:bcp:47"; 2603 case KO: return "urn:ietf:bcp:47"; 2604 case LT: return "urn:ietf:bcp:47"; 2605 case LTLT: return "urn:ietf:bcp:47"; 2606 case LV: return "urn:ietf:bcp:47"; 2607 case LVLV: return "urn:ietf:bcp:47"; 2608 case NL: return "urn:ietf:bcp:47"; 2609 case NLBE: return "urn:ietf:bcp:47"; 2610 case NLNL: return "urn:ietf:bcp:47"; 2611 case NO: return "urn:ietf:bcp:47"; 2612 case NONO: return "urn:ietf:bcp:47"; 2613 case PA: return "urn:ietf:bcp:47"; 2614 case PL: return "urn:ietf:bcp:47"; 2615 case PLPL: return "urn:ietf:bcp:47"; 2616 case PT: return "urn:ietf:bcp:47"; 2617 case PTPT: return "urn:ietf:bcp:47"; 2618 case PTBR: return "urn:ietf:bcp:47"; 2619 case RO: return "urn:ietf:bcp:47"; 2620 case RORO: return "urn:ietf:bcp:47"; 2621 case RU: return "urn:ietf:bcp:47"; 2622 case RURU: return "urn:ietf:bcp:47"; 2623 case SK: return "urn:ietf:bcp:47"; 2624 case SKSK: return "urn:ietf:bcp:47"; 2625 case SL: return "urn:ietf:bcp:47"; 2626 case SLSI: return "urn:ietf:bcp:47"; 2627 case SR: return "urn:ietf:bcp:47"; 2628 case SRRS: return "urn:ietf:bcp:47"; 2629 case SV: return "urn:ietf:bcp:47"; 2630 case SVSE: return "urn:ietf:bcp:47"; 2631 case TE: return "urn:ietf:bcp:47"; 2632 case ZH: return "urn:ietf:bcp:47"; 2633 case ZHCN: return "urn:ietf:bcp:47"; 2634 case ZHHK: return "urn:ietf:bcp:47"; 2635 case ZHSG: return "urn:ietf:bcp:47"; 2636 case ZHTW: return "urn:ietf:bcp:47"; 2637 case NULL: return null; 2638 default: return "?"; 2639 } 2640 } 2641 public String getDefinition() { 2642 switch (this) { 2643 case AR: return ""; 2644 case BG: return ""; 2645 case BGBG: return ""; 2646 case BN: return ""; 2647 case CS: return ""; 2648 case CSCZ: return ""; 2649 case BS: return ""; 2650 case BSBA: return ""; 2651 case DA: return ""; 2652 case DADK: return ""; 2653 case DE: return ""; 2654 case DEAT: return ""; 2655 case DECH: return ""; 2656 case DEDE: return ""; 2657 case EL: return ""; 2658 case ELGR: return ""; 2659 case EN: return ""; 2660 case ENAU: return ""; 2661 case ENCA: return ""; 2662 case ENGB: return ""; 2663 case ENIN: return ""; 2664 case ENNZ: return ""; 2665 case ENSG: return ""; 2666 case ENUS: return ""; 2667 case ES: return ""; 2668 case ESAR: return ""; 2669 case ESES: return ""; 2670 case ESUY: return ""; 2671 case ET: return ""; 2672 case ETEE: return ""; 2673 case FI: return ""; 2674 case FR: return ""; 2675 case FRBE: return ""; 2676 case FRCH: return ""; 2677 case FRFR: return ""; 2678 case FIFI: return ""; 2679 case FRCA: return ""; 2680 case FY: return ""; 2681 case FYNL: return ""; 2682 case HI: return ""; 2683 case HR: return ""; 2684 case HRHR: return ""; 2685 case IS: return ""; 2686 case ISIS: return ""; 2687 case IT: return ""; 2688 case ITCH: return ""; 2689 case ITIT: return ""; 2690 case JA: return ""; 2691 case KO: return ""; 2692 case LT: return ""; 2693 case LTLT: return ""; 2694 case LV: return ""; 2695 case LVLV: return ""; 2696 case NL: return ""; 2697 case NLBE: return ""; 2698 case NLNL: return ""; 2699 case NO: return ""; 2700 case NONO: return ""; 2701 case PA: return ""; 2702 case PL: return ""; 2703 case PLPL: return ""; 2704 case PT: return ""; 2705 case PTPT: return ""; 2706 case PTBR: return ""; 2707 case RO: return ""; 2708 case RORO: return ""; 2709 case RU: return ""; 2710 case RURU: return ""; 2711 case SK: return ""; 2712 case SKSK: return ""; 2713 case SL: return ""; 2714 case SLSI: return ""; 2715 case SR: return ""; 2716 case SRRS: return ""; 2717 case SV: return ""; 2718 case SVSE: return ""; 2719 case TE: return ""; 2720 case ZH: return ""; 2721 case ZHCN: return ""; 2722 case ZHHK: return ""; 2723 case ZHSG: return ""; 2724 case ZHTW: return ""; 2725 case NULL: return null; 2726 default: return "?"; 2727 } 2728 } 2729 public String getDisplay() { 2730 switch (this) { 2731 case AR: return "Arabisk"; 2732 case BG: return "Bulgarian"; 2733 case BGBG: return "Bulgarian (Bulgaria)"; 2734 case BN: return "Bengali"; 2735 case CS: return "Czech"; 2736 case CSCZ: return "Czech (Czechia)"; 2737 case BS: return "Bosnian"; 2738 case BSBA: return "Bosnian (Bosnia and Herzegovina))"; 2739 case DA: return "Danish"; 2740 case DADK: return "Danish (Denmark)"; 2741 case DE: return "German"; 2742 case DEAT: return "German (Austria)"; 2743 case DECH: return "German (Switzerland)"; 2744 case DEDE: return "German (Germany)"; 2745 case EL: return "Greek"; 2746 case ELGR: return "Greek (Greece)"; 2747 case EN: return "English"; 2748 case ENAU: return "English (Australia)"; 2749 case ENCA: return "English (Canada)"; 2750 case ENGB: return "English (Great Britain)"; 2751 case ENIN: return "English (India)"; 2752 case ENNZ: return "English (New Zealand)"; 2753 case ENSG: return "English (Singapore)"; 2754 case ENUS: return "English (United States)"; 2755 case ES: return "Spanish"; 2756 case ESAR: return "Spanish (Argentina)"; 2757 case ESES: return "Spanish (Spain)"; 2758 case ESUY: return "Spanish (Uruguay)"; 2759 case ET: return "Estonian"; 2760 case ETEE: return "Estonian (Estonia)"; 2761 case FI: return "Finnish"; 2762 case FR: return "French"; 2763 case FRBE: return "French (Belgium)"; 2764 case FRCH: return "French (Switzerland)"; 2765 case FRFR: return "French (France)"; 2766 case FIFI: return "Finnish (Finland)"; 2767 case FRCA: return "French (Canada)"; 2768 case FY: return "Frisian"; 2769 case FYNL: return "Frisian (Netherlands)"; 2770 case HI: return "Hindi"; 2771 case HR: return "Croatian"; 2772 case HRHR: return "Croatian (Croatia)"; 2773 case IS: return "Icelandic"; 2774 case ISIS: return "Icelandic (Iceland)"; 2775 case IT: return "Italian"; 2776 case ITCH: return "Italian (Switzerland)"; 2777 case ITIT: return "Italian (Italy)"; 2778 case JA: return "Japanese"; 2779 case KO: return "Korean"; 2780 case LT: return "Lithuanian"; 2781 case LTLT: return "Lithuanian (Lithuania)"; 2782 case LV: return "Latvian"; 2783 case LVLV: return "Latvian (Latvia)"; 2784 case NL: return "Dutch"; 2785 case NLBE: return "Dutch (Belgium)"; 2786 case NLNL: return "Dutch (Netherlands)"; 2787 case NO: return "Norwegian"; 2788 case NONO: return "Norwegian (Norway)"; 2789 case PA: return "Punjabi"; 2790 case PL: return "Polskie"; 2791 case PLPL: return "Polish (Poland)"; 2792 case PT: return "Portuguese"; 2793 case PTPT: return "Portuguese (Portugal)"; 2794 case PTBR: return "Portuguese (Brazil)"; 2795 case RO: return "Romanian"; 2796 case RORO: return "Romanian (Romania)"; 2797 case RU: return "Russian"; 2798 case RURU: return "Russian (Russia)"; 2799 case SK: return "Slovakian"; 2800 case SKSK: return "Slovakian (Slovakia)"; 2801 case SL: return "Slovenian"; 2802 case SLSI: return "Slovenian (Slovenia)"; 2803 case SR: return "Serbian"; 2804 case SRRS: return "Serbian (Serbia)"; 2805 case SV: return "Swedish"; 2806 case SVSE: return "Swedish (Sweden)"; 2807 case TE: return "Telugu"; 2808 case ZH: return "Chinese"; 2809 case ZHCN: return "Chinese (China)"; 2810 case ZHHK: return "Chinese (Hong Kong)"; 2811 case ZHSG: return "Chinese (Singapore)"; 2812 case ZHTW: return "Chinese (Taiwan)"; 2813 case NULL: return null; 2814 default: return "?"; 2815 } 2816 } 2817 } 2818 2819 public static class CommonLanguagesEnumFactory implements EnumFactory<CommonLanguages> { 2820 public CommonLanguages fromCode(String codeString) throws IllegalArgumentException { 2821 if (codeString == null || "".equals(codeString)) 2822 if (codeString == null || "".equals(codeString)) 2823 return null; 2824 if ("ar".equals(codeString)) 2825 return CommonLanguages.AR; 2826 if ("bg".equals(codeString)) 2827 return CommonLanguages.BG; 2828 if ("bg-BG".equals(codeString)) 2829 return CommonLanguages.BGBG; 2830 if ("bn".equals(codeString)) 2831 return CommonLanguages.BN; 2832 if ("cs".equals(codeString)) 2833 return CommonLanguages.CS; 2834 if ("cs-CZ".equals(codeString)) 2835 return CommonLanguages.CSCZ; 2836 if ("bs".equals(codeString)) 2837 return CommonLanguages.BS; 2838 if ("bs-BA".equals(codeString)) 2839 return CommonLanguages.BSBA; 2840 if ("da".equals(codeString)) 2841 return CommonLanguages.DA; 2842 if ("da-DK".equals(codeString)) 2843 return CommonLanguages.DADK; 2844 if ("de".equals(codeString)) 2845 return CommonLanguages.DE; 2846 if ("de-AT".equals(codeString)) 2847 return CommonLanguages.DEAT; 2848 if ("de-CH".equals(codeString)) 2849 return CommonLanguages.DECH; 2850 if ("de-DE".equals(codeString)) 2851 return CommonLanguages.DEDE; 2852 if ("el".equals(codeString)) 2853 return CommonLanguages.EL; 2854 if ("el-GR".equals(codeString)) 2855 return CommonLanguages.ELGR; 2856 if ("en".equals(codeString)) 2857 return CommonLanguages.EN; 2858 if ("en-AU".equals(codeString)) 2859 return CommonLanguages.ENAU; 2860 if ("en-CA".equals(codeString)) 2861 return CommonLanguages.ENCA; 2862 if ("en-GB".equals(codeString)) 2863 return CommonLanguages.ENGB; 2864 if ("en-IN".equals(codeString)) 2865 return CommonLanguages.ENIN; 2866 if ("en-NZ".equals(codeString)) 2867 return CommonLanguages.ENNZ; 2868 if ("en-SG".equals(codeString)) 2869 return CommonLanguages.ENSG; 2870 if ("en-US".equals(codeString)) 2871 return CommonLanguages.ENUS; 2872 if ("es".equals(codeString)) 2873 return CommonLanguages.ES; 2874 if ("es-AR".equals(codeString)) 2875 return CommonLanguages.ESAR; 2876 if ("es-ES".equals(codeString)) 2877 return CommonLanguages.ESES; 2878 if ("es-UY".equals(codeString)) 2879 return CommonLanguages.ESUY; 2880 if ("et".equals(codeString)) 2881 return CommonLanguages.ET; 2882 if ("et-EE".equals(codeString)) 2883 return CommonLanguages.ETEE; 2884 if ("fi".equals(codeString)) 2885 return CommonLanguages.FI; 2886 if ("fr".equals(codeString)) 2887 return CommonLanguages.FR; 2888 if ("fr-BE".equals(codeString)) 2889 return CommonLanguages.FRBE; 2890 if ("fr-CH".equals(codeString)) 2891 return CommonLanguages.FRCH; 2892 if ("fr-FR".equals(codeString)) 2893 return CommonLanguages.FRFR; 2894 if ("fi-FI".equals(codeString)) 2895 return CommonLanguages.FIFI; 2896 if ("fr-CA".equals(codeString)) 2897 return CommonLanguages.FRCA; 2898 if ("fy".equals(codeString)) 2899 return CommonLanguages.FY; 2900 if ("fy-NL".equals(codeString)) 2901 return CommonLanguages.FYNL; 2902 if ("hi".equals(codeString)) 2903 return CommonLanguages.HI; 2904 if ("hr".equals(codeString)) 2905 return CommonLanguages.HR; 2906 if ("hr-HR".equals(codeString)) 2907 return CommonLanguages.HRHR; 2908 if ("is".equals(codeString)) 2909 return CommonLanguages.IS; 2910 if ("is-IS".equals(codeString)) 2911 return CommonLanguages.ISIS; 2912 if ("it".equals(codeString)) 2913 return CommonLanguages.IT; 2914 if ("it-CH".equals(codeString)) 2915 return CommonLanguages.ITCH; 2916 if ("it-IT".equals(codeString)) 2917 return CommonLanguages.ITIT; 2918 if ("ja".equals(codeString)) 2919 return CommonLanguages.JA; 2920 if ("ko".equals(codeString)) 2921 return CommonLanguages.KO; 2922 if ("lt".equals(codeString)) 2923 return CommonLanguages.LT; 2924 if ("lt-LT".equals(codeString)) 2925 return CommonLanguages.LTLT; 2926 if ("lv".equals(codeString)) 2927 return CommonLanguages.LV; 2928 if ("lv-LV".equals(codeString)) 2929 return CommonLanguages.LVLV; 2930 if ("nl".equals(codeString)) 2931 return CommonLanguages.NL; 2932 if ("nl-BE".equals(codeString)) 2933 return CommonLanguages.NLBE; 2934 if ("nl-NL".equals(codeString)) 2935 return CommonLanguages.NLNL; 2936 if ("no".equals(codeString)) 2937 return CommonLanguages.NO; 2938 if ("no-NO".equals(codeString)) 2939 return CommonLanguages.NONO; 2940 if ("pa".equals(codeString)) 2941 return CommonLanguages.PA; 2942 if ("pl".equals(codeString)) 2943 return CommonLanguages.PL; 2944 if ("pl-PL".equals(codeString)) 2945 return CommonLanguages.PLPL; 2946 if ("pt".equals(codeString)) 2947 return CommonLanguages.PT; 2948 if ("pt-PT".equals(codeString)) 2949 return CommonLanguages.PTPT; 2950 if ("pt-BR".equals(codeString)) 2951 return CommonLanguages.PTBR; 2952 if ("ro".equals(codeString)) 2953 return CommonLanguages.RO; 2954 if ("ro-RO".equals(codeString)) 2955 return CommonLanguages.RORO; 2956 if ("ru".equals(codeString)) 2957 return CommonLanguages.RU; 2958 if ("ru-RU".equals(codeString)) 2959 return CommonLanguages.RURU; 2960 if ("sk".equals(codeString)) 2961 return CommonLanguages.SK; 2962 if ("sk-SK".equals(codeString)) 2963 return CommonLanguages.SKSK; 2964 if ("sl".equals(codeString)) 2965 return CommonLanguages.SL; 2966 if ("sl-SI".equals(codeString)) 2967 return CommonLanguages.SLSI; 2968 if ("sr".equals(codeString)) 2969 return CommonLanguages.SR; 2970 if ("sr-RS".equals(codeString)) 2971 return CommonLanguages.SRRS; 2972 if ("sv".equals(codeString)) 2973 return CommonLanguages.SV; 2974 if ("sv-SE".equals(codeString)) 2975 return CommonLanguages.SVSE; 2976 if ("te".equals(codeString)) 2977 return CommonLanguages.TE; 2978 if ("zh".equals(codeString)) 2979 return CommonLanguages.ZH; 2980 if ("zh-CN".equals(codeString)) 2981 return CommonLanguages.ZHCN; 2982 if ("zh-HK".equals(codeString)) 2983 return CommonLanguages.ZHHK; 2984 if ("zh-SG".equals(codeString)) 2985 return CommonLanguages.ZHSG; 2986 if ("zh-TW".equals(codeString)) 2987 return CommonLanguages.ZHTW; 2988 throw new IllegalArgumentException("Unknown CommonLanguages code '"+codeString+"'"); 2989 } 2990 2991 public Enumeration<CommonLanguages> fromType(PrimitiveType<?> code) throws FHIRException { 2992 if (code == null) 2993 return null; 2994 if (code.isEmpty()) 2995 return new Enumeration<CommonLanguages>(this, CommonLanguages.NULL, code); 2996 String codeString = ((PrimitiveType) code).asStringValue(); 2997 if (codeString == null || "".equals(codeString)) 2998 return new Enumeration<CommonLanguages>(this, CommonLanguages.NULL, code); 2999 if ("ar".equals(codeString)) 3000 return new Enumeration<CommonLanguages>(this, CommonLanguages.AR, code); 3001 if ("bg".equals(codeString)) 3002 return new Enumeration<CommonLanguages>(this, CommonLanguages.BG, code); 3003 if ("bg-BG".equals(codeString)) 3004 return new Enumeration<CommonLanguages>(this, CommonLanguages.BGBG, code); 3005 if ("bn".equals(codeString)) 3006 return new Enumeration<CommonLanguages>(this, CommonLanguages.BN, code); 3007 if ("cs".equals(codeString)) 3008 return new Enumeration<CommonLanguages>(this, CommonLanguages.CS, code); 3009 if ("cs-CZ".equals(codeString)) 3010 return new Enumeration<CommonLanguages>(this, CommonLanguages.CSCZ, code); 3011 if ("bs".equals(codeString)) 3012 return new Enumeration<CommonLanguages>(this, CommonLanguages.BS, code); 3013 if ("bs-BA".equals(codeString)) 3014 return new Enumeration<CommonLanguages>(this, CommonLanguages.BSBA, code); 3015 if ("da".equals(codeString)) 3016 return new Enumeration<CommonLanguages>(this, CommonLanguages.DA, code); 3017 if ("da-DK".equals(codeString)) 3018 return new Enumeration<CommonLanguages>(this, CommonLanguages.DADK, code); 3019 if ("de".equals(codeString)) 3020 return new Enumeration<CommonLanguages>(this, CommonLanguages.DE, code); 3021 if ("de-AT".equals(codeString)) 3022 return new Enumeration<CommonLanguages>(this, CommonLanguages.DEAT, code); 3023 if ("de-CH".equals(codeString)) 3024 return new Enumeration<CommonLanguages>(this, CommonLanguages.DECH, code); 3025 if ("de-DE".equals(codeString)) 3026 return new Enumeration<CommonLanguages>(this, CommonLanguages.DEDE, code); 3027 if ("el".equals(codeString)) 3028 return new Enumeration<CommonLanguages>(this, CommonLanguages.EL, code); 3029 if ("el-GR".equals(codeString)) 3030 return new Enumeration<CommonLanguages>(this, CommonLanguages.ELGR, code); 3031 if ("en".equals(codeString)) 3032 return new Enumeration<CommonLanguages>(this, CommonLanguages.EN, code); 3033 if ("en-AU".equals(codeString)) 3034 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENAU, code); 3035 if ("en-CA".equals(codeString)) 3036 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENCA, code); 3037 if ("en-GB".equals(codeString)) 3038 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENGB, code); 3039 if ("en-IN".equals(codeString)) 3040 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENIN, code); 3041 if ("en-NZ".equals(codeString)) 3042 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENNZ, code); 3043 if ("en-SG".equals(codeString)) 3044 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENSG, code); 3045 if ("en-US".equals(codeString)) 3046 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENUS, code); 3047 if ("es".equals(codeString)) 3048 return new Enumeration<CommonLanguages>(this, CommonLanguages.ES, code); 3049 if ("es-AR".equals(codeString)) 3050 return new Enumeration<CommonLanguages>(this, CommonLanguages.ESAR, code); 3051 if ("es-ES".equals(codeString)) 3052 return new Enumeration<CommonLanguages>(this, CommonLanguages.ESES, code); 3053 if ("es-UY".equals(codeString)) 3054 return new Enumeration<CommonLanguages>(this, CommonLanguages.ESUY, code); 3055 if ("et".equals(codeString)) 3056 return new Enumeration<CommonLanguages>(this, CommonLanguages.ET, code); 3057 if ("et-EE".equals(codeString)) 3058 return new Enumeration<CommonLanguages>(this, CommonLanguages.ETEE, code); 3059 if ("fi".equals(codeString)) 3060 return new Enumeration<CommonLanguages>(this, CommonLanguages.FI, code); 3061 if ("fr".equals(codeString)) 3062 return new Enumeration<CommonLanguages>(this, CommonLanguages.FR, code); 3063 if ("fr-BE".equals(codeString)) 3064 return new Enumeration<CommonLanguages>(this, CommonLanguages.FRBE, code); 3065 if ("fr-CH".equals(codeString)) 3066 return new Enumeration<CommonLanguages>(this, CommonLanguages.FRCH, code); 3067 if ("fr-FR".equals(codeString)) 3068 return new Enumeration<CommonLanguages>(this, CommonLanguages.FRFR, code); 3069 if ("fi-FI".equals(codeString)) 3070 return new Enumeration<CommonLanguages>(this, CommonLanguages.FIFI, code); 3071 if ("fr-CA".equals(codeString)) 3072 return new Enumeration<CommonLanguages>(this, CommonLanguages.FRCA, code); 3073 if ("fy".equals(codeString)) 3074 return new Enumeration<CommonLanguages>(this, CommonLanguages.FY, code); 3075 if ("fy-NL".equals(codeString)) 3076 return new Enumeration<CommonLanguages>(this, CommonLanguages.FYNL, code); 3077 if ("hi".equals(codeString)) 3078 return new Enumeration<CommonLanguages>(this, CommonLanguages.HI, code); 3079 if ("hr".equals(codeString)) 3080 return new Enumeration<CommonLanguages>(this, CommonLanguages.HR, code); 3081 if ("hr-HR".equals(codeString)) 3082 return new Enumeration<CommonLanguages>(this, CommonLanguages.HRHR, code); 3083 if ("is".equals(codeString)) 3084 return new Enumeration<CommonLanguages>(this, CommonLanguages.IS, code); 3085 if ("is-IS".equals(codeString)) 3086 return new Enumeration<CommonLanguages>(this, CommonLanguages.ISIS, code); 3087 if ("it".equals(codeString)) 3088 return new Enumeration<CommonLanguages>(this, CommonLanguages.IT, code); 3089 if ("it-CH".equals(codeString)) 3090 return new Enumeration<CommonLanguages>(this, CommonLanguages.ITCH, code); 3091 if ("it-IT".equals(codeString)) 3092 return new Enumeration<CommonLanguages>(this, CommonLanguages.ITIT, code); 3093 if ("ja".equals(codeString)) 3094 return new Enumeration<CommonLanguages>(this, CommonLanguages.JA, code); 3095 if ("ko".equals(codeString)) 3096 return new Enumeration<CommonLanguages>(this, CommonLanguages.KO, code); 3097 if ("lt".equals(codeString)) 3098 return new Enumeration<CommonLanguages>(this, CommonLanguages.LT, code); 3099 if ("lt-LT".equals(codeString)) 3100 return new Enumeration<CommonLanguages>(this, CommonLanguages.LTLT, code); 3101 if ("lv".equals(codeString)) 3102 return new Enumeration<CommonLanguages>(this, CommonLanguages.LV, code); 3103 if ("lv-LV".equals(codeString)) 3104 return new Enumeration<CommonLanguages>(this, CommonLanguages.LVLV, code); 3105 if ("nl".equals(codeString)) 3106 return new Enumeration<CommonLanguages>(this, CommonLanguages.NL, code); 3107 if ("nl-BE".equals(codeString)) 3108 return new Enumeration<CommonLanguages>(this, CommonLanguages.NLBE, code); 3109 if ("nl-NL".equals(codeString)) 3110 return new Enumeration<CommonLanguages>(this, CommonLanguages.NLNL, code); 3111 if ("no".equals(codeString)) 3112 return new Enumeration<CommonLanguages>(this, CommonLanguages.NO, code); 3113 if ("no-NO".equals(codeString)) 3114 return new Enumeration<CommonLanguages>(this, CommonLanguages.NONO, code); 3115 if ("pa".equals(codeString)) 3116 return new Enumeration<CommonLanguages>(this, CommonLanguages.PA, code); 3117 if ("pl".equals(codeString)) 3118 return new Enumeration<CommonLanguages>(this, CommonLanguages.PL, code); 3119 if ("pl-PL".equals(codeString)) 3120 return new Enumeration<CommonLanguages>(this, CommonLanguages.PLPL, code); 3121 if ("pt".equals(codeString)) 3122 return new Enumeration<CommonLanguages>(this, CommonLanguages.PT, code); 3123 if ("pt-PT".equals(codeString)) 3124 return new Enumeration<CommonLanguages>(this, CommonLanguages.PTPT, code); 3125 if ("pt-BR".equals(codeString)) 3126 return new Enumeration<CommonLanguages>(this, CommonLanguages.PTBR, code); 3127 if ("ro".equals(codeString)) 3128 return new Enumeration<CommonLanguages>(this, CommonLanguages.RO, code); 3129 if ("ro-RO".equals(codeString)) 3130 return new Enumeration<CommonLanguages>(this, CommonLanguages.RORO, code); 3131 if ("ru".equals(codeString)) 3132 return new Enumeration<CommonLanguages>(this, CommonLanguages.RU, code); 3133 if ("ru-RU".equals(codeString)) 3134 return new Enumeration<CommonLanguages>(this, CommonLanguages.RURU, code); 3135 if ("sk".equals(codeString)) 3136 return new Enumeration<CommonLanguages>(this, CommonLanguages.SK, code); 3137 if ("sk-SK".equals(codeString)) 3138 return new Enumeration<CommonLanguages>(this, CommonLanguages.SKSK, code); 3139 if ("sl".equals(codeString)) 3140 return new Enumeration<CommonLanguages>(this, CommonLanguages.SL, code); 3141 if ("sl-SI".equals(codeString)) 3142 return new Enumeration<CommonLanguages>(this, CommonLanguages.SLSI, code); 3143 if ("sr".equals(codeString)) 3144 return new Enumeration<CommonLanguages>(this, CommonLanguages.SR, code); 3145 if ("sr-RS".equals(codeString)) 3146 return new Enumeration<CommonLanguages>(this, CommonLanguages.SRRS, code); 3147 if ("sv".equals(codeString)) 3148 return new Enumeration<CommonLanguages>(this, CommonLanguages.SV, code); 3149 if ("sv-SE".equals(codeString)) 3150 return new Enumeration<CommonLanguages>(this, CommonLanguages.SVSE, code); 3151 if ("te".equals(codeString)) 3152 return new Enumeration<CommonLanguages>(this, CommonLanguages.TE, code); 3153 if ("zh".equals(codeString)) 3154 return new Enumeration<CommonLanguages>(this, CommonLanguages.ZH, code); 3155 if ("zh-CN".equals(codeString)) 3156 return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHCN, code); 3157 if ("zh-HK".equals(codeString)) 3158 return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHHK, code); 3159 if ("zh-SG".equals(codeString)) 3160 return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHSG, code); 3161 if ("zh-TW".equals(codeString)) 3162 return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHTW, code); 3163 throw new FHIRException("Unknown CommonLanguages code '"+codeString+"'"); 3164 } 3165 public String toCode(CommonLanguages code) { 3166 if (code == CommonLanguages.AR) 3167 return "ar"; 3168 if (code == CommonLanguages.BG) 3169 return "bg"; 3170 if (code == CommonLanguages.BGBG) 3171 return "bg-BG"; 3172 if (code == CommonLanguages.BN) 3173 return "bn"; 3174 if (code == CommonLanguages.CS) 3175 return "cs"; 3176 if (code == CommonLanguages.CSCZ) 3177 return "cs-CZ"; 3178 if (code == CommonLanguages.BS) 3179 return "bs"; 3180 if (code == CommonLanguages.BSBA) 3181 return "bs-BA"; 3182 if (code == CommonLanguages.DA) 3183 return "da"; 3184 if (code == CommonLanguages.DADK) 3185 return "da-DK"; 3186 if (code == CommonLanguages.DE) 3187 return "de"; 3188 if (code == CommonLanguages.DEAT) 3189 return "de-AT"; 3190 if (code == CommonLanguages.DECH) 3191 return "de-CH"; 3192 if (code == CommonLanguages.DEDE) 3193 return "de-DE"; 3194 if (code == CommonLanguages.EL) 3195 return "el"; 3196 if (code == CommonLanguages.ELGR) 3197 return "el-GR"; 3198 if (code == CommonLanguages.EN) 3199 return "en"; 3200 if (code == CommonLanguages.ENAU) 3201 return "en-AU"; 3202 if (code == CommonLanguages.ENCA) 3203 return "en-CA"; 3204 if (code == CommonLanguages.ENGB) 3205 return "en-GB"; 3206 if (code == CommonLanguages.ENIN) 3207 return "en-IN"; 3208 if (code == CommonLanguages.ENNZ) 3209 return "en-NZ"; 3210 if (code == CommonLanguages.ENSG) 3211 return "en-SG"; 3212 if (code == CommonLanguages.ENUS) 3213 return "en-US"; 3214 if (code == CommonLanguages.ES) 3215 return "es"; 3216 if (code == CommonLanguages.ESAR) 3217 return "es-AR"; 3218 if (code == CommonLanguages.ESES) 3219 return "es-ES"; 3220 if (code == CommonLanguages.ESUY) 3221 return "es-UY"; 3222 if (code == CommonLanguages.ET) 3223 return "et"; 3224 if (code == CommonLanguages.ETEE) 3225 return "et-EE"; 3226 if (code == CommonLanguages.FI) 3227 return "fi"; 3228 if (code == CommonLanguages.FR) 3229 return "fr"; 3230 if (code == CommonLanguages.FRBE) 3231 return "fr-BE"; 3232 if (code == CommonLanguages.FRCH) 3233 return "fr-CH"; 3234 if (code == CommonLanguages.FRFR) 3235 return "fr-FR"; 3236 if (code == CommonLanguages.FIFI) 3237 return "fi-FI"; 3238 if (code == CommonLanguages.FRCA) 3239 return "fr-CA"; 3240 if (code == CommonLanguages.FY) 3241 return "fy"; 3242 if (code == CommonLanguages.FYNL) 3243 return "fy-NL"; 3244 if (code == CommonLanguages.HI) 3245 return "hi"; 3246 if (code == CommonLanguages.HR) 3247 return "hr"; 3248 if (code == CommonLanguages.HRHR) 3249 return "hr-HR"; 3250 if (code == CommonLanguages.IS) 3251 return "is"; 3252 if (code == CommonLanguages.ISIS) 3253 return "is-IS"; 3254 if (code == CommonLanguages.IT) 3255 return "it"; 3256 if (code == CommonLanguages.ITCH) 3257 return "it-CH"; 3258 if (code == CommonLanguages.ITIT) 3259 return "it-IT"; 3260 if (code == CommonLanguages.JA) 3261 return "ja"; 3262 if (code == CommonLanguages.KO) 3263 return "ko"; 3264 if (code == CommonLanguages.LT) 3265 return "lt"; 3266 if (code == CommonLanguages.LTLT) 3267 return "lt-LT"; 3268 if (code == CommonLanguages.LV) 3269 return "lv"; 3270 if (code == CommonLanguages.LVLV) 3271 return "lv-LV"; 3272 if (code == CommonLanguages.NL) 3273 return "nl"; 3274 if (code == CommonLanguages.NLBE) 3275 return "nl-BE"; 3276 if (code == CommonLanguages.NLNL) 3277 return "nl-NL"; 3278 if (code == CommonLanguages.NO) 3279 return "no"; 3280 if (code == CommonLanguages.NONO) 3281 return "no-NO"; 3282 if (code == CommonLanguages.PA) 3283 return "pa"; 3284 if (code == CommonLanguages.PL) 3285 return "pl"; 3286 if (code == CommonLanguages.PLPL) 3287 return "pl-PL"; 3288 if (code == CommonLanguages.PT) 3289 return "pt"; 3290 if (code == CommonLanguages.PTPT) 3291 return "pt-PT"; 3292 if (code == CommonLanguages.PTBR) 3293 return "pt-BR"; 3294 if (code == CommonLanguages.RO) 3295 return "ro"; 3296 if (code == CommonLanguages.RORO) 3297 return "ro-RO"; 3298 if (code == CommonLanguages.RU) 3299 return "ru"; 3300 if (code == CommonLanguages.RURU) 3301 return "ru-RU"; 3302 if (code == CommonLanguages.SK) 3303 return "sk"; 3304 if (code == CommonLanguages.SKSK) 3305 return "sk-SK"; 3306 if (code == CommonLanguages.SL) 3307 return "sl"; 3308 if (code == CommonLanguages.SLSI) 3309 return "sl-SI"; 3310 if (code == CommonLanguages.SR) 3311 return "sr"; 3312 if (code == CommonLanguages.SRRS) 3313 return "sr-RS"; 3314 if (code == CommonLanguages.SV) 3315 return "sv"; 3316 if (code == CommonLanguages.SVSE) 3317 return "sv-SE"; 3318 if (code == CommonLanguages.TE) 3319 return "te"; 3320 if (code == CommonLanguages.ZH) 3321 return "zh"; 3322 if (code == CommonLanguages.ZHCN) 3323 return "zh-CN"; 3324 if (code == CommonLanguages.ZHHK) 3325 return "zh-HK"; 3326 if (code == CommonLanguages.ZHSG) 3327 return "zh-SG"; 3328 if (code == CommonLanguages.ZHTW) 3329 return "zh-TW"; 3330 return "?"; 3331 } 3332 public String toSystem(CommonLanguages code) { 3333 return code.getSystem(); 3334 } 3335 } 3336 3337 public enum CompartmentType { 3338 /** 3339 * The compartment definition is for the patient compartment. 3340 */ 3341 PATIENT, 3342 /** 3343 * The compartment definition is for the encounter compartment. 3344 */ 3345 ENCOUNTER, 3346 /** 3347 * The compartment definition is for the related-person compartment. 3348 */ 3349 RELATEDPERSON, 3350 /** 3351 * The compartment definition is for the practitioner compartment. 3352 */ 3353 PRACTITIONER, 3354 /** 3355 * The compartment definition is for the device compartment. 3356 */ 3357 DEVICE, 3358 /** 3359 * The compartment definition is for the episodeofcare compartment. 3360 */ 3361 EPISODEOFCARE, 3362 /** 3363 * added to help the parsers 3364 */ 3365 NULL; 3366 public static CompartmentType fromCode(String codeString) throws FHIRException { 3367 if (codeString == null || "".equals(codeString)) 3368 return null; 3369 if ("Patient".equals(codeString)) 3370 return PATIENT; 3371 if ("Encounter".equals(codeString)) 3372 return ENCOUNTER; 3373 if ("RelatedPerson".equals(codeString)) 3374 return RELATEDPERSON; 3375 if ("Practitioner".equals(codeString)) 3376 return PRACTITIONER; 3377 if ("Device".equals(codeString)) 3378 return DEVICE; 3379 if ("EpisodeOfCare".equals(codeString)) 3380 return EPISODEOFCARE; 3381 throw new FHIRException("Unknown CompartmentType code '"+codeString+"'"); 3382 } 3383 public static boolean isValidCode(String codeString) { 3384 if (codeString == null || "".equals(codeString)) 3385 return false; 3386 return Utilities.existsInList(codeString, "Patient", "Encounter", "RelatedPerson", "Practitioner", "Device", "EpisodeOfCare"); 3387 } 3388 public String toCode() { 3389 switch (this) { 3390 case PATIENT: return "Patient"; 3391 case ENCOUNTER: return "Encounter"; 3392 case RELATEDPERSON: return "RelatedPerson"; 3393 case PRACTITIONER: return "Practitioner"; 3394 case DEVICE: return "Device"; 3395 case EPISODEOFCARE: return "EpisodeOfCare"; 3396 case NULL: return null; 3397 default: return "?"; 3398 } 3399 } 3400 public String getSystem() { 3401 switch (this) { 3402 case PATIENT: return "http://hl7.org/fhir/compartment-type"; 3403 case ENCOUNTER: return "http://hl7.org/fhir/compartment-type"; 3404 case RELATEDPERSON: return "http://hl7.org/fhir/compartment-type"; 3405 case PRACTITIONER: return "http://hl7.org/fhir/compartment-type"; 3406 case DEVICE: return "http://hl7.org/fhir/compartment-type"; 3407 case EPISODEOFCARE: return "http://hl7.org/fhir/compartment-type"; 3408 case NULL: return null; 3409 default: return "?"; 3410 } 3411 } 3412 public String getDefinition() { 3413 switch (this) { 3414 case PATIENT: return "The compartment definition is for the patient compartment."; 3415 case ENCOUNTER: return "The compartment definition is for the encounter compartment."; 3416 case RELATEDPERSON: return "The compartment definition is for the related-person compartment."; 3417 case PRACTITIONER: return "The compartment definition is for the practitioner compartment."; 3418 case DEVICE: return "The compartment definition is for the device compartment."; 3419 case EPISODEOFCARE: return "The compartment definition is for the episodeofcare compartment."; 3420 case NULL: return null; 3421 default: return "?"; 3422 } 3423 } 3424 public String getDisplay() { 3425 switch (this) { 3426 case PATIENT: return "Patient"; 3427 case ENCOUNTER: return "Encounter"; 3428 case RELATEDPERSON: return "RelatedPerson"; 3429 case PRACTITIONER: return "Practitioner"; 3430 case DEVICE: return "Device"; 3431 case EPISODEOFCARE: return "EpisodeOfCare"; 3432 case NULL: return null; 3433 default: return "?"; 3434 } 3435 } 3436 } 3437 3438 public static class CompartmentTypeEnumFactory implements EnumFactory<CompartmentType> { 3439 public CompartmentType fromCode(String codeString) throws IllegalArgumentException { 3440 if (codeString == null || "".equals(codeString)) 3441 if (codeString == null || "".equals(codeString)) 3442 return null; 3443 if ("Patient".equals(codeString)) 3444 return CompartmentType.PATIENT; 3445 if ("Encounter".equals(codeString)) 3446 return CompartmentType.ENCOUNTER; 3447 if ("RelatedPerson".equals(codeString)) 3448 return CompartmentType.RELATEDPERSON; 3449 if ("Practitioner".equals(codeString)) 3450 return CompartmentType.PRACTITIONER; 3451 if ("Device".equals(codeString)) 3452 return CompartmentType.DEVICE; 3453 if ("EpisodeOfCare".equals(codeString)) 3454 return CompartmentType.EPISODEOFCARE; 3455 throw new IllegalArgumentException("Unknown CompartmentType code '"+codeString+"'"); 3456 } 3457 3458 public Enumeration<CompartmentType> fromType(PrimitiveType<?> code) throws FHIRException { 3459 if (code == null) 3460 return null; 3461 if (code.isEmpty()) 3462 return new Enumeration<CompartmentType>(this, CompartmentType.NULL, code); 3463 String codeString = ((PrimitiveType) code).asStringValue(); 3464 if (codeString == null || "".equals(codeString)) 3465 return new Enumeration<CompartmentType>(this, CompartmentType.NULL, code); 3466 if ("Patient".equals(codeString)) 3467 return new Enumeration<CompartmentType>(this, CompartmentType.PATIENT, code); 3468 if ("Encounter".equals(codeString)) 3469 return new Enumeration<CompartmentType>(this, CompartmentType.ENCOUNTER, code); 3470 if ("RelatedPerson".equals(codeString)) 3471 return new Enumeration<CompartmentType>(this, CompartmentType.RELATEDPERSON, code); 3472 if ("Practitioner".equals(codeString)) 3473 return new Enumeration<CompartmentType>(this, CompartmentType.PRACTITIONER, code); 3474 if ("Device".equals(codeString)) 3475 return new Enumeration<CompartmentType>(this, CompartmentType.DEVICE, code); 3476 if ("EpisodeOfCare".equals(codeString)) 3477 return new Enumeration<CompartmentType>(this, CompartmentType.EPISODEOFCARE, code); 3478 throw new FHIRException("Unknown CompartmentType code '"+codeString+"'"); 3479 } 3480 public String toCode(CompartmentType code) { 3481 if (code == CompartmentType.PATIENT) 3482 return "Patient"; 3483 if (code == CompartmentType.ENCOUNTER) 3484 return "Encounter"; 3485 if (code == CompartmentType.RELATEDPERSON) 3486 return "RelatedPerson"; 3487 if (code == CompartmentType.PRACTITIONER) 3488 return "Practitioner"; 3489 if (code == CompartmentType.DEVICE) 3490 return "Device"; 3491 if (code == CompartmentType.EPISODEOFCARE) 3492 return "EpisodeOfCare"; 3493 return "?"; 3494 } 3495 public String toSystem(CompartmentType code) { 3496 return code.getSystem(); 3497 } 3498 } 3499 3500 public enum CompositionStatus { 3501 /** 3502 * The existence of the composition is registered, but there is nothing yet available. 3503 */ 3504 REGISTERED, 3505 /** 3506 * This is a partial (e.g. initial, interim or preliminary) composition: data in the composition may be incomplete or unverified. 3507 */ 3508 PARTIAL, 3509 /** 3510 * Verified early results are available, but not all results are final. 3511 */ 3512 PRELIMINARY, 3513 /** 3514 * 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. 3515 */ 3516 FINAL, 3517 /** 3518 * 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. 3519 */ 3520 AMENDED, 3521 /** 3522 * Subsequent to being final, the composition content has been modified to correct an error in the composition or referenced results. 3523 */ 3524 CORRECTED, 3525 /** 3526 * Subsequent to being final, the composition content has been modified by adding new content. The existing content is unchanged. 3527 */ 3528 APPENDED, 3529 /** 3530 * The composition is unavailable because the measurement was not started or not completed (also sometimes called "aborted"). 3531 */ 3532 CANCELLED, 3533 /** 3534 * 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. 3535 */ 3536 ENTEREDINERROR, 3537 /** 3538 * This composition has been withdrawn or superseded and should no longer be used. 3539 */ 3540 DEPRECATED, 3541 /** 3542 * 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. 3543 */ 3544 UNKNOWN, 3545 /** 3546 * added to help the parsers 3547 */ 3548 NULL; 3549 public static CompositionStatus fromCode(String codeString) throws FHIRException { 3550 if (codeString == null || "".equals(codeString)) 3551 return null; 3552 if ("registered".equals(codeString)) 3553 return REGISTERED; 3554 if ("partial".equals(codeString)) 3555 return PARTIAL; 3556 if ("preliminary".equals(codeString)) 3557 return PRELIMINARY; 3558 if ("final".equals(codeString)) 3559 return FINAL; 3560 if ("amended".equals(codeString)) 3561 return AMENDED; 3562 if ("corrected".equals(codeString)) 3563 return CORRECTED; 3564 if ("appended".equals(codeString)) 3565 return APPENDED; 3566 if ("cancelled".equals(codeString)) 3567 return CANCELLED; 3568 if ("entered-in-error".equals(codeString)) 3569 return ENTEREDINERROR; 3570 if ("deprecated".equals(codeString)) 3571 return DEPRECATED; 3572 if ("unknown".equals(codeString)) 3573 return UNKNOWN; 3574 throw new FHIRException("Unknown CompositionStatus code '"+codeString+"'"); 3575 } 3576 public static boolean isValidCode(String codeString) { 3577 if (codeString == null || "".equals(codeString)) 3578 return false; 3579 return Utilities.existsInList(codeString, "registered", "partial", "preliminary", "final", "amended", "corrected", "appended", "cancelled", "entered-in-error", "deprecated", "unknown"); 3580 } 3581 public String toCode() { 3582 switch (this) { 3583 case REGISTERED: return "registered"; 3584 case PARTIAL: return "partial"; 3585 case PRELIMINARY: return "preliminary"; 3586 case FINAL: return "final"; 3587 case AMENDED: return "amended"; 3588 case CORRECTED: return "corrected"; 3589 case APPENDED: return "appended"; 3590 case CANCELLED: return "cancelled"; 3591 case ENTEREDINERROR: return "entered-in-error"; 3592 case DEPRECATED: return "deprecated"; 3593 case UNKNOWN: return "unknown"; 3594 case NULL: return null; 3595 default: return "?"; 3596 } 3597 } 3598 public String getSystem() { 3599 switch (this) { 3600 case REGISTERED: return "http://hl7.org/fhir/composition-status"; 3601 case PARTIAL: return "http://hl7.org/fhir/composition-status"; 3602 case PRELIMINARY: return "http://hl7.org/fhir/composition-status"; 3603 case FINAL: return "http://hl7.org/fhir/composition-status"; 3604 case AMENDED: return "http://hl7.org/fhir/composition-status"; 3605 case CORRECTED: return "http://hl7.org/fhir/composition-status"; 3606 case APPENDED: return "http://hl7.org/fhir/composition-status"; 3607 case CANCELLED: return "http://hl7.org/fhir/composition-status"; 3608 case ENTEREDINERROR: return "http://hl7.org/fhir/composition-status"; 3609 case DEPRECATED: return "http://hl7.org/fhir/composition-status"; 3610 case UNKNOWN: return "http://hl7.org/fhir/composition-status"; 3611 case NULL: return null; 3612 default: return "?"; 3613 } 3614 } 3615 public String getDefinition() { 3616 switch (this) { 3617 case REGISTERED: return "The existence of the composition is registered, but there is nothing yet available."; 3618 case PARTIAL: return "This is a partial (e.g. initial, interim or preliminary) composition: data in the composition may be incomplete or unverified."; 3619 case PRELIMINARY: return "Verified early results are available, but not all results are final."; 3620 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."; 3621 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."; 3622 case CORRECTED: return "Subsequent to being final, the composition content has been modified to correct an error in the composition or referenced results."; 3623 case APPENDED: return "Subsequent to being final, the composition content has been modified by adding new content. The existing content is unchanged."; 3624 case CANCELLED: return "The composition is unavailable because the measurement was not started or not completed (also sometimes called \"aborted\")."; 3625 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."; 3626 case DEPRECATED: return "This composition has been withdrawn or superseded and should no longer be used."; 3627 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."; 3628 case NULL: return null; 3629 default: return "?"; 3630 } 3631 } 3632 public String getDisplay() { 3633 switch (this) { 3634 case REGISTERED: return "Registered"; 3635 case PARTIAL: return "Partial"; 3636 case PRELIMINARY: return "Preliminary"; 3637 case FINAL: return "Final"; 3638 case AMENDED: return "Amended"; 3639 case CORRECTED: return "Corrected"; 3640 case APPENDED: return "Appended"; 3641 case CANCELLED: return "Cancelled"; 3642 case ENTEREDINERROR: return "Entered in Error"; 3643 case DEPRECATED: return "Deprecated"; 3644 case UNKNOWN: return "Unknown"; 3645 case NULL: return null; 3646 default: return "?"; 3647 } 3648 } 3649 } 3650 3651 public static class CompositionStatusEnumFactory implements EnumFactory<CompositionStatus> { 3652 public CompositionStatus fromCode(String codeString) throws IllegalArgumentException { 3653 if (codeString == null || "".equals(codeString)) 3654 if (codeString == null || "".equals(codeString)) 3655 return null; 3656 if ("registered".equals(codeString)) 3657 return CompositionStatus.REGISTERED; 3658 if ("partial".equals(codeString)) 3659 return CompositionStatus.PARTIAL; 3660 if ("preliminary".equals(codeString)) 3661 return CompositionStatus.PRELIMINARY; 3662 if ("final".equals(codeString)) 3663 return CompositionStatus.FINAL; 3664 if ("amended".equals(codeString)) 3665 return CompositionStatus.AMENDED; 3666 if ("corrected".equals(codeString)) 3667 return CompositionStatus.CORRECTED; 3668 if ("appended".equals(codeString)) 3669 return CompositionStatus.APPENDED; 3670 if ("cancelled".equals(codeString)) 3671 return CompositionStatus.CANCELLED; 3672 if ("entered-in-error".equals(codeString)) 3673 return CompositionStatus.ENTEREDINERROR; 3674 if ("deprecated".equals(codeString)) 3675 return CompositionStatus.DEPRECATED; 3676 if ("unknown".equals(codeString)) 3677 return CompositionStatus.UNKNOWN; 3678 throw new IllegalArgumentException("Unknown CompositionStatus code '"+codeString+"'"); 3679 } 3680 3681 public Enumeration<CompositionStatus> fromType(PrimitiveType<?> code) throws FHIRException { 3682 if (code == null) 3683 return null; 3684 if (code.isEmpty()) 3685 return new Enumeration<CompositionStatus>(this, CompositionStatus.NULL, code); 3686 String codeString = ((PrimitiveType) code).asStringValue(); 3687 if (codeString == null || "".equals(codeString)) 3688 return new Enumeration<CompositionStatus>(this, CompositionStatus.NULL, code); 3689 if ("registered".equals(codeString)) 3690 return new Enumeration<CompositionStatus>(this, CompositionStatus.REGISTERED, code); 3691 if ("partial".equals(codeString)) 3692 return new Enumeration<CompositionStatus>(this, CompositionStatus.PARTIAL, code); 3693 if ("preliminary".equals(codeString)) 3694 return new Enumeration<CompositionStatus>(this, CompositionStatus.PRELIMINARY, code); 3695 if ("final".equals(codeString)) 3696 return new Enumeration<CompositionStatus>(this, CompositionStatus.FINAL, code); 3697 if ("amended".equals(codeString)) 3698 return new Enumeration<CompositionStatus>(this, CompositionStatus.AMENDED, code); 3699 if ("corrected".equals(codeString)) 3700 return new Enumeration<CompositionStatus>(this, CompositionStatus.CORRECTED, code); 3701 if ("appended".equals(codeString)) 3702 return new Enumeration<CompositionStatus>(this, CompositionStatus.APPENDED, code); 3703 if ("cancelled".equals(codeString)) 3704 return new Enumeration<CompositionStatus>(this, CompositionStatus.CANCELLED, code); 3705 if ("entered-in-error".equals(codeString)) 3706 return new Enumeration<CompositionStatus>(this, CompositionStatus.ENTEREDINERROR, code); 3707 if ("deprecated".equals(codeString)) 3708 return new Enumeration<CompositionStatus>(this, CompositionStatus.DEPRECATED, code); 3709 if ("unknown".equals(codeString)) 3710 return new Enumeration<CompositionStatus>(this, CompositionStatus.UNKNOWN, code); 3711 throw new FHIRException("Unknown CompositionStatus code '"+codeString+"'"); 3712 } 3713 public String toCode(CompositionStatus code) { 3714 if (code == CompositionStatus.REGISTERED) 3715 return "registered"; 3716 if (code == CompositionStatus.PARTIAL) 3717 return "partial"; 3718 if (code == CompositionStatus.PRELIMINARY) 3719 return "preliminary"; 3720 if (code == CompositionStatus.FINAL) 3721 return "final"; 3722 if (code == CompositionStatus.AMENDED) 3723 return "amended"; 3724 if (code == CompositionStatus.CORRECTED) 3725 return "corrected"; 3726 if (code == CompositionStatus.APPENDED) 3727 return "appended"; 3728 if (code == CompositionStatus.CANCELLED) 3729 return "cancelled"; 3730 if (code == CompositionStatus.ENTEREDINERROR) 3731 return "entered-in-error"; 3732 if (code == CompositionStatus.DEPRECATED) 3733 return "deprecated"; 3734 if (code == CompositionStatus.UNKNOWN) 3735 return "unknown"; 3736 return "?"; 3737 } 3738 public String toSystem(CompositionStatus code) { 3739 return code.getSystem(); 3740 } 3741 } 3742 3743 public enum ConceptMapRelationship { 3744 /** 3745 * The concepts are related to each other, but the exact relationship is not known. 3746 */ 3747 RELATEDTO, 3748 /** 3749 * The definitions of the concepts mean the same thing. 3750 */ 3751 EQUIVALENT, 3752 /** 3753 * The source concept is narrower in meaning than the target concept. 3754 */ 3755 SOURCEISNARROWERTHANTARGET, 3756 /** 3757 * The source concept is broader in meaning than the target concept. 3758 */ 3759 SOURCEISBROADERTHANTARGET, 3760 /** 3761 * This is an explicit assertion that the target concept is not related to the source concept. 3762 */ 3763 NOTRELATEDTO, 3764 /** 3765 * added to help the parsers 3766 */ 3767 NULL; 3768 public static ConceptMapRelationship fromCode(String codeString) throws FHIRException { 3769 if (codeString == null || "".equals(codeString)) 3770 return null; 3771 if ("related-to".equals(codeString)) 3772 return RELATEDTO; 3773 if ("equivalent".equals(codeString)) 3774 return EQUIVALENT; 3775 if ("source-is-narrower-than-target".equals(codeString)) 3776 return SOURCEISNARROWERTHANTARGET; 3777 if ("source-is-broader-than-target".equals(codeString)) 3778 return SOURCEISBROADERTHANTARGET; 3779 if ("not-related-to".equals(codeString)) 3780 return NOTRELATEDTO; 3781 throw new FHIRException("Unknown ConceptMapRelationship code '"+codeString+"'"); 3782 } 3783 public static boolean isValidCode(String codeString) { 3784 if (codeString == null || "".equals(codeString)) 3785 return false; 3786 return Utilities.existsInList(codeString, "related-to", "equivalent", "source-is-narrower-than-target", "source-is-broader-than-target", "not-related-to"); 3787 } 3788 public String toCode() { 3789 switch (this) { 3790 case RELATEDTO: return "related-to"; 3791 case EQUIVALENT: return "equivalent"; 3792 case SOURCEISNARROWERTHANTARGET: return "source-is-narrower-than-target"; 3793 case SOURCEISBROADERTHANTARGET: return "source-is-broader-than-target"; 3794 case NOTRELATEDTO: return "not-related-to"; 3795 case NULL: return null; 3796 default: return "?"; 3797 } 3798 } 3799 public String getSystem() { 3800 switch (this) { 3801 case RELATEDTO: return "http://hl7.org/fhir/concept-map-relationship"; 3802 case EQUIVALENT: return "http://hl7.org/fhir/concept-map-relationship"; 3803 case SOURCEISNARROWERTHANTARGET: return "http://hl7.org/fhir/concept-map-relationship"; 3804 case SOURCEISBROADERTHANTARGET: return "http://hl7.org/fhir/concept-map-relationship"; 3805 case NOTRELATEDTO: return "http://hl7.org/fhir/concept-map-relationship"; 3806 case NULL: return null; 3807 default: return "?"; 3808 } 3809 } 3810 public String getDefinition() { 3811 switch (this) { 3812 case RELATEDTO: return "The concepts are related to each other, but the exact relationship is not known."; 3813 case EQUIVALENT: return "The definitions of the concepts mean the same thing."; 3814 case SOURCEISNARROWERTHANTARGET: return "The source concept is narrower in meaning than the target concept."; 3815 case SOURCEISBROADERTHANTARGET: return "The source concept is broader in meaning than the target concept."; 3816 case NOTRELATEDTO: return "This is an explicit assertion that the target concept is not related to the source concept."; 3817 case NULL: return null; 3818 default: return "?"; 3819 } 3820 } 3821 public String getDisplay() { 3822 switch (this) { 3823 case RELATEDTO: return "Related To"; 3824 case EQUIVALENT: return "Equivalent"; 3825 case SOURCEISNARROWERTHANTARGET: return "Source Is Narrower Than Target"; 3826 case SOURCEISBROADERTHANTARGET: return "Source Is Broader Than Target"; 3827 case NOTRELATEDTO: return "Not Related To"; 3828 case NULL: return null; 3829 default: return "?"; 3830 } 3831 } 3832 public String getSymbol() { 3833 switch (this) { 3834 case RELATEDTO: return "-"; 3835 case EQUIVALENT: return "="; 3836 case SOURCEISNARROWERTHANTARGET: return "<"; 3837 case SOURCEISBROADERTHANTARGET: return ">"; 3838 case NOTRELATEDTO: return "!="; 3839 case NULL: return null; 3840 default: return "?"; 3841 } 3842 } 3843 } 3844 3845 public static class ConceptMapRelationshipEnumFactory implements EnumFactory<ConceptMapRelationship> { 3846 public ConceptMapRelationship fromCode(String codeString) throws IllegalArgumentException { 3847 if (codeString == null || "".equals(codeString)) 3848 if (codeString == null || "".equals(codeString)) 3849 return null; 3850 if ("related-to".equals(codeString)) 3851 return ConceptMapRelationship.RELATEDTO; 3852 if ("equivalent".equals(codeString)) 3853 return ConceptMapRelationship.EQUIVALENT; 3854 if ("source-is-narrower-than-target".equals(codeString)) 3855 return ConceptMapRelationship.SOURCEISNARROWERTHANTARGET; 3856 if ("source-is-broader-than-target".equals(codeString)) 3857 return ConceptMapRelationship.SOURCEISBROADERTHANTARGET; 3858 if ("not-related-to".equals(codeString)) 3859 return ConceptMapRelationship.NOTRELATEDTO; 3860 throw new IllegalArgumentException("Unknown ConceptMapRelationship code '"+codeString+"'"); 3861 } 3862 3863 public Enumeration<ConceptMapRelationship> fromType(PrimitiveType<?> code) throws FHIRException { 3864 if (code == null) 3865 return null; 3866 if (code.isEmpty()) 3867 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NULL, code); 3868 String codeString = ((PrimitiveType) code).asStringValue(); 3869 if (codeString == null || "".equals(codeString)) 3870 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NULL, code); 3871 if ("related-to".equals(codeString)) 3872 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.RELATEDTO, code); 3873 if ("equivalent".equals(codeString)) 3874 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.EQUIVALENT, code); 3875 if ("source-is-narrower-than-target".equals(codeString)) 3876 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.SOURCEISNARROWERTHANTARGET, code); 3877 if ("source-is-broader-than-target".equals(codeString)) 3878 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.SOURCEISBROADERTHANTARGET, code); 3879 if ("not-related-to".equals(codeString)) 3880 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NOTRELATEDTO, code); 3881 throw new FHIRException("Unknown ConceptMapRelationship code '"+codeString+"'"); 3882 } 3883 public String toCode(ConceptMapRelationship code) { 3884 if (code == ConceptMapRelationship.RELATEDTO) 3885 return "related-to"; 3886 if (code == ConceptMapRelationship.EQUIVALENT) 3887 return "equivalent"; 3888 if (code == ConceptMapRelationship.SOURCEISNARROWERTHANTARGET) 3889 return "source-is-narrower-than-target"; 3890 if (code == ConceptMapRelationship.SOURCEISBROADERTHANTARGET) 3891 return "source-is-broader-than-target"; 3892 if (code == ConceptMapRelationship.NOTRELATEDTO) 3893 return "not-related-to"; 3894 return "?"; 3895 } 3896 public String toSystem(ConceptMapRelationship code) { 3897 return code.getSystem(); 3898 } 3899 } 3900 3901 public enum ConsentDataMeaning { 3902 /** 3903 * The consent applies directly to the instance of the resource. 3904 */ 3905 INSTANCE, 3906 /** 3907 * The consent applies directly to the instance of the resource and instances it refers to. 3908 */ 3909 RELATED, 3910 /** 3911 * The consent applies directly to the instance of the resource and instances that refer to it. 3912 */ 3913 DEPENDENTS, 3914 /** 3915 * The consent applies to instances of resources that are authored by. 3916 */ 3917 AUTHOREDBY, 3918 /** 3919 * added to help the parsers 3920 */ 3921 NULL; 3922 public static ConsentDataMeaning fromCode(String codeString) throws FHIRException { 3923 if (codeString == null || "".equals(codeString)) 3924 return null; 3925 if ("instance".equals(codeString)) 3926 return INSTANCE; 3927 if ("related".equals(codeString)) 3928 return RELATED; 3929 if ("dependents".equals(codeString)) 3930 return DEPENDENTS; 3931 if ("authoredby".equals(codeString)) 3932 return AUTHOREDBY; 3933 throw new FHIRException("Unknown ConsentDataMeaning code '"+codeString+"'"); 3934 } 3935 public static boolean isValidCode(String codeString) { 3936 if (codeString == null || "".equals(codeString)) 3937 return false; 3938 return Utilities.existsInList(codeString, "instance", "related", "dependents", "authoredby"); 3939 } 3940 public String toCode() { 3941 switch (this) { 3942 case INSTANCE: return "instance"; 3943 case RELATED: return "related"; 3944 case DEPENDENTS: return "dependents"; 3945 case AUTHOREDBY: return "authoredby"; 3946 case NULL: return null; 3947 default: return "?"; 3948 } 3949 } 3950 public String getSystem() { 3951 switch (this) { 3952 case INSTANCE: return "http://hl7.org/fhir/consent-data-meaning"; 3953 case RELATED: return "http://hl7.org/fhir/consent-data-meaning"; 3954 case DEPENDENTS: return "http://hl7.org/fhir/consent-data-meaning"; 3955 case AUTHOREDBY: return "http://hl7.org/fhir/consent-data-meaning"; 3956 case NULL: return null; 3957 default: return "?"; 3958 } 3959 } 3960 public String getDefinition() { 3961 switch (this) { 3962 case INSTANCE: return "The consent applies directly to the instance of the resource."; 3963 case RELATED: return "The consent applies directly to the instance of the resource and instances it refers to."; 3964 case DEPENDENTS: return "The consent applies directly to the instance of the resource and instances that refer to it."; 3965 case AUTHOREDBY: return "The consent applies to instances of resources that are authored by."; 3966 case NULL: return null; 3967 default: return "?"; 3968 } 3969 } 3970 public String getDisplay() { 3971 switch (this) { 3972 case INSTANCE: return "Instance"; 3973 case RELATED: return "Related"; 3974 case DEPENDENTS: return "Dependents"; 3975 case AUTHOREDBY: return "AuthoredBy"; 3976 case NULL: return null; 3977 default: return "?"; 3978 } 3979 } 3980 } 3981 3982 public static class ConsentDataMeaningEnumFactory implements EnumFactory<ConsentDataMeaning> { 3983 public ConsentDataMeaning fromCode(String codeString) throws IllegalArgumentException { 3984 if (codeString == null || "".equals(codeString)) 3985 if (codeString == null || "".equals(codeString)) 3986 return null; 3987 if ("instance".equals(codeString)) 3988 return ConsentDataMeaning.INSTANCE; 3989 if ("related".equals(codeString)) 3990 return ConsentDataMeaning.RELATED; 3991 if ("dependents".equals(codeString)) 3992 return ConsentDataMeaning.DEPENDENTS; 3993 if ("authoredby".equals(codeString)) 3994 return ConsentDataMeaning.AUTHOREDBY; 3995 throw new IllegalArgumentException("Unknown ConsentDataMeaning code '"+codeString+"'"); 3996 } 3997 3998 public Enumeration<ConsentDataMeaning> fromType(PrimitiveType<?> code) throws FHIRException { 3999 if (code == null) 4000 return null; 4001 if (code.isEmpty()) 4002 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.NULL, code); 4003 String codeString = ((PrimitiveType) code).asStringValue(); 4004 if (codeString == null || "".equals(codeString)) 4005 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.NULL, code); 4006 if ("instance".equals(codeString)) 4007 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.INSTANCE, code); 4008 if ("related".equals(codeString)) 4009 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.RELATED, code); 4010 if ("dependents".equals(codeString)) 4011 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.DEPENDENTS, code); 4012 if ("authoredby".equals(codeString)) 4013 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.AUTHOREDBY, code); 4014 throw new FHIRException("Unknown ConsentDataMeaning code '"+codeString+"'"); 4015 } 4016 public String toCode(ConsentDataMeaning code) { 4017 if (code == ConsentDataMeaning.INSTANCE) 4018 return "instance"; 4019 if (code == ConsentDataMeaning.RELATED) 4020 return "related"; 4021 if (code == ConsentDataMeaning.DEPENDENTS) 4022 return "dependents"; 4023 if (code == ConsentDataMeaning.AUTHOREDBY) 4024 return "authoredby"; 4025 return "?"; 4026 } 4027 public String toSystem(ConsentDataMeaning code) { 4028 return code.getSystem(); 4029 } 4030 } 4031 4032 public enum ConsentProvisionType { 4033 /** 4034 * Consent is denied for actions meeting these rules. 4035 */ 4036 DENY, 4037 /** 4038 * Consent is provided for actions meeting these rules. 4039 */ 4040 PERMIT, 4041 /** 4042 * added to help the parsers 4043 */ 4044 NULL; 4045 public static ConsentProvisionType fromCode(String codeString) throws FHIRException { 4046 if (codeString == null || "".equals(codeString)) 4047 return null; 4048 if ("deny".equals(codeString)) 4049 return DENY; 4050 if ("permit".equals(codeString)) 4051 return PERMIT; 4052 throw new FHIRException("Unknown ConsentProvisionType code '"+codeString+"'"); 4053 } 4054 public static boolean isValidCode(String codeString) { 4055 if (codeString == null || "".equals(codeString)) 4056 return false; 4057 return Utilities.existsInList(codeString, "deny", "permit"); 4058 } 4059 public String toCode() { 4060 switch (this) { 4061 case DENY: return "deny"; 4062 case PERMIT: return "permit"; 4063 case NULL: return null; 4064 default: return "?"; 4065 } 4066 } 4067 public String getSystem() { 4068 switch (this) { 4069 case DENY: return "http://hl7.org/fhir/consent-provision-type"; 4070 case PERMIT: return "http://hl7.org/fhir/consent-provision-type"; 4071 case NULL: return null; 4072 default: return "?"; 4073 } 4074 } 4075 public String getDefinition() { 4076 switch (this) { 4077 case DENY: return "Consent is denied for actions meeting these rules."; 4078 case PERMIT: return "Consent is provided for actions meeting these rules."; 4079 case NULL: return null; 4080 default: return "?"; 4081 } 4082 } 4083 public String getDisplay() { 4084 switch (this) { 4085 case DENY: return "Deny"; 4086 case PERMIT: return "Permit"; 4087 case NULL: return null; 4088 default: return "?"; 4089 } 4090 } 4091 } 4092 4093 public static class ConsentProvisionTypeEnumFactory implements EnumFactory<ConsentProvisionType> { 4094 public ConsentProvisionType fromCode(String codeString) throws IllegalArgumentException { 4095 if (codeString == null || "".equals(codeString)) 4096 if (codeString == null || "".equals(codeString)) 4097 return null; 4098 if ("deny".equals(codeString)) 4099 return ConsentProvisionType.DENY; 4100 if ("permit".equals(codeString)) 4101 return ConsentProvisionType.PERMIT; 4102 throw new IllegalArgumentException("Unknown ConsentProvisionType code '"+codeString+"'"); 4103 } 4104 4105 public Enumeration<ConsentProvisionType> fromType(PrimitiveType<?> code) throws FHIRException { 4106 if (code == null) 4107 return null; 4108 if (code.isEmpty()) 4109 return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.NULL, code); 4110 String codeString = ((PrimitiveType) code).asStringValue(); 4111 if (codeString == null || "".equals(codeString)) 4112 return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.NULL, code); 4113 if ("deny".equals(codeString)) 4114 return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.DENY, code); 4115 if ("permit".equals(codeString)) 4116 return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.PERMIT, code); 4117 throw new FHIRException("Unknown ConsentProvisionType code '"+codeString+"'"); 4118 } 4119 public String toCode(ConsentProvisionType code) { 4120 if (code == ConsentProvisionType.DENY) 4121 return "deny"; 4122 if (code == ConsentProvisionType.PERMIT) 4123 return "permit"; 4124 return "?"; 4125 } 4126 public String toSystem(ConsentProvisionType code) { 4127 return code.getSystem(); 4128 } 4129 } 4130 4131 public enum Currencies { 4132 /** 4133 * null 4134 */ 4135 AED, 4136 /** 4137 * null 4138 */ 4139 AFN, 4140 /** 4141 * null 4142 */ 4143 ALL, 4144 /** 4145 * null 4146 */ 4147 AMD, 4148 /** 4149 * null 4150 */ 4151 ANG, 4152 /** 4153 * null 4154 */ 4155 AOA, 4156 /** 4157 * null 4158 */ 4159 ARS, 4160 /** 4161 * null 4162 */ 4163 AUD, 4164 /** 4165 * null 4166 */ 4167 AWG, 4168 /** 4169 * null 4170 */ 4171 AZN, 4172 /** 4173 * null 4174 */ 4175 BAM, 4176 /** 4177 * null 4178 */ 4179 BBD, 4180 /** 4181 * null 4182 */ 4183 BDT, 4184 /** 4185 * null 4186 */ 4187 BGN, 4188 /** 4189 * null 4190 */ 4191 BHD, 4192 /** 4193 * null 4194 */ 4195 BIF, 4196 /** 4197 * null 4198 */ 4199 BMD, 4200 /** 4201 * null 4202 */ 4203 BND, 4204 /** 4205 * null 4206 */ 4207 BOB, 4208 /** 4209 * null 4210 */ 4211 BOV, 4212 /** 4213 * null 4214 */ 4215 BRL, 4216 /** 4217 * null 4218 */ 4219 BSD, 4220 /** 4221 * null 4222 */ 4223 BTN, 4224 /** 4225 * null 4226 */ 4227 BWP, 4228 /** 4229 * null 4230 */ 4231 BYN, 4232 /** 4233 * null 4234 */ 4235 BZD, 4236 /** 4237 * null 4238 */ 4239 CAD, 4240 /** 4241 * null 4242 */ 4243 CDF, 4244 /** 4245 * null 4246 */ 4247 CHE, 4248 /** 4249 * null 4250 */ 4251 CHF, 4252 /** 4253 * null 4254 */ 4255 CHW, 4256 /** 4257 * null 4258 */ 4259 CLF, 4260 /** 4261 * null 4262 */ 4263 CLP, 4264 /** 4265 * null 4266 */ 4267 CNY, 4268 /** 4269 * null 4270 */ 4271 COP, 4272 /** 4273 * null 4274 */ 4275 COU, 4276 /** 4277 * null 4278 */ 4279 CRC, 4280 /** 4281 * null 4282 */ 4283 CUC, 4284 /** 4285 * null 4286 */ 4287 CUP, 4288 /** 4289 * null 4290 */ 4291 CVE, 4292 /** 4293 * null 4294 */ 4295 CZK, 4296 /** 4297 * null 4298 */ 4299 DJF, 4300 /** 4301 * null 4302 */ 4303 DKK, 4304 /** 4305 * null 4306 */ 4307 DOP, 4308 /** 4309 * null 4310 */ 4311 DZD, 4312 /** 4313 * null 4314 */ 4315 EGP, 4316 /** 4317 * null 4318 */ 4319 ERN, 4320 /** 4321 * null 4322 */ 4323 ETB, 4324 /** 4325 * null 4326 */ 4327 EUR, 4328 /** 4329 * null 4330 */ 4331 FJD, 4332 /** 4333 * null 4334 */ 4335 FKP, 4336 /** 4337 * null 4338 */ 4339 GBP, 4340 /** 4341 * null 4342 */ 4343 GEL, 4344 /** 4345 * null 4346 */ 4347 GGP, 4348 /** 4349 * null 4350 */ 4351 GHS, 4352 /** 4353 * null 4354 */ 4355 GIP, 4356 /** 4357 * null 4358 */ 4359 GMD, 4360 /** 4361 * null 4362 */ 4363 GNF, 4364 /** 4365 * null 4366 */ 4367 GTQ, 4368 /** 4369 * null 4370 */ 4371 GYD, 4372 /** 4373 * null 4374 */ 4375 HKD, 4376 /** 4377 * null 4378 */ 4379 HNL, 4380 /** 4381 * null 4382 */ 4383 HRK, 4384 /** 4385 * null 4386 */ 4387 HTG, 4388 /** 4389 * null 4390 */ 4391 HUF, 4392 /** 4393 * null 4394 */ 4395 IDR, 4396 /** 4397 * null 4398 */ 4399 ILS, 4400 /** 4401 * null 4402 */ 4403 IMP, 4404 /** 4405 * null 4406 */ 4407 INR, 4408 /** 4409 * null 4410 */ 4411 IQD, 4412 /** 4413 * null 4414 */ 4415 IRR, 4416 /** 4417 * null 4418 */ 4419 ISK, 4420 /** 4421 * null 4422 */ 4423 JEP, 4424 /** 4425 * null 4426 */ 4427 JMD, 4428 /** 4429 * null 4430 */ 4431 JOD, 4432 /** 4433 * null 4434 */ 4435 JPY, 4436 /** 4437 * null 4438 */ 4439 KES, 4440 /** 4441 * null 4442 */ 4443 KGS, 4444 /** 4445 * null 4446 */ 4447 KHR, 4448 /** 4449 * null 4450 */ 4451 KMF, 4452 /** 4453 * null 4454 */ 4455 KPW, 4456 /** 4457 * null 4458 */ 4459 KRW, 4460 /** 4461 * null 4462 */ 4463 KWD, 4464 /** 4465 * null 4466 */ 4467 KYD, 4468 /** 4469 * null 4470 */ 4471 KZT, 4472 /** 4473 * null 4474 */ 4475 LAK, 4476 /** 4477 * null 4478 */ 4479 LBP, 4480 /** 4481 * null 4482 */ 4483 LKR, 4484 /** 4485 * null 4486 */ 4487 LRD, 4488 /** 4489 * null 4490 */ 4491 LSL, 4492 /** 4493 * null 4494 */ 4495 LYD, 4496 /** 4497 * null 4498 */ 4499 MAD, 4500 /** 4501 * null 4502 */ 4503 MDL, 4504 /** 4505 * null 4506 */ 4507 MGA, 4508 /** 4509 * null 4510 */ 4511 MKD, 4512 /** 4513 * null 4514 */ 4515 MMK, 4516 /** 4517 * null 4518 */ 4519 MNT, 4520 /** 4521 * null 4522 */ 4523 MOP, 4524 /** 4525 * null 4526 */ 4527 MRU, 4528 /** 4529 * null 4530 */ 4531 MUR, 4532 /** 4533 * null 4534 */ 4535 MVR, 4536 /** 4537 * null 4538 */ 4539 MWK, 4540 /** 4541 * null 4542 */ 4543 MXN, 4544 /** 4545 * null 4546 */ 4547 MXV, 4548 /** 4549 * null 4550 */ 4551 MYR, 4552 /** 4553 * null 4554 */ 4555 MZN, 4556 /** 4557 * null 4558 */ 4559 NAD, 4560 /** 4561 * null 4562 */ 4563 NGN, 4564 /** 4565 * null 4566 */ 4567 NIO, 4568 /** 4569 * null 4570 */ 4571 NOK, 4572 /** 4573 * null 4574 */ 4575 NPR, 4576 /** 4577 * null 4578 */ 4579 NZD, 4580 /** 4581 * null 4582 */ 4583 OMR, 4584 /** 4585 * null 4586 */ 4587 PAB, 4588 /** 4589 * null 4590 */ 4591 PEN, 4592 /** 4593 * null 4594 */ 4595 PGK, 4596 /** 4597 * null 4598 */ 4599 PHP, 4600 /** 4601 * null 4602 */ 4603 PKR, 4604 /** 4605 * null 4606 */ 4607 PLN, 4608 /** 4609 * null 4610 */ 4611 PYG, 4612 /** 4613 * null 4614 */ 4615 QAR, 4616 /** 4617 * null 4618 */ 4619 RON, 4620 /** 4621 * null 4622 */ 4623 RSD, 4624 /** 4625 * null 4626 */ 4627 RUB, 4628 /** 4629 * null 4630 */ 4631 RWF, 4632 /** 4633 * null 4634 */ 4635 SAR, 4636 /** 4637 * null 4638 */ 4639 SBD, 4640 /** 4641 * null 4642 */ 4643 SCR, 4644 /** 4645 * null 4646 */ 4647 SDG, 4648 /** 4649 * null 4650 */ 4651 SEK, 4652 /** 4653 * null 4654 */ 4655 SGD, 4656 /** 4657 * null 4658 */ 4659 SHP, 4660 /** 4661 * null 4662 */ 4663 SLL, 4664 /** 4665 * null 4666 */ 4667 SOS, 4668 /** 4669 * null 4670 */ 4671 SRD, 4672 /** 4673 * null 4674 */ 4675 SSP, 4676 /** 4677 * null 4678 */ 4679 STN, 4680 /** 4681 * null 4682 */ 4683 SVC, 4684 /** 4685 * null 4686 */ 4687 SYP, 4688 /** 4689 * null 4690 */ 4691 SZL, 4692 /** 4693 * null 4694 */ 4695 THB, 4696 /** 4697 * null 4698 */ 4699 TJS, 4700 /** 4701 * null 4702 */ 4703 TMT, 4704 /** 4705 * null 4706 */ 4707 TND, 4708 /** 4709 * null 4710 */ 4711 TOP, 4712 /** 4713 * null 4714 */ 4715 TRY, 4716 /** 4717 * null 4718 */ 4719 TTD, 4720 /** 4721 * null 4722 */ 4723 TVD, 4724 /** 4725 * null 4726 */ 4727 TWD, 4728 /** 4729 * null 4730 */ 4731 TZS, 4732 /** 4733 * null 4734 */ 4735 UAH, 4736 /** 4737 * null 4738 */ 4739 UGX, 4740 /** 4741 * null 4742 */ 4743 USD, 4744 /** 4745 * null 4746 */ 4747 USN, 4748 /** 4749 * null 4750 */ 4751 UYI, 4752 /** 4753 * null 4754 */ 4755 UYU, 4756 /** 4757 * null 4758 */ 4759 UZS, 4760 /** 4761 * null 4762 */ 4763 VEF, 4764 /** 4765 * null 4766 */ 4767 VND, 4768 /** 4769 * null 4770 */ 4771 VUV, 4772 /** 4773 * null 4774 */ 4775 WST, 4776 /** 4777 * null 4778 */ 4779 XAF, 4780 /** 4781 * null 4782 */ 4783 XAG, 4784 /** 4785 * null 4786 */ 4787 XAU, 4788 /** 4789 * null 4790 */ 4791 XBA, 4792 /** 4793 * null 4794 */ 4795 XBB, 4796 /** 4797 * null 4798 */ 4799 XBC, 4800 /** 4801 * null 4802 */ 4803 XBD, 4804 /** 4805 * null 4806 */ 4807 XCD, 4808 /** 4809 * null 4810 */ 4811 XDR, 4812 /** 4813 * null 4814 */ 4815 XOF, 4816 /** 4817 * null 4818 */ 4819 XPD, 4820 /** 4821 * null 4822 */ 4823 XPF, 4824 /** 4825 * null 4826 */ 4827 XPT, 4828 /** 4829 * null 4830 */ 4831 XSU, 4832 /** 4833 * null 4834 */ 4835 XTS, 4836 /** 4837 * null 4838 */ 4839 XUA, 4840 /** 4841 * null 4842 */ 4843 XXX, 4844 /** 4845 * null 4846 */ 4847 YER, 4848 /** 4849 * null 4850 */ 4851 ZAR, 4852 /** 4853 * null 4854 */ 4855 ZMW, 4856 /** 4857 * null 4858 */ 4859 ZWL, 4860 /** 4861 * added to help the parsers 4862 */ 4863 NULL; 4864 public static Currencies fromCode(String codeString) throws FHIRException { 4865 if (codeString == null || "".equals(codeString)) 4866 return null; 4867 if ("AED".equals(codeString)) 4868 return AED; 4869 if ("AFN".equals(codeString)) 4870 return AFN; 4871 if ("ALL".equals(codeString)) 4872 return ALL; 4873 if ("AMD".equals(codeString)) 4874 return AMD; 4875 if ("ANG".equals(codeString)) 4876 return ANG; 4877 if ("AOA".equals(codeString)) 4878 return AOA; 4879 if ("ARS".equals(codeString)) 4880 return ARS; 4881 if ("AUD".equals(codeString)) 4882 return AUD; 4883 if ("AWG".equals(codeString)) 4884 return AWG; 4885 if ("AZN".equals(codeString)) 4886 return AZN; 4887 if ("BAM".equals(codeString)) 4888 return BAM; 4889 if ("BBD".equals(codeString)) 4890 return BBD; 4891 if ("BDT".equals(codeString)) 4892 return BDT; 4893 if ("BGN".equals(codeString)) 4894 return BGN; 4895 if ("BHD".equals(codeString)) 4896 return BHD; 4897 if ("BIF".equals(codeString)) 4898 return BIF; 4899 if ("BMD".equals(codeString)) 4900 return BMD; 4901 if ("BND".equals(codeString)) 4902 return BND; 4903 if ("BOB".equals(codeString)) 4904 return BOB; 4905 if ("BOV".equals(codeString)) 4906 return BOV; 4907 if ("BRL".equals(codeString)) 4908 return BRL; 4909 if ("BSD".equals(codeString)) 4910 return BSD; 4911 if ("BTN".equals(codeString)) 4912 return BTN; 4913 if ("BWP".equals(codeString)) 4914 return BWP; 4915 if ("BYN".equals(codeString)) 4916 return BYN; 4917 if ("BZD".equals(codeString)) 4918 return BZD; 4919 if ("CAD".equals(codeString)) 4920 return CAD; 4921 if ("CDF".equals(codeString)) 4922 return CDF; 4923 if ("CHE".equals(codeString)) 4924 return CHE; 4925 if ("CHF".equals(codeString)) 4926 return CHF; 4927 if ("CHW".equals(codeString)) 4928 return CHW; 4929 if ("CLF".equals(codeString)) 4930 return CLF; 4931 if ("CLP".equals(codeString)) 4932 return CLP; 4933 if ("CNY".equals(codeString)) 4934 return CNY; 4935 if ("COP".equals(codeString)) 4936 return COP; 4937 if ("COU".equals(codeString)) 4938 return COU; 4939 if ("CRC".equals(codeString)) 4940 return CRC; 4941 if ("CUC".equals(codeString)) 4942 return CUC; 4943 if ("CUP".equals(codeString)) 4944 return CUP; 4945 if ("CVE".equals(codeString)) 4946 return CVE; 4947 if ("CZK".equals(codeString)) 4948 return CZK; 4949 if ("DJF".equals(codeString)) 4950 return DJF; 4951 if ("DKK".equals(codeString)) 4952 return DKK; 4953 if ("DOP".equals(codeString)) 4954 return DOP; 4955 if ("DZD".equals(codeString)) 4956 return DZD; 4957 if ("EGP".equals(codeString)) 4958 return EGP; 4959 if ("ERN".equals(codeString)) 4960 return ERN; 4961 if ("ETB".equals(codeString)) 4962 return ETB; 4963 if ("EUR".equals(codeString)) 4964 return EUR; 4965 if ("FJD".equals(codeString)) 4966 return FJD; 4967 if ("FKP".equals(codeString)) 4968 return FKP; 4969 if ("GBP".equals(codeString)) 4970 return GBP; 4971 if ("GEL".equals(codeString)) 4972 return GEL; 4973 if ("GGP".equals(codeString)) 4974 return GGP; 4975 if ("GHS".equals(codeString)) 4976 return GHS; 4977 if ("GIP".equals(codeString)) 4978 return GIP; 4979 if ("GMD".equals(codeString)) 4980 return GMD; 4981 if ("GNF".equals(codeString)) 4982 return GNF; 4983 if ("GTQ".equals(codeString)) 4984 return GTQ; 4985 if ("GYD".equals(codeString)) 4986 return GYD; 4987 if ("HKD".equals(codeString)) 4988 return HKD; 4989 if ("HNL".equals(codeString)) 4990 return HNL; 4991 if ("HRK".equals(codeString)) 4992 return HRK; 4993 if ("HTG".equals(codeString)) 4994 return HTG; 4995 if ("HUF".equals(codeString)) 4996 return HUF; 4997 if ("IDR".equals(codeString)) 4998 return IDR; 4999 if ("ILS".equals(codeString)) 5000 return ILS; 5001 if ("IMP".equals(codeString)) 5002 return IMP; 5003 if ("INR".equals(codeString)) 5004 return INR; 5005 if ("IQD".equals(codeString)) 5006 return IQD; 5007 if ("IRR".equals(codeString)) 5008 return IRR; 5009 if ("ISK".equals(codeString)) 5010 return ISK; 5011 if ("JEP".equals(codeString)) 5012 return JEP; 5013 if ("JMD".equals(codeString)) 5014 return JMD; 5015 if ("JOD".equals(codeString)) 5016 return JOD; 5017 if ("JPY".equals(codeString)) 5018 return JPY; 5019 if ("KES".equals(codeString)) 5020 return KES; 5021 if ("KGS".equals(codeString)) 5022 return KGS; 5023 if ("KHR".equals(codeString)) 5024 return KHR; 5025 if ("KMF".equals(codeString)) 5026 return KMF; 5027 if ("KPW".equals(codeString)) 5028 return KPW; 5029 if ("KRW".equals(codeString)) 5030 return KRW; 5031 if ("KWD".equals(codeString)) 5032 return KWD; 5033 if ("KYD".equals(codeString)) 5034 return KYD; 5035 if ("KZT".equals(codeString)) 5036 return KZT; 5037 if ("LAK".equals(codeString)) 5038 return LAK; 5039 if ("LBP".equals(codeString)) 5040 return LBP; 5041 if ("LKR".equals(codeString)) 5042 return LKR; 5043 if ("LRD".equals(codeString)) 5044 return LRD; 5045 if ("LSL".equals(codeString)) 5046 return LSL; 5047 if ("LYD".equals(codeString)) 5048 return LYD; 5049 if ("MAD".equals(codeString)) 5050 return MAD; 5051 if ("MDL".equals(codeString)) 5052 return MDL; 5053 if ("MGA".equals(codeString)) 5054 return MGA; 5055 if ("MKD".equals(codeString)) 5056 return MKD; 5057 if ("MMK".equals(codeString)) 5058 return MMK; 5059 if ("MNT".equals(codeString)) 5060 return MNT; 5061 if ("MOP".equals(codeString)) 5062 return MOP; 5063 if ("MRU".equals(codeString)) 5064 return MRU; 5065 if ("MUR".equals(codeString)) 5066 return MUR; 5067 if ("MVR".equals(codeString)) 5068 return MVR; 5069 if ("MWK".equals(codeString)) 5070 return MWK; 5071 if ("MXN".equals(codeString)) 5072 return MXN; 5073 if ("MXV".equals(codeString)) 5074 return MXV; 5075 if ("MYR".equals(codeString)) 5076 return MYR; 5077 if ("MZN".equals(codeString)) 5078 return MZN; 5079 if ("NAD".equals(codeString)) 5080 return NAD; 5081 if ("NGN".equals(codeString)) 5082 return NGN; 5083 if ("NIO".equals(codeString)) 5084 return NIO; 5085 if ("NOK".equals(codeString)) 5086 return NOK; 5087 if ("NPR".equals(codeString)) 5088 return NPR; 5089 if ("NZD".equals(codeString)) 5090 return NZD; 5091 if ("OMR".equals(codeString)) 5092 return OMR; 5093 if ("PAB".equals(codeString)) 5094 return PAB; 5095 if ("PEN".equals(codeString)) 5096 return PEN; 5097 if ("PGK".equals(codeString)) 5098 return PGK; 5099 if ("PHP".equals(codeString)) 5100 return PHP; 5101 if ("PKR".equals(codeString)) 5102 return PKR; 5103 if ("PLN".equals(codeString)) 5104 return PLN; 5105 if ("PYG".equals(codeString)) 5106 return PYG; 5107 if ("QAR".equals(codeString)) 5108 return QAR; 5109 if ("RON".equals(codeString)) 5110 return RON; 5111 if ("RSD".equals(codeString)) 5112 return RSD; 5113 if ("RUB".equals(codeString)) 5114 return RUB; 5115 if ("RWF".equals(codeString)) 5116 return RWF; 5117 if ("SAR".equals(codeString)) 5118 return SAR; 5119 if ("SBD".equals(codeString)) 5120 return SBD; 5121 if ("SCR".equals(codeString)) 5122 return SCR; 5123 if ("SDG".equals(codeString)) 5124 return SDG; 5125 if ("SEK".equals(codeString)) 5126 return SEK; 5127 if ("SGD".equals(codeString)) 5128 return SGD; 5129 if ("SHP".equals(codeString)) 5130 return SHP; 5131 if ("SLL".equals(codeString)) 5132 return SLL; 5133 if ("SOS".equals(codeString)) 5134 return SOS; 5135 if ("SRD".equals(codeString)) 5136 return SRD; 5137 if ("SSP".equals(codeString)) 5138 return SSP; 5139 if ("STN".equals(codeString)) 5140 return STN; 5141 if ("SVC".equals(codeString)) 5142 return SVC; 5143 if ("SYP".equals(codeString)) 5144 return SYP; 5145 if ("SZL".equals(codeString)) 5146 return SZL; 5147 if ("THB".equals(codeString)) 5148 return THB; 5149 if ("TJS".equals(codeString)) 5150 return TJS; 5151 if ("TMT".equals(codeString)) 5152 return TMT; 5153 if ("TND".equals(codeString)) 5154 return TND; 5155 if ("TOP".equals(codeString)) 5156 return TOP; 5157 if ("TRY".equals(codeString)) 5158 return TRY; 5159 if ("TTD".equals(codeString)) 5160 return TTD; 5161 if ("TVD".equals(codeString)) 5162 return TVD; 5163 if ("TWD".equals(codeString)) 5164 return TWD; 5165 if ("TZS".equals(codeString)) 5166 return TZS; 5167 if ("UAH".equals(codeString)) 5168 return UAH; 5169 if ("UGX".equals(codeString)) 5170 return UGX; 5171 if ("USD".equals(codeString)) 5172 return USD; 5173 if ("USN".equals(codeString)) 5174 return USN; 5175 if ("UYI".equals(codeString)) 5176 return UYI; 5177 if ("UYU".equals(codeString)) 5178 return UYU; 5179 if ("UZS".equals(codeString)) 5180 return UZS; 5181 if ("VEF".equals(codeString)) 5182 return VEF; 5183 if ("VND".equals(codeString)) 5184 return VND; 5185 if ("VUV".equals(codeString)) 5186 return VUV; 5187 if ("WST".equals(codeString)) 5188 return WST; 5189 if ("XAF".equals(codeString)) 5190 return XAF; 5191 if ("XAG".equals(codeString)) 5192 return XAG; 5193 if ("XAU".equals(codeString)) 5194 return XAU; 5195 if ("XBA".equals(codeString)) 5196 return XBA; 5197 if ("XBB".equals(codeString)) 5198 return XBB; 5199 if ("XBC".equals(codeString)) 5200 return XBC; 5201 if ("XBD".equals(codeString)) 5202 return XBD; 5203 if ("XCD".equals(codeString)) 5204 return XCD; 5205 if ("XDR".equals(codeString)) 5206 return XDR; 5207 if ("XOF".equals(codeString)) 5208 return XOF; 5209 if ("XPD".equals(codeString)) 5210 return XPD; 5211 if ("XPF".equals(codeString)) 5212 return XPF; 5213 if ("XPT".equals(codeString)) 5214 return XPT; 5215 if ("XSU".equals(codeString)) 5216 return XSU; 5217 if ("XTS".equals(codeString)) 5218 return XTS; 5219 if ("XUA".equals(codeString)) 5220 return XUA; 5221 if ("XXX".equals(codeString)) 5222 return XXX; 5223 if ("YER".equals(codeString)) 5224 return YER; 5225 if ("ZAR".equals(codeString)) 5226 return ZAR; 5227 if ("ZMW".equals(codeString)) 5228 return ZMW; 5229 if ("ZWL".equals(codeString)) 5230 return ZWL; 5231 throw new FHIRException("Unknown Currencies code '"+codeString+"'"); 5232 } 5233 public static boolean isValidCode(String codeString) { 5234 if (codeString == null || "".equals(codeString)) 5235 return false; 5236 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"); 5237 } 5238 public String toCode() { 5239 switch (this) { 5240 case AED: return "AED"; 5241 case AFN: return "AFN"; 5242 case ALL: return "ALL"; 5243 case AMD: return "AMD"; 5244 case ANG: return "ANG"; 5245 case AOA: return "AOA"; 5246 case ARS: return "ARS"; 5247 case AUD: return "AUD"; 5248 case AWG: return "AWG"; 5249 case AZN: return "AZN"; 5250 case BAM: return "BAM"; 5251 case BBD: return "BBD"; 5252 case BDT: return "BDT"; 5253 case BGN: return "BGN"; 5254 case BHD: return "BHD"; 5255 case BIF: return "BIF"; 5256 case BMD: return "BMD"; 5257 case BND: return "BND"; 5258 case BOB: return "BOB"; 5259 case BOV: return "BOV"; 5260 case BRL: return "BRL"; 5261 case BSD: return "BSD"; 5262 case BTN: return "BTN"; 5263 case BWP: return "BWP"; 5264 case BYN: return "BYN"; 5265 case BZD: return "BZD"; 5266 case CAD: return "CAD"; 5267 case CDF: return "CDF"; 5268 case CHE: return "CHE"; 5269 case CHF: return "CHF"; 5270 case CHW: return "CHW"; 5271 case CLF: return "CLF"; 5272 case CLP: return "CLP"; 5273 case CNY: return "CNY"; 5274 case COP: return "COP"; 5275 case COU: return "COU"; 5276 case CRC: return "CRC"; 5277 case CUC: return "CUC"; 5278 case CUP: return "CUP"; 5279 case CVE: return "CVE"; 5280 case CZK: return "CZK"; 5281 case DJF: return "DJF"; 5282 case DKK: return "DKK"; 5283 case DOP: return "DOP"; 5284 case DZD: return "DZD"; 5285 case EGP: return "EGP"; 5286 case ERN: return "ERN"; 5287 case ETB: return "ETB"; 5288 case EUR: return "EUR"; 5289 case FJD: return "FJD"; 5290 case FKP: return "FKP"; 5291 case GBP: return "GBP"; 5292 case GEL: return "GEL"; 5293 case GGP: return "GGP"; 5294 case GHS: return "GHS"; 5295 case GIP: return "GIP"; 5296 case GMD: return "GMD"; 5297 case GNF: return "GNF"; 5298 case GTQ: return "GTQ"; 5299 case GYD: return "GYD"; 5300 case HKD: return "HKD"; 5301 case HNL: return "HNL"; 5302 case HRK: return "HRK"; 5303 case HTG: return "HTG"; 5304 case HUF: return "HUF"; 5305 case IDR: return "IDR"; 5306 case ILS: return "ILS"; 5307 case IMP: return "IMP"; 5308 case INR: return "INR"; 5309 case IQD: return "IQD"; 5310 case IRR: return "IRR"; 5311 case ISK: return "ISK"; 5312 case JEP: return "JEP"; 5313 case JMD: return "JMD"; 5314 case JOD: return "JOD"; 5315 case JPY: return "JPY"; 5316 case KES: return "KES"; 5317 case KGS: return "KGS"; 5318 case KHR: return "KHR"; 5319 case KMF: return "KMF"; 5320 case KPW: return "KPW"; 5321 case KRW: return "KRW"; 5322 case KWD: return "KWD"; 5323 case KYD: return "KYD"; 5324 case KZT: return "KZT"; 5325 case LAK: return "LAK"; 5326 case LBP: return "LBP"; 5327 case LKR: return "LKR"; 5328 case LRD: return "LRD"; 5329 case LSL: return "LSL"; 5330 case LYD: return "LYD"; 5331 case MAD: return "MAD"; 5332 case MDL: return "MDL"; 5333 case MGA: return "MGA"; 5334 case MKD: return "MKD"; 5335 case MMK: return "MMK"; 5336 case MNT: return "MNT"; 5337 case MOP: return "MOP"; 5338 case MRU: return "MRU"; 5339 case MUR: return "MUR"; 5340 case MVR: return "MVR"; 5341 case MWK: return "MWK"; 5342 case MXN: return "MXN"; 5343 case MXV: return "MXV"; 5344 case MYR: return "MYR"; 5345 case MZN: return "MZN"; 5346 case NAD: return "NAD"; 5347 case NGN: return "NGN"; 5348 case NIO: return "NIO"; 5349 case NOK: return "NOK"; 5350 case NPR: return "NPR"; 5351 case NZD: return "NZD"; 5352 case OMR: return "OMR"; 5353 case PAB: return "PAB"; 5354 case PEN: return "PEN"; 5355 case PGK: return "PGK"; 5356 case PHP: return "PHP"; 5357 case PKR: return "PKR"; 5358 case PLN: return "PLN"; 5359 case PYG: return "PYG"; 5360 case QAR: return "QAR"; 5361 case RON: return "RON"; 5362 case RSD: return "RSD"; 5363 case RUB: return "RUB"; 5364 case RWF: return "RWF"; 5365 case SAR: return "SAR"; 5366 case SBD: return "SBD"; 5367 case SCR: return "SCR"; 5368 case SDG: return "SDG"; 5369 case SEK: return "SEK"; 5370 case SGD: return "SGD"; 5371 case SHP: return "SHP"; 5372 case SLL: return "SLL"; 5373 case SOS: return "SOS"; 5374 case SRD: return "SRD"; 5375 case SSP: return "SSP"; 5376 case STN: return "STN"; 5377 case SVC: return "SVC"; 5378 case SYP: return "SYP"; 5379 case SZL: return "SZL"; 5380 case THB: return "THB"; 5381 case TJS: return "TJS"; 5382 case TMT: return "TMT"; 5383 case TND: return "TND"; 5384 case TOP: return "TOP"; 5385 case TRY: return "TRY"; 5386 case TTD: return "TTD"; 5387 case TVD: return "TVD"; 5388 case TWD: return "TWD"; 5389 case TZS: return "TZS"; 5390 case UAH: return "UAH"; 5391 case UGX: return "UGX"; 5392 case USD: return "USD"; 5393 case USN: return "USN"; 5394 case UYI: return "UYI"; 5395 case UYU: return "UYU"; 5396 case UZS: return "UZS"; 5397 case VEF: return "VEF"; 5398 case VND: return "VND"; 5399 case VUV: return "VUV"; 5400 case WST: return "WST"; 5401 case XAF: return "XAF"; 5402 case XAG: return "XAG"; 5403 case XAU: return "XAU"; 5404 case XBA: return "XBA"; 5405 case XBB: return "XBB"; 5406 case XBC: return "XBC"; 5407 case XBD: return "XBD"; 5408 case XCD: return "XCD"; 5409 case XDR: return "XDR"; 5410 case XOF: return "XOF"; 5411 case XPD: return "XPD"; 5412 case XPF: return "XPF"; 5413 case XPT: return "XPT"; 5414 case XSU: return "XSU"; 5415 case XTS: return "XTS"; 5416 case XUA: return "XUA"; 5417 case XXX: return "XXX"; 5418 case YER: return "YER"; 5419 case ZAR: return "ZAR"; 5420 case ZMW: return "ZMW"; 5421 case ZWL: return "ZWL"; 5422 case NULL: return null; 5423 default: return "?"; 5424 } 5425 } 5426 public String getSystem() { 5427 switch (this) { 5428 case AED: return "urn:iso:std:iso:4217"; 5429 case AFN: return "urn:iso:std:iso:4217"; 5430 case ALL: return "urn:iso:std:iso:4217"; 5431 case AMD: return "urn:iso:std:iso:4217"; 5432 case ANG: return "urn:iso:std:iso:4217"; 5433 case AOA: return "urn:iso:std:iso:4217"; 5434 case ARS: return "urn:iso:std:iso:4217"; 5435 case AUD: return "urn:iso:std:iso:4217"; 5436 case AWG: return "urn:iso:std:iso:4217"; 5437 case AZN: return "urn:iso:std:iso:4217"; 5438 case BAM: return "urn:iso:std:iso:4217"; 5439 case BBD: return "urn:iso:std:iso:4217"; 5440 case BDT: return "urn:iso:std:iso:4217"; 5441 case BGN: return "urn:iso:std:iso:4217"; 5442 case BHD: return "urn:iso:std:iso:4217"; 5443 case BIF: return "urn:iso:std:iso:4217"; 5444 case BMD: return "urn:iso:std:iso:4217"; 5445 case BND: return "urn:iso:std:iso:4217"; 5446 case BOB: return "urn:iso:std:iso:4217"; 5447 case BOV: return "urn:iso:std:iso:4217"; 5448 case BRL: return "urn:iso:std:iso:4217"; 5449 case BSD: return "urn:iso:std:iso:4217"; 5450 case BTN: return "urn:iso:std:iso:4217"; 5451 case BWP: return "urn:iso:std:iso:4217"; 5452 case BYN: return "urn:iso:std:iso:4217"; 5453 case BZD: return "urn:iso:std:iso:4217"; 5454 case CAD: return "urn:iso:std:iso:4217"; 5455 case CDF: return "urn:iso:std:iso:4217"; 5456 case CHE: return "urn:iso:std:iso:4217"; 5457 case CHF: return "urn:iso:std:iso:4217"; 5458 case CHW: return "urn:iso:std:iso:4217"; 5459 case CLF: return "urn:iso:std:iso:4217"; 5460 case CLP: return "urn:iso:std:iso:4217"; 5461 case CNY: return "urn:iso:std:iso:4217"; 5462 case COP: return "urn:iso:std:iso:4217"; 5463 case COU: return "urn:iso:std:iso:4217"; 5464 case CRC: return "urn:iso:std:iso:4217"; 5465 case CUC: return "urn:iso:std:iso:4217"; 5466 case CUP: return "urn:iso:std:iso:4217"; 5467 case CVE: return "urn:iso:std:iso:4217"; 5468 case CZK: return "urn:iso:std:iso:4217"; 5469 case DJF: return "urn:iso:std:iso:4217"; 5470 case DKK: return "urn:iso:std:iso:4217"; 5471 case DOP: return "urn:iso:std:iso:4217"; 5472 case DZD: return "urn:iso:std:iso:4217"; 5473 case EGP: return "urn:iso:std:iso:4217"; 5474 case ERN: return "urn:iso:std:iso:4217"; 5475 case ETB: return "urn:iso:std:iso:4217"; 5476 case EUR: return "urn:iso:std:iso:4217"; 5477 case FJD: return "urn:iso:std:iso:4217"; 5478 case FKP: return "urn:iso:std:iso:4217"; 5479 case GBP: return "urn:iso:std:iso:4217"; 5480 case GEL: return "urn:iso:std:iso:4217"; 5481 case GGP: return "urn:iso:std:iso:4217"; 5482 case GHS: return "urn:iso:std:iso:4217"; 5483 case GIP: return "urn:iso:std:iso:4217"; 5484 case GMD: return "urn:iso:std:iso:4217"; 5485 case GNF: return "urn:iso:std:iso:4217"; 5486 case GTQ: return "urn:iso:std:iso:4217"; 5487 case GYD: return "urn:iso:std:iso:4217"; 5488 case HKD: return "urn:iso:std:iso:4217"; 5489 case HNL: return "urn:iso:std:iso:4217"; 5490 case HRK: return "urn:iso:std:iso:4217"; 5491 case HTG: return "urn:iso:std:iso:4217"; 5492 case HUF: return "urn:iso:std:iso:4217"; 5493 case IDR: return "urn:iso:std:iso:4217"; 5494 case ILS: return "urn:iso:std:iso:4217"; 5495 case IMP: return "urn:iso:std:iso:4217"; 5496 case INR: return "urn:iso:std:iso:4217"; 5497 case IQD: return "urn:iso:std:iso:4217"; 5498 case IRR: return "urn:iso:std:iso:4217"; 5499 case ISK: return "urn:iso:std:iso:4217"; 5500 case JEP: return "urn:iso:std:iso:4217"; 5501 case JMD: return "urn:iso:std:iso:4217"; 5502 case JOD: return "urn:iso:std:iso:4217"; 5503 case JPY: return "urn:iso:std:iso:4217"; 5504 case KES: return "urn:iso:std:iso:4217"; 5505 case KGS: return "urn:iso:std:iso:4217"; 5506 case KHR: return "urn:iso:std:iso:4217"; 5507 case KMF: return "urn:iso:std:iso:4217"; 5508 case KPW: return "urn:iso:std:iso:4217"; 5509 case KRW: return "urn:iso:std:iso:4217"; 5510 case KWD: return "urn:iso:std:iso:4217"; 5511 case KYD: return "urn:iso:std:iso:4217"; 5512 case KZT: return "urn:iso:std:iso:4217"; 5513 case LAK: return "urn:iso:std:iso:4217"; 5514 case LBP: return "urn:iso:std:iso:4217"; 5515 case LKR: return "urn:iso:std:iso:4217"; 5516 case LRD: return "urn:iso:std:iso:4217"; 5517 case LSL: return "urn:iso:std:iso:4217"; 5518 case LYD: return "urn:iso:std:iso:4217"; 5519 case MAD: return "urn:iso:std:iso:4217"; 5520 case MDL: return "urn:iso:std:iso:4217"; 5521 case MGA: return "urn:iso:std:iso:4217"; 5522 case MKD: return "urn:iso:std:iso:4217"; 5523 case MMK: return "urn:iso:std:iso:4217"; 5524 case MNT: return "urn:iso:std:iso:4217"; 5525 case MOP: return "urn:iso:std:iso:4217"; 5526 case MRU: return "urn:iso:std:iso:4217"; 5527 case MUR: return "urn:iso:std:iso:4217"; 5528 case MVR: return "urn:iso:std:iso:4217"; 5529 case MWK: return "urn:iso:std:iso:4217"; 5530 case MXN: return "urn:iso:std:iso:4217"; 5531 case MXV: return "urn:iso:std:iso:4217"; 5532 case MYR: return "urn:iso:std:iso:4217"; 5533 case MZN: return "urn:iso:std:iso:4217"; 5534 case NAD: return "urn:iso:std:iso:4217"; 5535 case NGN: return "urn:iso:std:iso:4217"; 5536 case NIO: return "urn:iso:std:iso:4217"; 5537 case NOK: return "urn:iso:std:iso:4217"; 5538 case NPR: return "urn:iso:std:iso:4217"; 5539 case NZD: return "urn:iso:std:iso:4217"; 5540 case OMR: return "urn:iso:std:iso:4217"; 5541 case PAB: return "urn:iso:std:iso:4217"; 5542 case PEN: return "urn:iso:std:iso:4217"; 5543 case PGK: return "urn:iso:std:iso:4217"; 5544 case PHP: return "urn:iso:std:iso:4217"; 5545 case PKR: return "urn:iso:std:iso:4217"; 5546 case PLN: return "urn:iso:std:iso:4217"; 5547 case PYG: return "urn:iso:std:iso:4217"; 5548 case QAR: return "urn:iso:std:iso:4217"; 5549 case RON: return "urn:iso:std:iso:4217"; 5550 case RSD: return "urn:iso:std:iso:4217"; 5551 case RUB: return "urn:iso:std:iso:4217"; 5552 case RWF: return "urn:iso:std:iso:4217"; 5553 case SAR: return "urn:iso:std:iso:4217"; 5554 case SBD: return "urn:iso:std:iso:4217"; 5555 case SCR: return "urn:iso:std:iso:4217"; 5556 case SDG: return "urn:iso:std:iso:4217"; 5557 case SEK: return "urn:iso:std:iso:4217"; 5558 case SGD: return "urn:iso:std:iso:4217"; 5559 case SHP: return "urn:iso:std:iso:4217"; 5560 case SLL: return "urn:iso:std:iso:4217"; 5561 case SOS: return "urn:iso:std:iso:4217"; 5562 case SRD: return "urn:iso:std:iso:4217"; 5563 case SSP: return "urn:iso:std:iso:4217"; 5564 case STN: return "urn:iso:std:iso:4217"; 5565 case SVC: return "urn:iso:std:iso:4217"; 5566 case SYP: return "urn:iso:std:iso:4217"; 5567 case SZL: return "urn:iso:std:iso:4217"; 5568 case THB: return "urn:iso:std:iso:4217"; 5569 case TJS: return "urn:iso:std:iso:4217"; 5570 case TMT: return "urn:iso:std:iso:4217"; 5571 case TND: return "urn:iso:std:iso:4217"; 5572 case TOP: return "urn:iso:std:iso:4217"; 5573 case TRY: return "urn:iso:std:iso:4217"; 5574 case TTD: return "urn:iso:std:iso:4217"; 5575 case TVD: return "urn:iso:std:iso:4217"; 5576 case TWD: return "urn:iso:std:iso:4217"; 5577 case TZS: return "urn:iso:std:iso:4217"; 5578 case UAH: return "urn:iso:std:iso:4217"; 5579 case UGX: return "urn:iso:std:iso:4217"; 5580 case USD: return "urn:iso:std:iso:4217"; 5581 case USN: return "urn:iso:std:iso:4217"; 5582 case UYI: return "urn:iso:std:iso:4217"; 5583 case UYU: return "urn:iso:std:iso:4217"; 5584 case UZS: return "urn:iso:std:iso:4217"; 5585 case VEF: return "urn:iso:std:iso:4217"; 5586 case VND: return "urn:iso:std:iso:4217"; 5587 case VUV: return "urn:iso:std:iso:4217"; 5588 case WST: return "urn:iso:std:iso:4217"; 5589 case XAF: return "urn:iso:std:iso:4217"; 5590 case XAG: return "urn:iso:std:iso:4217"; 5591 case XAU: return "urn:iso:std:iso:4217"; 5592 case XBA: return "urn:iso:std:iso:4217"; 5593 case XBB: return "urn:iso:std:iso:4217"; 5594 case XBC: return "urn:iso:std:iso:4217"; 5595 case XBD: return "urn:iso:std:iso:4217"; 5596 case XCD: return "urn:iso:std:iso:4217"; 5597 case XDR: return "urn:iso:std:iso:4217"; 5598 case XOF: return "urn:iso:std:iso:4217"; 5599 case XPD: return "urn:iso:std:iso:4217"; 5600 case XPF: return "urn:iso:std:iso:4217"; 5601 case XPT: return "urn:iso:std:iso:4217"; 5602 case XSU: return "urn:iso:std:iso:4217"; 5603 case XTS: return "urn:iso:std:iso:4217"; 5604 case XUA: return "urn:iso:std:iso:4217"; 5605 case XXX: return "urn:iso:std:iso:4217"; 5606 case YER: return "urn:iso:std:iso:4217"; 5607 case ZAR: return "urn:iso:std:iso:4217"; 5608 case ZMW: return "urn:iso:std:iso:4217"; 5609 case ZWL: return "urn:iso:std:iso:4217"; 5610 case NULL: return null; 5611 default: return "?"; 5612 } 5613 } 5614 public String getDefinition() { 5615 switch (this) { 5616 case AED: return ""; 5617 case AFN: return ""; 5618 case ALL: return ""; 5619 case AMD: return ""; 5620 case ANG: return ""; 5621 case AOA: return ""; 5622 case ARS: return ""; 5623 case AUD: return ""; 5624 case AWG: return ""; 5625 case AZN: return ""; 5626 case BAM: return ""; 5627 case BBD: return ""; 5628 case BDT: return ""; 5629 case BGN: return ""; 5630 case BHD: return ""; 5631 case BIF: return ""; 5632 case BMD: return ""; 5633 case BND: return ""; 5634 case BOB: return ""; 5635 case BOV: return ""; 5636 case BRL: return ""; 5637 case BSD: return ""; 5638 case BTN: return ""; 5639 case BWP: return ""; 5640 case BYN: return ""; 5641 case BZD: return ""; 5642 case CAD: return ""; 5643 case CDF: return ""; 5644 case CHE: return ""; 5645 case CHF: return ""; 5646 case CHW: return ""; 5647 case CLF: return ""; 5648 case CLP: return ""; 5649 case CNY: return ""; 5650 case COP: return ""; 5651 case COU: return ""; 5652 case CRC: return ""; 5653 case CUC: return ""; 5654 case CUP: return ""; 5655 case CVE: return ""; 5656 case CZK: return ""; 5657 case DJF: return ""; 5658 case DKK: return ""; 5659 case DOP: return ""; 5660 case DZD: return ""; 5661 case EGP: return ""; 5662 case ERN: return ""; 5663 case ETB: return ""; 5664 case EUR: return ""; 5665 case FJD: return ""; 5666 case FKP: return ""; 5667 case GBP: return ""; 5668 case GEL: return ""; 5669 case GGP: return ""; 5670 case GHS: return ""; 5671 case GIP: return ""; 5672 case GMD: return ""; 5673 case GNF: return ""; 5674 case GTQ: return ""; 5675 case GYD: return ""; 5676 case HKD: return ""; 5677 case HNL: return ""; 5678 case HRK: return ""; 5679 case HTG: return ""; 5680 case HUF: return ""; 5681 case IDR: return ""; 5682 case ILS: return ""; 5683 case IMP: return ""; 5684 case INR: return ""; 5685 case IQD: return ""; 5686 case IRR: return ""; 5687 case ISK: return ""; 5688 case JEP: return ""; 5689 case JMD: return ""; 5690 case JOD: return ""; 5691 case JPY: return ""; 5692 case KES: return ""; 5693 case KGS: return ""; 5694 case KHR: return ""; 5695 case KMF: return ""; 5696 case KPW: return ""; 5697 case KRW: return ""; 5698 case KWD: return ""; 5699 case KYD: return ""; 5700 case KZT: return ""; 5701 case LAK: return ""; 5702 case LBP: return ""; 5703 case LKR: return ""; 5704 case LRD: return ""; 5705 case LSL: return ""; 5706 case LYD: return ""; 5707 case MAD: return ""; 5708 case MDL: return ""; 5709 case MGA: return ""; 5710 case MKD: return ""; 5711 case MMK: return ""; 5712 case MNT: return ""; 5713 case MOP: return ""; 5714 case MRU: return ""; 5715 case MUR: return ""; 5716 case MVR: return ""; 5717 case MWK: return ""; 5718 case MXN: return ""; 5719 case MXV: return ""; 5720 case MYR: return ""; 5721 case MZN: return ""; 5722 case NAD: return ""; 5723 case NGN: return ""; 5724 case NIO: return ""; 5725 case NOK: return ""; 5726 case NPR: return ""; 5727 case NZD: return ""; 5728 case OMR: return ""; 5729 case PAB: return ""; 5730 case PEN: return ""; 5731 case PGK: return ""; 5732 case PHP: return ""; 5733 case PKR: return ""; 5734 case PLN: return ""; 5735 case PYG: return ""; 5736 case QAR: return ""; 5737 case RON: return ""; 5738 case RSD: return ""; 5739 case RUB: return ""; 5740 case RWF: return ""; 5741 case SAR: return ""; 5742 case SBD: return ""; 5743 case SCR: return ""; 5744 case SDG: return ""; 5745 case SEK: return ""; 5746 case SGD: return ""; 5747 case SHP: return ""; 5748 case SLL: return ""; 5749 case SOS: return ""; 5750 case SRD: return ""; 5751 case SSP: return ""; 5752 case STN: return ""; 5753 case SVC: return ""; 5754 case SYP: return ""; 5755 case SZL: return ""; 5756 case THB: return ""; 5757 case TJS: return ""; 5758 case TMT: return ""; 5759 case TND: return ""; 5760 case TOP: return ""; 5761 case TRY: return ""; 5762 case TTD: return ""; 5763 case TVD: return ""; 5764 case TWD: return ""; 5765 case TZS: return ""; 5766 case UAH: return ""; 5767 case UGX: return ""; 5768 case USD: return ""; 5769 case USN: return ""; 5770 case UYI: return ""; 5771 case UYU: return ""; 5772 case UZS: return ""; 5773 case VEF: return ""; 5774 case VND: return ""; 5775 case VUV: return ""; 5776 case WST: return ""; 5777 case XAF: return ""; 5778 case XAG: return ""; 5779 case XAU: return ""; 5780 case XBA: return ""; 5781 case XBB: return ""; 5782 case XBC: return ""; 5783 case XBD: return ""; 5784 case XCD: return ""; 5785 case XDR: return ""; 5786 case XOF: return ""; 5787 case XPD: return ""; 5788 case XPF: return ""; 5789 case XPT: return ""; 5790 case XSU: return ""; 5791 case XTS: return ""; 5792 case XUA: return ""; 5793 case XXX: return ""; 5794 case YER: return ""; 5795 case ZAR: return ""; 5796 case ZMW: return ""; 5797 case ZWL: return ""; 5798 case NULL: return null; 5799 default: return "?"; 5800 } 5801 } 5802 public String getDisplay() { 5803 switch (this) { 5804 case AED: return "United Arab Emirates dirham"; 5805 case AFN: return "Afghan afghani"; 5806 case ALL: return "Albanian lek"; 5807 case AMD: return "Armenian dram"; 5808 case ANG: return "Netherlands Antillean guilder"; 5809 case AOA: return "Angolan kwanza"; 5810 case ARS: return "Argentine peso"; 5811 case AUD: return "Australian dollar"; 5812 case AWG: return "Aruban florin"; 5813 case AZN: return "Azerbaijani manat"; 5814 case BAM: return "Bosnia and Herzegovina convertible mark"; 5815 case BBD: return "Barbados dollar"; 5816 case BDT: return "Bangladeshi taka"; 5817 case BGN: return "Bulgarian lev"; 5818 case BHD: return "Bahraini dinar"; 5819 case BIF: return "Burundian franc"; 5820 case BMD: return "Bermudian dollar"; 5821 case BND: return "Brunei dollar"; 5822 case BOB: return "Boliviano"; 5823 case BOV: return "Bolivian Mvdol (funds code)"; 5824 case BRL: return "Brazilian real"; 5825 case BSD: return "Bahamian dollar"; 5826 case BTN: return "Bhutanese ngultrum"; 5827 case BWP: return "Botswana pula"; 5828 case BYN: return "Belarusian ruble"; 5829 case BZD: return "Belize dollar"; 5830 case CAD: return "Canadian dollar"; 5831 case CDF: return "Congolese franc"; 5832 case CHE: return "WIR Euro (complementary currency)"; 5833 case CHF: return "Swiss franc"; 5834 case CHW: return "WIR Franc (complementary currency)"; 5835 case CLF: return "Unidad de Fomento (funds code)"; 5836 case CLP: return "Chilean peso"; 5837 case CNY: return "Renminbi (Chinese) yuan[8]"; 5838 case COP: return "Colombian peso"; 5839 case COU: return "Unidad de Valor Real (UVR) (funds code)[9]"; 5840 case CRC: return "Costa Rican colon"; 5841 case CUC: return "Cuban convertible peso"; 5842 case CUP: return "Cuban peso"; 5843 case CVE: return "Cape Verde escudo"; 5844 case CZK: return "Czech koruna"; 5845 case DJF: return "Djiboutian franc"; 5846 case DKK: return "Danish krone"; 5847 case DOP: return "Dominican peso"; 5848 case DZD: return "Algerian dinar"; 5849 case EGP: return "Egyptian pound"; 5850 case ERN: return "Eritrean nakfa"; 5851 case ETB: return "Ethiopian birr"; 5852 case EUR: return "Euro"; 5853 case FJD: return "Fiji dollar"; 5854 case FKP: return "Falkland Islands pound"; 5855 case GBP: return "Pound sterling"; 5856 case GEL: return "Georgian lari"; 5857 case GGP: return "Guernsey Pound"; 5858 case GHS: return "Ghanaian cedi"; 5859 case GIP: return "Gibraltar pound"; 5860 case GMD: return "Gambian dalasi"; 5861 case GNF: return "Guinean franc"; 5862 case GTQ: return "Guatemalan quetzal"; 5863 case GYD: return "Guyanese dollar"; 5864 case HKD: return "Hong Kong dollar"; 5865 case HNL: return "Honduran lempira"; 5866 case HRK: return "Croatian kuna"; 5867 case HTG: return "Haitian gourde"; 5868 case HUF: return "Hungarian forint"; 5869 case IDR: return "Indonesian rupiah"; 5870 case ILS: return "Israeli new shekel"; 5871 case IMP: return "Isle of Man Pound"; 5872 case INR: return "Indian rupee"; 5873 case IQD: return "Iraqi dinar"; 5874 case IRR: return "Iranian rial"; 5875 case ISK: return "Icelandic króna"; 5876 case JEP: return "Jersey Pound"; 5877 case JMD: return "Jamaican dollar"; 5878 case JOD: return "Jordanian dinar"; 5879 case JPY: return "Japanese yen"; 5880 case KES: return "Kenyan shilling"; 5881 case KGS: return "Kyrgyzstani som"; 5882 case KHR: return "Cambodian riel"; 5883 case KMF: return "Comoro franc"; 5884 case KPW: return "North Korean won"; 5885 case KRW: return "South Korean won"; 5886 case KWD: return "Kuwaiti dinar"; 5887 case KYD: return "Cayman Islands dollar"; 5888 case KZT: return "Kazakhstani tenge"; 5889 case LAK: return "Lao kip"; 5890 case LBP: return "Lebanese pound"; 5891 case LKR: return "Sri Lankan rupee"; 5892 case LRD: return "Liberian dollar"; 5893 case LSL: return "Lesotho loti"; 5894 case LYD: return "Libyan dinar"; 5895 case MAD: return "Moroccan dirham"; 5896 case MDL: return "Moldovan leu"; 5897 case MGA: return "Malagasy ariary"; 5898 case MKD: return "Macedonian denar"; 5899 case MMK: return "Myanmar kyat"; 5900 case MNT: return "Mongolian tögrög"; 5901 case MOP: return "Macanese pataca"; 5902 case MRU: return "Mauritanian ouguiya"; 5903 case MUR: return "Mauritian rupee"; 5904 case MVR: return "Maldivian rufiyaa"; 5905 case MWK: return "Malawian kwacha"; 5906 case MXN: return "Mexican peso"; 5907 case MXV: return "Mexican Unidad de Inversion (UDI) (funds code)"; 5908 case MYR: return "Malaysian ringgit"; 5909 case MZN: return "Mozambican metical"; 5910 case NAD: return "Namibian dollar"; 5911 case NGN: return "Nigerian naira"; 5912 case NIO: return "Nicaraguan córdoba"; 5913 case NOK: return "Norwegian krone"; 5914 case NPR: return "Nepalese rupee"; 5915 case NZD: return "New Zealand dollar"; 5916 case OMR: return "Omani rial"; 5917 case PAB: return "Panamanian balboa"; 5918 case PEN: return "Peruvian Sol"; 5919 case PGK: return "Papua New Guinean kina"; 5920 case PHP: return "Philippine piso[13]"; 5921 case PKR: return "Pakistani rupee"; 5922 case PLN: return "Polish z?oty"; 5923 case PYG: return "Paraguayan guaraní"; 5924 case QAR: return "Qatari riyal"; 5925 case RON: return "Romanian leu"; 5926 case RSD: return "Serbian dinar"; 5927 case RUB: return "Russian ruble"; 5928 case RWF: return "Rwandan franc"; 5929 case SAR: return "Saudi riyal"; 5930 case SBD: return "Solomon Islands dollar"; 5931 case SCR: return "Seychelles rupee"; 5932 case SDG: return "Sudanese pound"; 5933 case SEK: return "Swedish krona/kronor"; 5934 case SGD: return "Singapore dollar"; 5935 case SHP: return "Saint Helena pound"; 5936 case SLL: return "Sierra Leonean leone"; 5937 case SOS: return "Somali shilling"; 5938 case SRD: return "Surinamese dollar"; 5939 case SSP: return "South Sudanese pound"; 5940 case STN: return "São Tomé and Príncipe dobra"; 5941 case SVC: return "Salvadoran colón"; 5942 case SYP: return "Syrian pound"; 5943 case SZL: return "Swazi lilangeni"; 5944 case THB: return "Thai baht"; 5945 case TJS: return "Tajikistani somoni"; 5946 case TMT: return "Turkmenistan manat"; 5947 case TND: return "Tunisian dinar"; 5948 case TOP: return "Tongan pa?anga"; 5949 case TRY: return "Turkish lira"; 5950 case TTD: return "Trinidad and Tobago dollar"; 5951 case TVD: return "Tuvalu Dollar"; 5952 case TWD: return "New Taiwan dollar"; 5953 case TZS: return "Tanzanian shilling"; 5954 case UAH: return "Ukrainian hryvnia"; 5955 case UGX: return "Ugandan shilling"; 5956 case USD: return "United States dollar"; 5957 case USN: return "United States dollar (next day) (funds code)"; 5958 case UYI: return "Uruguay Peso en Unidades Indexadas (URUIURUI) (funds code)"; 5959 case UYU: return "Uruguayan peso"; 5960 case UZS: return "Uzbekistan som"; 5961 case VEF: return "Venezuelan bolívar"; 5962 case VND: return "Vietnamese ??ng"; 5963 case VUV: return "Vanuatu vatu"; 5964 case WST: return "Samoan tala"; 5965 case XAF: return "CFA franc BEAC"; 5966 case XAG: return "Silver (one troy ounce)"; 5967 case XAU: return "Gold (one troy ounce)"; 5968 case XBA: return "European Composite Unit (EURCO) (bond market unit)"; 5969 case XBB: return "European Monetary Unit (E.M.U.-6) (bond market unit)"; 5970 case XBC: return "European Unit of Account 9 (E.U.A.-9) (bond market unit)"; 5971 case XBD: return "European Unit of Account 17 (E.U.A.-17) (bond market unit)"; 5972 case XCD: return "East Caribbean dollar"; 5973 case XDR: return "Special drawing rights"; 5974 case XOF: return "CFA franc BCEAO"; 5975 case XPD: return "Palladium (one troy ounce)"; 5976 case XPF: return "CFP franc (franc Pacifique)"; 5977 case XPT: return "Platinum (one troy ounce)"; 5978 case XSU: return "SUCRE"; 5979 case XTS: return "Code reserved for testing purposes"; 5980 case XUA: return "ADB Unit of Account"; 5981 case XXX: return "No currency"; 5982 case YER: return "Yemeni rial"; 5983 case ZAR: return "South African rand"; 5984 case ZMW: return "Zambian kwacha"; 5985 case ZWL: return "Zimbabwean dollar A/10"; 5986 case NULL: return null; 5987 default: return "?"; 5988 } 5989 } 5990 } 5991 5992 public static class CurrenciesEnumFactory implements EnumFactory<Currencies> { 5993 public Currencies fromCode(String codeString) throws IllegalArgumentException { 5994 if (codeString == null || "".equals(codeString)) 5995 if (codeString == null || "".equals(codeString)) 5996 return null; 5997 if ("AED".equals(codeString)) 5998 return Currencies.AED; 5999 if ("AFN".equals(codeString)) 6000 return Currencies.AFN; 6001 if ("ALL".equals(codeString)) 6002 return Currencies.ALL; 6003 if ("AMD".equals(codeString)) 6004 return Currencies.AMD; 6005 if ("ANG".equals(codeString)) 6006 return Currencies.ANG; 6007 if ("AOA".equals(codeString)) 6008 return Currencies.AOA; 6009 if ("ARS".equals(codeString)) 6010 return Currencies.ARS; 6011 if ("AUD".equals(codeString)) 6012 return Currencies.AUD; 6013 if ("AWG".equals(codeString)) 6014 return Currencies.AWG; 6015 if ("AZN".equals(codeString)) 6016 return Currencies.AZN; 6017 if ("BAM".equals(codeString)) 6018 return Currencies.BAM; 6019 if ("BBD".equals(codeString)) 6020 return Currencies.BBD; 6021 if ("BDT".equals(codeString)) 6022 return Currencies.BDT; 6023 if ("BGN".equals(codeString)) 6024 return Currencies.BGN; 6025 if ("BHD".equals(codeString)) 6026 return Currencies.BHD; 6027 if ("BIF".equals(codeString)) 6028 return Currencies.BIF; 6029 if ("BMD".equals(codeString)) 6030 return Currencies.BMD; 6031 if ("BND".equals(codeString)) 6032 return Currencies.BND; 6033 if ("BOB".equals(codeString)) 6034 return Currencies.BOB; 6035 if ("BOV".equals(codeString)) 6036 return Currencies.BOV; 6037 if ("BRL".equals(codeString)) 6038 return Currencies.BRL; 6039 if ("BSD".equals(codeString)) 6040 return Currencies.BSD; 6041 if ("BTN".equals(codeString)) 6042 return Currencies.BTN; 6043 if ("BWP".equals(codeString)) 6044 return Currencies.BWP; 6045 if ("BYN".equals(codeString)) 6046 return Currencies.BYN; 6047 if ("BZD".equals(codeString)) 6048 return Currencies.BZD; 6049 if ("CAD".equals(codeString)) 6050 return Currencies.CAD; 6051 if ("CDF".equals(codeString)) 6052 return Currencies.CDF; 6053 if ("CHE".equals(codeString)) 6054 return Currencies.CHE; 6055 if ("CHF".equals(codeString)) 6056 return Currencies.CHF; 6057 if ("CHW".equals(codeString)) 6058 return Currencies.CHW; 6059 if ("CLF".equals(codeString)) 6060 return Currencies.CLF; 6061 if ("CLP".equals(codeString)) 6062 return Currencies.CLP; 6063 if ("CNY".equals(codeString)) 6064 return Currencies.CNY; 6065 if ("COP".equals(codeString)) 6066 return Currencies.COP; 6067 if ("COU".equals(codeString)) 6068 return Currencies.COU; 6069 if ("CRC".equals(codeString)) 6070 return Currencies.CRC; 6071 if ("CUC".equals(codeString)) 6072 return Currencies.CUC; 6073 if ("CUP".equals(codeString)) 6074 return Currencies.CUP; 6075 if ("CVE".equals(codeString)) 6076 return Currencies.CVE; 6077 if ("CZK".equals(codeString)) 6078 return Currencies.CZK; 6079 if ("DJF".equals(codeString)) 6080 return Currencies.DJF; 6081 if ("DKK".equals(codeString)) 6082 return Currencies.DKK; 6083 if ("DOP".equals(codeString)) 6084 return Currencies.DOP; 6085 if ("DZD".equals(codeString)) 6086 return Currencies.DZD; 6087 if ("EGP".equals(codeString)) 6088 return Currencies.EGP; 6089 if ("ERN".equals(codeString)) 6090 return Currencies.ERN; 6091 if ("ETB".equals(codeString)) 6092 return Currencies.ETB; 6093 if ("EUR".equals(codeString)) 6094 return Currencies.EUR; 6095 if ("FJD".equals(codeString)) 6096 return Currencies.FJD; 6097 if ("FKP".equals(codeString)) 6098 return Currencies.FKP; 6099 if ("GBP".equals(codeString)) 6100 return Currencies.GBP; 6101 if ("GEL".equals(codeString)) 6102 return Currencies.GEL; 6103 if ("GGP".equals(codeString)) 6104 return Currencies.GGP; 6105 if ("GHS".equals(codeString)) 6106 return Currencies.GHS; 6107 if ("GIP".equals(codeString)) 6108 return Currencies.GIP; 6109 if ("GMD".equals(codeString)) 6110 return Currencies.GMD; 6111 if ("GNF".equals(codeString)) 6112 return Currencies.GNF; 6113 if ("GTQ".equals(codeString)) 6114 return Currencies.GTQ; 6115 if ("GYD".equals(codeString)) 6116 return Currencies.GYD; 6117 if ("HKD".equals(codeString)) 6118 return Currencies.HKD; 6119 if ("HNL".equals(codeString)) 6120 return Currencies.HNL; 6121 if ("HRK".equals(codeString)) 6122 return Currencies.HRK; 6123 if ("HTG".equals(codeString)) 6124 return Currencies.HTG; 6125 if ("HUF".equals(codeString)) 6126 return Currencies.HUF; 6127 if ("IDR".equals(codeString)) 6128 return Currencies.IDR; 6129 if ("ILS".equals(codeString)) 6130 return Currencies.ILS; 6131 if ("IMP".equals(codeString)) 6132 return Currencies.IMP; 6133 if ("INR".equals(codeString)) 6134 return Currencies.INR; 6135 if ("IQD".equals(codeString)) 6136 return Currencies.IQD; 6137 if ("IRR".equals(codeString)) 6138 return Currencies.IRR; 6139 if ("ISK".equals(codeString)) 6140 return Currencies.ISK; 6141 if ("JEP".equals(codeString)) 6142 return Currencies.JEP; 6143 if ("JMD".equals(codeString)) 6144 return Currencies.JMD; 6145 if ("JOD".equals(codeString)) 6146 return Currencies.JOD; 6147 if ("JPY".equals(codeString)) 6148 return Currencies.JPY; 6149 if ("KES".equals(codeString)) 6150 return Currencies.KES; 6151 if ("KGS".equals(codeString)) 6152 return Currencies.KGS; 6153 if ("KHR".equals(codeString)) 6154 return Currencies.KHR; 6155 if ("KMF".equals(codeString)) 6156 return Currencies.KMF; 6157 if ("KPW".equals(codeString)) 6158 return Currencies.KPW; 6159 if ("KRW".equals(codeString)) 6160 return Currencies.KRW; 6161 if ("KWD".equals(codeString)) 6162 return Currencies.KWD; 6163 if ("KYD".equals(codeString)) 6164 return Currencies.KYD; 6165 if ("KZT".equals(codeString)) 6166 return Currencies.KZT; 6167 if ("LAK".equals(codeString)) 6168 return Currencies.LAK; 6169 if ("LBP".equals(codeString)) 6170 return Currencies.LBP; 6171 if ("LKR".equals(codeString)) 6172 return Currencies.LKR; 6173 if ("LRD".equals(codeString)) 6174 return Currencies.LRD; 6175 if ("LSL".equals(codeString)) 6176 return Currencies.LSL; 6177 if ("LYD".equals(codeString)) 6178 return Currencies.LYD; 6179 if ("MAD".equals(codeString)) 6180 return Currencies.MAD; 6181 if ("MDL".equals(codeString)) 6182 return Currencies.MDL; 6183 if ("MGA".equals(codeString)) 6184 return Currencies.MGA; 6185 if ("MKD".equals(codeString)) 6186 return Currencies.MKD; 6187 if ("MMK".equals(codeString)) 6188 return Currencies.MMK; 6189 if ("MNT".equals(codeString)) 6190 return Currencies.MNT; 6191 if ("MOP".equals(codeString)) 6192 return Currencies.MOP; 6193 if ("MRU".equals(codeString)) 6194 return Currencies.MRU; 6195 if ("MUR".equals(codeString)) 6196 return Currencies.MUR; 6197 if ("MVR".equals(codeString)) 6198 return Currencies.MVR; 6199 if ("MWK".equals(codeString)) 6200 return Currencies.MWK; 6201 if ("MXN".equals(codeString)) 6202 return Currencies.MXN; 6203 if ("MXV".equals(codeString)) 6204 return Currencies.MXV; 6205 if ("MYR".equals(codeString)) 6206 return Currencies.MYR; 6207 if ("MZN".equals(codeString)) 6208 return Currencies.MZN; 6209 if ("NAD".equals(codeString)) 6210 return Currencies.NAD; 6211 if ("NGN".equals(codeString)) 6212 return Currencies.NGN; 6213 if ("NIO".equals(codeString)) 6214 return Currencies.NIO; 6215 if ("NOK".equals(codeString)) 6216 return Currencies.NOK; 6217 if ("NPR".equals(codeString)) 6218 return Currencies.NPR; 6219 if ("NZD".equals(codeString)) 6220 return Currencies.NZD; 6221 if ("OMR".equals(codeString)) 6222 return Currencies.OMR; 6223 if ("PAB".equals(codeString)) 6224 return Currencies.PAB; 6225 if ("PEN".equals(codeString)) 6226 return Currencies.PEN; 6227 if ("PGK".equals(codeString)) 6228 return Currencies.PGK; 6229 if ("PHP".equals(codeString)) 6230 return Currencies.PHP; 6231 if ("PKR".equals(codeString)) 6232 return Currencies.PKR; 6233 if ("PLN".equals(codeString)) 6234 return Currencies.PLN; 6235 if ("PYG".equals(codeString)) 6236 return Currencies.PYG; 6237 if ("QAR".equals(codeString)) 6238 return Currencies.QAR; 6239 if ("RON".equals(codeString)) 6240 return Currencies.RON; 6241 if ("RSD".equals(codeString)) 6242 return Currencies.RSD; 6243 if ("RUB".equals(codeString)) 6244 return Currencies.RUB; 6245 if ("RWF".equals(codeString)) 6246 return Currencies.RWF; 6247 if ("SAR".equals(codeString)) 6248 return Currencies.SAR; 6249 if ("SBD".equals(codeString)) 6250 return Currencies.SBD; 6251 if ("SCR".equals(codeString)) 6252 return Currencies.SCR; 6253 if ("SDG".equals(codeString)) 6254 return Currencies.SDG; 6255 if ("SEK".equals(codeString)) 6256 return Currencies.SEK; 6257 if ("SGD".equals(codeString)) 6258 return Currencies.SGD; 6259 if ("SHP".equals(codeString)) 6260 return Currencies.SHP; 6261 if ("SLL".equals(codeString)) 6262 return Currencies.SLL; 6263 if ("SOS".equals(codeString)) 6264 return Currencies.SOS; 6265 if ("SRD".equals(codeString)) 6266 return Currencies.SRD; 6267 if ("SSP".equals(codeString)) 6268 return Currencies.SSP; 6269 if ("STN".equals(codeString)) 6270 return Currencies.STN; 6271 if ("SVC".equals(codeString)) 6272 return Currencies.SVC; 6273 if ("SYP".equals(codeString)) 6274 return Currencies.SYP; 6275 if ("SZL".equals(codeString)) 6276 return Currencies.SZL; 6277 if ("THB".equals(codeString)) 6278 return Currencies.THB; 6279 if ("TJS".equals(codeString)) 6280 return Currencies.TJS; 6281 if ("TMT".equals(codeString)) 6282 return Currencies.TMT; 6283 if ("TND".equals(codeString)) 6284 return Currencies.TND; 6285 if ("TOP".equals(codeString)) 6286 return Currencies.TOP; 6287 if ("TRY".equals(codeString)) 6288 return Currencies.TRY; 6289 if ("TTD".equals(codeString)) 6290 return Currencies.TTD; 6291 if ("TVD".equals(codeString)) 6292 return Currencies.TVD; 6293 if ("TWD".equals(codeString)) 6294 return Currencies.TWD; 6295 if ("TZS".equals(codeString)) 6296 return Currencies.TZS; 6297 if ("UAH".equals(codeString)) 6298 return Currencies.UAH; 6299 if ("UGX".equals(codeString)) 6300 return Currencies.UGX; 6301 if ("USD".equals(codeString)) 6302 return Currencies.USD; 6303 if ("USN".equals(codeString)) 6304 return Currencies.USN; 6305 if ("UYI".equals(codeString)) 6306 return Currencies.UYI; 6307 if ("UYU".equals(codeString)) 6308 return Currencies.UYU; 6309 if ("UZS".equals(codeString)) 6310 return Currencies.UZS; 6311 if ("VEF".equals(codeString)) 6312 return Currencies.VEF; 6313 if ("VND".equals(codeString)) 6314 return Currencies.VND; 6315 if ("VUV".equals(codeString)) 6316 return Currencies.VUV; 6317 if ("WST".equals(codeString)) 6318 return Currencies.WST; 6319 if ("XAF".equals(codeString)) 6320 return Currencies.XAF; 6321 if ("XAG".equals(codeString)) 6322 return Currencies.XAG; 6323 if ("XAU".equals(codeString)) 6324 return Currencies.XAU; 6325 if ("XBA".equals(codeString)) 6326 return Currencies.XBA; 6327 if ("XBB".equals(codeString)) 6328 return Currencies.XBB; 6329 if ("XBC".equals(codeString)) 6330 return Currencies.XBC; 6331 if ("XBD".equals(codeString)) 6332 return Currencies.XBD; 6333 if ("XCD".equals(codeString)) 6334 return Currencies.XCD; 6335 if ("XDR".equals(codeString)) 6336 return Currencies.XDR; 6337 if ("XOF".equals(codeString)) 6338 return Currencies.XOF; 6339 if ("XPD".equals(codeString)) 6340 return Currencies.XPD; 6341 if ("XPF".equals(codeString)) 6342 return Currencies.XPF; 6343 if ("XPT".equals(codeString)) 6344 return Currencies.XPT; 6345 if ("XSU".equals(codeString)) 6346 return Currencies.XSU; 6347 if ("XTS".equals(codeString)) 6348 return Currencies.XTS; 6349 if ("XUA".equals(codeString)) 6350 return Currencies.XUA; 6351 if ("XXX".equals(codeString)) 6352 return Currencies.XXX; 6353 if ("YER".equals(codeString)) 6354 return Currencies.YER; 6355 if ("ZAR".equals(codeString)) 6356 return Currencies.ZAR; 6357 if ("ZMW".equals(codeString)) 6358 return Currencies.ZMW; 6359 if ("ZWL".equals(codeString)) 6360 return Currencies.ZWL; 6361 throw new IllegalArgumentException("Unknown Currencies code '"+codeString+"'"); 6362 } 6363 6364 public Enumeration<Currencies> fromType(PrimitiveType<?> code) throws FHIRException { 6365 if (code == null) 6366 return null; 6367 if (code.isEmpty()) 6368 return new Enumeration<Currencies>(this, Currencies.NULL, code); 6369 String codeString = ((PrimitiveType) code).asStringValue(); 6370 if (codeString == null || "".equals(codeString)) 6371 return new Enumeration<Currencies>(this, Currencies.NULL, code); 6372 if ("AED".equals(codeString)) 6373 return new Enumeration<Currencies>(this, Currencies.AED, code); 6374 if ("AFN".equals(codeString)) 6375 return new Enumeration<Currencies>(this, Currencies.AFN, code); 6376 if ("ALL".equals(codeString)) 6377 return new Enumeration<Currencies>(this, Currencies.ALL, code); 6378 if ("AMD".equals(codeString)) 6379 return new Enumeration<Currencies>(this, Currencies.AMD, code); 6380 if ("ANG".equals(codeString)) 6381 return new Enumeration<Currencies>(this, Currencies.ANG, code); 6382 if ("AOA".equals(codeString)) 6383 return new Enumeration<Currencies>(this, Currencies.AOA, code); 6384 if ("ARS".equals(codeString)) 6385 return new Enumeration<Currencies>(this, Currencies.ARS, code); 6386 if ("AUD".equals(codeString)) 6387 return new Enumeration<Currencies>(this, Currencies.AUD, code); 6388 if ("AWG".equals(codeString)) 6389 return new Enumeration<Currencies>(this, Currencies.AWG, code); 6390 if ("AZN".equals(codeString)) 6391 return new Enumeration<Currencies>(this, Currencies.AZN, code); 6392 if ("BAM".equals(codeString)) 6393 return new Enumeration<Currencies>(this, Currencies.BAM, code); 6394 if ("BBD".equals(codeString)) 6395 return new Enumeration<Currencies>(this, Currencies.BBD, code); 6396 if ("BDT".equals(codeString)) 6397 return new Enumeration<Currencies>(this, Currencies.BDT, code); 6398 if ("BGN".equals(codeString)) 6399 return new Enumeration<Currencies>(this, Currencies.BGN, code); 6400 if ("BHD".equals(codeString)) 6401 return new Enumeration<Currencies>(this, Currencies.BHD, code); 6402 if ("BIF".equals(codeString)) 6403 return new Enumeration<Currencies>(this, Currencies.BIF, code); 6404 if ("BMD".equals(codeString)) 6405 return new Enumeration<Currencies>(this, Currencies.BMD, code); 6406 if ("BND".equals(codeString)) 6407 return new Enumeration<Currencies>(this, Currencies.BND, code); 6408 if ("BOB".equals(codeString)) 6409 return new Enumeration<Currencies>(this, Currencies.BOB, code); 6410 if ("BOV".equals(codeString)) 6411 return new Enumeration<Currencies>(this, Currencies.BOV, code); 6412 if ("BRL".equals(codeString)) 6413 return new Enumeration<Currencies>(this, Currencies.BRL, code); 6414 if ("BSD".equals(codeString)) 6415 return new Enumeration<Currencies>(this, Currencies.BSD, code); 6416 if ("BTN".equals(codeString)) 6417 return new Enumeration<Currencies>(this, Currencies.BTN, code); 6418 if ("BWP".equals(codeString)) 6419 return new Enumeration<Currencies>(this, Currencies.BWP, code); 6420 if ("BYN".equals(codeString)) 6421 return new Enumeration<Currencies>(this, Currencies.BYN, code); 6422 if ("BZD".equals(codeString)) 6423 return new Enumeration<Currencies>(this, Currencies.BZD, code); 6424 if ("CAD".equals(codeString)) 6425 return new Enumeration<Currencies>(this, Currencies.CAD, code); 6426 if ("CDF".equals(codeString)) 6427 return new Enumeration<Currencies>(this, Currencies.CDF, code); 6428 if ("CHE".equals(codeString)) 6429 return new Enumeration<Currencies>(this, Currencies.CHE, code); 6430 if ("CHF".equals(codeString)) 6431 return new Enumeration<Currencies>(this, Currencies.CHF, code); 6432 if ("CHW".equals(codeString)) 6433 return new Enumeration<Currencies>(this, Currencies.CHW, code); 6434 if ("CLF".equals(codeString)) 6435 return new Enumeration<Currencies>(this, Currencies.CLF, code); 6436 if ("CLP".equals(codeString)) 6437 return new Enumeration<Currencies>(this, Currencies.CLP, code); 6438 if ("CNY".equals(codeString)) 6439 return new Enumeration<Currencies>(this, Currencies.CNY, code); 6440 if ("COP".equals(codeString)) 6441 return new Enumeration<Currencies>(this, Currencies.COP, code); 6442 if ("COU".equals(codeString)) 6443 return new Enumeration<Currencies>(this, Currencies.COU, code); 6444 if ("CRC".equals(codeString)) 6445 return new Enumeration<Currencies>(this, Currencies.CRC, code); 6446 if ("CUC".equals(codeString)) 6447 return new Enumeration<Currencies>(this, Currencies.CUC, code); 6448 if ("CUP".equals(codeString)) 6449 return new Enumeration<Currencies>(this, Currencies.CUP, code); 6450 if ("CVE".equals(codeString)) 6451 return new Enumeration<Currencies>(this, Currencies.CVE, code); 6452 if ("CZK".equals(codeString)) 6453 return new Enumeration<Currencies>(this, Currencies.CZK, code); 6454 if ("DJF".equals(codeString)) 6455 return new Enumeration<Currencies>(this, Currencies.DJF, code); 6456 if ("DKK".equals(codeString)) 6457 return new Enumeration<Currencies>(this, Currencies.DKK, code); 6458 if ("DOP".equals(codeString)) 6459 return new Enumeration<Currencies>(this, Currencies.DOP, code); 6460 if ("DZD".equals(codeString)) 6461 return new Enumeration<Currencies>(this, Currencies.DZD, code); 6462 if ("EGP".equals(codeString)) 6463 return new Enumeration<Currencies>(this, Currencies.EGP, code); 6464 if ("ERN".equals(codeString)) 6465 return new Enumeration<Currencies>(this, Currencies.ERN, code); 6466 if ("ETB".equals(codeString)) 6467 return new Enumeration<Currencies>(this, Currencies.ETB, code); 6468 if ("EUR".equals(codeString)) 6469 return new Enumeration<Currencies>(this, Currencies.EUR, code); 6470 if ("FJD".equals(codeString)) 6471 return new Enumeration<Currencies>(this, Currencies.FJD, code); 6472 if ("FKP".equals(codeString)) 6473 return new Enumeration<Currencies>(this, Currencies.FKP, code); 6474 if ("GBP".equals(codeString)) 6475 return new Enumeration<Currencies>(this, Currencies.GBP, code); 6476 if ("GEL".equals(codeString)) 6477 return new Enumeration<Currencies>(this, Currencies.GEL, code); 6478 if ("GGP".equals(codeString)) 6479 return new Enumeration<Currencies>(this, Currencies.GGP, code); 6480 if ("GHS".equals(codeString)) 6481 return new Enumeration<Currencies>(this, Currencies.GHS, code); 6482 if ("GIP".equals(codeString)) 6483 return new Enumeration<Currencies>(this, Currencies.GIP, code); 6484 if ("GMD".equals(codeString)) 6485 return new Enumeration<Currencies>(this, Currencies.GMD, code); 6486 if ("GNF".equals(codeString)) 6487 return new Enumeration<Currencies>(this, Currencies.GNF, code); 6488 if ("GTQ".equals(codeString)) 6489 return new Enumeration<Currencies>(this, Currencies.GTQ, code); 6490 if ("GYD".equals(codeString)) 6491 return new Enumeration<Currencies>(this, Currencies.GYD, code); 6492 if ("HKD".equals(codeString)) 6493 return new Enumeration<Currencies>(this, Currencies.HKD, code); 6494 if ("HNL".equals(codeString)) 6495 return new Enumeration<Currencies>(this, Currencies.HNL, code); 6496 if ("HRK".equals(codeString)) 6497 return new Enumeration<Currencies>(this, Currencies.HRK, code); 6498 if ("HTG".equals(codeString)) 6499 return new Enumeration<Currencies>(this, Currencies.HTG, code); 6500 if ("HUF".equals(codeString)) 6501 return new Enumeration<Currencies>(this, Currencies.HUF, code); 6502 if ("IDR".equals(codeString)) 6503 return new Enumeration<Currencies>(this, Currencies.IDR, code); 6504 if ("ILS".equals(codeString)) 6505 return new Enumeration<Currencies>(this, Currencies.ILS, code); 6506 if ("IMP".equals(codeString)) 6507 return new Enumeration<Currencies>(this, Currencies.IMP, code); 6508 if ("INR".equals(codeString)) 6509 return new Enumeration<Currencies>(this, Currencies.INR, code); 6510 if ("IQD".equals(codeString)) 6511 return new Enumeration<Currencies>(this, Currencies.IQD, code); 6512 if ("IRR".equals(codeString)) 6513 return new Enumeration<Currencies>(this, Currencies.IRR, code); 6514 if ("ISK".equals(codeString)) 6515 return new Enumeration<Currencies>(this, Currencies.ISK, code); 6516 if ("JEP".equals(codeString)) 6517 return new Enumeration<Currencies>(this, Currencies.JEP, code); 6518 if ("JMD".equals(codeString)) 6519 return new Enumeration<Currencies>(this, Currencies.JMD, code); 6520 if ("JOD".equals(codeString)) 6521 return new Enumeration<Currencies>(this, Currencies.JOD, code); 6522 if ("JPY".equals(codeString)) 6523 return new Enumeration<Currencies>(this, Currencies.JPY, code); 6524 if ("KES".equals(codeString)) 6525 return new Enumeration<Currencies>(this, Currencies.KES, code); 6526 if ("KGS".equals(codeString)) 6527 return new Enumeration<Currencies>(this, Currencies.KGS, code); 6528 if ("KHR".equals(codeString)) 6529 return new Enumeration<Currencies>(this, Currencies.KHR, code); 6530 if ("KMF".equals(codeString)) 6531 return new Enumeration<Currencies>(this, Currencies.KMF, code); 6532 if ("KPW".equals(codeString)) 6533 return new Enumeration<Currencies>(this, Currencies.KPW, code); 6534 if ("KRW".equals(codeString)) 6535 return new Enumeration<Currencies>(this, Currencies.KRW, code); 6536 if ("KWD".equals(codeString)) 6537 return new Enumeration<Currencies>(this, Currencies.KWD, code); 6538 if ("KYD".equals(codeString)) 6539 return new Enumeration<Currencies>(this, Currencies.KYD, code); 6540 if ("KZT".equals(codeString)) 6541 return new Enumeration<Currencies>(this, Currencies.KZT, code); 6542 if ("LAK".equals(codeString)) 6543 return new Enumeration<Currencies>(this, Currencies.LAK, code); 6544 if ("LBP".equals(codeString)) 6545 return new Enumeration<Currencies>(this, Currencies.LBP, code); 6546 if ("LKR".equals(codeString)) 6547 return new Enumeration<Currencies>(this, Currencies.LKR, code); 6548 if ("LRD".equals(codeString)) 6549 return new Enumeration<Currencies>(this, Currencies.LRD, code); 6550 if ("LSL".equals(codeString)) 6551 return new Enumeration<Currencies>(this, Currencies.LSL, code); 6552 if ("LYD".equals(codeString)) 6553 return new Enumeration<Currencies>(this, Currencies.LYD, code); 6554 if ("MAD".equals(codeString)) 6555 return new Enumeration<Currencies>(this, Currencies.MAD, code); 6556 if ("MDL".equals(codeString)) 6557 return new Enumeration<Currencies>(this, Currencies.MDL, code); 6558 if ("MGA".equals(codeString)) 6559 return new Enumeration<Currencies>(this, Currencies.MGA, code); 6560 if ("MKD".equals(codeString)) 6561 return new Enumeration<Currencies>(this, Currencies.MKD, code); 6562 if ("MMK".equals(codeString)) 6563 return new Enumeration<Currencies>(this, Currencies.MMK, code); 6564 if ("MNT".equals(codeString)) 6565 return new Enumeration<Currencies>(this, Currencies.MNT, code); 6566 if ("MOP".equals(codeString)) 6567 return new Enumeration<Currencies>(this, Currencies.MOP, code); 6568 if ("MRU".equals(codeString)) 6569 return new Enumeration<Currencies>(this, Currencies.MRU, code); 6570 if ("MUR".equals(codeString)) 6571 return new Enumeration<Currencies>(this, Currencies.MUR, code); 6572 if ("MVR".equals(codeString)) 6573 return new Enumeration<Currencies>(this, Currencies.MVR, code); 6574 if ("MWK".equals(codeString)) 6575 return new Enumeration<Currencies>(this, Currencies.MWK, code); 6576 if ("MXN".equals(codeString)) 6577 return new Enumeration<Currencies>(this, Currencies.MXN, code); 6578 if ("MXV".equals(codeString)) 6579 return new Enumeration<Currencies>(this, Currencies.MXV, code); 6580 if ("MYR".equals(codeString)) 6581 return new Enumeration<Currencies>(this, Currencies.MYR, code); 6582 if ("MZN".equals(codeString)) 6583 return new Enumeration<Currencies>(this, Currencies.MZN, code); 6584 if ("NAD".equals(codeString)) 6585 return new Enumeration<Currencies>(this, Currencies.NAD, code); 6586 if ("NGN".equals(codeString)) 6587 return new Enumeration<Currencies>(this, Currencies.NGN, code); 6588 if ("NIO".equals(codeString)) 6589 return new Enumeration<Currencies>(this, Currencies.NIO, code); 6590 if ("NOK".equals(codeString)) 6591 return new Enumeration<Currencies>(this, Currencies.NOK, code); 6592 if ("NPR".equals(codeString)) 6593 return new Enumeration<Currencies>(this, Currencies.NPR, code); 6594 if ("NZD".equals(codeString)) 6595 return new Enumeration<Currencies>(this, Currencies.NZD, code); 6596 if ("OMR".equals(codeString)) 6597 return new Enumeration<Currencies>(this, Currencies.OMR, code); 6598 if ("PAB".equals(codeString)) 6599 return new Enumeration<Currencies>(this, Currencies.PAB, code); 6600 if ("PEN".equals(codeString)) 6601 return new Enumeration<Currencies>(this, Currencies.PEN, code); 6602 if ("PGK".equals(codeString)) 6603 return new Enumeration<Currencies>(this, Currencies.PGK, code); 6604 if ("PHP".equals(codeString)) 6605 return new Enumeration<Currencies>(this, Currencies.PHP, code); 6606 if ("PKR".equals(codeString)) 6607 return new Enumeration<Currencies>(this, Currencies.PKR, code); 6608 if ("PLN".equals(codeString)) 6609 return new Enumeration<Currencies>(this, Currencies.PLN, code); 6610 if ("PYG".equals(codeString)) 6611 return new Enumeration<Currencies>(this, Currencies.PYG, code); 6612 if ("QAR".equals(codeString)) 6613 return new Enumeration<Currencies>(this, Currencies.QAR, code); 6614 if ("RON".equals(codeString)) 6615 return new Enumeration<Currencies>(this, Currencies.RON, code); 6616 if ("RSD".equals(codeString)) 6617 return new Enumeration<Currencies>(this, Currencies.RSD, code); 6618 if ("RUB".equals(codeString)) 6619 return new Enumeration<Currencies>(this, Currencies.RUB, code); 6620 if ("RWF".equals(codeString)) 6621 return new Enumeration<Currencies>(this, Currencies.RWF, code); 6622 if ("SAR".equals(codeString)) 6623 return new Enumeration<Currencies>(this, Currencies.SAR, code); 6624 if ("SBD".equals(codeString)) 6625 return new Enumeration<Currencies>(this, Currencies.SBD, code); 6626 if ("SCR".equals(codeString)) 6627 return new Enumeration<Currencies>(this, Currencies.SCR, code); 6628 if ("SDG".equals(codeString)) 6629 return new Enumeration<Currencies>(this, Currencies.SDG, code); 6630 if ("SEK".equals(codeString)) 6631 return new Enumeration<Currencies>(this, Currencies.SEK, code); 6632 if ("SGD".equals(codeString)) 6633 return new Enumeration<Currencies>(this, Currencies.SGD, code); 6634 if ("SHP".equals(codeString)) 6635 return new Enumeration<Currencies>(this, Currencies.SHP, code); 6636 if ("SLL".equals(codeString)) 6637 return new Enumeration<Currencies>(this, Currencies.SLL, code); 6638 if ("SOS".equals(codeString)) 6639 return new Enumeration<Currencies>(this, Currencies.SOS, code); 6640 if ("SRD".equals(codeString)) 6641 return new Enumeration<Currencies>(this, Currencies.SRD, code); 6642 if ("SSP".equals(codeString)) 6643 return new Enumeration<Currencies>(this, Currencies.SSP, code); 6644 if ("STN".equals(codeString)) 6645 return new Enumeration<Currencies>(this, Currencies.STN, code); 6646 if ("SVC".equals(codeString)) 6647 return new Enumeration<Currencies>(this, Currencies.SVC, code); 6648 if ("SYP".equals(codeString)) 6649 return new Enumeration<Currencies>(this, Currencies.SYP, code); 6650 if ("SZL".equals(codeString)) 6651 return new Enumeration<Currencies>(this, Currencies.SZL, code); 6652 if ("THB".equals(codeString)) 6653 return new Enumeration<Currencies>(this, Currencies.THB, code); 6654 if ("TJS".equals(codeString)) 6655 return new Enumeration<Currencies>(this, Currencies.TJS, code); 6656 if ("TMT".equals(codeString)) 6657 return new Enumeration<Currencies>(this, Currencies.TMT, code); 6658 if ("TND".equals(codeString)) 6659 return new Enumeration<Currencies>(this, Currencies.TND, code); 6660 if ("TOP".equals(codeString)) 6661 return new Enumeration<Currencies>(this, Currencies.TOP, code); 6662 if ("TRY".equals(codeString)) 6663 return new Enumeration<Currencies>(this, Currencies.TRY, code); 6664 if ("TTD".equals(codeString)) 6665 return new Enumeration<Currencies>(this, Currencies.TTD, code); 6666 if ("TVD".equals(codeString)) 6667 return new Enumeration<Currencies>(this, Currencies.TVD, code); 6668 if ("TWD".equals(codeString)) 6669 return new Enumeration<Currencies>(this, Currencies.TWD, code); 6670 if ("TZS".equals(codeString)) 6671 return new Enumeration<Currencies>(this, Currencies.TZS, code); 6672 if ("UAH".equals(codeString)) 6673 return new Enumeration<Currencies>(this, Currencies.UAH, code); 6674 if ("UGX".equals(codeString)) 6675 return new Enumeration<Currencies>(this, Currencies.UGX, code); 6676 if ("USD".equals(codeString)) 6677 return new Enumeration<Currencies>(this, Currencies.USD, code); 6678 if ("USN".equals(codeString)) 6679 return new Enumeration<Currencies>(this, Currencies.USN, code); 6680 if ("UYI".equals(codeString)) 6681 return new Enumeration<Currencies>(this, Currencies.UYI, code); 6682 if ("UYU".equals(codeString)) 6683 return new Enumeration<Currencies>(this, Currencies.UYU, code); 6684 if ("UZS".equals(codeString)) 6685 return new Enumeration<Currencies>(this, Currencies.UZS, code); 6686 if ("VEF".equals(codeString)) 6687 return new Enumeration<Currencies>(this, Currencies.VEF, code); 6688 if ("VND".equals(codeString)) 6689 return new Enumeration<Currencies>(this, Currencies.VND, code); 6690 if ("VUV".equals(codeString)) 6691 return new Enumeration<Currencies>(this, Currencies.VUV, code); 6692 if ("WST".equals(codeString)) 6693 return new Enumeration<Currencies>(this, Currencies.WST, code); 6694 if ("XAF".equals(codeString)) 6695 return new Enumeration<Currencies>(this, Currencies.XAF, code); 6696 if ("XAG".equals(codeString)) 6697 return new Enumeration<Currencies>(this, Currencies.XAG, code); 6698 if ("XAU".equals(codeString)) 6699 return new Enumeration<Currencies>(this, Currencies.XAU, code); 6700 if ("XBA".equals(codeString)) 6701 return new Enumeration<Currencies>(this, Currencies.XBA, code); 6702 if ("XBB".equals(codeString)) 6703 return new Enumeration<Currencies>(this, Currencies.XBB, code); 6704 if ("XBC".equals(codeString)) 6705 return new Enumeration<Currencies>(this, Currencies.XBC, code); 6706 if ("XBD".equals(codeString)) 6707 return new Enumeration<Currencies>(this, Currencies.XBD, code); 6708 if ("XCD".equals(codeString)) 6709 return new Enumeration<Currencies>(this, Currencies.XCD, code); 6710 if ("XDR".equals(codeString)) 6711 return new Enumeration<Currencies>(this, Currencies.XDR, code); 6712 if ("XOF".equals(codeString)) 6713 return new Enumeration<Currencies>(this, Currencies.XOF, code); 6714 if ("XPD".equals(codeString)) 6715 return new Enumeration<Currencies>(this, Currencies.XPD, code); 6716 if ("XPF".equals(codeString)) 6717 return new Enumeration<Currencies>(this, Currencies.XPF, code); 6718 if ("XPT".equals(codeString)) 6719 return new Enumeration<Currencies>(this, Currencies.XPT, code); 6720 if ("XSU".equals(codeString)) 6721 return new Enumeration<Currencies>(this, Currencies.XSU, code); 6722 if ("XTS".equals(codeString)) 6723 return new Enumeration<Currencies>(this, Currencies.XTS, code); 6724 if ("XUA".equals(codeString)) 6725 return new Enumeration<Currencies>(this, Currencies.XUA, code); 6726 if ("XXX".equals(codeString)) 6727 return new Enumeration<Currencies>(this, Currencies.XXX, code); 6728 if ("YER".equals(codeString)) 6729 return new Enumeration<Currencies>(this, Currencies.YER, code); 6730 if ("ZAR".equals(codeString)) 6731 return new Enumeration<Currencies>(this, Currencies.ZAR, code); 6732 if ("ZMW".equals(codeString)) 6733 return new Enumeration<Currencies>(this, Currencies.ZMW, code); 6734 if ("ZWL".equals(codeString)) 6735 return new Enumeration<Currencies>(this, Currencies.ZWL, code); 6736 throw new FHIRException("Unknown Currencies code '"+codeString+"'"); 6737 } 6738 public String toCode(Currencies code) { 6739 if (code == Currencies.AED) 6740 return "AED"; 6741 if (code == Currencies.AFN) 6742 return "AFN"; 6743 if (code == Currencies.ALL) 6744 return "ALL"; 6745 if (code == Currencies.AMD) 6746 return "AMD"; 6747 if (code == Currencies.ANG) 6748 return "ANG"; 6749 if (code == Currencies.AOA) 6750 return "AOA"; 6751 if (code == Currencies.ARS) 6752 return "ARS"; 6753 if (code == Currencies.AUD) 6754 return "AUD"; 6755 if (code == Currencies.AWG) 6756 return "AWG"; 6757 if (code == Currencies.AZN) 6758 return "AZN"; 6759 if (code == Currencies.BAM) 6760 return "BAM"; 6761 if (code == Currencies.BBD) 6762 return "BBD"; 6763 if (code == Currencies.BDT) 6764 return "BDT"; 6765 if (code == Currencies.BGN) 6766 return "BGN"; 6767 if (code == Currencies.BHD) 6768 return "BHD"; 6769 if (code == Currencies.BIF) 6770 return "BIF"; 6771 if (code == Currencies.BMD) 6772 return "BMD"; 6773 if (code == Currencies.BND) 6774 return "BND"; 6775 if (code == Currencies.BOB) 6776 return "BOB"; 6777 if (code == Currencies.BOV) 6778 return "BOV"; 6779 if (code == Currencies.BRL) 6780 return "BRL"; 6781 if (code == Currencies.BSD) 6782 return "BSD"; 6783 if (code == Currencies.BTN) 6784 return "BTN"; 6785 if (code == Currencies.BWP) 6786 return "BWP"; 6787 if (code == Currencies.BYN) 6788 return "BYN"; 6789 if (code == Currencies.BZD) 6790 return "BZD"; 6791 if (code == Currencies.CAD) 6792 return "CAD"; 6793 if (code == Currencies.CDF) 6794 return "CDF"; 6795 if (code == Currencies.CHE) 6796 return "CHE"; 6797 if (code == Currencies.CHF) 6798 return "CHF"; 6799 if (code == Currencies.CHW) 6800 return "CHW"; 6801 if (code == Currencies.CLF) 6802 return "CLF"; 6803 if (code == Currencies.CLP) 6804 return "CLP"; 6805 if (code == Currencies.CNY) 6806 return "CNY"; 6807 if (code == Currencies.COP) 6808 return "COP"; 6809 if (code == Currencies.COU) 6810 return "COU"; 6811 if (code == Currencies.CRC) 6812 return "CRC"; 6813 if (code == Currencies.CUC) 6814 return "CUC"; 6815 if (code == Currencies.CUP) 6816 return "CUP"; 6817 if (code == Currencies.CVE) 6818 return "CVE"; 6819 if (code == Currencies.CZK) 6820 return "CZK"; 6821 if (code == Currencies.DJF) 6822 return "DJF"; 6823 if (code == Currencies.DKK) 6824 return "DKK"; 6825 if (code == Currencies.DOP) 6826 return "DOP"; 6827 if (code == Currencies.DZD) 6828 return "DZD"; 6829 if (code == Currencies.EGP) 6830 return "EGP"; 6831 if (code == Currencies.ERN) 6832 return "ERN"; 6833 if (code == Currencies.ETB) 6834 return "ETB"; 6835 if (code == Currencies.EUR) 6836 return "EUR"; 6837 if (code == Currencies.FJD) 6838 return "FJD"; 6839 if (code == Currencies.FKP) 6840 return "FKP"; 6841 if (code == Currencies.GBP) 6842 return "GBP"; 6843 if (code == Currencies.GEL) 6844 return "GEL"; 6845 if (code == Currencies.GGP) 6846 return "GGP"; 6847 if (code == Currencies.GHS) 6848 return "GHS"; 6849 if (code == Currencies.GIP) 6850 return "GIP"; 6851 if (code == Currencies.GMD) 6852 return "GMD"; 6853 if (code == Currencies.GNF) 6854 return "GNF"; 6855 if (code == Currencies.GTQ) 6856 return "GTQ"; 6857 if (code == Currencies.GYD) 6858 return "GYD"; 6859 if (code == Currencies.HKD) 6860 return "HKD"; 6861 if (code == Currencies.HNL) 6862 return "HNL"; 6863 if (code == Currencies.HRK) 6864 return "HRK"; 6865 if (code == Currencies.HTG) 6866 return "HTG"; 6867 if (code == Currencies.HUF) 6868 return "HUF"; 6869 if (code == Currencies.IDR) 6870 return "IDR"; 6871 if (code == Currencies.ILS) 6872 return "ILS"; 6873 if (code == Currencies.IMP) 6874 return "IMP"; 6875 if (code == Currencies.INR) 6876 return "INR"; 6877 if (code == Currencies.IQD) 6878 return "IQD"; 6879 if (code == Currencies.IRR) 6880 return "IRR"; 6881 if (code == Currencies.ISK) 6882 return "ISK"; 6883 if (code == Currencies.JEP) 6884 return "JEP"; 6885 if (code == Currencies.JMD) 6886 return "JMD"; 6887 if (code == Currencies.JOD) 6888 return "JOD"; 6889 if (code == Currencies.JPY) 6890 return "JPY"; 6891 if (code == Currencies.KES) 6892 return "KES"; 6893 if (code == Currencies.KGS) 6894 return "KGS"; 6895 if (code == Currencies.KHR) 6896 return "KHR"; 6897 if (code == Currencies.KMF) 6898 return "KMF"; 6899 if (code == Currencies.KPW) 6900 return "KPW"; 6901 if (code == Currencies.KRW) 6902 return "KRW"; 6903 if (code == Currencies.KWD) 6904 return "KWD"; 6905 if (code == Currencies.KYD) 6906 return "KYD"; 6907 if (code == Currencies.KZT) 6908 return "KZT"; 6909 if (code == Currencies.LAK) 6910 return "LAK"; 6911 if (code == Currencies.LBP) 6912 return "LBP"; 6913 if (code == Currencies.LKR) 6914 return "LKR"; 6915 if (code == Currencies.LRD) 6916 return "LRD"; 6917 if (code == Currencies.LSL) 6918 return "LSL"; 6919 if (code == Currencies.LYD) 6920 return "LYD"; 6921 if (code == Currencies.MAD) 6922 return "MAD"; 6923 if (code == Currencies.MDL) 6924 return "MDL"; 6925 if (code == Currencies.MGA) 6926 return "MGA"; 6927 if (code == Currencies.MKD) 6928 return "MKD"; 6929 if (code == Currencies.MMK) 6930 return "MMK"; 6931 if (code == Currencies.MNT) 6932 return "MNT"; 6933 if (code == Currencies.MOP) 6934 return "MOP"; 6935 if (code == Currencies.MRU) 6936 return "MRU"; 6937 if (code == Currencies.MUR) 6938 return "MUR"; 6939 if (code == Currencies.MVR) 6940 return "MVR"; 6941 if (code == Currencies.MWK) 6942 return "MWK"; 6943 if (code == Currencies.MXN) 6944 return "MXN"; 6945 if (code == Currencies.MXV) 6946 return "MXV"; 6947 if (code == Currencies.MYR) 6948 return "MYR"; 6949 if (code == Currencies.MZN) 6950 return "MZN"; 6951 if (code == Currencies.NAD) 6952 return "NAD"; 6953 if (code == Currencies.NGN) 6954 return "NGN"; 6955 if (code == Currencies.NIO) 6956 return "NIO"; 6957 if (code == Currencies.NOK) 6958 return "NOK"; 6959 if (code == Currencies.NPR) 6960 return "NPR"; 6961 if (code == Currencies.NZD) 6962 return "NZD"; 6963 if (code == Currencies.OMR) 6964 return "OMR"; 6965 if (code == Currencies.PAB) 6966 return "PAB"; 6967 if (code == Currencies.PEN) 6968 return "PEN"; 6969 if (code == Currencies.PGK) 6970 return "PGK"; 6971 if (code == Currencies.PHP) 6972 return "PHP"; 6973 if (code == Currencies.PKR) 6974 return "PKR"; 6975 if (code == Currencies.PLN) 6976 return "PLN"; 6977 if (code == Currencies.PYG) 6978 return "PYG"; 6979 if (code == Currencies.QAR) 6980 return "QAR"; 6981 if (code == Currencies.RON) 6982 return "RON"; 6983 if (code == Currencies.RSD) 6984 return "RSD"; 6985 if (code == Currencies.RUB) 6986 return "RUB"; 6987 if (code == Currencies.RWF) 6988 return "RWF"; 6989 if (code == Currencies.SAR) 6990 return "SAR"; 6991 if (code == Currencies.SBD) 6992 return "SBD"; 6993 if (code == Currencies.SCR) 6994 return "SCR"; 6995 if (code == Currencies.SDG) 6996 return "SDG"; 6997 if (code == Currencies.SEK) 6998 return "SEK"; 6999 if (code == Currencies.SGD) 7000 return "SGD"; 7001 if (code == Currencies.SHP) 7002 return "SHP"; 7003 if (code == Currencies.SLL) 7004 return "SLL"; 7005 if (code == Currencies.SOS) 7006 return "SOS"; 7007 if (code == Currencies.SRD) 7008 return "SRD"; 7009 if (code == Currencies.SSP) 7010 return "SSP"; 7011 if (code == Currencies.STN) 7012 return "STN"; 7013 if (code == Currencies.SVC) 7014 return "SVC"; 7015 if (code == Currencies.SYP) 7016 return "SYP"; 7017 if (code == Currencies.SZL) 7018 return "SZL"; 7019 if (code == Currencies.THB) 7020 return "THB"; 7021 if (code == Currencies.TJS) 7022 return "TJS"; 7023 if (code == Currencies.TMT) 7024 return "TMT"; 7025 if (code == Currencies.TND) 7026 return "TND"; 7027 if (code == Currencies.TOP) 7028 return "TOP"; 7029 if (code == Currencies.TRY) 7030 return "TRY"; 7031 if (code == Currencies.TTD) 7032 return "TTD"; 7033 if (code == Currencies.TVD) 7034 return "TVD"; 7035 if (code == Currencies.TWD) 7036 return "TWD"; 7037 if (code == Currencies.TZS) 7038 return "TZS"; 7039 if (code == Currencies.UAH) 7040 return "UAH"; 7041 if (code == Currencies.UGX) 7042 return "UGX"; 7043 if (code == Currencies.USD) 7044 return "USD"; 7045 if (code == Currencies.USN) 7046 return "USN"; 7047 if (code == Currencies.UYI) 7048 return "UYI"; 7049 if (code == Currencies.UYU) 7050 return "UYU"; 7051 if (code == Currencies.UZS) 7052 return "UZS"; 7053 if (code == Currencies.VEF) 7054 return "VEF"; 7055 if (code == Currencies.VND) 7056 return "VND"; 7057 if (code == Currencies.VUV) 7058 return "VUV"; 7059 if (code == Currencies.WST) 7060 return "WST"; 7061 if (code == Currencies.XAF) 7062 return "XAF"; 7063 if (code == Currencies.XAG) 7064 return "XAG"; 7065 if (code == Currencies.XAU) 7066 return "XAU"; 7067 if (code == Currencies.XBA) 7068 return "XBA"; 7069 if (code == Currencies.XBB) 7070 return "XBB"; 7071 if (code == Currencies.XBC) 7072 return "XBC"; 7073 if (code == Currencies.XBD) 7074 return "XBD"; 7075 if (code == Currencies.XCD) 7076 return "XCD"; 7077 if (code == Currencies.XDR) 7078 return "XDR"; 7079 if (code == Currencies.XOF) 7080 return "XOF"; 7081 if (code == Currencies.XPD) 7082 return "XPD"; 7083 if (code == Currencies.XPF) 7084 return "XPF"; 7085 if (code == Currencies.XPT) 7086 return "XPT"; 7087 if (code == Currencies.XSU) 7088 return "XSU"; 7089 if (code == Currencies.XTS) 7090 return "XTS"; 7091 if (code == Currencies.XUA) 7092 return "XUA"; 7093 if (code == Currencies.XXX) 7094 return "XXX"; 7095 if (code == Currencies.YER) 7096 return "YER"; 7097 if (code == Currencies.ZAR) 7098 return "ZAR"; 7099 if (code == Currencies.ZMW) 7100 return "ZMW"; 7101 if (code == Currencies.ZWL) 7102 return "ZWL"; 7103 return "?"; 7104 } 7105 public String toSystem(Currencies code) { 7106 return code.getSystem(); 7107 } 7108 } 7109 7110 public enum DaysOfWeek { 7111 /** 7112 * Monday. 7113 */ 7114 MON, 7115 /** 7116 * Tuesday. 7117 */ 7118 TUE, 7119 /** 7120 * Wednesday. 7121 */ 7122 WED, 7123 /** 7124 * Thursday. 7125 */ 7126 THU, 7127 /** 7128 * Friday. 7129 */ 7130 FRI, 7131 /** 7132 * Saturday. 7133 */ 7134 SAT, 7135 /** 7136 * Sunday. 7137 */ 7138 SUN, 7139 /** 7140 * added to help the parsers 7141 */ 7142 NULL; 7143 public static DaysOfWeek fromCode(String codeString) throws FHIRException { 7144 if (codeString == null || "".equals(codeString)) 7145 return null; 7146 if ("mon".equals(codeString)) 7147 return MON; 7148 if ("tue".equals(codeString)) 7149 return TUE; 7150 if ("wed".equals(codeString)) 7151 return WED; 7152 if ("thu".equals(codeString)) 7153 return THU; 7154 if ("fri".equals(codeString)) 7155 return FRI; 7156 if ("sat".equals(codeString)) 7157 return SAT; 7158 if ("sun".equals(codeString)) 7159 return SUN; 7160 throw new FHIRException("Unknown DaysOfWeek code '"+codeString+"'"); 7161 } 7162 public static boolean isValidCode(String codeString) { 7163 if (codeString == null || "".equals(codeString)) 7164 return false; 7165 return Utilities.existsInList(codeString, "mon", "tue", "wed", "thu", "fri", "sat", "sun"); 7166 } 7167 public String toCode() { 7168 switch (this) { 7169 case MON: return "mon"; 7170 case TUE: return "tue"; 7171 case WED: return "wed"; 7172 case THU: return "thu"; 7173 case FRI: return "fri"; 7174 case SAT: return "sat"; 7175 case SUN: return "sun"; 7176 case NULL: return null; 7177 default: return "?"; 7178 } 7179 } 7180 public String getSystem() { 7181 switch (this) { 7182 case MON: return "http://hl7.org/fhir/days-of-week"; 7183 case TUE: return "http://hl7.org/fhir/days-of-week"; 7184 case WED: return "http://hl7.org/fhir/days-of-week"; 7185 case THU: return "http://hl7.org/fhir/days-of-week"; 7186 case FRI: return "http://hl7.org/fhir/days-of-week"; 7187 case SAT: return "http://hl7.org/fhir/days-of-week"; 7188 case SUN: return "http://hl7.org/fhir/days-of-week"; 7189 case NULL: return null; 7190 default: return "?"; 7191 } 7192 } 7193 public String getDefinition() { 7194 switch (this) { 7195 case MON: return "Monday."; 7196 case TUE: return "Tuesday."; 7197 case WED: return "Wednesday."; 7198 case THU: return "Thursday."; 7199 case FRI: return "Friday."; 7200 case SAT: return "Saturday."; 7201 case SUN: return "Sunday."; 7202 case NULL: return null; 7203 default: return "?"; 7204 } 7205 } 7206 public String getDisplay() { 7207 switch (this) { 7208 case MON: return "Monday"; 7209 case TUE: return "Tuesday"; 7210 case WED: return "Wednesday"; 7211 case THU: return "Thursday"; 7212 case FRI: return "Friday"; 7213 case SAT: return "Saturday"; 7214 case SUN: return "Sunday"; 7215 case NULL: return null; 7216 default: return "?"; 7217 } 7218 } 7219 } 7220 7221 public static class DaysOfWeekEnumFactory implements EnumFactory<DaysOfWeek> { 7222 public DaysOfWeek fromCode(String codeString) throws IllegalArgumentException { 7223 if (codeString == null || "".equals(codeString)) 7224 if (codeString == null || "".equals(codeString)) 7225 return null; 7226 if ("mon".equals(codeString)) 7227 return DaysOfWeek.MON; 7228 if ("tue".equals(codeString)) 7229 return DaysOfWeek.TUE; 7230 if ("wed".equals(codeString)) 7231 return DaysOfWeek.WED; 7232 if ("thu".equals(codeString)) 7233 return DaysOfWeek.THU; 7234 if ("fri".equals(codeString)) 7235 return DaysOfWeek.FRI; 7236 if ("sat".equals(codeString)) 7237 return DaysOfWeek.SAT; 7238 if ("sun".equals(codeString)) 7239 return DaysOfWeek.SUN; 7240 throw new IllegalArgumentException("Unknown DaysOfWeek code '"+codeString+"'"); 7241 } 7242 7243 public Enumeration<DaysOfWeek> fromType(PrimitiveType<?> code) throws FHIRException { 7244 if (code == null) 7245 return null; 7246 if (code.isEmpty()) 7247 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.NULL, code); 7248 String codeString = ((PrimitiveType) code).asStringValue(); 7249 if (codeString == null || "".equals(codeString)) 7250 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.NULL, code); 7251 if ("mon".equals(codeString)) 7252 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.MON, code); 7253 if ("tue".equals(codeString)) 7254 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.TUE, code); 7255 if ("wed".equals(codeString)) 7256 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.WED, code); 7257 if ("thu".equals(codeString)) 7258 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.THU, code); 7259 if ("fri".equals(codeString)) 7260 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.FRI, code); 7261 if ("sat".equals(codeString)) 7262 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.SAT, code); 7263 if ("sun".equals(codeString)) 7264 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.SUN, code); 7265 throw new FHIRException("Unknown DaysOfWeek code '"+codeString+"'"); 7266 } 7267 public String toCode(DaysOfWeek code) { 7268 if (code == DaysOfWeek.MON) 7269 return "mon"; 7270 if (code == DaysOfWeek.TUE) 7271 return "tue"; 7272 if (code == DaysOfWeek.WED) 7273 return "wed"; 7274 if (code == DaysOfWeek.THU) 7275 return "thu"; 7276 if (code == DaysOfWeek.FRI) 7277 return "fri"; 7278 if (code == DaysOfWeek.SAT) 7279 return "sat"; 7280 if (code == DaysOfWeek.SUN) 7281 return "sun"; 7282 return "?"; 7283 } 7284 public String toSystem(DaysOfWeek code) { 7285 return code.getSystem(); 7286 } 7287 } 7288 7289 public enum DeviceNameType { 7290 /** 7291 * 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. 7292 */ 7293 REGISTEREDNAME, 7294 /** 7295 * 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. 7296 */ 7297 USERFRIENDLYNAME, 7298 /** 7299 * 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. 7300 */ 7301 PATIENTREPORTEDNAME, 7302 /** 7303 * added to help the parsers 7304 */ 7305 NULL; 7306 public static DeviceNameType fromCode(String codeString) throws FHIRException { 7307 if (codeString == null || "".equals(codeString)) 7308 return null; 7309 if ("registered-name".equals(codeString)) 7310 return REGISTEREDNAME; 7311 if ("user-friendly-name".equals(codeString)) 7312 return USERFRIENDLYNAME; 7313 if ("patient-reported-name".equals(codeString)) 7314 return PATIENTREPORTEDNAME; 7315 throw new FHIRException("Unknown DeviceNameType code '"+codeString+"'"); 7316 } 7317 public static boolean isValidCode(String codeString) { 7318 if (codeString == null || "".equals(codeString)) 7319 return false; 7320 return Utilities.existsInList(codeString, "registered-name", "user-friendly-name", "patient-reported-name"); 7321 } 7322 public String toCode() { 7323 switch (this) { 7324 case REGISTEREDNAME: return "registered-name"; 7325 case USERFRIENDLYNAME: return "user-friendly-name"; 7326 case PATIENTREPORTEDNAME: return "patient-reported-name"; 7327 case NULL: return null; 7328 default: return "?"; 7329 } 7330 } 7331 public String getSystem() { 7332 switch (this) { 7333 case REGISTEREDNAME: return "http://hl7.org/fhir/device-nametype"; 7334 case USERFRIENDLYNAME: return "http://hl7.org/fhir/device-nametype"; 7335 case PATIENTREPORTEDNAME: return "http://hl7.org/fhir/device-nametype"; 7336 case NULL: return null; 7337 default: return "?"; 7338 } 7339 } 7340 public String getDefinition() { 7341 switch (this) { 7342 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."; 7343 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."; 7344 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."; 7345 case NULL: return null; 7346 default: return "?"; 7347 } 7348 } 7349 public String getDisplay() { 7350 switch (this) { 7351 case REGISTEREDNAME: return "Registered name"; 7352 case USERFRIENDLYNAME: return "User Friendly name"; 7353 case PATIENTREPORTEDNAME: return "Patient Reported name"; 7354 case NULL: return null; 7355 default: return "?"; 7356 } 7357 } 7358 } 7359 7360 public static class DeviceNameTypeEnumFactory implements EnumFactory<DeviceNameType> { 7361 public DeviceNameType fromCode(String codeString) throws IllegalArgumentException { 7362 if (codeString == null || "".equals(codeString)) 7363 if (codeString == null || "".equals(codeString)) 7364 return null; 7365 if ("registered-name".equals(codeString)) 7366 return DeviceNameType.REGISTEREDNAME; 7367 if ("user-friendly-name".equals(codeString)) 7368 return DeviceNameType.USERFRIENDLYNAME; 7369 if ("patient-reported-name".equals(codeString)) 7370 return DeviceNameType.PATIENTREPORTEDNAME; 7371 throw new IllegalArgumentException("Unknown DeviceNameType code '"+codeString+"'"); 7372 } 7373 7374 public Enumeration<DeviceNameType> fromType(PrimitiveType<?> code) throws FHIRException { 7375 if (code == null) 7376 return null; 7377 if (code.isEmpty()) 7378 return new Enumeration<DeviceNameType>(this, DeviceNameType.NULL, code); 7379 String codeString = ((PrimitiveType) code).asStringValue(); 7380 if (codeString == null || "".equals(codeString)) 7381 return new Enumeration<DeviceNameType>(this, DeviceNameType.NULL, code); 7382 if ("registered-name".equals(codeString)) 7383 return new Enumeration<DeviceNameType>(this, DeviceNameType.REGISTEREDNAME, code); 7384 if ("user-friendly-name".equals(codeString)) 7385 return new Enumeration<DeviceNameType>(this, DeviceNameType.USERFRIENDLYNAME, code); 7386 if ("patient-reported-name".equals(codeString)) 7387 return new Enumeration<DeviceNameType>(this, DeviceNameType.PATIENTREPORTEDNAME, code); 7388 throw new FHIRException("Unknown DeviceNameType code '"+codeString+"'"); 7389 } 7390 public String toCode(DeviceNameType code) { 7391 if (code == DeviceNameType.REGISTEREDNAME) 7392 return "registered-name"; 7393 if (code == DeviceNameType.USERFRIENDLYNAME) 7394 return "user-friendly-name"; 7395 if (code == DeviceNameType.PATIENTREPORTEDNAME) 7396 return "patient-reported-name"; 7397 return "?"; 7398 } 7399 public String toSystem(DeviceNameType code) { 7400 return code.getSystem(); 7401 } 7402 } 7403 7404 public enum EncounterStatus { 7405 /** 7406 * The Encounter has not yet started. 7407 */ 7408 PLANNED, 7409 /** 7410 * The Encounter has begun and the patient is present / the practitioner and the patient are meeting. 7411 */ 7412 INPROGRESS, 7413 /** 7414 * The Encounter has begun, but is currently on hold, e.g. because the patient is temporarily on leave. 7415 */ 7416 ONHOLD, 7417 /** 7418 * 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. 7419 */ 7420 DISCHARGED, 7421 /** 7422 * The Encounter has ended. 7423 */ 7424 COMPLETED, 7425 /** 7426 * The Encounter has ended before it has begun. 7427 */ 7428 CANCELLED, 7429 /** 7430 * 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. 7431 */ 7432 DISCONTINUED, 7433 /** 7434 * This instance should not have been part of this patient's medical record. 7435 */ 7436 ENTEREDINERROR, 7437 /** 7438 * 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". 7439 */ 7440 UNKNOWN, 7441 /** 7442 * added to help the parsers 7443 */ 7444 NULL; 7445 public static EncounterStatus fromCode(String codeString) throws FHIRException { 7446 if (codeString == null || "".equals(codeString)) 7447 return null; 7448 if ("planned".equals(codeString)) 7449 return PLANNED; 7450 if ("in-progress".equals(codeString)) 7451 return INPROGRESS; 7452 if ("on-hold".equals(codeString)) 7453 return ONHOLD; 7454 if ("discharged".equals(codeString)) 7455 return DISCHARGED; 7456 if ("completed".equals(codeString)) 7457 return COMPLETED; 7458 if ("cancelled".equals(codeString)) 7459 return CANCELLED; 7460 if ("discontinued".equals(codeString)) 7461 return DISCONTINUED; 7462 if ("entered-in-error".equals(codeString)) 7463 return ENTEREDINERROR; 7464 if ("unknown".equals(codeString)) 7465 return UNKNOWN; 7466 throw new FHIRException("Unknown EncounterStatus code '"+codeString+"'"); 7467 } 7468 public static boolean isValidCode(String codeString) { 7469 if (codeString == null || "".equals(codeString)) 7470 return false; 7471 return Utilities.existsInList(codeString, "planned", "in-progress", "on-hold", "discharged", "completed", "cancelled", "discontinued", "entered-in-error", "unknown"); 7472 } 7473 public String toCode() { 7474 switch (this) { 7475 case PLANNED: return "planned"; 7476 case INPROGRESS: return "in-progress"; 7477 case ONHOLD: return "on-hold"; 7478 case DISCHARGED: return "discharged"; 7479 case COMPLETED: return "completed"; 7480 case CANCELLED: return "cancelled"; 7481 case DISCONTINUED: return "discontinued"; 7482 case ENTEREDINERROR: return "entered-in-error"; 7483 case UNKNOWN: return "unknown"; 7484 case NULL: return null; 7485 default: return "?"; 7486 } 7487 } 7488 public String getSystem() { 7489 switch (this) { 7490 case PLANNED: return "http://hl7.org/fhir/encounter-status"; 7491 case INPROGRESS: return "http://hl7.org/fhir/encounter-status"; 7492 case ONHOLD: return "http://hl7.org/fhir/encounter-status"; 7493 case DISCHARGED: return "http://hl7.org/fhir/encounter-status"; 7494 case COMPLETED: return "http://hl7.org/fhir/encounter-status"; 7495 case CANCELLED: return "http://hl7.org/fhir/encounter-status"; 7496 case DISCONTINUED: return "http://hl7.org/fhir/encounter-status"; 7497 case ENTEREDINERROR: return "http://hl7.org/fhir/encounter-status"; 7498 case UNKNOWN: return "http://hl7.org/fhir/encounter-status"; 7499 case NULL: return null; 7500 default: return "?"; 7501 } 7502 } 7503 public String getDefinition() { 7504 switch (this) { 7505 case PLANNED: return "The Encounter has not yet started."; 7506 case INPROGRESS: return "The Encounter has begun and the patient is present / the practitioner and the patient are meeting."; 7507 case ONHOLD: return "The Encounter has begun, but is currently on hold, e.g. because the patient is temporarily on leave."; 7508 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."; 7509 case COMPLETED: return "The Encounter has ended."; 7510 case CANCELLED: return "The Encounter has ended before it has begun."; 7511 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."; 7512 case ENTEREDINERROR: return "This instance should not have been part of this patient's medical record."; 7513 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\"."; 7514 case NULL: return null; 7515 default: return "?"; 7516 } 7517 } 7518 public String getDisplay() { 7519 switch (this) { 7520 case PLANNED: return "Planned"; 7521 case INPROGRESS: return "In Progress"; 7522 case ONHOLD: return "On Hold"; 7523 case DISCHARGED: return "Discharged"; 7524 case COMPLETED: return "Completed"; 7525 case CANCELLED: return "Cancelled"; 7526 case DISCONTINUED: return "Discontinued"; 7527 case ENTEREDINERROR: return "Entered in Error"; 7528 case UNKNOWN: return "Unknown"; 7529 case NULL: return null; 7530 default: return "?"; 7531 } 7532 } 7533 } 7534 7535 public static class EncounterStatusEnumFactory implements EnumFactory<EncounterStatus> { 7536 public EncounterStatus fromCode(String codeString) throws IllegalArgumentException { 7537 if (codeString == null || "".equals(codeString)) 7538 if (codeString == null || "".equals(codeString)) 7539 return null; 7540 if ("planned".equals(codeString)) 7541 return EncounterStatus.PLANNED; 7542 if ("in-progress".equals(codeString)) 7543 return EncounterStatus.INPROGRESS; 7544 if ("on-hold".equals(codeString)) 7545 return EncounterStatus.ONHOLD; 7546 if ("discharged".equals(codeString)) 7547 return EncounterStatus.DISCHARGED; 7548 if ("completed".equals(codeString)) 7549 return EncounterStatus.COMPLETED; 7550 if ("cancelled".equals(codeString)) 7551 return EncounterStatus.CANCELLED; 7552 if ("discontinued".equals(codeString)) 7553 return EncounterStatus.DISCONTINUED; 7554 if ("entered-in-error".equals(codeString)) 7555 return EncounterStatus.ENTEREDINERROR; 7556 if ("unknown".equals(codeString)) 7557 return EncounterStatus.UNKNOWN; 7558 throw new IllegalArgumentException("Unknown EncounterStatus code '"+codeString+"'"); 7559 } 7560 7561 public Enumeration<EncounterStatus> fromType(PrimitiveType<?> code) throws FHIRException { 7562 if (code == null) 7563 return null; 7564 if (code.isEmpty()) 7565 return new Enumeration<EncounterStatus>(this, EncounterStatus.NULL, code); 7566 String codeString = ((PrimitiveType) code).asStringValue(); 7567 if (codeString == null || "".equals(codeString)) 7568 return new Enumeration<EncounterStatus>(this, EncounterStatus.NULL, code); 7569 if ("planned".equals(codeString)) 7570 return new Enumeration<EncounterStatus>(this, EncounterStatus.PLANNED, code); 7571 if ("in-progress".equals(codeString)) 7572 return new Enumeration<EncounterStatus>(this, EncounterStatus.INPROGRESS, code); 7573 if ("on-hold".equals(codeString)) 7574 return new Enumeration<EncounterStatus>(this, EncounterStatus.ONHOLD, code); 7575 if ("discharged".equals(codeString)) 7576 return new Enumeration<EncounterStatus>(this, EncounterStatus.DISCHARGED, code); 7577 if ("completed".equals(codeString)) 7578 return new Enumeration<EncounterStatus>(this, EncounterStatus.COMPLETED, code); 7579 if ("cancelled".equals(codeString)) 7580 return new Enumeration<EncounterStatus>(this, EncounterStatus.CANCELLED, code); 7581 if ("discontinued".equals(codeString)) 7582 return new Enumeration<EncounterStatus>(this, EncounterStatus.DISCONTINUED, code); 7583 if ("entered-in-error".equals(codeString)) 7584 return new Enumeration<EncounterStatus>(this, EncounterStatus.ENTEREDINERROR, code); 7585 if ("unknown".equals(codeString)) 7586 return new Enumeration<EncounterStatus>(this, EncounterStatus.UNKNOWN, code); 7587 throw new FHIRException("Unknown EncounterStatus code '"+codeString+"'"); 7588 } 7589 public String toCode(EncounterStatus code) { 7590 if (code == EncounterStatus.PLANNED) 7591 return "planned"; 7592 if (code == EncounterStatus.INPROGRESS) 7593 return "in-progress"; 7594 if (code == EncounterStatus.ONHOLD) 7595 return "on-hold"; 7596 if (code == EncounterStatus.DISCHARGED) 7597 return "discharged"; 7598 if (code == EncounterStatus.COMPLETED) 7599 return "completed"; 7600 if (code == EncounterStatus.CANCELLED) 7601 return "cancelled"; 7602 if (code == EncounterStatus.DISCONTINUED) 7603 return "discontinued"; 7604 if (code == EncounterStatus.ENTEREDINERROR) 7605 return "entered-in-error"; 7606 if (code == EncounterStatus.UNKNOWN) 7607 return "unknown"; 7608 return "?"; 7609 } 7610 public String toSystem(EncounterStatus code) { 7611 return code.getSystem(); 7612 } 7613 } 7614 7615 public enum EventStatus { 7616 /** 7617 * 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. 7618 */ 7619 PREPARATION, 7620 /** 7621 * The event is currently occurring. 7622 */ 7623 INPROGRESS, 7624 /** 7625 * 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. 7626 */ 7627 NOTDONE, 7628 /** 7629 * The event has been temporarily stopped but is expected to resume in the future. 7630 */ 7631 ONHOLD, 7632 /** 7633 * 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. 7634 */ 7635 STOPPED, 7636 /** 7637 * The event has now concluded. 7638 */ 7639 COMPLETED, 7640 /** 7641 * 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".). 7642 */ 7643 ENTEREDINERROR, 7644 /** 7645 * 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. 7646 */ 7647 UNKNOWN, 7648 /** 7649 * added to help the parsers 7650 */ 7651 NULL; 7652 public static EventStatus fromCode(String codeString) throws FHIRException { 7653 if (codeString == null || "".equals(codeString)) 7654 return null; 7655 if ("preparation".equals(codeString)) 7656 return PREPARATION; 7657 if ("in-progress".equals(codeString)) 7658 return INPROGRESS; 7659 if ("not-done".equals(codeString)) 7660 return NOTDONE; 7661 if ("on-hold".equals(codeString)) 7662 return ONHOLD; 7663 if ("stopped".equals(codeString)) 7664 return STOPPED; 7665 if ("completed".equals(codeString)) 7666 return COMPLETED; 7667 if ("entered-in-error".equals(codeString)) 7668 return ENTEREDINERROR; 7669 if ("unknown".equals(codeString)) 7670 return UNKNOWN; 7671 throw new FHIRException("Unknown EventStatus code '"+codeString+"'"); 7672 } 7673 public static boolean isValidCode(String codeString) { 7674 if (codeString == null || "".equals(codeString)) 7675 return false; 7676 return Utilities.existsInList(codeString, "preparation", "in-progress", "not-done", "on-hold", "stopped", "completed", "entered-in-error", "unknown"); 7677 } 7678 public String toCode() { 7679 switch (this) { 7680 case PREPARATION: return "preparation"; 7681 case INPROGRESS: return "in-progress"; 7682 case NOTDONE: return "not-done"; 7683 case ONHOLD: return "on-hold"; 7684 case STOPPED: return "stopped"; 7685 case COMPLETED: return "completed"; 7686 case ENTEREDINERROR: return "entered-in-error"; 7687 case UNKNOWN: return "unknown"; 7688 case NULL: return null; 7689 default: return "?"; 7690 } 7691 } 7692 public String getSystem() { 7693 switch (this) { 7694 case PREPARATION: return "http://hl7.org/fhir/event-status"; 7695 case INPROGRESS: return "http://hl7.org/fhir/event-status"; 7696 case NOTDONE: return "http://hl7.org/fhir/event-status"; 7697 case ONHOLD: return "http://hl7.org/fhir/event-status"; 7698 case STOPPED: return "http://hl7.org/fhir/event-status"; 7699 case COMPLETED: return "http://hl7.org/fhir/event-status"; 7700 case ENTEREDINERROR: return "http://hl7.org/fhir/event-status"; 7701 case UNKNOWN: return "http://hl7.org/fhir/event-status"; 7702 case NULL: return null; 7703 default: return "?"; 7704 } 7705 } 7706 public String getDefinition() { 7707 switch (this) { 7708 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."; 7709 case INPROGRESS: return "The event is currently occurring."; 7710 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."; 7711 case ONHOLD: return "The event has been temporarily stopped but is expected to resume in the future."; 7712 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."; 7713 case COMPLETED: return "The event has now concluded."; 7714 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\".)."; 7715 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."; 7716 case NULL: return null; 7717 default: return "?"; 7718 } 7719 } 7720 public String getDisplay() { 7721 switch (this) { 7722 case PREPARATION: return "Preparation"; 7723 case INPROGRESS: return "In Progress"; 7724 case NOTDONE: return "Not Done"; 7725 case ONHOLD: return "On Hold"; 7726 case STOPPED: return "Stopped"; 7727 case COMPLETED: return "Completed"; 7728 case ENTEREDINERROR: return "Entered in Error"; 7729 case UNKNOWN: return "Unknown"; 7730 case NULL: return null; 7731 default: return "?"; 7732 } 7733 } 7734 } 7735 7736 public static class EventStatusEnumFactory implements EnumFactory<EventStatus> { 7737 public EventStatus fromCode(String codeString) throws IllegalArgumentException { 7738 if (codeString == null || "".equals(codeString)) 7739 if (codeString == null || "".equals(codeString)) 7740 return null; 7741 if ("preparation".equals(codeString)) 7742 return EventStatus.PREPARATION; 7743 if ("in-progress".equals(codeString)) 7744 return EventStatus.INPROGRESS; 7745 if ("not-done".equals(codeString)) 7746 return EventStatus.NOTDONE; 7747 if ("on-hold".equals(codeString)) 7748 return EventStatus.ONHOLD; 7749 if ("stopped".equals(codeString)) 7750 return EventStatus.STOPPED; 7751 if ("completed".equals(codeString)) 7752 return EventStatus.COMPLETED; 7753 if ("entered-in-error".equals(codeString)) 7754 return EventStatus.ENTEREDINERROR; 7755 if ("unknown".equals(codeString)) 7756 return EventStatus.UNKNOWN; 7757 throw new IllegalArgumentException("Unknown EventStatus code '"+codeString+"'"); 7758 } 7759 7760 public Enumeration<EventStatus> fromType(PrimitiveType<?> code) throws FHIRException { 7761 if (code == null) 7762 return null; 7763 if (code.isEmpty()) 7764 return new Enumeration<EventStatus>(this, EventStatus.NULL, code); 7765 String codeString = ((PrimitiveType) code).asStringValue(); 7766 if (codeString == null || "".equals(codeString)) 7767 return new Enumeration<EventStatus>(this, EventStatus.NULL, code); 7768 if ("preparation".equals(codeString)) 7769 return new Enumeration<EventStatus>(this, EventStatus.PREPARATION, code); 7770 if ("in-progress".equals(codeString)) 7771 return new Enumeration<EventStatus>(this, EventStatus.INPROGRESS, code); 7772 if ("not-done".equals(codeString)) 7773 return new Enumeration<EventStatus>(this, EventStatus.NOTDONE, code); 7774 if ("on-hold".equals(codeString)) 7775 return new Enumeration<EventStatus>(this, EventStatus.ONHOLD, code); 7776 if ("stopped".equals(codeString)) 7777 return new Enumeration<EventStatus>(this, EventStatus.STOPPED, code); 7778 if ("completed".equals(codeString)) 7779 return new Enumeration<EventStatus>(this, EventStatus.COMPLETED, code); 7780 if ("entered-in-error".equals(codeString)) 7781 return new Enumeration<EventStatus>(this, EventStatus.ENTEREDINERROR, code); 7782 if ("unknown".equals(codeString)) 7783 return new Enumeration<EventStatus>(this, EventStatus.UNKNOWN, code); 7784 throw new FHIRException("Unknown EventStatus code '"+codeString+"'"); 7785 } 7786 public String toCode(EventStatus code) { 7787 if (code == EventStatus.PREPARATION) 7788 return "preparation"; 7789 if (code == EventStatus.INPROGRESS) 7790 return "in-progress"; 7791 if (code == EventStatus.NOTDONE) 7792 return "not-done"; 7793 if (code == EventStatus.ONHOLD) 7794 return "on-hold"; 7795 if (code == EventStatus.STOPPED) 7796 return "stopped"; 7797 if (code == EventStatus.COMPLETED) 7798 return "completed"; 7799 if (code == EventStatus.ENTEREDINERROR) 7800 return "entered-in-error"; 7801 if (code == EventStatus.UNKNOWN) 7802 return "unknown"; 7803 return "?"; 7804 } 7805 public String toSystem(EventStatus code) { 7806 return code.getSystem(); 7807 } 7808 } 7809 7810 public enum EvidenceVariableHandling { 7811 /** 7812 * 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). 7813 */ 7814 CONTINUOUS, 7815 /** 7816 * 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). 7817 */ 7818 DICHOTOMOUS, 7819 /** 7820 * 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). 7821 */ 7822 ORDINAL, 7823 /** 7824 * 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. 7825 */ 7826 POLYCHOTOMOUS, 7827 /** 7828 * added to help the parsers 7829 */ 7830 NULL; 7831 public static EvidenceVariableHandling fromCode(String codeString) throws FHIRException { 7832 if (codeString == null || "".equals(codeString)) 7833 return null; 7834 if ("continuous".equals(codeString)) 7835 return CONTINUOUS; 7836 if ("dichotomous".equals(codeString)) 7837 return DICHOTOMOUS; 7838 if ("ordinal".equals(codeString)) 7839 return ORDINAL; 7840 if ("polychotomous".equals(codeString)) 7841 return POLYCHOTOMOUS; 7842 throw new FHIRException("Unknown EvidenceVariableHandling code '"+codeString+"'"); 7843 } 7844 public static boolean isValidCode(String codeString) { 7845 if (codeString == null || "".equals(codeString)) 7846 return false; 7847 return Utilities.existsInList(codeString, "continuous", "dichotomous", "ordinal", "polychotomous"); 7848 } 7849 public String toCode() { 7850 switch (this) { 7851 case CONTINUOUS: return "continuous"; 7852 case DICHOTOMOUS: return "dichotomous"; 7853 case ORDINAL: return "ordinal"; 7854 case POLYCHOTOMOUS: return "polychotomous"; 7855 case NULL: return null; 7856 default: return "?"; 7857 } 7858 } 7859 public String getSystem() { 7860 switch (this) { 7861 case CONTINUOUS: return "http://hl7.org/fhir/variable-handling"; 7862 case DICHOTOMOUS: return "http://hl7.org/fhir/variable-handling"; 7863 case ORDINAL: return "http://hl7.org/fhir/variable-handling"; 7864 case POLYCHOTOMOUS: return "http://hl7.org/fhir/variable-handling"; 7865 case NULL: return null; 7866 default: return "?"; 7867 } 7868 } 7869 public String getDefinition() { 7870 switch (this) { 7871 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)."; 7872 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)."; 7873 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)."; 7874 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."; 7875 case NULL: return null; 7876 default: return "?"; 7877 } 7878 } 7879 public String getDisplay() { 7880 switch (this) { 7881 case CONTINUOUS: return "continuous variable"; 7882 case DICHOTOMOUS: return "dichotomous variable"; 7883 case ORDINAL: return "ordinal variable"; 7884 case POLYCHOTOMOUS: return "polychotomous variable"; 7885 case NULL: return null; 7886 default: return "?"; 7887 } 7888 } 7889 } 7890 7891 public static class EvidenceVariableHandlingEnumFactory implements EnumFactory<EvidenceVariableHandling> { 7892 public EvidenceVariableHandling fromCode(String codeString) throws IllegalArgumentException { 7893 if (codeString == null || "".equals(codeString)) 7894 if (codeString == null || "".equals(codeString)) 7895 return null; 7896 if ("continuous".equals(codeString)) 7897 return EvidenceVariableHandling.CONTINUOUS; 7898 if ("dichotomous".equals(codeString)) 7899 return EvidenceVariableHandling.DICHOTOMOUS; 7900 if ("ordinal".equals(codeString)) 7901 return EvidenceVariableHandling.ORDINAL; 7902 if ("polychotomous".equals(codeString)) 7903 return EvidenceVariableHandling.POLYCHOTOMOUS; 7904 throw new IllegalArgumentException("Unknown EvidenceVariableHandling code '"+codeString+"'"); 7905 } 7906 7907 public Enumeration<EvidenceVariableHandling> fromType(PrimitiveType<?> code) throws FHIRException { 7908 if (code == null) 7909 return null; 7910 if (code.isEmpty()) 7911 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.NULL, code); 7912 String codeString = ((PrimitiveType) code).asStringValue(); 7913 if (codeString == null || "".equals(codeString)) 7914 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.NULL, code); 7915 if ("continuous".equals(codeString)) 7916 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.CONTINUOUS, code); 7917 if ("dichotomous".equals(codeString)) 7918 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.DICHOTOMOUS, code); 7919 if ("ordinal".equals(codeString)) 7920 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.ORDINAL, code); 7921 if ("polychotomous".equals(codeString)) 7922 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.POLYCHOTOMOUS, code); 7923 throw new FHIRException("Unknown EvidenceVariableHandling code '"+codeString+"'"); 7924 } 7925 public String toCode(EvidenceVariableHandling code) { 7926 if (code == EvidenceVariableHandling.CONTINUOUS) 7927 return "continuous"; 7928 if (code == EvidenceVariableHandling.DICHOTOMOUS) 7929 return "dichotomous"; 7930 if (code == EvidenceVariableHandling.ORDINAL) 7931 return "ordinal"; 7932 if (code == EvidenceVariableHandling.POLYCHOTOMOUS) 7933 return "polychotomous"; 7934 return "?"; 7935 } 7936 public String toSystem(EvidenceVariableHandling code) { 7937 return code.getSystem(); 7938 } 7939 } 7940 7941 public enum ExampleScenarioActorType { 7942 /** 7943 * A human actor 7944 */ 7945 PERSON, 7946 /** 7947 * A software application or other system 7948 */ 7949 SYSTEM, 7950 /** 7951 * added to help the parsers 7952 */ 7953 NULL; 7954 public static ExampleScenarioActorType fromCode(String codeString) throws FHIRException { 7955 if (codeString == null || "".equals(codeString)) 7956 return null; 7957 if ("person".equals(codeString)) 7958 return PERSON; 7959 if ("system".equals(codeString)) 7960 return SYSTEM; 7961 throw new FHIRException("Unknown ExampleScenarioActorType code '"+codeString+"'"); 7962 } 7963 public static boolean isValidCode(String codeString) { 7964 if (codeString == null || "".equals(codeString)) 7965 return false; 7966 return Utilities.existsInList(codeString, "person", "system"); 7967 } 7968 public String toCode() { 7969 switch (this) { 7970 case PERSON: return "person"; 7971 case SYSTEM: return "system"; 7972 case NULL: return null; 7973 default: return "?"; 7974 } 7975 } 7976 public String getSystem() { 7977 switch (this) { 7978 case PERSON: return "http://hl7.org/fhir/examplescenario-actor-type"; 7979 case SYSTEM: return "http://hl7.org/fhir/examplescenario-actor-type"; 7980 case NULL: return null; 7981 default: return "?"; 7982 } 7983 } 7984 public String getDefinition() { 7985 switch (this) { 7986 case PERSON: return "A human actor"; 7987 case SYSTEM: return "A software application or other system"; 7988 case NULL: return null; 7989 default: return "?"; 7990 } 7991 } 7992 public String getDisplay() { 7993 switch (this) { 7994 case PERSON: return "Person"; 7995 case SYSTEM: return "System"; 7996 case NULL: return null; 7997 default: return "?"; 7998 } 7999 } 8000 } 8001 8002 public static class ExampleScenarioActorTypeEnumFactory implements EnumFactory<ExampleScenarioActorType> { 8003 public ExampleScenarioActorType fromCode(String codeString) throws IllegalArgumentException { 8004 if (codeString == null || "".equals(codeString)) 8005 if (codeString == null || "".equals(codeString)) 8006 return null; 8007 if ("person".equals(codeString)) 8008 return ExampleScenarioActorType.PERSON; 8009 if ("system".equals(codeString)) 8010 return ExampleScenarioActorType.SYSTEM; 8011 throw new IllegalArgumentException("Unknown ExampleScenarioActorType code '"+codeString+"'"); 8012 } 8013 8014 public Enumeration<ExampleScenarioActorType> fromType(PrimitiveType<?> code) throws FHIRException { 8015 if (code == null) 8016 return null; 8017 if (code.isEmpty()) 8018 return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.NULL, code); 8019 String codeString = ((PrimitiveType) code).asStringValue(); 8020 if (codeString == null || "".equals(codeString)) 8021 return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.NULL, code); 8022 if ("person".equals(codeString)) 8023 return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.PERSON, code); 8024 if ("system".equals(codeString)) 8025 return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.SYSTEM, code); 8026 throw new FHIRException("Unknown ExampleScenarioActorType code '"+codeString+"'"); 8027 } 8028 public String toCode(ExampleScenarioActorType code) { 8029 if (code == ExampleScenarioActorType.PERSON) 8030 return "person"; 8031 if (code == ExampleScenarioActorType.SYSTEM) 8032 return "system"; 8033 return "?"; 8034 } 8035 public String toSystem(ExampleScenarioActorType code) { 8036 return code.getSystem(); 8037 } 8038 } 8039 8040 public enum FHIRTypes { 8041 /** 8042 * Base Type: Base definition for all types defined in FHIR type system. 8043 */ 8044 BASE, 8045 /** 8046 * Element Type: Base definition for all elements in a resource. 8047 */ 8048 ELEMENT, 8049 /** 8050 * BackboneElement Type: Base definition for all elements that are defined inside a resource - but not those in a data type. 8051 */ 8052 BACKBONEELEMENT, 8053 /** 8054 * DataType Type: The base class for all re-useable types defined as part of the FHIR Specification. 8055 */ 8056 DATATYPE, 8057 /** 8058 * 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. 8059The ISO21090-codedString may be used to provide a coded representation of the contents of strings in an Address. 8060 */ 8061 ADDRESS, 8062 /** 8063 * Annotation Type: A text note which also contains information about who made the statement and when. 8064 */ 8065 ANNOTATION, 8066 /** 8067 * Attachment Type: For referring to data content defined in other formats. 8068 */ 8069 ATTACHMENT, 8070 /** 8071 * Availability Type: Availability data for an {item}. 8072 */ 8073 AVAILABILITY, 8074 /** 8075 * BackboneType Type: Base definition for the few data types that are allowed to carry modifier extensions. 8076 */ 8077 BACKBONETYPE, 8078 /** 8079 * Dosage Type: Indicates how the medication is/was taken or should be taken by the patient. 8080 */ 8081 DOSAGE, 8082 /** 8083 * ElementDefinition Type: Captures constraints on each element within the resource, profile, or extension. 8084 */ 8085 ELEMENTDEFINITION, 8086 /** 8087 * 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. 8088 */ 8089 MARKETINGSTATUS, 8090 /** 8091 * ProductShelfLife Type: The shelf-life and storage information for a medicinal product item or container can be described using this class. 8092 */ 8093 PRODUCTSHELFLIFE, 8094 /** 8095 * 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. 8096 */ 8097 TIMING, 8098 /** 8099 * CodeableConcept Type: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text. 8100 */ 8101 CODEABLECONCEPT, 8102 /** 8103 * CodeableReference Type: A reference to a resource (by instance), or instead, a reference to a concept defined in a terminology or ontology (by class). 8104 */ 8105 CODEABLEREFERENCE, 8106 /** 8107 * Coding Type: A reference to a code defined by a terminology system. 8108 */ 8109 CODING, 8110 /** 8111 * ContactDetail Type: Specifies contact information for a person or organization. 8112 */ 8113 CONTACTDETAIL, 8114 /** 8115 * ContactPoint Type: Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc. 8116 */ 8117 CONTACTPOINT, 8118 /** 8119 * Contributor Type: A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers. 8120 */ 8121 CONTRIBUTOR, 8122 /** 8123 * 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. 8124 */ 8125 DATAREQUIREMENT, 8126 /** 8127 * 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. 8128 */ 8129 EXPRESSION, 8130 /** 8131 * 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. 8132 */ 8133 EXTENDEDCONTACTDETAIL, 8134 /** 8135 * Extension Type: Optional Extension Element - found in all resources. 8136 */ 8137 EXTENSION, 8138 /** 8139 * 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. 8140 */ 8141 HUMANNAME, 8142 /** 8143 * Identifier Type: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers. 8144 */ 8145 IDENTIFIER, 8146 /** 8147 * 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. 8148 */ 8149 META, 8150 /** 8151 * MonetaryComponent Type: Availability data for an {item}. 8152 */ 8153 MONETARYCOMPONENT, 8154 /** 8155 * Money Type: An amount of economic utility in some recognized currency. 8156 */ 8157 MONEY, 8158 /** 8159 * Narrative Type: A human-readable summary of the resource conveying the essential clinical and business information for the resource. 8160 */ 8161 NARRATIVE, 8162 /** 8163 * 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. 8164 */ 8165 PARAMETERDEFINITION, 8166 /** 8167 * Period Type: A time period defined by a start and end date and optionally time. 8168 */ 8169 PERIOD, 8170 /** 8171 * PrimitiveType Type: The base type for all re-useable types defined that have a simple property. 8172 */ 8173 PRIMITIVETYPE, 8174 /** 8175 * base64Binary Type: A stream of bytes 8176 */ 8177 BASE64BINARY, 8178 /** 8179 * boolean Type: Value of "true" or "false" 8180 */ 8181 BOOLEAN, 8182 /** 8183 * 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. 8184 */ 8185 DATE, 8186 /** 8187 * 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. 8188 */ 8189 DATETIME, 8190 /** 8191 * decimal Type: A rational number with implicit precision 8192 */ 8193 DECIMAL, 8194 /** 8195 * instant Type: An instant in time - known at least to the second 8196 */ 8197 INSTANT, 8198 /** 8199 * integer Type: A whole number 8200 */ 8201 INTEGER, 8202 /** 8203 * positiveInt type: An integer with a value that is positive (e.g. >0) 8204 */ 8205 POSITIVEINT, 8206 /** 8207 * unsignedInt type: An integer with a value that is not negative (e.g. >= 0) 8208 */ 8209 UNSIGNEDINT, 8210 /** 8211 * integer64 Type: A very large whole number 8212 */ 8213 INTEGER64, 8214 /** 8215 * string Type: A sequence of Unicode characters 8216 */ 8217 STRING, 8218 /** 8219 * 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 8220 */ 8221 CODE, 8222 /** 8223 * 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. 8224 */ 8225 ID, 8226 /** 8227 * markdown type: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine 8228 */ 8229 MARKDOWN, 8230 /** 8231 * time Type: A time during the day, with no date specified 8232 */ 8233 TIME, 8234 /** 8235 * uri Type: String of characters used to identify a name or a resource 8236 */ 8237 URI, 8238 /** 8239 * canonical type: A URI that is a reference to a canonical URL on a FHIR resource 8240 */ 8241 CANONICAL, 8242 /** 8243 * oid type: An OID represented as a URI 8244 */ 8245 OID, 8246 /** 8247 * url type: A URI that is a literal reference 8248 */ 8249 URL, 8250 /** 8251 * uuid type: A UUID, represented as a URI 8252 */ 8253 UUID, 8254 /** 8255 * 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. 8256 */ 8257 QUANTITY, 8258 /** 8259 * Age Type: A duration of time during which an organism (or a process) has existed. 8260 */ 8261 AGE, 8262 /** 8263 * 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. 8264 */ 8265 COUNT, 8266 /** 8267 * Distance Type: A length - a value with a unit that is a physical distance. 8268 */ 8269 DISTANCE, 8270 /** 8271 * Duration Type: A length of time. 8272 */ 8273 DURATION, 8274 /** 8275 * Range Type: A set of ordered Quantities defined by a low and high limit. 8276 */ 8277 RANGE, 8278 /** 8279 * Ratio Type: A relationship of two Quantity values - expressed as a numerator and a denominator. 8280 */ 8281 RATIO, 8282 /** 8283 * RatioRange Type: A range of ratios expressed as a low and high numerator and a denominator. 8284 */ 8285 RATIORANGE, 8286 /** 8287 * Reference Type: A reference from one resource to another. 8288 */ 8289 REFERENCE, 8290 /** 8291 * RelatedArtifact Type: Related artifacts such as additional documentation, justification, or bibliographic references. 8292 */ 8293 RELATEDARTIFACT, 8294 /** 8295 * 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. 8296 */ 8297 SAMPLEDDATA, 8298 /** 8299 * 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. 8300 */ 8301 SIGNATURE, 8302 /** 8303 * TriggerDefinition Type: A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element. 8304 */ 8305 TRIGGERDEFINITION, 8306 /** 8307 * 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). 8308 */ 8309 USAGECONTEXT, 8310 /** 8311 * VirtualServiceDetail Type: Virtual Service Contact Details. 8312 */ 8313 VIRTUALSERVICEDETAIL, 8314 /** 8315 * xhtml Type definition 8316 */ 8317 XHTML, 8318 /** 8319 * This is the base resource type for everything. 8320 */ 8321 RESOURCE, 8322 /** 8323 * 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. 8324 */ 8325 BINARY, 8326 /** 8327 * A container for a collection of resources. 8328 */ 8329 BUNDLE, 8330 /** 8331 * A resource that includes narrative, extensions, and contained resources. 8332 */ 8333 DOMAINRESOURCE, 8334 /** 8335 * 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. 8336 */ 8337 ACCOUNT, 8338 /** 8339 * This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context. 8340 */ 8341 ACTIVITYDEFINITION, 8342 /** 8343 * 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. 8344 */ 8345 ACTORDEFINITION, 8346 /** 8347 * 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). 8348 */ 8349 ADMINISTRABLEPRODUCTDEFINITION, 8350 /** 8351 * 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. 8352 */ 8353 ADVERSEEVENT, 8354 /** 8355 * Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance. 8356 */ 8357 ALLERGYINTOLERANCE, 8358 /** 8359 * 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). 8360 */ 8361 APPOINTMENT, 8362 /** 8363 * A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection. 8364 */ 8365 APPOINTMENTRESPONSE, 8366 /** 8367 * This Resource provides one or more comments, classifiers or ratings about a Resource and supports attribution and rights management metadata for the added content. 8368 */ 8369 ARTIFACTASSESSMENT, 8370 /** 8371 * A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis. 8372 */ 8373 AUDITEVENT, 8374 /** 8375 * 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. 8376 */ 8377 BASIC, 8378 /** 8379 * A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity. 8380 */ 8381 BIOLOGICALLYDERIVEDPRODUCT, 8382 /** 8383 * A record of dispensation of a biologically derived product. 8384 */ 8385 BIOLOGICALLYDERIVEDPRODUCTDISPENSE, 8386 /** 8387 * 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. 8388 */ 8389 BODYSTRUCTURE, 8390 /** 8391 * Common Interface declaration for conformance and knowledge artifact resources. 8392 */ 8393 CANONICALRESOURCE, 8394 /** 8395 * 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. 8396 */ 8397 CAPABILITYSTATEMENT, 8398 /** 8399 * 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. 8400 */ 8401 CAREPLAN, 8402 /** 8403 * The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care. 8404 */ 8405 CARETEAM, 8406 /** 8407 * 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. 8408 */ 8409 CHARGEITEM, 8410 /** 8411 * 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. 8412 */ 8413 CHARGEITEMDEFINITION, 8414 /** 8415 * 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. 8416 */ 8417 CITATION, 8418 /** 8419 * 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. 8420 */ 8421 CLAIM, 8422 /** 8423 * This resource provides the adjudication details from the processing of a Claim resource. 8424 */ 8425 CLAIMRESPONSE, 8426 /** 8427 * 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. 8428 */ 8429 CLINICALIMPRESSION, 8430 /** 8431 * A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure. 8432 */ 8433 CLINICALUSEDEFINITION, 8434 /** 8435 * 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. 8436 */ 8437 CODESYSTEM, 8438 /** 8439 * 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. 8440 */ 8441 COMMUNICATION, 8442 /** 8443 * 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. 8444 */ 8445 COMMUNICATIONREQUEST, 8446 /** 8447 * A compartment definition that defines how resources are accessed on a server. 8448 */ 8449 COMPARTMENTDEFINITION, 8450 /** 8451 * 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.). 8452 */ 8453 COMPOSITION, 8454 /** 8455 * 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. 8456 */ 8457 CONCEPTMAP, 8458 /** 8459 * A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern. 8460 */ 8461 CONDITION, 8462 /** 8463 * A definition of a condition and information relevant to managing it. 8464 */ 8465 CONDITIONDEFINITION, 8466 /** 8467 * 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. 8468 */ 8469 CONSENT, 8470 /** 8471 * Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement. 8472 */ 8473 CONTRACT, 8474 /** 8475 * Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment. 8476 */ 8477 COVERAGE, 8478 /** 8479 * 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. 8480 */ 8481 COVERAGEELIGIBILITYREQUEST, 8482 /** 8483 * This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource. 8484 */ 8485 COVERAGEELIGIBILITYRESPONSE, 8486 /** 8487 * 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. 8488 */ 8489 DETECTEDISSUE, 8490 /** 8491 * 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. 8492 */ 8493 DEVICE, 8494 /** 8495 * A record of association of a device. 8496 */ 8497 DEVICEASSOCIATION, 8498 /** 8499 * This is a specialized resource that defines the characteristics and capabilities of a device. 8500 */ 8501 DEVICEDEFINITION, 8502 /** 8503 * 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. 8504 */ 8505 DEVICEDISPENSE, 8506 /** 8507 * 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. 8508 */ 8509 DEVICEMETRIC, 8510 /** 8511 * 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. 8512 */ 8513 DEVICEREQUEST, 8514 /** 8515 * 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. 8516 */ 8517 DEVICEUSAGE, 8518 /** 8519 * 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. 8520 */ 8521 DIAGNOSTICREPORT, 8522 /** 8523 * 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. 8524 */ 8525 DOCUMENTREFERENCE, 8526 /** 8527 * 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). 8528 */ 8529 ENCOUNTER, 8530 /** 8531 * A record of significant events/milestones key data throughout the history of an Encounter 8532 */ 8533 ENCOUNTERHISTORY, 8534 /** 8535 * 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. 8536 */ 8537 ENDPOINT, 8538 /** 8539 * This resource provides the insurance enrollment details to the insurer regarding a specified coverage. 8540 */ 8541 ENROLLMENTREQUEST, 8542 /** 8543 * This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource. 8544 */ 8545 ENROLLMENTRESPONSE, 8546 /** 8547 * 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. 8548 */ 8549 EPISODEOFCARE, 8550 /** 8551 * The EventDefinition resource provides a reusable description of when a particular event can occur. 8552 */ 8553 EVENTDEFINITION, 8554 /** 8555 * 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. 8556 */ 8557 EVIDENCE, 8558 /** 8559 * 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. 8560 */ 8561 EVIDENCEREPORT, 8562 /** 8563 * The EvidenceVariable resource describes an element that knowledge (Evidence) is about. 8564 */ 8565 EVIDENCEVARIABLE, 8566 /** 8567 * A walkthrough of a workflow showing the interaction between systems and the instances shared, possibly including the evolution of instances over time. 8568 */ 8569 EXAMPLESCENARIO, 8570 /** 8571 * 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. 8572 */ 8573 EXPLANATIONOFBENEFIT, 8574 /** 8575 * Significant health conditions for a person related to the patient relevant in the context of care for the patient. 8576 */ 8577 FAMILYMEMBERHISTORY, 8578 /** 8579 * Prospective warnings of potential issues when providing care to the patient. 8580 */ 8581 FLAG, 8582 /** 8583 * 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. 8584 */ 8585 FORMULARYITEM, 8586 /** 8587 * A set of analyses performed to analyze and generate genomic data. 8588 */ 8589 GENOMICSTUDY, 8590 /** 8591 * 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. 8592 */ 8593 GOAL, 8594 /** 8595 * 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. 8596 */ 8597 GRAPHDEFINITION, 8598 /** 8599 * 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. 8600 */ 8601 GROUP, 8602 /** 8603 * 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. 8604 */ 8605 GUIDANCERESPONSE, 8606 /** 8607 * 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. 8608 */ 8609 HEALTHCARESERVICE, 8610 /** 8611 * 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. 8612 */ 8613 IMAGINGSELECTION, 8614 /** 8615 * 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. 8616 */ 8617 IMAGINGSTUDY, 8618 /** 8619 * 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. 8620 */ 8621 IMMUNIZATION, 8622 /** 8623 * Describes a comparison of an immunization event against published recommendations to determine if the administration is "valid" in relation to those recommendations. 8624 */ 8625 IMMUNIZATIONEVALUATION, 8626 /** 8627 * A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification. 8628 */ 8629 IMMUNIZATIONRECOMMENDATION, 8630 /** 8631 * 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. 8632 */ 8633 IMPLEMENTATIONGUIDE, 8634 /** 8635 * An ingredient of a manufactured item or pharmaceutical product. 8636 */ 8637 INGREDIENT, 8638 /** 8639 * Details of a Health Insurance product/plan provided by an organization. 8640 */ 8641 INSURANCEPLAN, 8642 /** 8643 * functional description of an inventory item used in inventory and supply-related workflows. 8644 */ 8645 INVENTORYITEM, 8646 /** 8647 * A report of inventory or stock items. 8648 */ 8649 INVENTORYREPORT, 8650 /** 8651 * Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose. 8652 */ 8653 INVOICE, 8654 /** 8655 * 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. 8656 */ 8657 LIBRARY, 8658 /** 8659 * Identifies two or more records (resource instances) that refer to the same real-world "occurrence". 8660 */ 8661 LINKAGE, 8662 /** 8663 * A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc. 8664 */ 8665 LIST, 8666 /** 8667 * Details and position information for a place where services are provided and resources and participants may be stored, found, contained, or accommodated. 8668 */ 8669 LOCATION, 8670 /** 8671 * The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product. 8672 */ 8673 MANUFACTUREDITEMDEFINITION, 8674 /** 8675 * The Measure resource provides the definition of a quality measure. 8676 */ 8677 MEASURE, 8678 /** 8679 * The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation. 8680 */ 8681 MEASUREREPORT, 8682 /** 8683 * 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. 8684 */ 8685 MEDICATION, 8686 /** 8687 * 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. 8688 */ 8689 MEDICATIONADMINISTRATION, 8690 /** 8691 * 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. 8692 */ 8693 MEDICATIONDISPENSE, 8694 /** 8695 * Information about a medication that is used to support knowledge. 8696 */ 8697 MEDICATIONKNOWLEDGE, 8698 /** 8699 * 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. 8700 */ 8701 MEDICATIONREQUEST, 8702 /** 8703 * 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. 8704 8705The 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. 8706 */ 8707 MEDICATIONSTATEMENT, 8708 /** 8709 * 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.). 8710 */ 8711 MEDICINALPRODUCTDEFINITION, 8712 /** 8713 * 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. 8714 */ 8715 MESSAGEDEFINITION, 8716 /** 8717 * 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. 8718 */ 8719 MESSAGEHEADER, 8720 /** 8721 * Common Interface declaration for conformance and knowledge artifact resources. 8722 */ 8723 METADATARESOURCE, 8724 /** 8725 * Representation of a molecular sequence. 8726 */ 8727 MOLECULARSEQUENCE, 8728 /** 8729 * 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. 8730 */ 8731 NAMINGSYSTEM, 8732 /** 8733 * 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. 8734 */ 8735 NUTRITIONINTAKE, 8736 /** 8737 * A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident. 8738 */ 8739 NUTRITIONORDER, 8740 /** 8741 * A food or supplement that is consumed by patients. 8742 */ 8743 NUTRITIONPRODUCT, 8744 /** 8745 * Measurements and simple assertions made about a patient, device or other subject. 8746 */ 8747 OBSERVATION, 8748 /** 8749 * Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service. 8750 */ 8751 OBSERVATIONDEFINITION, 8752 /** 8753 * A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction). 8754 */ 8755 OPERATIONDEFINITION, 8756 /** 8757 * A collection of error, warning, or information messages that result from a system action. 8758 */ 8759 OPERATIONOUTCOME, 8760 /** 8761 * 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. 8762 */ 8763 ORGANIZATION, 8764 /** 8765 * Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship. 8766 */ 8767 ORGANIZATIONAFFILIATION, 8768 /** 8769 * A medically related item or items, in a container or package. 8770 */ 8771 PACKAGEDPRODUCTDEFINITION, 8772 /** 8773 * Demographics and other administrative information about an individual or animal receiving care or other health-related services. 8774 */ 8775 PATIENT, 8776 /** 8777 * This resource provides the status of the payment for goods and services rendered, and the request and response resource references. 8778 */ 8779 PAYMENTNOTICE, 8780 /** 8781 * This resource provides the details including amount of a payment and allocates the payment items being paid. 8782 */ 8783 PAYMENTRECONCILIATION, 8784 /** 8785 * Permission resource holds access rules for a given data and context. 8786 */ 8787 PERMISSION, 8788 /** 8789 * Demographics and administrative information about a person independent of a specific health-related context. 8790 */ 8791 PERSON, 8792 /** 8793 * 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. 8794 */ 8795 PLANDEFINITION, 8796 /** 8797 * A person who is directly or indirectly involved in the provisioning of healthcare or related services. 8798 */ 8799 PRACTITIONER, 8800 /** 8801 * A specific set of Roles/Locations/specialties/services that a practitioner may perform, or has performed at an organization during a period of time. 8802 */ 8803 PRACTITIONERROLE, 8804 /** 8805 * 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. 8806 */ 8807 PROCEDURE, 8808 /** 8809 * 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. 8810 */ 8811 PROVENANCE, 8812 /** 8813 * 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. 8814 */ 8815 QUESTIONNAIRE, 8816 /** 8817 * 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. 8818 */ 8819 QUESTIONNAIRERESPONSE, 8820 /** 8821 * 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. 8822 */ 8823 REGULATEDAUTHORIZATION, 8824 /** 8825 * 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. 8826 */ 8827 RELATEDPERSON, 8828 /** 8829 * 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". 8830 */ 8831 REQUESTORCHESTRATION, 8832 /** 8833 * 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. 8834 */ 8835 REQUIREMENTS, 8836 /** 8837 * 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. 8838 */ 8839 RESEARCHSTUDY, 8840 /** 8841 * A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study. 8842 */ 8843 RESEARCHSUBJECT, 8844 /** 8845 * An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome. 8846 */ 8847 RISKASSESSMENT, 8848 /** 8849 * A container for slots of time that may be available for booking appointments. 8850 */ 8851 SCHEDULE, 8852 /** 8853 * A search parameter that defines a named search item that can be used to search/filter on a resource. 8854 */ 8855 SEARCHPARAMETER, 8856 /** 8857 * A record of a request for service such as diagnostic investigations, treatments, or operations to be performed. 8858 */ 8859 SERVICEREQUEST, 8860 /** 8861 * A slot of time on a schedule that may be available for booking appointments. 8862 */ 8863 SLOT, 8864 /** 8865 * A sample to be used for analysis. 8866 */ 8867 SPECIMEN, 8868 /** 8869 * A kind of specimen with associated set of requirements. 8870 */ 8871 SPECIMENDEFINITION, 8872 /** 8873 * 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. 8874 */ 8875 STRUCTUREDEFINITION, 8876 /** 8877 * A Map of relationships between 2 structures that can be used to transform data. 8878 */ 8879 STRUCTUREMAP, 8880 /** 8881 * The subscription resource describes a particular client's request to be notified about a SubscriptionTopic. 8882 */ 8883 SUBSCRIPTION, 8884 /** 8885 * The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted. 8886 */ 8887 SUBSCRIPTIONSTATUS, 8888 /** 8889 * Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic. 8890 */ 8891 SUBSCRIPTIONTOPIC, 8892 /** 8893 * A homogeneous material with a definite composition. 8894 */ 8895 SUBSTANCE, 8896 /** 8897 * The detailed description of a substance, typically at a level beyond what is used for prescribing. 8898 */ 8899 SUBSTANCEDEFINITION, 8900 /** 8901 * 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. 8902 */ 8903 SUBSTANCENUCLEICACID, 8904 /** 8905 * Properties of a substance specific to it being a polymer. 8906 */ 8907 SUBSTANCEPOLYMER, 8908 /** 8909 * 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. 8910 */ 8911 SUBSTANCEPROTEIN, 8912 /** 8913 * Todo. 8914 */ 8915 SUBSTANCEREFERENCEINFORMATION, 8916 /** 8917 * 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. 8918 */ 8919 SUBSTANCESOURCEMATERIAL, 8920 /** 8921 * Record of delivery of what is supplied. 8922 */ 8923 SUPPLYDELIVERY, 8924 /** 8925 * 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. 8926 */ 8927 SUPPLYREQUEST, 8928 /** 8929 * A task to be performed. 8930 */ 8931 TASK, 8932 /** 8933 * 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. 8934 */ 8935 TERMINOLOGYCAPABILITIES, 8936 /** 8937 * A plan for executing testing on an artifact or specifications 8938 */ 8939 TESTPLAN, 8940 /** 8941 * A summary of information based on the results of executing a TestScript. 8942 */ 8943 TESTREPORT, 8944 /** 8945 * A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification. 8946 */ 8947 TESTSCRIPT, 8948 /** 8949 * Record of transport. 8950 */ 8951 TRANSPORT, 8952 /** 8953 * 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). 8954 */ 8955 VALUESET, 8956 /** 8957 * Describes validation requirements, source(s), status and dates for one or more elements. 8958 */ 8959 VERIFICATIONRESULT, 8960 /** 8961 * An authorization for the provision of glasses and/or contact lenses to a patient. 8962 */ 8963 VISIONPRESCRIPTION, 8964 /** 8965 * 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. 8966 */ 8967 PARAMETERS, 8968 /** 8969 * added to help the parsers 8970 */ 8971 NULL; 8972 public static FHIRTypes fromCode(String codeString) throws FHIRException { 8973 if (codeString == null || "".equals(codeString)) 8974 return null; 8975 if ("Base".equals(codeString)) 8976 return BASE; 8977 if ("Element".equals(codeString)) 8978 return ELEMENT; 8979 if ("BackboneElement".equals(codeString)) 8980 return BACKBONEELEMENT; 8981 if ("DataType".equals(codeString)) 8982 return DATATYPE; 8983 if ("Address".equals(codeString)) 8984 return ADDRESS; 8985 if ("Annotation".equals(codeString)) 8986 return ANNOTATION; 8987 if ("Attachment".equals(codeString)) 8988 return ATTACHMENT; 8989 if ("Availability".equals(codeString)) 8990 return AVAILABILITY; 8991 if ("BackboneType".equals(codeString)) 8992 return BACKBONETYPE; 8993 if ("Dosage".equals(codeString)) 8994 return DOSAGE; 8995 if ("ElementDefinition".equals(codeString)) 8996 return ELEMENTDEFINITION; 8997 if ("MarketingStatus".equals(codeString)) 8998 return MARKETINGSTATUS; 8999 if ("ProductShelfLife".equals(codeString)) 9000 return PRODUCTSHELFLIFE; 9001 if ("Timing".equals(codeString)) 9002 return TIMING; 9003 if ("CodeableConcept".equals(codeString)) 9004 return CODEABLECONCEPT; 9005 if ("CodeableReference".equals(codeString)) 9006 return CODEABLEREFERENCE; 9007 if ("Coding".equals(codeString)) 9008 return CODING; 9009 if ("ContactDetail".equals(codeString)) 9010 return CONTACTDETAIL; 9011 if ("ContactPoint".equals(codeString)) 9012 return CONTACTPOINT; 9013 if ("Contributor".equals(codeString)) 9014 return CONTRIBUTOR; 9015 if ("DataRequirement".equals(codeString)) 9016 return DATAREQUIREMENT; 9017 if ("Expression".equals(codeString)) 9018 return EXPRESSION; 9019 if ("ExtendedContactDetail".equals(codeString)) 9020 return EXTENDEDCONTACTDETAIL; 9021 if ("Extension".equals(codeString)) 9022 return EXTENSION; 9023 if ("HumanName".equals(codeString)) 9024 return HUMANNAME; 9025 if ("Identifier".equals(codeString)) 9026 return IDENTIFIER; 9027 if ("Meta".equals(codeString)) 9028 return META; 9029 if ("MonetaryComponent".equals(codeString)) 9030 return MONETARYCOMPONENT; 9031 if ("Money".equals(codeString)) 9032 return MONEY; 9033 if ("Narrative".equals(codeString)) 9034 return NARRATIVE; 9035 if ("ParameterDefinition".equals(codeString)) 9036 return PARAMETERDEFINITION; 9037 if ("Period".equals(codeString)) 9038 return PERIOD; 9039 if ("PrimitiveType".equals(codeString)) 9040 return PRIMITIVETYPE; 9041 if ("base64Binary".equals(codeString)) 9042 return BASE64BINARY; 9043 if ("boolean".equals(codeString)) 9044 return BOOLEAN; 9045 if ("date".equals(codeString)) 9046 return DATE; 9047 if ("dateTime".equals(codeString)) 9048 return DATETIME; 9049 if ("decimal".equals(codeString)) 9050 return DECIMAL; 9051 if ("instant".equals(codeString)) 9052 return INSTANT; 9053 if ("integer".equals(codeString)) 9054 return INTEGER; 9055 if ("positiveInt".equals(codeString)) 9056 return POSITIVEINT; 9057 if ("unsignedInt".equals(codeString)) 9058 return UNSIGNEDINT; 9059 if ("integer64".equals(codeString)) 9060 return INTEGER64; 9061 if ("string".equals(codeString)) 9062 return STRING; 9063 if ("code".equals(codeString)) 9064 return CODE; 9065 if ("id".equals(codeString)) 9066 return ID; 9067 if ("markdown".equals(codeString)) 9068 return MARKDOWN; 9069 if ("time".equals(codeString)) 9070 return TIME; 9071 if ("uri".equals(codeString)) 9072 return URI; 9073 if ("canonical".equals(codeString)) 9074 return CANONICAL; 9075 if ("oid".equals(codeString)) 9076 return OID; 9077 if ("url".equals(codeString)) 9078 return URL; 9079 if ("uuid".equals(codeString)) 9080 return UUID; 9081 if ("Quantity".equals(codeString)) 9082 return QUANTITY; 9083 if ("Age".equals(codeString)) 9084 return AGE; 9085 if ("Count".equals(codeString)) 9086 return COUNT; 9087 if ("Distance".equals(codeString)) 9088 return DISTANCE; 9089 if ("Duration".equals(codeString)) 9090 return DURATION; 9091 if ("Range".equals(codeString)) 9092 return RANGE; 9093 if ("Ratio".equals(codeString)) 9094 return RATIO; 9095 if ("RatioRange".equals(codeString)) 9096 return RATIORANGE; 9097 if ("Reference".equals(codeString)) 9098 return REFERENCE; 9099 if ("RelatedArtifact".equals(codeString)) 9100 return RELATEDARTIFACT; 9101 if ("SampledData".equals(codeString)) 9102 return SAMPLEDDATA; 9103 if ("Signature".equals(codeString)) 9104 return SIGNATURE; 9105 if ("TriggerDefinition".equals(codeString)) 9106 return TRIGGERDEFINITION; 9107 if ("UsageContext".equals(codeString)) 9108 return USAGECONTEXT; 9109 if ("VirtualServiceDetail".equals(codeString)) 9110 return VIRTUALSERVICEDETAIL; 9111 if ("xhtml".equals(codeString)) 9112 return XHTML; 9113 if ("Resource".equals(codeString) || "Any".equals(codeString)) 9114 return RESOURCE; 9115 if ("Binary".equals(codeString)) 9116 return BINARY; 9117 if ("Bundle".equals(codeString)) 9118 return BUNDLE; 9119 if ("DomainResource".equals(codeString)) 9120 return DOMAINRESOURCE; 9121 if ("Account".equals(codeString)) 9122 return ACCOUNT; 9123 if ("ActivityDefinition".equals(codeString)) 9124 return ACTIVITYDEFINITION; 9125 if ("ActorDefinition".equals(codeString)) 9126 return ACTORDEFINITION; 9127 if ("AdministrableProductDefinition".equals(codeString)) 9128 return ADMINISTRABLEPRODUCTDEFINITION; 9129 if ("AdverseEvent".equals(codeString)) 9130 return ADVERSEEVENT; 9131 if ("AllergyIntolerance".equals(codeString)) 9132 return ALLERGYINTOLERANCE; 9133 if ("Appointment".equals(codeString)) 9134 return APPOINTMENT; 9135 if ("AppointmentResponse".equals(codeString)) 9136 return APPOINTMENTRESPONSE; 9137 if ("ArtifactAssessment".equals(codeString)) 9138 return ARTIFACTASSESSMENT; 9139 if ("AuditEvent".equals(codeString)) 9140 return AUDITEVENT; 9141 if ("Basic".equals(codeString)) 9142 return BASIC; 9143 if ("BiologicallyDerivedProduct".equals(codeString)) 9144 return BIOLOGICALLYDERIVEDPRODUCT; 9145 if ("BiologicallyDerivedProductDispense".equals(codeString)) 9146 return BIOLOGICALLYDERIVEDPRODUCTDISPENSE; 9147 if ("BodyStructure".equals(codeString)) 9148 return BODYSTRUCTURE; 9149 if ("CanonicalResource".equals(codeString)) 9150 return CANONICALRESOURCE; 9151 if ("CapabilityStatement".equals(codeString)) 9152 return CAPABILITYSTATEMENT; 9153 if ("CarePlan".equals(codeString)) 9154 return CAREPLAN; 9155 if ("CareTeam".equals(codeString)) 9156 return CARETEAM; 9157 if ("ChargeItem".equals(codeString)) 9158 return CHARGEITEM; 9159 if ("ChargeItemDefinition".equals(codeString)) 9160 return CHARGEITEMDEFINITION; 9161 if ("Citation".equals(codeString)) 9162 return CITATION; 9163 if ("Claim".equals(codeString)) 9164 return CLAIM; 9165 if ("ClaimResponse".equals(codeString)) 9166 return CLAIMRESPONSE; 9167 if ("ClinicalImpression".equals(codeString)) 9168 return CLINICALIMPRESSION; 9169 if ("ClinicalUseDefinition".equals(codeString)) 9170 return CLINICALUSEDEFINITION; 9171 if ("CodeSystem".equals(codeString)) 9172 return CODESYSTEM; 9173 if ("Communication".equals(codeString)) 9174 return COMMUNICATION; 9175 if ("CommunicationRequest".equals(codeString)) 9176 return COMMUNICATIONREQUEST; 9177 if ("CompartmentDefinition".equals(codeString)) 9178 return COMPARTMENTDEFINITION; 9179 if ("Composition".equals(codeString)) 9180 return COMPOSITION; 9181 if ("ConceptMap".equals(codeString)) 9182 return CONCEPTMAP; 9183 if ("Condition".equals(codeString)) 9184 return CONDITION; 9185 if ("ConditionDefinition".equals(codeString)) 9186 return CONDITIONDEFINITION; 9187 if ("Consent".equals(codeString)) 9188 return CONSENT; 9189 if ("Contract".equals(codeString)) 9190 return CONTRACT; 9191 if ("Coverage".equals(codeString)) 9192 return COVERAGE; 9193 if ("CoverageEligibilityRequest".equals(codeString)) 9194 return COVERAGEELIGIBILITYREQUEST; 9195 if ("CoverageEligibilityResponse".equals(codeString)) 9196 return COVERAGEELIGIBILITYRESPONSE; 9197 if ("DetectedIssue".equals(codeString)) 9198 return DETECTEDISSUE; 9199 if ("Device".equals(codeString)) 9200 return DEVICE; 9201 if ("DeviceAssociation".equals(codeString)) 9202 return DEVICEASSOCIATION; 9203 if ("DeviceDefinition".equals(codeString)) 9204 return DEVICEDEFINITION; 9205 if ("DeviceDispense".equals(codeString)) 9206 return DEVICEDISPENSE; 9207 if ("DeviceMetric".equals(codeString)) 9208 return DEVICEMETRIC; 9209 if ("DeviceRequest".equals(codeString)) 9210 return DEVICEREQUEST; 9211 if ("DeviceUsage".equals(codeString)) 9212 return DEVICEUSAGE; 9213 if ("DiagnosticReport".equals(codeString)) 9214 return DIAGNOSTICREPORT; 9215 if ("DocumentReference".equals(codeString)) 9216 return DOCUMENTREFERENCE; 9217 if ("Encounter".equals(codeString)) 9218 return ENCOUNTER; 9219 if ("EncounterHistory".equals(codeString)) 9220 return ENCOUNTERHISTORY; 9221 if ("Endpoint".equals(codeString)) 9222 return ENDPOINT; 9223 if ("EnrollmentRequest".equals(codeString)) 9224 return ENROLLMENTREQUEST; 9225 if ("EnrollmentResponse".equals(codeString)) 9226 return ENROLLMENTRESPONSE; 9227 if ("EpisodeOfCare".equals(codeString)) 9228 return EPISODEOFCARE; 9229 if ("EventDefinition".equals(codeString)) 9230 return EVENTDEFINITION; 9231 if ("Evidence".equals(codeString)) 9232 return EVIDENCE; 9233 if ("EvidenceReport".equals(codeString)) 9234 return EVIDENCEREPORT; 9235 if ("EvidenceVariable".equals(codeString)) 9236 return EVIDENCEVARIABLE; 9237 if ("ExampleScenario".equals(codeString)) 9238 return EXAMPLESCENARIO; 9239 if ("ExplanationOfBenefit".equals(codeString)) 9240 return EXPLANATIONOFBENEFIT; 9241 if ("FamilyMemberHistory".equals(codeString)) 9242 return FAMILYMEMBERHISTORY; 9243 if ("Flag".equals(codeString)) 9244 return FLAG; 9245 if ("FormularyItem".equals(codeString)) 9246 return FORMULARYITEM; 9247 if ("GenomicStudy".equals(codeString)) 9248 return GENOMICSTUDY; 9249 if ("Goal".equals(codeString)) 9250 return GOAL; 9251 if ("GraphDefinition".equals(codeString)) 9252 return GRAPHDEFINITION; 9253 if ("Group".equals(codeString)) 9254 return GROUP; 9255 if ("GuidanceResponse".equals(codeString)) 9256 return GUIDANCERESPONSE; 9257 if ("HealthcareService".equals(codeString)) 9258 return HEALTHCARESERVICE; 9259 if ("ImagingSelection".equals(codeString)) 9260 return IMAGINGSELECTION; 9261 if ("ImagingStudy".equals(codeString)) 9262 return IMAGINGSTUDY; 9263 if ("Immunization".equals(codeString)) 9264 return IMMUNIZATION; 9265 if ("ImmunizationEvaluation".equals(codeString)) 9266 return IMMUNIZATIONEVALUATION; 9267 if ("ImmunizationRecommendation".equals(codeString)) 9268 return IMMUNIZATIONRECOMMENDATION; 9269 if ("ImplementationGuide".equals(codeString)) 9270 return IMPLEMENTATIONGUIDE; 9271 if ("Ingredient".equals(codeString)) 9272 return INGREDIENT; 9273 if ("InsurancePlan".equals(codeString)) 9274 return INSURANCEPLAN; 9275 if ("InventoryItem".equals(codeString)) 9276 return INVENTORYITEM; 9277 if ("InventoryReport".equals(codeString)) 9278 return INVENTORYREPORT; 9279 if ("Invoice".equals(codeString)) 9280 return INVOICE; 9281 if ("Library".equals(codeString)) 9282 return LIBRARY; 9283 if ("Linkage".equals(codeString)) 9284 return LINKAGE; 9285 if ("List".equals(codeString)) 9286 return LIST; 9287 if ("Location".equals(codeString)) 9288 return LOCATION; 9289 if ("ManufacturedItemDefinition".equals(codeString)) 9290 return MANUFACTUREDITEMDEFINITION; 9291 if ("Measure".equals(codeString)) 9292 return MEASURE; 9293 if ("MeasureReport".equals(codeString)) 9294 return MEASUREREPORT; 9295 if ("Medication".equals(codeString)) 9296 return MEDICATION; 9297 if ("MedicationAdministration".equals(codeString)) 9298 return MEDICATIONADMINISTRATION; 9299 if ("MedicationDispense".equals(codeString)) 9300 return MEDICATIONDISPENSE; 9301 if ("MedicationKnowledge".equals(codeString)) 9302 return MEDICATIONKNOWLEDGE; 9303 if ("MedicationRequest".equals(codeString)) 9304 return MEDICATIONREQUEST; 9305 if ("MedicationStatement".equals(codeString)) 9306 return MEDICATIONSTATEMENT; 9307 if ("MedicinalProductDefinition".equals(codeString)) 9308 return MEDICINALPRODUCTDEFINITION; 9309 if ("MessageDefinition".equals(codeString)) 9310 return MESSAGEDEFINITION; 9311 if ("MessageHeader".equals(codeString)) 9312 return MESSAGEHEADER; 9313 if ("MetadataResource".equals(codeString)) 9314 return METADATARESOURCE; 9315 if ("MolecularSequence".equals(codeString)) 9316 return MOLECULARSEQUENCE; 9317 if ("NamingSystem".equals(codeString)) 9318 return NAMINGSYSTEM; 9319 if ("NutritionIntake".equals(codeString)) 9320 return NUTRITIONINTAKE; 9321 if ("NutritionOrder".equals(codeString)) 9322 return NUTRITIONORDER; 9323 if ("NutritionProduct".equals(codeString)) 9324 return NUTRITIONPRODUCT; 9325 if ("Observation".equals(codeString)) 9326 return OBSERVATION; 9327 if ("ObservationDefinition".equals(codeString)) 9328 return OBSERVATIONDEFINITION; 9329 if ("OperationDefinition".equals(codeString)) 9330 return OPERATIONDEFINITION; 9331 if ("OperationOutcome".equals(codeString)) 9332 return OPERATIONOUTCOME; 9333 if ("Organization".equals(codeString)) 9334 return ORGANIZATION; 9335 if ("OrganizationAffiliation".equals(codeString)) 9336 return ORGANIZATIONAFFILIATION; 9337 if ("PackagedProductDefinition".equals(codeString)) 9338 return PACKAGEDPRODUCTDEFINITION; 9339 if ("Patient".equals(codeString)) 9340 return PATIENT; 9341 if ("PaymentNotice".equals(codeString)) 9342 return PAYMENTNOTICE; 9343 if ("PaymentReconciliation".equals(codeString)) 9344 return PAYMENTRECONCILIATION; 9345 if ("Permission".equals(codeString)) 9346 return PERMISSION; 9347 if ("Person".equals(codeString)) 9348 return PERSON; 9349 if ("PlanDefinition".equals(codeString)) 9350 return PLANDEFINITION; 9351 if ("Practitioner".equals(codeString)) 9352 return PRACTITIONER; 9353 if ("PractitionerRole".equals(codeString)) 9354 return PRACTITIONERROLE; 9355 if ("Procedure".equals(codeString)) 9356 return PROCEDURE; 9357 if ("Provenance".equals(codeString)) 9358 return PROVENANCE; 9359 if ("Questionnaire".equals(codeString)) 9360 return QUESTIONNAIRE; 9361 if ("QuestionnaireResponse".equals(codeString)) 9362 return QUESTIONNAIRERESPONSE; 9363 if ("RegulatedAuthorization".equals(codeString)) 9364 return REGULATEDAUTHORIZATION; 9365 if ("RelatedPerson".equals(codeString)) 9366 return RELATEDPERSON; 9367 if ("RequestOrchestration".equals(codeString)) 9368 return REQUESTORCHESTRATION; 9369 if ("Requirements".equals(codeString)) 9370 return REQUIREMENTS; 9371 if ("ResearchStudy".equals(codeString)) 9372 return RESEARCHSTUDY; 9373 if ("ResearchSubject".equals(codeString)) 9374 return RESEARCHSUBJECT; 9375 if ("RiskAssessment".equals(codeString)) 9376 return RISKASSESSMENT; 9377 if ("Schedule".equals(codeString)) 9378 return SCHEDULE; 9379 if ("SearchParameter".equals(codeString)) 9380 return SEARCHPARAMETER; 9381 if ("ServiceRequest".equals(codeString)) 9382 return SERVICEREQUEST; 9383 if ("Slot".equals(codeString)) 9384 return SLOT; 9385 if ("Specimen".equals(codeString)) 9386 return SPECIMEN; 9387 if ("SpecimenDefinition".equals(codeString)) 9388 return SPECIMENDEFINITION; 9389 if ("StructureDefinition".equals(codeString)) 9390 return STRUCTUREDEFINITION; 9391 if ("StructureMap".equals(codeString)) 9392 return STRUCTUREMAP; 9393 if ("Subscription".equals(codeString)) 9394 return SUBSCRIPTION; 9395 if ("SubscriptionStatus".equals(codeString)) 9396 return SUBSCRIPTIONSTATUS; 9397 if ("SubscriptionTopic".equals(codeString)) 9398 return SUBSCRIPTIONTOPIC; 9399 if ("Substance".equals(codeString)) 9400 return SUBSTANCE; 9401 if ("SubstanceDefinition".equals(codeString)) 9402 return SUBSTANCEDEFINITION; 9403 if ("SubstanceNucleicAcid".equals(codeString)) 9404 return SUBSTANCENUCLEICACID; 9405 if ("SubstancePolymer".equals(codeString)) 9406 return SUBSTANCEPOLYMER; 9407 if ("SubstanceProtein".equals(codeString)) 9408 return SUBSTANCEPROTEIN; 9409 if ("SubstanceReferenceInformation".equals(codeString)) 9410 return SUBSTANCEREFERENCEINFORMATION; 9411 if ("SubstanceSourceMaterial".equals(codeString)) 9412 return SUBSTANCESOURCEMATERIAL; 9413 if ("SupplyDelivery".equals(codeString)) 9414 return SUPPLYDELIVERY; 9415 if ("SupplyRequest".equals(codeString)) 9416 return SUPPLYREQUEST; 9417 if ("Task".equals(codeString)) 9418 return TASK; 9419 if ("TerminologyCapabilities".equals(codeString)) 9420 return TERMINOLOGYCAPABILITIES; 9421 if ("TestPlan".equals(codeString)) 9422 return TESTPLAN; 9423 if ("TestReport".equals(codeString)) 9424 return TESTREPORT; 9425 if ("TestScript".equals(codeString)) 9426 return TESTSCRIPT; 9427 if ("Transport".equals(codeString)) 9428 return TRANSPORT; 9429 if ("ValueSet".equals(codeString)) 9430 return VALUESET; 9431 if ("VerificationResult".equals(codeString)) 9432 return VERIFICATIONRESULT; 9433 if ("VisionPrescription".equals(codeString)) 9434 return VISIONPRESCRIPTION; 9435 if ("Parameters".equals(codeString)) 9436 return PARAMETERS; 9437 throw new FHIRException("Unknown FHIRTypes code '"+codeString+"'"); 9438 } 9439 public static boolean isValidCode(String codeString) { 9440 if (codeString == null || "".equals(codeString)) 9441 return false; 9442 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", "ExtendedContactDetail", "Extension", "HumanName", "Identifier", "Meta", "MonetaryComponent", "Money", "Narrative", "ParameterDefinition", "Period", "PrimitiveType", "base64Binary", "boolean", "date", "dateTime", "decimal", "instant", "integer", "positiveInt", "unsignedInt", "integer64", "string", "code", "id", "markdown", "time", "uri", "canonical", "oid", "url", "uuid", "Quantity", "Age", "Count", "Distance", "Duration", "Range", "Ratio", "RatioRange", "Reference", "RelatedArtifact", "SampledData", "Signature", "TriggerDefinition", "UsageContext", "VirtualServiceDetail", "xhtml", "Resource", "Binary", "Bundle", "DomainResource", "Account", "ActivityDefinition", "ActorDefinition", "AdministrableProductDefinition", "AdverseEvent", "AllergyIntolerance", "Appointment", "AppointmentResponse", "ArtifactAssessment", "AuditEvent", "Basic", "BiologicallyDerivedProduct", "BiologicallyDerivedProductDispense", "BodyStructure", "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", "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", "Patient", "PaymentNotice", "PaymentReconciliation", "Permission", "Person", "PlanDefinition", "Practitioner", "PractitionerRole", "Procedure", "Provenance", "Questionnaire", "QuestionnaireResponse", "RegulatedAuthorization", "RelatedPerson", "RequestOrchestration", "Requirements", "ResearchStudy", "ResearchSubject", "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", "Parameters"); 9443 } 9444 public String toCode() { 9445 switch (this) { 9446 case BASE: return "Base"; 9447 case ELEMENT: return "Element"; 9448 case BACKBONEELEMENT: return "BackboneElement"; 9449 case DATATYPE: return "DataType"; 9450 case ADDRESS: return "Address"; 9451 case ANNOTATION: return "Annotation"; 9452 case ATTACHMENT: return "Attachment"; 9453 case AVAILABILITY: return "Availability"; 9454 case BACKBONETYPE: return "BackboneType"; 9455 case DOSAGE: return "Dosage"; 9456 case ELEMENTDEFINITION: return "ElementDefinition"; 9457 case MARKETINGSTATUS: return "MarketingStatus"; 9458 case PRODUCTSHELFLIFE: return "ProductShelfLife"; 9459 case TIMING: return "Timing"; 9460 case CODEABLECONCEPT: return "CodeableConcept"; 9461 case CODEABLEREFERENCE: return "CodeableReference"; 9462 case CODING: return "Coding"; 9463 case CONTACTDETAIL: return "ContactDetail"; 9464 case CONTACTPOINT: return "ContactPoint"; 9465 case CONTRIBUTOR: return "Contributor"; 9466 case DATAREQUIREMENT: return "DataRequirement"; 9467 case EXPRESSION: return "Expression"; 9468 case EXTENDEDCONTACTDETAIL: return "ExtendedContactDetail"; 9469 case EXTENSION: return "Extension"; 9470 case HUMANNAME: return "HumanName"; 9471 case IDENTIFIER: return "Identifier"; 9472 case META: return "Meta"; 9473 case MONETARYCOMPONENT: return "MonetaryComponent"; 9474 case MONEY: return "Money"; 9475 case NARRATIVE: return "Narrative"; 9476 case PARAMETERDEFINITION: return "ParameterDefinition"; 9477 case PERIOD: return "Period"; 9478 case PRIMITIVETYPE: return "PrimitiveType"; 9479 case BASE64BINARY: return "base64Binary"; 9480 case BOOLEAN: return "boolean"; 9481 case DATE: return "date"; 9482 case DATETIME: return "dateTime"; 9483 case DECIMAL: return "decimal"; 9484 case INSTANT: return "instant"; 9485 case INTEGER: return "integer"; 9486 case POSITIVEINT: return "positiveInt"; 9487 case UNSIGNEDINT: return "unsignedInt"; 9488 case INTEGER64: return "integer64"; 9489 case STRING: return "string"; 9490 case CODE: return "code"; 9491 case ID: return "id"; 9492 case MARKDOWN: return "markdown"; 9493 case TIME: return "time"; 9494 case URI: return "uri"; 9495 case CANONICAL: return "canonical"; 9496 case OID: return "oid"; 9497 case URL: return "url"; 9498 case UUID: return "uuid"; 9499 case QUANTITY: return "Quantity"; 9500 case AGE: return "Age"; 9501 case COUNT: return "Count"; 9502 case DISTANCE: return "Distance"; 9503 case DURATION: return "Duration"; 9504 case RANGE: return "Range"; 9505 case RATIO: return "Ratio"; 9506 case RATIORANGE: return "RatioRange"; 9507 case REFERENCE: return "Reference"; 9508 case RELATEDARTIFACT: return "RelatedArtifact"; 9509 case SAMPLEDDATA: return "SampledData"; 9510 case SIGNATURE: return "Signature"; 9511 case TRIGGERDEFINITION: return "TriggerDefinition"; 9512 case USAGECONTEXT: return "UsageContext"; 9513 case VIRTUALSERVICEDETAIL: return "VirtualServiceDetail"; 9514 case XHTML: return "xhtml"; 9515 case RESOURCE: return "Resource"; 9516 case BINARY: return "Binary"; 9517 case BUNDLE: return "Bundle"; 9518 case DOMAINRESOURCE: return "DomainResource"; 9519 case ACCOUNT: return "Account"; 9520 case ACTIVITYDEFINITION: return "ActivityDefinition"; 9521 case ACTORDEFINITION: return "ActorDefinition"; 9522 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 9523 case ADVERSEEVENT: return "AdverseEvent"; 9524 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 9525 case APPOINTMENT: return "Appointment"; 9526 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 9527 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 9528 case AUDITEVENT: return "AuditEvent"; 9529 case BASIC: return "Basic"; 9530 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 9531 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "BiologicallyDerivedProductDispense"; 9532 case BODYSTRUCTURE: return "BodyStructure"; 9533 case CANONICALRESOURCE: return "CanonicalResource"; 9534 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 9535 case CAREPLAN: return "CarePlan"; 9536 case CARETEAM: return "CareTeam"; 9537 case CHARGEITEM: return "ChargeItem"; 9538 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 9539 case CITATION: return "Citation"; 9540 case CLAIM: return "Claim"; 9541 case CLAIMRESPONSE: return "ClaimResponse"; 9542 case CLINICALIMPRESSION: return "ClinicalImpression"; 9543 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 9544 case CODESYSTEM: return "CodeSystem"; 9545 case COMMUNICATION: return "Communication"; 9546 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 9547 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 9548 case COMPOSITION: return "Composition"; 9549 case CONCEPTMAP: return "ConceptMap"; 9550 case CONDITION: return "Condition"; 9551 case CONDITIONDEFINITION: return "ConditionDefinition"; 9552 case CONSENT: return "Consent"; 9553 case CONTRACT: return "Contract"; 9554 case COVERAGE: return "Coverage"; 9555 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 9556 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 9557 case DETECTEDISSUE: return "DetectedIssue"; 9558 case DEVICE: return "Device"; 9559 case DEVICEASSOCIATION: return "DeviceAssociation"; 9560 case DEVICEDEFINITION: return "DeviceDefinition"; 9561 case DEVICEDISPENSE: return "DeviceDispense"; 9562 case DEVICEMETRIC: return "DeviceMetric"; 9563 case DEVICEREQUEST: return "DeviceRequest"; 9564 case DEVICEUSAGE: return "DeviceUsage"; 9565 case DIAGNOSTICREPORT: return "DiagnosticReport"; 9566 case DOCUMENTREFERENCE: return "DocumentReference"; 9567 case ENCOUNTER: return "Encounter"; 9568 case ENCOUNTERHISTORY: return "EncounterHistory"; 9569 case ENDPOINT: return "Endpoint"; 9570 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 9571 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 9572 case EPISODEOFCARE: return "EpisodeOfCare"; 9573 case EVENTDEFINITION: return "EventDefinition"; 9574 case EVIDENCE: return "Evidence"; 9575 case EVIDENCEREPORT: return "EvidenceReport"; 9576 case EVIDENCEVARIABLE: return "EvidenceVariable"; 9577 case EXAMPLESCENARIO: return "ExampleScenario"; 9578 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 9579 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 9580 case FLAG: return "Flag"; 9581 case FORMULARYITEM: return "FormularyItem"; 9582 case GENOMICSTUDY: return "GenomicStudy"; 9583 case GOAL: return "Goal"; 9584 case GRAPHDEFINITION: return "GraphDefinition"; 9585 case GROUP: return "Group"; 9586 case GUIDANCERESPONSE: return "GuidanceResponse"; 9587 case HEALTHCARESERVICE: return "HealthcareService"; 9588 case IMAGINGSELECTION: return "ImagingSelection"; 9589 case IMAGINGSTUDY: return "ImagingStudy"; 9590 case IMMUNIZATION: return "Immunization"; 9591 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 9592 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 9593 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 9594 case INGREDIENT: return "Ingredient"; 9595 case INSURANCEPLAN: return "InsurancePlan"; 9596 case INVENTORYITEM: return "InventoryItem"; 9597 case INVENTORYREPORT: return "InventoryReport"; 9598 case INVOICE: return "Invoice"; 9599 case LIBRARY: return "Library"; 9600 case LINKAGE: return "Linkage"; 9601 case LIST: return "List"; 9602 case LOCATION: return "Location"; 9603 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 9604 case MEASURE: return "Measure"; 9605 case MEASUREREPORT: return "MeasureReport"; 9606 case MEDICATION: return "Medication"; 9607 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 9608 case MEDICATIONDISPENSE: return "MedicationDispense"; 9609 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 9610 case MEDICATIONREQUEST: return "MedicationRequest"; 9611 case MEDICATIONSTATEMENT: return "MedicationStatement"; 9612 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 9613 case MESSAGEDEFINITION: return "MessageDefinition"; 9614 case MESSAGEHEADER: return "MessageHeader"; 9615 case METADATARESOURCE: return "MetadataResource"; 9616 case MOLECULARSEQUENCE: return "MolecularSequence"; 9617 case NAMINGSYSTEM: return "NamingSystem"; 9618 case NUTRITIONINTAKE: return "NutritionIntake"; 9619 case NUTRITIONORDER: return "NutritionOrder"; 9620 case NUTRITIONPRODUCT: return "NutritionProduct"; 9621 case OBSERVATION: return "Observation"; 9622 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 9623 case OPERATIONDEFINITION: return "OperationDefinition"; 9624 case OPERATIONOUTCOME: return "OperationOutcome"; 9625 case ORGANIZATION: return "Organization"; 9626 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 9627 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 9628 case PATIENT: return "Patient"; 9629 case PAYMENTNOTICE: return "PaymentNotice"; 9630 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 9631 case PERMISSION: return "Permission"; 9632 case PERSON: return "Person"; 9633 case PLANDEFINITION: return "PlanDefinition"; 9634 case PRACTITIONER: return "Practitioner"; 9635 case PRACTITIONERROLE: return "PractitionerRole"; 9636 case PROCEDURE: return "Procedure"; 9637 case PROVENANCE: return "Provenance"; 9638 case QUESTIONNAIRE: return "Questionnaire"; 9639 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 9640 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 9641 case RELATEDPERSON: return "RelatedPerson"; 9642 case REQUESTORCHESTRATION: return "RequestOrchestration"; 9643 case REQUIREMENTS: return "Requirements"; 9644 case RESEARCHSTUDY: return "ResearchStudy"; 9645 case RESEARCHSUBJECT: return "ResearchSubject"; 9646 case RISKASSESSMENT: return "RiskAssessment"; 9647 case SCHEDULE: return "Schedule"; 9648 case SEARCHPARAMETER: return "SearchParameter"; 9649 case SERVICEREQUEST: return "ServiceRequest"; 9650 case SLOT: return "Slot"; 9651 case SPECIMEN: return "Specimen"; 9652 case SPECIMENDEFINITION: return "SpecimenDefinition"; 9653 case STRUCTUREDEFINITION: return "StructureDefinition"; 9654 case STRUCTUREMAP: return "StructureMap"; 9655 case SUBSCRIPTION: return "Subscription"; 9656 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 9657 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 9658 case SUBSTANCE: return "Substance"; 9659 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 9660 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 9661 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 9662 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 9663 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 9664 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 9665 case SUPPLYDELIVERY: return "SupplyDelivery"; 9666 case SUPPLYREQUEST: return "SupplyRequest"; 9667 case TASK: return "Task"; 9668 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 9669 case TESTPLAN: return "TestPlan"; 9670 case TESTREPORT: return "TestReport"; 9671 case TESTSCRIPT: return "TestScript"; 9672 case TRANSPORT: return "Transport"; 9673 case VALUESET: return "ValueSet"; 9674 case VERIFICATIONRESULT: return "VerificationResult"; 9675 case VISIONPRESCRIPTION: return "VisionPrescription"; 9676 case PARAMETERS: return "Parameters"; 9677 case NULL: return null; 9678 default: return "?"; 9679 } 9680 } 9681 public String getSystem() { 9682 switch (this) { 9683 case BASE: return "http://hl7.org/fhir/fhir-types"; 9684 case ELEMENT: return "http://hl7.org/fhir/fhir-types"; 9685 case BACKBONEELEMENT: return "http://hl7.org/fhir/fhir-types"; 9686 case DATATYPE: return "http://hl7.org/fhir/fhir-types"; 9687 case ADDRESS: return "http://hl7.org/fhir/fhir-types"; 9688 case ANNOTATION: return "http://hl7.org/fhir/fhir-types"; 9689 case ATTACHMENT: return "http://hl7.org/fhir/fhir-types"; 9690 case AVAILABILITY: return "http://hl7.org/fhir/fhir-types"; 9691 case BACKBONETYPE: return "http://hl7.org/fhir/fhir-types"; 9692 case DOSAGE: return "http://hl7.org/fhir/fhir-types"; 9693 case ELEMENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9694 case MARKETINGSTATUS: return "http://hl7.org/fhir/fhir-types"; 9695 case PRODUCTSHELFLIFE: return "http://hl7.org/fhir/fhir-types"; 9696 case TIMING: return "http://hl7.org/fhir/fhir-types"; 9697 case CODEABLECONCEPT: return "http://hl7.org/fhir/fhir-types"; 9698 case CODEABLEREFERENCE: return "http://hl7.org/fhir/fhir-types"; 9699 case CODING: return "http://hl7.org/fhir/fhir-types"; 9700 case CONTACTDETAIL: return "http://hl7.org/fhir/fhir-types"; 9701 case CONTACTPOINT: return "http://hl7.org/fhir/fhir-types"; 9702 case CONTRIBUTOR: return "http://hl7.org/fhir/fhir-types"; 9703 case DATAREQUIREMENT: return "http://hl7.org/fhir/fhir-types"; 9704 case EXPRESSION: return "http://hl7.org/fhir/fhir-types"; 9705 case EXTENDEDCONTACTDETAIL: return "http://hl7.org/fhir/fhir-types"; 9706 case EXTENSION: return "http://hl7.org/fhir/fhir-types"; 9707 case HUMANNAME: return "http://hl7.org/fhir/fhir-types"; 9708 case IDENTIFIER: return "http://hl7.org/fhir/fhir-types"; 9709 case META: return "http://hl7.org/fhir/fhir-types"; 9710 case MONETARYCOMPONENT: return "http://hl7.org/fhir/fhir-types"; 9711 case MONEY: return "http://hl7.org/fhir/fhir-types"; 9712 case NARRATIVE: return "http://hl7.org/fhir/fhir-types"; 9713 case PARAMETERDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9714 case PERIOD: return "http://hl7.org/fhir/fhir-types"; 9715 case PRIMITIVETYPE: return "http://hl7.org/fhir/fhir-types"; 9716 case BASE64BINARY: return "http://hl7.org/fhir/fhir-types"; 9717 case BOOLEAN: return "http://hl7.org/fhir/fhir-types"; 9718 case DATE: return "http://hl7.org/fhir/fhir-types"; 9719 case DATETIME: return "http://hl7.org/fhir/fhir-types"; 9720 case DECIMAL: return "http://hl7.org/fhir/fhir-types"; 9721 case INSTANT: return "http://hl7.org/fhir/fhir-types"; 9722 case INTEGER: return "http://hl7.org/fhir/fhir-types"; 9723 case POSITIVEINT: return "http://hl7.org/fhir/fhir-types"; 9724 case UNSIGNEDINT: return "http://hl7.org/fhir/fhir-types"; 9725 case INTEGER64: return "http://hl7.org/fhir/fhir-types"; 9726 case STRING: return "http://hl7.org/fhir/fhir-types"; 9727 case CODE: return "http://hl7.org/fhir/fhir-types"; 9728 case ID: return "http://hl7.org/fhir/fhir-types"; 9729 case MARKDOWN: return "http://hl7.org/fhir/fhir-types"; 9730 case TIME: return "http://hl7.org/fhir/fhir-types"; 9731 case URI: return "http://hl7.org/fhir/fhir-types"; 9732 case CANONICAL: return "http://hl7.org/fhir/fhir-types"; 9733 case OID: return "http://hl7.org/fhir/fhir-types"; 9734 case URL: return "http://hl7.org/fhir/fhir-types"; 9735 case UUID: return "http://hl7.org/fhir/fhir-types"; 9736 case QUANTITY: return "http://hl7.org/fhir/fhir-types"; 9737 case AGE: return "http://hl7.org/fhir/fhir-types"; 9738 case COUNT: return "http://hl7.org/fhir/fhir-types"; 9739 case DISTANCE: return "http://hl7.org/fhir/fhir-types"; 9740 case DURATION: return "http://hl7.org/fhir/fhir-types"; 9741 case RANGE: return "http://hl7.org/fhir/fhir-types"; 9742 case RATIO: return "http://hl7.org/fhir/fhir-types"; 9743 case RATIORANGE: return "http://hl7.org/fhir/fhir-types"; 9744 case REFERENCE: return "http://hl7.org/fhir/fhir-types"; 9745 case RELATEDARTIFACT: return "http://hl7.org/fhir/fhir-types"; 9746 case SAMPLEDDATA: return "http://hl7.org/fhir/fhir-types"; 9747 case SIGNATURE: return "http://hl7.org/fhir/fhir-types"; 9748 case TRIGGERDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9749 case USAGECONTEXT: return "http://hl7.org/fhir/fhir-types"; 9750 case VIRTUALSERVICEDETAIL: return "http://hl7.org/fhir/fhir-types"; 9751 case XHTML: return "http://hl7.org/fhir/fhir-types"; 9752 case RESOURCE: return "http://hl7.org/fhir/fhir-types"; 9753 case BINARY: return "http://hl7.org/fhir/fhir-types"; 9754 case BUNDLE: return "http://hl7.org/fhir/fhir-types"; 9755 case DOMAINRESOURCE: return "http://hl7.org/fhir/fhir-types"; 9756 case ACCOUNT: return "http://hl7.org/fhir/fhir-types"; 9757 case ACTIVITYDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9758 case ACTORDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9759 case ADMINISTRABLEPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9760 case ADVERSEEVENT: return "http://hl7.org/fhir/fhir-types"; 9761 case ALLERGYINTOLERANCE: return "http://hl7.org/fhir/fhir-types"; 9762 case APPOINTMENT: return "http://hl7.org/fhir/fhir-types"; 9763 case APPOINTMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 9764 case ARTIFACTASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 9765 case AUDITEVENT: return "http://hl7.org/fhir/fhir-types"; 9766 case BASIC: return "http://hl7.org/fhir/fhir-types"; 9767 case BIOLOGICALLYDERIVEDPRODUCT: return "http://hl7.org/fhir/fhir-types"; 9768 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "http://hl7.org/fhir/fhir-types"; 9769 case BODYSTRUCTURE: return "http://hl7.org/fhir/fhir-types"; 9770 case CANONICALRESOURCE: return "http://hl7.org/fhir/fhir-types"; 9771 case CAPABILITYSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 9772 case CAREPLAN: return "http://hl7.org/fhir/fhir-types"; 9773 case CARETEAM: return "http://hl7.org/fhir/fhir-types"; 9774 case CHARGEITEM: return "http://hl7.org/fhir/fhir-types"; 9775 case CHARGEITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9776 case CITATION: return "http://hl7.org/fhir/fhir-types"; 9777 case CLAIM: return "http://hl7.org/fhir/fhir-types"; 9778 case CLAIMRESPONSE: return "http://hl7.org/fhir/fhir-types"; 9779 case CLINICALIMPRESSION: return "http://hl7.org/fhir/fhir-types"; 9780 case CLINICALUSEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9781 case CODESYSTEM: return "http://hl7.org/fhir/fhir-types"; 9782 case COMMUNICATION: return "http://hl7.org/fhir/fhir-types"; 9783 case COMMUNICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 9784 case COMPARTMENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9785 case COMPOSITION: return "http://hl7.org/fhir/fhir-types"; 9786 case CONCEPTMAP: return "http://hl7.org/fhir/fhir-types"; 9787 case CONDITION: return "http://hl7.org/fhir/fhir-types"; 9788 case CONDITIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9789 case CONSENT: return "http://hl7.org/fhir/fhir-types"; 9790 case CONTRACT: return "http://hl7.org/fhir/fhir-types"; 9791 case COVERAGE: return "http://hl7.org/fhir/fhir-types"; 9792 case COVERAGEELIGIBILITYREQUEST: return "http://hl7.org/fhir/fhir-types"; 9793 case COVERAGEELIGIBILITYRESPONSE: return "http://hl7.org/fhir/fhir-types"; 9794 case DETECTEDISSUE: return "http://hl7.org/fhir/fhir-types"; 9795 case DEVICE: return "http://hl7.org/fhir/fhir-types"; 9796 case DEVICEASSOCIATION: return "http://hl7.org/fhir/fhir-types"; 9797 case DEVICEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9798 case DEVICEDISPENSE: return "http://hl7.org/fhir/fhir-types"; 9799 case DEVICEMETRIC: return "http://hl7.org/fhir/fhir-types"; 9800 case DEVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 9801 case DEVICEUSAGE: return "http://hl7.org/fhir/fhir-types"; 9802 case DIAGNOSTICREPORT: return "http://hl7.org/fhir/fhir-types"; 9803 case DOCUMENTREFERENCE: return "http://hl7.org/fhir/fhir-types"; 9804 case ENCOUNTER: return "http://hl7.org/fhir/fhir-types"; 9805 case ENCOUNTERHISTORY: return "http://hl7.org/fhir/fhir-types"; 9806 case ENDPOINT: return "http://hl7.org/fhir/fhir-types"; 9807 case ENROLLMENTREQUEST: return "http://hl7.org/fhir/fhir-types"; 9808 case ENROLLMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 9809 case EPISODEOFCARE: return "http://hl7.org/fhir/fhir-types"; 9810 case EVENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9811 case EVIDENCE: return "http://hl7.org/fhir/fhir-types"; 9812 case EVIDENCEREPORT: return "http://hl7.org/fhir/fhir-types"; 9813 case EVIDENCEVARIABLE: return "http://hl7.org/fhir/fhir-types"; 9814 case EXAMPLESCENARIO: return "http://hl7.org/fhir/fhir-types"; 9815 case EXPLANATIONOFBENEFIT: return "http://hl7.org/fhir/fhir-types"; 9816 case FAMILYMEMBERHISTORY: return "http://hl7.org/fhir/fhir-types"; 9817 case FLAG: return "http://hl7.org/fhir/fhir-types"; 9818 case FORMULARYITEM: return "http://hl7.org/fhir/fhir-types"; 9819 case GENOMICSTUDY: return "http://hl7.org/fhir/fhir-types"; 9820 case GOAL: return "http://hl7.org/fhir/fhir-types"; 9821 case GRAPHDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9822 case GROUP: return "http://hl7.org/fhir/fhir-types"; 9823 case GUIDANCERESPONSE: return "http://hl7.org/fhir/fhir-types"; 9824 case HEALTHCARESERVICE: return "http://hl7.org/fhir/fhir-types"; 9825 case IMAGINGSELECTION: return "http://hl7.org/fhir/fhir-types"; 9826 case IMAGINGSTUDY: return "http://hl7.org/fhir/fhir-types"; 9827 case IMMUNIZATION: return "http://hl7.org/fhir/fhir-types"; 9828 case IMMUNIZATIONEVALUATION: return "http://hl7.org/fhir/fhir-types"; 9829 case IMMUNIZATIONRECOMMENDATION: return "http://hl7.org/fhir/fhir-types"; 9830 case IMPLEMENTATIONGUIDE: return "http://hl7.org/fhir/fhir-types"; 9831 case INGREDIENT: return "http://hl7.org/fhir/fhir-types"; 9832 case INSURANCEPLAN: return "http://hl7.org/fhir/fhir-types"; 9833 case INVENTORYITEM: return "http://hl7.org/fhir/fhir-types"; 9834 case INVENTORYREPORT: return "http://hl7.org/fhir/fhir-types"; 9835 case INVOICE: return "http://hl7.org/fhir/fhir-types"; 9836 case LIBRARY: return "http://hl7.org/fhir/fhir-types"; 9837 case LINKAGE: return "http://hl7.org/fhir/fhir-types"; 9838 case LIST: return "http://hl7.org/fhir/fhir-types"; 9839 case LOCATION: return "http://hl7.org/fhir/fhir-types"; 9840 case MANUFACTUREDITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9841 case MEASURE: return "http://hl7.org/fhir/fhir-types"; 9842 case MEASUREREPORT: return "http://hl7.org/fhir/fhir-types"; 9843 case MEDICATION: return "http://hl7.org/fhir/fhir-types"; 9844 case MEDICATIONADMINISTRATION: return "http://hl7.org/fhir/fhir-types"; 9845 case MEDICATIONDISPENSE: return "http://hl7.org/fhir/fhir-types"; 9846 case MEDICATIONKNOWLEDGE: return "http://hl7.org/fhir/fhir-types"; 9847 case MEDICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 9848 case MEDICATIONSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 9849 case MEDICINALPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9850 case MESSAGEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9851 case MESSAGEHEADER: return "http://hl7.org/fhir/fhir-types"; 9852 case METADATARESOURCE: return "http://hl7.org/fhir/fhir-types"; 9853 case MOLECULARSEQUENCE: return "http://hl7.org/fhir/fhir-types"; 9854 case NAMINGSYSTEM: return "http://hl7.org/fhir/fhir-types"; 9855 case NUTRITIONINTAKE: return "http://hl7.org/fhir/fhir-types"; 9856 case NUTRITIONORDER: return "http://hl7.org/fhir/fhir-types"; 9857 case NUTRITIONPRODUCT: return "http://hl7.org/fhir/fhir-types"; 9858 case OBSERVATION: return "http://hl7.org/fhir/fhir-types"; 9859 case OBSERVATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9860 case OPERATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9861 case OPERATIONOUTCOME: return "http://hl7.org/fhir/fhir-types"; 9862 case ORGANIZATION: return "http://hl7.org/fhir/fhir-types"; 9863 case ORGANIZATIONAFFILIATION: return "http://hl7.org/fhir/fhir-types"; 9864 case PACKAGEDPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9865 case PATIENT: return "http://hl7.org/fhir/fhir-types"; 9866 case PAYMENTNOTICE: return "http://hl7.org/fhir/fhir-types"; 9867 case PAYMENTRECONCILIATION: return "http://hl7.org/fhir/fhir-types"; 9868 case PERMISSION: return "http://hl7.org/fhir/fhir-types"; 9869 case PERSON: return "http://hl7.org/fhir/fhir-types"; 9870 case PLANDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9871 case PRACTITIONER: return "http://hl7.org/fhir/fhir-types"; 9872 case PRACTITIONERROLE: return "http://hl7.org/fhir/fhir-types"; 9873 case PROCEDURE: return "http://hl7.org/fhir/fhir-types"; 9874 case PROVENANCE: return "http://hl7.org/fhir/fhir-types"; 9875 case QUESTIONNAIRE: return "http://hl7.org/fhir/fhir-types"; 9876 case QUESTIONNAIRERESPONSE: return "http://hl7.org/fhir/fhir-types"; 9877 case REGULATEDAUTHORIZATION: return "http://hl7.org/fhir/fhir-types"; 9878 case RELATEDPERSON: return "http://hl7.org/fhir/fhir-types"; 9879 case REQUESTORCHESTRATION: return "http://hl7.org/fhir/fhir-types"; 9880 case REQUIREMENTS: return "http://hl7.org/fhir/fhir-types"; 9881 case RESEARCHSTUDY: return "http://hl7.org/fhir/fhir-types"; 9882 case RESEARCHSUBJECT: return "http://hl7.org/fhir/fhir-types"; 9883 case RISKASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 9884 case SCHEDULE: return "http://hl7.org/fhir/fhir-types"; 9885 case SEARCHPARAMETER: return "http://hl7.org/fhir/fhir-types"; 9886 case SERVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 9887 case SLOT: return "http://hl7.org/fhir/fhir-types"; 9888 case SPECIMEN: return "http://hl7.org/fhir/fhir-types"; 9889 case SPECIMENDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9890 case STRUCTUREDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9891 case STRUCTUREMAP: return "http://hl7.org/fhir/fhir-types"; 9892 case SUBSCRIPTION: return "http://hl7.org/fhir/fhir-types"; 9893 case SUBSCRIPTIONSTATUS: return "http://hl7.org/fhir/fhir-types"; 9894 case SUBSCRIPTIONTOPIC: return "http://hl7.org/fhir/fhir-types"; 9895 case SUBSTANCE: return "http://hl7.org/fhir/fhir-types"; 9896 case SUBSTANCEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9897 case SUBSTANCENUCLEICACID: return "http://hl7.org/fhir/fhir-types"; 9898 case SUBSTANCEPOLYMER: return "http://hl7.org/fhir/fhir-types"; 9899 case SUBSTANCEPROTEIN: return "http://hl7.org/fhir/fhir-types"; 9900 case SUBSTANCEREFERENCEINFORMATION: return "http://hl7.org/fhir/fhir-types"; 9901 case SUBSTANCESOURCEMATERIAL: return "http://hl7.org/fhir/fhir-types"; 9902 case SUPPLYDELIVERY: return "http://hl7.org/fhir/fhir-types"; 9903 case SUPPLYREQUEST: return "http://hl7.org/fhir/fhir-types"; 9904 case TASK: return "http://hl7.org/fhir/fhir-types"; 9905 case TERMINOLOGYCAPABILITIES: return "http://hl7.org/fhir/fhir-types"; 9906 case TESTPLAN: return "http://hl7.org/fhir/fhir-types"; 9907 case TESTREPORT: return "http://hl7.org/fhir/fhir-types"; 9908 case TESTSCRIPT: return "http://hl7.org/fhir/fhir-types"; 9909 case TRANSPORT: return "http://hl7.org/fhir/fhir-types"; 9910 case VALUESET: return "http://hl7.org/fhir/fhir-types"; 9911 case VERIFICATIONRESULT: return "http://hl7.org/fhir/fhir-types"; 9912 case VISIONPRESCRIPTION: return "http://hl7.org/fhir/fhir-types"; 9913 case PARAMETERS: return "http://hl7.org/fhir/fhir-types"; 9914 case NULL: return null; 9915 default: return "?"; 9916 } 9917 } 9918 public String getDefinition() { 9919 switch (this) { 9920 case BASE: return "Base Type: Base definition for all types defined in FHIR type system."; 9921 case ELEMENT: return "Element Type: Base definition for all elements in a resource."; 9922 case BACKBONEELEMENT: return "BackboneElement Type: Base definition for all elements that are defined inside a resource - but not those in a data type."; 9923 case DATATYPE: return "DataType Type: The base class for all re-useable types defined as part of the FHIR Specification."; 9924 case ADDRESS: return "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.\nThe ISO21090-codedString may be used to provide a coded representation of the contents of strings in an Address."; 9925 case ANNOTATION: return "Annotation Type: A text note which also contains information about who made the statement and when."; 9926 case ATTACHMENT: return "Attachment Type: For referring to data content defined in other formats."; 9927 case AVAILABILITY: return "Availability Type: Availability data for an {item}."; 9928 case BACKBONETYPE: return "BackboneType Type: Base definition for the few data types that are allowed to carry modifier extensions."; 9929 case DOSAGE: return "Dosage Type: Indicates how the medication is/was taken or should be taken by the patient."; 9930 case ELEMENTDEFINITION: return "ElementDefinition Type: Captures constraints on each element within the resource, profile, or extension."; 9931 case MARKETINGSTATUS: return "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."; 9932 case PRODUCTSHELFLIFE: return "ProductShelfLife Type: The shelf-life and storage information for a medicinal product item or container can be described using this class."; 9933 case TIMING: return "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."; 9934 case CODEABLECONCEPT: return "CodeableConcept Type: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text."; 9935 case CODEABLEREFERENCE: return "CodeableReference Type: A reference to a resource (by instance), or instead, a reference to a concept defined in a terminology or ontology (by class)."; 9936 case CODING: return "Coding Type: A reference to a code defined by a terminology system."; 9937 case CONTACTDETAIL: return "ContactDetail Type: Specifies contact information for a person or organization."; 9938 case CONTACTPOINT: return "ContactPoint Type: Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc."; 9939 case CONTRIBUTOR: return "Contributor Type: A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers."; 9940 case DATAREQUIREMENT: return "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."; 9941 case EXPRESSION: return "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."; 9942 case EXTENDEDCONTACTDETAIL: return "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."; 9943 case EXTENSION: return "Extension Type: Optional Extension Element - found in all resources."; 9944 case HUMANNAME: return "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."; 9945 case IDENTIFIER: return "Identifier Type: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers."; 9946 case META: return "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."; 9947 case MONETARYCOMPONENT: return "MonetaryComponent Type: Availability data for an {item}."; 9948 case MONEY: return "Money Type: An amount of economic utility in some recognized currency."; 9949 case NARRATIVE: return "Narrative Type: A human-readable summary of the resource conveying the essential clinical and business information for the resource."; 9950 case PARAMETERDEFINITION: return "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."; 9951 case PERIOD: return "Period Type: A time period defined by a start and end date and optionally time."; 9952 case PRIMITIVETYPE: return "PrimitiveType Type: The base type for all re-useable types defined that have a simple property."; 9953 case BASE64BINARY: return "base64Binary Type: A stream of bytes"; 9954 case BOOLEAN: return "boolean Type: Value of \"true\" or \"false\""; 9955 case DATE: return "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."; 9956 case DATETIME: return "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."; 9957 case DECIMAL: return "decimal Type: A rational number with implicit precision"; 9958 case INSTANT: return "instant Type: An instant in time - known at least to the second"; 9959 case INTEGER: return "integer Type: A whole number"; 9960 case POSITIVEINT: return "positiveInt type: An integer with a value that is positive (e.g. >0)"; 9961 case UNSIGNEDINT: return "unsignedInt type: An integer with a value that is not negative (e.g. >= 0)"; 9962 case INTEGER64: return "integer64 Type: A very large whole number"; 9963 case STRING: return "string Type: A sequence of Unicode characters"; 9964 case CODE: return "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"; 9965 case ID: return "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."; 9966 case MARKDOWN: return "markdown type: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine"; 9967 case TIME: return "time Type: A time during the day, with no date specified"; 9968 case URI: return "uri Type: String of characters used to identify a name or a resource"; 9969 case CANONICAL: return "canonical type: A URI that is a reference to a canonical URL on a FHIR resource"; 9970 case OID: return "oid type: An OID represented as a URI"; 9971 case URL: return "url type: A URI that is a literal reference"; 9972 case UUID: return "uuid type: A UUID, represented as a URI"; 9973 case QUANTITY: return "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."; 9974 case AGE: return "Age Type: A duration of time during which an organism (or a process) has existed."; 9975 case COUNT: return "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."; 9976 case DISTANCE: return "Distance Type: A length - a value with a unit that is a physical distance."; 9977 case DURATION: return "Duration Type: A length of time."; 9978 case RANGE: return "Range Type: A set of ordered Quantities defined by a low and high limit."; 9979 case RATIO: return "Ratio Type: A relationship of two Quantity values - expressed as a numerator and a denominator."; 9980 case RATIORANGE: return "RatioRange Type: A range of ratios expressed as a low and high numerator and a denominator."; 9981 case REFERENCE: return "Reference Type: A reference from one resource to another."; 9982 case RELATEDARTIFACT: return "RelatedArtifact Type: Related artifacts such as additional documentation, justification, or bibliographic references."; 9983 case SAMPLEDDATA: return "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."; 9984 case SIGNATURE: return "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."; 9985 case TRIGGERDEFINITION: return "TriggerDefinition Type: A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element."; 9986 case USAGECONTEXT: return "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)."; 9987 case VIRTUALSERVICEDETAIL: return "VirtualServiceDetail Type: Virtual Service Contact Details."; 9988 case XHTML: return "xhtml Type definition"; 9989 case RESOURCE: return "This is the base resource type for everything."; 9990 case BINARY: return "A resource that represents the data of a single raw artifact as digital content accessible in its native format. A Binary resource can contain any content, whether text, image, pdf, zip archive, etc."; 9991 case BUNDLE: return "A container for a collection of resources."; 9992 case DOMAINRESOURCE: return "A resource that includes narrative, extensions, and contained resources."; 9993 case ACCOUNT: return "A financial tool for tracking value accrued for a particular purpose. In the healthcare field, used to track charges for a patient, cost centers, etc."; 9994 case ACTIVITYDEFINITION: return "This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context."; 9995 case ACTORDEFINITION: return "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."; 9996 case ADMINISTRABLEPRODUCTDEFINITION: return "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)."; 9997 case ADVERSEEVENT: return "An event (i.e. any change to current patient status) that may be related to unintended effects on a patient or research 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."; 9998 case ALLERGYINTOLERANCE: return "Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance."; 9999 case APPOINTMENT: return "A booking of a healthcare event among patient(s), practitioner(s), related person(s) and/or device(s) for a specific date/time. This may result in one or more Encounter(s)."; 10000 case APPOINTMENTRESPONSE: return "A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection."; 10001 case ARTIFACTASSESSMENT: return "This Resource provides one or more comments, classifiers or ratings about a Resource and supports attribution and rights management metadata for the added content."; 10002 case AUDITEVENT: return "A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis."; 10003 case BASIC: return "Basic is used for handling concepts not yet defined in FHIR, narrative-only resources that don't map to an existing resource, and custom resources not appropriate for inclusion in the FHIR specification."; 10004 case BIOLOGICALLYDERIVEDPRODUCT: return "A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity."; 10005 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "A record of dispensation of a biologically derived product."; 10006 case BODYSTRUCTURE: return "Record details about an anatomical structure. This resource may be used when a coded concept does not provide the necessary detail needed for the use case."; 10007 case CANONICALRESOURCE: return "Common Interface declaration for conformance and knowledge artifact resources."; 10008 case CAPABILITYSTATEMENT: return "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."; 10009 case CAREPLAN: return "Describes the intention of how one or more practitioners intend to deliver care for a particular patient, group or community for a period of time, possibly limited to care for a specific condition or set of conditions."; 10010 case CARETEAM: return "The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care."; 10011 case CHARGEITEM: return "The resource ChargeItem describes the provision of healthcare provider products for a certain patient, therefore referring not only to the product, but containing in addition details of the provision, like date, time, amounts and participating organizations and persons. Main Usage of the ChargeItem is to enable the billing process and internal cost allocation."; 10012 case CHARGEITEMDEFINITION: return "The ChargeItemDefinition resource provides the properties that apply to the (billing) codes necessary to calculate costs and prices. The properties may differ largely depending on type and realm, therefore this resource gives only a rough structure and requires profiling for each type of billing code system."; 10013 case CITATION: return "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."; 10014 case CLAIM: return "A provider issued list of professional services and products which have been provided, or are to be provided, to a patient which is sent to an insurer for reimbursement."; 10015 case CLAIMRESPONSE: return "This resource provides the adjudication details from the processing of a Claim resource."; 10016 case CLINICALIMPRESSION: return "A record of a clinical assessment performed to determine what problem(s) may affect the patient and before planning the treatments or management strategies that are best to manage a patient's condition. Assessments are often 1:1 with a clinical consultation / encounter, but this varies greatly depending on the clinical workflow. This resource is called \"ClinicalImpression\" rather than \"ClinicalAssessment\" to avoid confusion with the recording of assessment tools such as Apgar score."; 10017 case CLINICALUSEDEFINITION: return "A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure."; 10018 case CODESYSTEM: return "The CodeSystem resource is used to declare the existence of and describe a code system or code system supplement and its key properties, and optionally define a part or all of its content."; 10019 case COMMUNICATION: return "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."; 10020 case COMMUNICATIONREQUEST: return "A request to convey information; e.g. the CDS system proposes that an alert be sent to a responsible provider, the CDS system proposes that the public health agency be notified about a reportable condition."; 10021 case COMPARTMENTDEFINITION: return "A compartment definition that defines how resources are accessed on a server."; 10022 case COMPOSITION: return "A set of healthcare-related information that is assembled together into a single logical package that provides a single coherent statement of meaning, establishes its own context and that has clinical attestation with regard to who is making the statement. A Composition defines the structure and narrative content necessary for a document. However, a Composition alone does not constitute a document. Rather, the Composition must be the first entry in a Bundle where Bundle.type=document, and any other resources referenced from Composition must be included as subsequent entries in the Bundle (for example Patient, Practitioner, Encounter, etc.)."; 10023 case CONCEPTMAP: return "A statement of relationships from one set of concepts to one or more other concepts - either concepts in code systems, or data element/data element concepts, or classes in class models."; 10024 case CONDITION: return "A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern."; 10025 case CONDITIONDEFINITION: return "A definition of a condition and information relevant to managing it."; 10026 case CONSENT: return "A record of a healthcare consumer?s choices or choices made on their behalf by a third party, which permits or denies identified recipient(s) or recipient role(s) to perform one or more actions within a given policy context, for specific purposes and periods of time."; 10027 case CONTRACT: return "Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement."; 10028 case COVERAGE: return "Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment."; 10029 case COVERAGEELIGIBILITYREQUEST: return "The CoverageEligibilityRequest provides patient and insurance coverage information to an insurer for them to respond, in the form of an CoverageEligibilityResponse, with information regarding whether the stated coverage is valid and in-force and optionally to provide the insurance details of the policy."; 10030 case COVERAGEELIGIBILITYRESPONSE: return "This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource."; 10031 case DETECTEDISSUE: return "Indicates an actual or potential clinical issue with or between one or more active or proposed clinical actions for a patient; e.g. Drug-drug interaction, Ineffective treatment frequency, Procedure-condition conflict, gaps in care, etc."; 10032 case DEVICE: return "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."; 10033 case DEVICEASSOCIATION: return "A record of association of a device."; 10034 case DEVICEDEFINITION: return "This is a specialized resource that defines the characteristics and capabilities of a device."; 10035 case DEVICEDISPENSE: return "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."; 10036 case DEVICEMETRIC: return "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. "; 10037 case DEVICEREQUEST: return "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."; 10038 case DEVICEUSAGE: return "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."; 10039 case DIAGNOSTICREPORT: return "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."; 10040 case DOCUMENTREFERENCE: return "A reference to a document of any kind for any purpose. While the term ?document? implies a more narrow focus, for this resource this ?document? encompasses *any* serialized object with a mime-type, it includes formal patient-centric documents (CDA), clinical notes, scanned paper, non-patient specific documents like policy text, as well as a photo, video, or audio recording acquired or used in healthcare. The DocumentReference resource provides metadata about the document so that the document can be discovered and managed. The actual content may be inline base64 encoded data or provided by direct reference."; 10041 case ENCOUNTER: return "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)."; 10042 case ENCOUNTERHISTORY: return "A record of significant events/milestones key data throughout the history of an Encounter"; 10043 case ENDPOINT: return "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."; 10044 case ENROLLMENTREQUEST: return "This resource provides the insurance enrollment details to the insurer regarding a specified coverage."; 10045 case ENROLLMENTRESPONSE: return "This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource."; 10046 case EPISODEOFCARE: return "An association between a patient and an organization / healthcare provider(s) during which time encounters may occur. The managing organization assumes a level of responsibility for the patient during this time."; 10047 case EVENTDEFINITION: return "The EventDefinition resource provides a reusable description of when a particular event can occur."; 10048 case EVIDENCE: return "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."; 10049 case EVIDENCEREPORT: return "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."; 10050 case EVIDENCEVARIABLE: return "The EvidenceVariable resource describes an element that knowledge (Evidence) is about."; 10051 case EXAMPLESCENARIO: return "A walkthrough of a workflow showing the interaction between systems and the instances shared, possibly including the evolution of instances over time."; 10052 case EXPLANATIONOFBENEFIT: return "This resource provides: the claim details; adjudication details from the processing of a Claim; and optionally account balance information, for informing the subscriber of the benefits provided."; 10053 case FAMILYMEMBERHISTORY: return "Significant health conditions for a person related to the patient relevant in the context of care for the patient."; 10054 case FLAG: return "Prospective warnings of potential issues when providing care to the patient."; 10055 case FORMULARYITEM: return "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."; 10056 case GENOMICSTUDY: return "A set of analyses performed to analyze and generate genomic data."; 10057 case GOAL: return "Describes the intended objective(s) for a patient, group or organization care, for example, weight loss, restoring an activity of daily living, obtaining herd immunity via immunization, meeting a process improvement objective, etc."; 10058 case GRAPHDEFINITION: return "A formal computable definition of a graph of resources - that is, a coherent set of resources that form a graph by following references. The Graph Definition resource defines a set and makes rules about the set."; 10059 case GROUP: return "Represents a defined collection of entities that may be discussed or acted upon collectively but which are not expected to act collectively, and are not formally or legally recognized; i.e. a collection of entities that isn't an Organization."; 10060 case GUIDANCERESPONSE: return "A guidance response is the formal response to a guidance request, including any output parameters returned by the evaluation, as well as the description of any proposed actions to be taken."; 10061 case HEALTHCARESERVICE: return "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."; 10062 case IMAGINGSELECTION: return "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."; 10063 case IMAGINGSTUDY: return "Representation of the content produced in a DICOM imaging study. A study comprises a set of series, each of which includes a set of Service-Object Pair Instances (SOP Instances - images or other data) acquired or produced in a common context. A series is of only one modality (e.g. X-ray, CT, MR, ultrasound), but a study may have multiple series of different modalities."; 10064 case IMMUNIZATION: return "Describes the event of a patient being administered a vaccine or a record of an immunization as reported by a patient, a clinician or another party."; 10065 case IMMUNIZATIONEVALUATION: return "Describes a comparison of an immunization event against published recommendations to determine if the administration is \"valid\" in relation to those recommendations."; 10066 case IMMUNIZATIONRECOMMENDATION: return "A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification."; 10067 case IMPLEMENTATIONGUIDE: return "A set of rules of how a particular interoperability or standards problem is solved - typically through the use of FHIR resources. This resource is used to gather all the parts of an implementation guide into a logical whole and to publish a computable definition of all the parts."; 10068 case INGREDIENT: return "An ingredient of a manufactured item or pharmaceutical product."; 10069 case INSURANCEPLAN: return "Details of a Health Insurance product/plan provided by an organization."; 10070 case INVENTORYITEM: return "functional description of an inventory item used in inventory and supply-related workflows."; 10071 case INVENTORYREPORT: return "A report of inventory or stock items."; 10072 case INVOICE: return "Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose."; 10073 case LIBRARY: return "The Library resource is a general-purpose container for knowledge asset definitions. It can be used to describe and expose existing knowledge assets such as logic libraries and information model descriptions, as well as to describe a collection of knowledge assets."; 10074 case LINKAGE: return "Identifies two or more records (resource instances) that refer to the same real-world \"occurrence\"."; 10075 case LIST: return "A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc."; 10076 case LOCATION: return "Details and position information for a place where services are provided and resources and participants may be stored, found, contained, or accommodated."; 10077 case MANUFACTUREDITEMDEFINITION: return "The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product."; 10078 case MEASURE: return "The Measure resource provides the definition of a quality measure."; 10079 case MEASUREREPORT: return "The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation."; 10080 case MEDICATION: return "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."; 10081 case MEDICATIONADMINISTRATION: return "Describes the event of a patient consuming or otherwise being administered a medication. This may be as simple as swallowing a tablet or it may be a long running infusion. Related resources tie this event to the authorizing prescription, and the specific encounter between patient and health care practitioner. This event can also be used to record waste using a status of not-done and the appropriate statusReason."; 10082 case MEDICATIONDISPENSE: return "Indicates that a medication product is to be or has been dispensed for a named person/patient. This includes a description of the medication product (supply) provided and the instructions for administering the medication. The medication dispense is the result of a pharmacy system responding to a medication order."; 10083 case MEDICATIONKNOWLEDGE: return "Information about a medication that is used to support knowledge."; 10084 case MEDICATIONREQUEST: return "An order or request for both supply of the medication and the instructions for administration of the medication to a patient. The resource is called \"MedicationRequest\" rather than \"MedicationPrescription\" or \"MedicationOrder\" to generalize the use across inpatient and outpatient settings, including care plans, etc., and to harmonize with workflow patterns."; 10085 case MEDICATIONSTATEMENT: return "A record of a medication that is being consumed by a patient. A MedicationStatement may indicate that the patient may be taking the medication now or has taken the medication in the past or will be taking the medication in the future. The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician. A common scenario where this information is captured is during the history taking process during a patient visit or stay. The medication information may come from sources such as the patient's memory, from a prescription bottle, or from a list of medications the patient, clinician or other party maintains. \n\nThe primary difference between a 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."; 10086 case MEDICINALPRODUCTDEFINITION: return "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.)."; 10087 case MESSAGEDEFINITION: return "Defines the characteristics of a message that can be shared between systems, including the type of event that initiates the message, the content to be transmitted and what response(s), if any, are permitted."; 10088 case MESSAGEHEADER: return "The header for a message exchange that is either requesting or responding to an action. The reference(s) that are the subject of the action as well as other information related to the action are typically transmitted in a bundle in which the MessageHeader resource instance is the first resource in the bundle."; 10089 case METADATARESOURCE: return "Common Interface declaration for conformance and knowledge artifact resources."; 10090 case MOLECULARSEQUENCE: return "Representation of a molecular sequence."; 10091 case NAMINGSYSTEM: return "A curated namespace that issues unique symbols within that namespace for the identification of concepts, people, devices, etc. Represents a \"System\" used within the Identifier and Coding data types."; 10092 case NUTRITIONINTAKE: return "A record of food or fluid that is being consumed by a patient. A NutritionIntake may indicate that the patient may be consuming the food or fluid now or has consumed the food or fluid in the past. The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician. A common scenario where this information is captured is during the history taking process during a patient visit or stay or through an app that tracks food or fluids consumed. The consumption information may come from sources such as the patient's memory, from a nutrition label, or from a clinician documenting observed intake."; 10093 case NUTRITIONORDER: return "A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident."; 10094 case NUTRITIONPRODUCT: return "A food or supplement that is consumed by patients."; 10095 case OBSERVATION: return "Measurements and simple assertions made about a patient, device or other subject."; 10096 case OBSERVATIONDEFINITION: return "Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service."; 10097 case OPERATIONDEFINITION: return "A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction)."; 10098 case OPERATIONOUTCOME: return "A collection of error, warning, or information messages that result from a system action."; 10099 case ORGANIZATION: return "A formally or informally recognized grouping of people or organizations formed for the purpose of achieving some form of collective action. Includes companies, institutions, corporations, departments, community groups, healthcare practice groups, payer/insurer, etc."; 10100 case ORGANIZATIONAFFILIATION: return "Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship."; 10101 case PACKAGEDPRODUCTDEFINITION: return "A medically related item or items, in a container or package."; 10102 case PATIENT: return "Demographics and other administrative information about an individual or animal receiving care or other health-related services."; 10103 case PAYMENTNOTICE: return "This resource provides the status of the payment for goods and services rendered, and the request and response resource references."; 10104 case PAYMENTRECONCILIATION: return "This resource provides the details including amount of a payment and allocates the payment items being paid."; 10105 case PERMISSION: return "Permission resource holds access rules for a given data and context."; 10106 case PERSON: return "Demographics and administrative information about a person independent of a specific health-related context."; 10107 case PLANDEFINITION: return "This resource allows for the definition of various types of plans as a sharable, consumable, and executable artifact. The resource is general enough to support the description of a broad range of clinical and non-clinical artifacts such as clinical decision support rules, order sets, protocols, and drug quality specifications."; 10108 case PRACTITIONER: return "A person who is directly or indirectly involved in the provisioning of healthcare or related services."; 10109 case PRACTITIONERROLE: return "A specific set of Roles/Locations/specialties/services that a practitioner may perform, or has performed at an organization during a period of time."; 10110 case PROCEDURE: return "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."; 10111 case PROVENANCE: return "Provenance of a resource is a record that describes entities and processes involved in producing and delivering or otherwise influencing that resource. Provenance provides a critical foundation for assessing authenticity, enabling trust, and allowing reproducibility. Provenance assertions are a form of contextual metadata and can themselves become important records with their own provenance. Provenance statement indicates clinical significance in terms of confidence in authenticity, reliability, and trustworthiness, integrity, and stage in lifecycle (e.g. Document Completion - has the artifact been legally authenticated), all of which may impact security, privacy, and trust policies."; 10112 case QUESTIONNAIRE: return "A structured set of questions intended to guide the collection of answers from end-users. Questionnaires provide detailed control over order, presentation, phraseology and grouping to allow coherent, consistent data collection."; 10113 case QUESTIONNAIRERESPONSE: return "A structured set of questions and their answers. The questions are ordered and grouped into coherent subsets, corresponding to the structure of the grouping of the questionnaire being responded to."; 10114 case REGULATEDAUTHORIZATION: return "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."; 10115 case RELATEDPERSON: return "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."; 10116 case REQUESTORCHESTRATION: return "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\"."; 10117 case REQUIREMENTS: return "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."; 10118 case RESEARCHSTUDY: return "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."; 10119 case RESEARCHSUBJECT: return "A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study."; 10120 case RISKASSESSMENT: return "An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome."; 10121 case SCHEDULE: return "A container for slots of time that may be available for booking appointments."; 10122 case SEARCHPARAMETER: return "A search parameter that defines a named search item that can be used to search/filter on a resource."; 10123 case SERVICEREQUEST: return "A record of a request for service such as diagnostic investigations, treatments, or operations to be performed."; 10124 case SLOT: return "A slot of time on a schedule that may be available for booking appointments."; 10125 case SPECIMEN: return "A sample to be used for analysis."; 10126 case SPECIMENDEFINITION: return "A kind of specimen with associated set of requirements."; 10127 case STRUCTUREDEFINITION: return "A definition of a FHIR structure. This resource is used to describe the underlying resources, data types defined in FHIR, and also for describing extensions and constraints on resources and data types."; 10128 case STRUCTUREMAP: return "A Map of relationships between 2 structures that can be used to transform data."; 10129 case SUBSCRIPTION: return "The subscription resource describes a particular client's request to be notified about a SubscriptionTopic."; 10130 case SUBSCRIPTIONSTATUS: return "The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted."; 10131 case SUBSCRIPTIONTOPIC: return "Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic."; 10132 case SUBSTANCE: return "A homogeneous material with a definite composition."; 10133 case SUBSTANCEDEFINITION: return "The detailed description of a substance, typically at a level beyond what is used for prescribing."; 10134 case SUBSTANCENUCLEICACID: return "Nucleic acids are defined by three distinct elements: the base, sugar and linkage. Individual substance/moiety IDs will be created for each of these elements. The nucleotide sequence will be always entered in the 5?-3? direction."; 10135 case SUBSTANCEPOLYMER: return "Properties of a substance specific to it being a polymer."; 10136 case SUBSTANCEPROTEIN: return "A SubstanceProtein is defined as a single unit of a linear amino acid sequence, or a combination of subunits that are either covalently linked or have a defined invariant stoichiometric relationship. This includes all synthetic, recombinant and purified SubstanceProteins of defined sequence, whether the use is therapeutic or prophylactic. This set of elements will be used to describe albumins, coagulation factors, cytokines, growth factors, peptide/SubstanceProtein hormones, enzymes, toxins, toxoids, recombinant vaccines, and immunomodulators."; 10137 case SUBSTANCEREFERENCEINFORMATION: return "Todo."; 10138 case SUBSTANCESOURCEMATERIAL: return "Source material shall capture information on the taxonomic and anatomical origins as well as the fraction of a material that can result in or can be modified to form a substance. This set of data elements shall be used to define polymer substances isolated from biological matrices. Taxonomic and anatomical origins shall be described using a controlled vocabulary as required. This information is captured for naturally derived polymers ( . starch) and structurally diverse substances. For Organisms belonging to the Kingdom Plantae the Substance level defines the fresh material of a single species or infraspecies, the Herbal Drug and the Herbal preparation. For Herbal preparations, the fraction information will be captured at the Substance information level and additional information for herbal extracts will be captured at the Specified Substance Group 1 information level. See for further explanation the Substance Class: Structurally Diverse and the herbal annex."; 10139 case SUPPLYDELIVERY: return "Record of delivery of what is supplied."; 10140 case SUPPLYREQUEST: return "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."; 10141 case TASK: return "A task to be performed."; 10142 case TERMINOLOGYCAPABILITIES: return "A TerminologyCapabilities resource documents a set of capabilities (behaviors) of a FHIR Terminology Server that may be used as a statement of actual server functionality or a statement of required or desired server implementation."; 10143 case TESTPLAN: return "A plan for executing testing on an artifact or specifications"; 10144 case TESTREPORT: return "A summary of information based on the results of executing a TestScript."; 10145 case TESTSCRIPT: return "A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification."; 10146 case TRANSPORT: return "Record of transport."; 10147 case VALUESET: return "A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html)."; 10148 case VERIFICATIONRESULT: return "Describes validation requirements, source(s), status and dates for one or more elements."; 10149 case VISIONPRESCRIPTION: return "An authorization for the provision of glasses and/or contact lenses to a patient."; 10150 case PARAMETERS: return "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."; 10151 case NULL: return null; 10152 default: return "?"; 10153 } 10154 } 10155 public String getDisplay() { 10156 switch (this) { 10157 case BASE: return "Base"; 10158 case ELEMENT: return "Element"; 10159 case BACKBONEELEMENT: return "BackboneElement"; 10160 case DATATYPE: return "DataType"; 10161 case ADDRESS: return "Address"; 10162 case ANNOTATION: return "Annotation"; 10163 case ATTACHMENT: return "Attachment"; 10164 case AVAILABILITY: return "Availability"; 10165 case BACKBONETYPE: return "BackboneType"; 10166 case DOSAGE: return "Dosage"; 10167 case ELEMENTDEFINITION: return "ElementDefinition"; 10168 case MARKETINGSTATUS: return "MarketingStatus"; 10169 case PRODUCTSHELFLIFE: return "ProductShelfLife"; 10170 case TIMING: return "Timing"; 10171 case CODEABLECONCEPT: return "CodeableConcept"; 10172 case CODEABLEREFERENCE: return "CodeableReference"; 10173 case CODING: return "Coding"; 10174 case CONTACTDETAIL: return "ContactDetail"; 10175 case CONTACTPOINT: return "ContactPoint"; 10176 case CONTRIBUTOR: return "Contributor"; 10177 case DATAREQUIREMENT: return "DataRequirement"; 10178 case EXPRESSION: return "Expression"; 10179 case EXTENDEDCONTACTDETAIL: return "ExtendedContactDetail"; 10180 case EXTENSION: return "Extension"; 10181 case HUMANNAME: return "HumanName"; 10182 case IDENTIFIER: return "Identifier"; 10183 case META: return "Meta"; 10184 case MONETARYCOMPONENT: return "MonetaryComponent"; 10185 case MONEY: return "Money"; 10186 case NARRATIVE: return "Narrative"; 10187 case PARAMETERDEFINITION: return "ParameterDefinition"; 10188 case PERIOD: return "Period"; 10189 case PRIMITIVETYPE: return "PrimitiveType"; 10190 case BASE64BINARY: return "base64Binary"; 10191 case BOOLEAN: return "boolean"; 10192 case DATE: return "date"; 10193 case DATETIME: return "dateTime"; 10194 case DECIMAL: return "decimal"; 10195 case INSTANT: return "instant"; 10196 case INTEGER: return "integer"; 10197 case POSITIVEINT: return "positiveInt"; 10198 case UNSIGNEDINT: return "unsignedInt"; 10199 case INTEGER64: return "integer64"; 10200 case STRING: return "string"; 10201 case CODE: return "code"; 10202 case ID: return "id"; 10203 case MARKDOWN: return "markdown"; 10204 case TIME: return "time"; 10205 case URI: return "uri"; 10206 case CANONICAL: return "canonical"; 10207 case OID: return "oid"; 10208 case URL: return "url"; 10209 case UUID: return "uuid"; 10210 case QUANTITY: return "Quantity"; 10211 case AGE: return "Age"; 10212 case COUNT: return "Count"; 10213 case DISTANCE: return "Distance"; 10214 case DURATION: return "Duration"; 10215 case RANGE: return "Range"; 10216 case RATIO: return "Ratio"; 10217 case RATIORANGE: return "RatioRange"; 10218 case REFERENCE: return "Reference"; 10219 case RELATEDARTIFACT: return "RelatedArtifact"; 10220 case SAMPLEDDATA: return "SampledData"; 10221 case SIGNATURE: return "Signature"; 10222 case TRIGGERDEFINITION: return "TriggerDefinition"; 10223 case USAGECONTEXT: return "UsageContext"; 10224 case VIRTUALSERVICEDETAIL: return "VirtualServiceDetail"; 10225 case XHTML: return "xhtml"; 10226 case RESOURCE: return "Resource"; 10227 case BINARY: return "Binary"; 10228 case BUNDLE: return "Bundle"; 10229 case DOMAINRESOURCE: return "DomainResource"; 10230 case ACCOUNT: return "Account"; 10231 case ACTIVITYDEFINITION: return "ActivityDefinition"; 10232 case ACTORDEFINITION: return "ActorDefinition"; 10233 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 10234 case ADVERSEEVENT: return "AdverseEvent"; 10235 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 10236 case APPOINTMENT: return "Appointment"; 10237 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 10238 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 10239 case AUDITEVENT: return "AuditEvent"; 10240 case BASIC: return "Basic"; 10241 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 10242 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "BiologicallyDerivedProductDispense"; 10243 case BODYSTRUCTURE: return "BodyStructure"; 10244 case CANONICALRESOURCE: return "CanonicalResource"; 10245 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 10246 case CAREPLAN: return "CarePlan"; 10247 case CARETEAM: return "CareTeam"; 10248 case CHARGEITEM: return "ChargeItem"; 10249 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 10250 case CITATION: return "Citation"; 10251 case CLAIM: return "Claim"; 10252 case CLAIMRESPONSE: return "ClaimResponse"; 10253 case CLINICALIMPRESSION: return "ClinicalImpression"; 10254 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 10255 case CODESYSTEM: return "CodeSystem"; 10256 case COMMUNICATION: return "Communication"; 10257 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 10258 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 10259 case COMPOSITION: return "Composition"; 10260 case CONCEPTMAP: return "ConceptMap"; 10261 case CONDITION: return "Condition"; 10262 case CONDITIONDEFINITION: return "ConditionDefinition"; 10263 case CONSENT: return "Consent"; 10264 case CONTRACT: return "Contract"; 10265 case COVERAGE: return "Coverage"; 10266 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 10267 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 10268 case DETECTEDISSUE: return "DetectedIssue"; 10269 case DEVICE: return "Device"; 10270 case DEVICEASSOCIATION: return "DeviceAssociation"; 10271 case DEVICEDEFINITION: return "DeviceDefinition"; 10272 case DEVICEDISPENSE: return "DeviceDispense"; 10273 case DEVICEMETRIC: return "DeviceMetric"; 10274 case DEVICEREQUEST: return "DeviceRequest"; 10275 case DEVICEUSAGE: return "DeviceUsage"; 10276 case DIAGNOSTICREPORT: return "DiagnosticReport"; 10277 case DOCUMENTREFERENCE: return "DocumentReference"; 10278 case ENCOUNTER: return "Encounter"; 10279 case ENCOUNTERHISTORY: return "EncounterHistory"; 10280 case ENDPOINT: return "Endpoint"; 10281 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 10282 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 10283 case EPISODEOFCARE: return "EpisodeOfCare"; 10284 case EVENTDEFINITION: return "EventDefinition"; 10285 case EVIDENCE: return "Evidence"; 10286 case EVIDENCEREPORT: return "EvidenceReport"; 10287 case EVIDENCEVARIABLE: return "EvidenceVariable"; 10288 case EXAMPLESCENARIO: return "ExampleScenario"; 10289 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 10290 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 10291 case FLAG: return "Flag"; 10292 case FORMULARYITEM: return "FormularyItem"; 10293 case GENOMICSTUDY: return "GenomicStudy"; 10294 case GOAL: return "Goal"; 10295 case GRAPHDEFINITION: return "GraphDefinition"; 10296 case GROUP: return "Group"; 10297 case GUIDANCERESPONSE: return "GuidanceResponse"; 10298 case HEALTHCARESERVICE: return "HealthcareService"; 10299 case IMAGINGSELECTION: return "ImagingSelection"; 10300 case IMAGINGSTUDY: return "ImagingStudy"; 10301 case IMMUNIZATION: return "Immunization"; 10302 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 10303 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 10304 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 10305 case INGREDIENT: return "Ingredient"; 10306 case INSURANCEPLAN: return "InsurancePlan"; 10307 case INVENTORYITEM: return "InventoryItem"; 10308 case INVENTORYREPORT: return "InventoryReport"; 10309 case INVOICE: return "Invoice"; 10310 case LIBRARY: return "Library"; 10311 case LINKAGE: return "Linkage"; 10312 case LIST: return "List"; 10313 case LOCATION: return "Location"; 10314 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 10315 case MEASURE: return "Measure"; 10316 case MEASUREREPORT: return "MeasureReport"; 10317 case MEDICATION: return "Medication"; 10318 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 10319 case MEDICATIONDISPENSE: return "MedicationDispense"; 10320 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 10321 case MEDICATIONREQUEST: return "MedicationRequest"; 10322 case MEDICATIONSTATEMENT: return "MedicationStatement"; 10323 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 10324 case MESSAGEDEFINITION: return "MessageDefinition"; 10325 case MESSAGEHEADER: return "MessageHeader"; 10326 case METADATARESOURCE: return "MetadataResource"; 10327 case MOLECULARSEQUENCE: return "MolecularSequence"; 10328 case NAMINGSYSTEM: return "NamingSystem"; 10329 case NUTRITIONINTAKE: return "NutritionIntake"; 10330 case NUTRITIONORDER: return "NutritionOrder"; 10331 case NUTRITIONPRODUCT: return "NutritionProduct"; 10332 case OBSERVATION: return "Observation"; 10333 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 10334 case OPERATIONDEFINITION: return "OperationDefinition"; 10335 case OPERATIONOUTCOME: return "OperationOutcome"; 10336 case ORGANIZATION: return "Organization"; 10337 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 10338 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 10339 case PATIENT: return "Patient"; 10340 case PAYMENTNOTICE: return "PaymentNotice"; 10341 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 10342 case PERMISSION: return "Permission"; 10343 case PERSON: return "Person"; 10344 case PLANDEFINITION: return "PlanDefinition"; 10345 case PRACTITIONER: return "Practitioner"; 10346 case PRACTITIONERROLE: return "PractitionerRole"; 10347 case PROCEDURE: return "Procedure"; 10348 case PROVENANCE: return "Provenance"; 10349 case QUESTIONNAIRE: return "Questionnaire"; 10350 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 10351 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 10352 case RELATEDPERSON: return "RelatedPerson"; 10353 case REQUESTORCHESTRATION: return "RequestOrchestration"; 10354 case REQUIREMENTS: return "Requirements"; 10355 case RESEARCHSTUDY: return "ResearchStudy"; 10356 case RESEARCHSUBJECT: return "ResearchSubject"; 10357 case RISKASSESSMENT: return "RiskAssessment"; 10358 case SCHEDULE: return "Schedule"; 10359 case SEARCHPARAMETER: return "SearchParameter"; 10360 case SERVICEREQUEST: return "ServiceRequest"; 10361 case SLOT: return "Slot"; 10362 case SPECIMEN: return "Specimen"; 10363 case SPECIMENDEFINITION: return "SpecimenDefinition"; 10364 case STRUCTUREDEFINITION: return "StructureDefinition"; 10365 case STRUCTUREMAP: return "StructureMap"; 10366 case SUBSCRIPTION: return "Subscription"; 10367 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 10368 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 10369 case SUBSTANCE: return "Substance"; 10370 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 10371 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 10372 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 10373 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 10374 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 10375 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 10376 case SUPPLYDELIVERY: return "SupplyDelivery"; 10377 case SUPPLYREQUEST: return "SupplyRequest"; 10378 case TASK: return "Task"; 10379 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 10380 case TESTPLAN: return "TestPlan"; 10381 case TESTREPORT: return "TestReport"; 10382 case TESTSCRIPT: return "TestScript"; 10383 case TRANSPORT: return "Transport"; 10384 case VALUESET: return "ValueSet"; 10385 case VERIFICATIONRESULT: return "VerificationResult"; 10386 case VISIONPRESCRIPTION: return "VisionPrescription"; 10387 case PARAMETERS: return "Parameters"; 10388 case NULL: return null; 10389 default: return "?"; 10390 } 10391 } 10392 } 10393 10394 public static class FHIRTypesEnumFactory implements EnumFactory<FHIRTypes> { 10395 public FHIRTypes fromCode(String codeString) throws IllegalArgumentException { 10396 if (codeString == null || "".equals(codeString)) 10397 if (codeString == null || "".equals(codeString)) 10398 return null; 10399 if ("Base".equals(codeString)) 10400 return FHIRTypes.BASE; 10401 if ("Element".equals(codeString)) 10402 return FHIRTypes.ELEMENT; 10403 if ("BackboneElement".equals(codeString)) 10404 return FHIRTypes.BACKBONEELEMENT; 10405 if ("DataType".equals(codeString)) 10406 return FHIRTypes.DATATYPE; 10407 if ("Address".equals(codeString)) 10408 return FHIRTypes.ADDRESS; 10409 if ("Annotation".equals(codeString)) 10410 return FHIRTypes.ANNOTATION; 10411 if ("Attachment".equals(codeString)) 10412 return FHIRTypes.ATTACHMENT; 10413 if ("Availability".equals(codeString)) 10414 return FHIRTypes.AVAILABILITY; 10415 if ("BackboneType".equals(codeString)) 10416 return FHIRTypes.BACKBONETYPE; 10417 if ("Dosage".equals(codeString)) 10418 return FHIRTypes.DOSAGE; 10419 if ("ElementDefinition".equals(codeString)) 10420 return FHIRTypes.ELEMENTDEFINITION; 10421 if ("MarketingStatus".equals(codeString)) 10422 return FHIRTypes.MARKETINGSTATUS; 10423 if ("ProductShelfLife".equals(codeString)) 10424 return FHIRTypes.PRODUCTSHELFLIFE; 10425 if ("Timing".equals(codeString)) 10426 return FHIRTypes.TIMING; 10427 if ("CodeableConcept".equals(codeString)) 10428 return FHIRTypes.CODEABLECONCEPT; 10429 if ("CodeableReference".equals(codeString)) 10430 return FHIRTypes.CODEABLEREFERENCE; 10431 if ("Coding".equals(codeString)) 10432 return FHIRTypes.CODING; 10433 if ("ContactDetail".equals(codeString)) 10434 return FHIRTypes.CONTACTDETAIL; 10435 if ("ContactPoint".equals(codeString)) 10436 return FHIRTypes.CONTACTPOINT; 10437 if ("Contributor".equals(codeString)) 10438 return FHIRTypes.CONTRIBUTOR; 10439 if ("DataRequirement".equals(codeString)) 10440 return FHIRTypes.DATAREQUIREMENT; 10441 if ("Expression".equals(codeString)) 10442 return FHIRTypes.EXPRESSION; 10443 if ("ExtendedContactDetail".equals(codeString)) 10444 return FHIRTypes.EXTENDEDCONTACTDETAIL; 10445 if ("Extension".equals(codeString)) 10446 return FHIRTypes.EXTENSION; 10447 if ("HumanName".equals(codeString)) 10448 return FHIRTypes.HUMANNAME; 10449 if ("Identifier".equals(codeString)) 10450 return FHIRTypes.IDENTIFIER; 10451 if ("Meta".equals(codeString)) 10452 return FHIRTypes.META; 10453 if ("MonetaryComponent".equals(codeString)) 10454 return FHIRTypes.MONETARYCOMPONENT; 10455 if ("Money".equals(codeString)) 10456 return FHIRTypes.MONEY; 10457 if ("Narrative".equals(codeString)) 10458 return FHIRTypes.NARRATIVE; 10459 if ("ParameterDefinition".equals(codeString)) 10460 return FHIRTypes.PARAMETERDEFINITION; 10461 if ("Period".equals(codeString)) 10462 return FHIRTypes.PERIOD; 10463 if ("PrimitiveType".equals(codeString)) 10464 return FHIRTypes.PRIMITIVETYPE; 10465 if ("base64Binary".equals(codeString)) 10466 return FHIRTypes.BASE64BINARY; 10467 if ("boolean".equals(codeString)) 10468 return FHIRTypes.BOOLEAN; 10469 if ("date".equals(codeString)) 10470 return FHIRTypes.DATE; 10471 if ("dateTime".equals(codeString)) 10472 return FHIRTypes.DATETIME; 10473 if ("decimal".equals(codeString)) 10474 return FHIRTypes.DECIMAL; 10475 if ("instant".equals(codeString)) 10476 return FHIRTypes.INSTANT; 10477 if ("integer".equals(codeString)) 10478 return FHIRTypes.INTEGER; 10479 if ("positiveInt".equals(codeString)) 10480 return FHIRTypes.POSITIVEINT; 10481 if ("unsignedInt".equals(codeString)) 10482 return FHIRTypes.UNSIGNEDINT; 10483 if ("integer64".equals(codeString)) 10484 return FHIRTypes.INTEGER64; 10485 if ("string".equals(codeString)) 10486 return FHIRTypes.STRING; 10487 if ("code".equals(codeString)) 10488 return FHIRTypes.CODE; 10489 if ("id".equals(codeString)) 10490 return FHIRTypes.ID; 10491 if ("markdown".equals(codeString)) 10492 return FHIRTypes.MARKDOWN; 10493 if ("time".equals(codeString)) 10494 return FHIRTypes.TIME; 10495 if ("uri".equals(codeString)) 10496 return FHIRTypes.URI; 10497 if ("canonical".equals(codeString)) 10498 return FHIRTypes.CANONICAL; 10499 if ("oid".equals(codeString)) 10500 return FHIRTypes.OID; 10501 if ("url".equals(codeString)) 10502 return FHIRTypes.URL; 10503 if ("uuid".equals(codeString)) 10504 return FHIRTypes.UUID; 10505 if ("Quantity".equals(codeString)) 10506 return FHIRTypes.QUANTITY; 10507 if ("Age".equals(codeString)) 10508 return FHIRTypes.AGE; 10509 if ("Count".equals(codeString)) 10510 return FHIRTypes.COUNT; 10511 if ("Distance".equals(codeString)) 10512 return FHIRTypes.DISTANCE; 10513 if ("Duration".equals(codeString)) 10514 return FHIRTypes.DURATION; 10515 if ("Range".equals(codeString)) 10516 return FHIRTypes.RANGE; 10517 if ("Ratio".equals(codeString)) 10518 return FHIRTypes.RATIO; 10519 if ("RatioRange".equals(codeString)) 10520 return FHIRTypes.RATIORANGE; 10521 if ("Reference".equals(codeString)) 10522 return FHIRTypes.REFERENCE; 10523 if ("RelatedArtifact".equals(codeString)) 10524 return FHIRTypes.RELATEDARTIFACT; 10525 if ("SampledData".equals(codeString)) 10526 return FHIRTypes.SAMPLEDDATA; 10527 if ("Signature".equals(codeString)) 10528 return FHIRTypes.SIGNATURE; 10529 if ("TriggerDefinition".equals(codeString)) 10530 return FHIRTypes.TRIGGERDEFINITION; 10531 if ("UsageContext".equals(codeString)) 10532 return FHIRTypes.USAGECONTEXT; 10533 if ("VirtualServiceDetail".equals(codeString)) 10534 return FHIRTypes.VIRTUALSERVICEDETAIL; 10535 if ("xhtml".equals(codeString)) 10536 return FHIRTypes.XHTML; 10537 if ("Resource".equals(codeString)) 10538 return FHIRTypes.RESOURCE; 10539 if ("Binary".equals(codeString)) 10540 return FHIRTypes.BINARY; 10541 if ("Bundle".equals(codeString)) 10542 return FHIRTypes.BUNDLE; 10543 if ("DomainResource".equals(codeString)) 10544 return FHIRTypes.DOMAINRESOURCE; 10545 if ("Account".equals(codeString)) 10546 return FHIRTypes.ACCOUNT; 10547 if ("ActivityDefinition".equals(codeString)) 10548 return FHIRTypes.ACTIVITYDEFINITION; 10549 if ("ActorDefinition".equals(codeString)) 10550 return FHIRTypes.ACTORDEFINITION; 10551 if ("AdministrableProductDefinition".equals(codeString)) 10552 return FHIRTypes.ADMINISTRABLEPRODUCTDEFINITION; 10553 if ("AdverseEvent".equals(codeString)) 10554 return FHIRTypes.ADVERSEEVENT; 10555 if ("AllergyIntolerance".equals(codeString)) 10556 return FHIRTypes.ALLERGYINTOLERANCE; 10557 if ("Appointment".equals(codeString)) 10558 return FHIRTypes.APPOINTMENT; 10559 if ("AppointmentResponse".equals(codeString)) 10560 return FHIRTypes.APPOINTMENTRESPONSE; 10561 if ("ArtifactAssessment".equals(codeString)) 10562 return FHIRTypes.ARTIFACTASSESSMENT; 10563 if ("AuditEvent".equals(codeString)) 10564 return FHIRTypes.AUDITEVENT; 10565 if ("Basic".equals(codeString)) 10566 return FHIRTypes.BASIC; 10567 if ("BiologicallyDerivedProduct".equals(codeString)) 10568 return FHIRTypes.BIOLOGICALLYDERIVEDPRODUCT; 10569 if ("BiologicallyDerivedProductDispense".equals(codeString)) 10570 return FHIRTypes.BIOLOGICALLYDERIVEDPRODUCTDISPENSE; 10571 if ("BodyStructure".equals(codeString)) 10572 return FHIRTypes.BODYSTRUCTURE; 10573 if ("CanonicalResource".equals(codeString)) 10574 return FHIRTypes.CANONICALRESOURCE; 10575 if ("CapabilityStatement".equals(codeString)) 10576 return FHIRTypes.CAPABILITYSTATEMENT; 10577 if ("CarePlan".equals(codeString)) 10578 return FHIRTypes.CAREPLAN; 10579 if ("CareTeam".equals(codeString)) 10580 return FHIRTypes.CARETEAM; 10581 if ("ChargeItem".equals(codeString)) 10582 return FHIRTypes.CHARGEITEM; 10583 if ("ChargeItemDefinition".equals(codeString)) 10584 return FHIRTypes.CHARGEITEMDEFINITION; 10585 if ("Citation".equals(codeString)) 10586 return FHIRTypes.CITATION; 10587 if ("Claim".equals(codeString)) 10588 return FHIRTypes.CLAIM; 10589 if ("ClaimResponse".equals(codeString)) 10590 return FHIRTypes.CLAIMRESPONSE; 10591 if ("ClinicalImpression".equals(codeString)) 10592 return FHIRTypes.CLINICALIMPRESSION; 10593 if ("ClinicalUseDefinition".equals(codeString)) 10594 return FHIRTypes.CLINICALUSEDEFINITION; 10595 if ("CodeSystem".equals(codeString)) 10596 return FHIRTypes.CODESYSTEM; 10597 if ("Communication".equals(codeString)) 10598 return FHIRTypes.COMMUNICATION; 10599 if ("CommunicationRequest".equals(codeString)) 10600 return FHIRTypes.COMMUNICATIONREQUEST; 10601 if ("CompartmentDefinition".equals(codeString)) 10602 return FHIRTypes.COMPARTMENTDEFINITION; 10603 if ("Composition".equals(codeString)) 10604 return FHIRTypes.COMPOSITION; 10605 if ("ConceptMap".equals(codeString)) 10606 return FHIRTypes.CONCEPTMAP; 10607 if ("Condition".equals(codeString)) 10608 return FHIRTypes.CONDITION; 10609 if ("ConditionDefinition".equals(codeString)) 10610 return FHIRTypes.CONDITIONDEFINITION; 10611 if ("Consent".equals(codeString)) 10612 return FHIRTypes.CONSENT; 10613 if ("Contract".equals(codeString)) 10614 return FHIRTypes.CONTRACT; 10615 if ("Coverage".equals(codeString)) 10616 return FHIRTypes.COVERAGE; 10617 if ("CoverageEligibilityRequest".equals(codeString)) 10618 return FHIRTypes.COVERAGEELIGIBILITYREQUEST; 10619 if ("CoverageEligibilityResponse".equals(codeString)) 10620 return FHIRTypes.COVERAGEELIGIBILITYRESPONSE; 10621 if ("DetectedIssue".equals(codeString)) 10622 return FHIRTypes.DETECTEDISSUE; 10623 if ("Device".equals(codeString)) 10624 return FHIRTypes.DEVICE; 10625 if ("DeviceAssociation".equals(codeString)) 10626 return FHIRTypes.DEVICEASSOCIATION; 10627 if ("DeviceDefinition".equals(codeString)) 10628 return FHIRTypes.DEVICEDEFINITION; 10629 if ("DeviceDispense".equals(codeString)) 10630 return FHIRTypes.DEVICEDISPENSE; 10631 if ("DeviceMetric".equals(codeString)) 10632 return FHIRTypes.DEVICEMETRIC; 10633 if ("DeviceRequest".equals(codeString)) 10634 return FHIRTypes.DEVICEREQUEST; 10635 if ("DeviceUsage".equals(codeString)) 10636 return FHIRTypes.DEVICEUSAGE; 10637 if ("DiagnosticReport".equals(codeString)) 10638 return FHIRTypes.DIAGNOSTICREPORT; 10639 if ("DocumentReference".equals(codeString)) 10640 return FHIRTypes.DOCUMENTREFERENCE; 10641 if ("Encounter".equals(codeString)) 10642 return FHIRTypes.ENCOUNTER; 10643 if ("EncounterHistory".equals(codeString)) 10644 return FHIRTypes.ENCOUNTERHISTORY; 10645 if ("Endpoint".equals(codeString)) 10646 return FHIRTypes.ENDPOINT; 10647 if ("EnrollmentRequest".equals(codeString)) 10648 return FHIRTypes.ENROLLMENTREQUEST; 10649 if ("EnrollmentResponse".equals(codeString)) 10650 return FHIRTypes.ENROLLMENTRESPONSE; 10651 if ("EpisodeOfCare".equals(codeString)) 10652 return FHIRTypes.EPISODEOFCARE; 10653 if ("EventDefinition".equals(codeString)) 10654 return FHIRTypes.EVENTDEFINITION; 10655 if ("Evidence".equals(codeString)) 10656 return FHIRTypes.EVIDENCE; 10657 if ("EvidenceReport".equals(codeString)) 10658 return FHIRTypes.EVIDENCEREPORT; 10659 if ("EvidenceVariable".equals(codeString)) 10660 return FHIRTypes.EVIDENCEVARIABLE; 10661 if ("ExampleScenario".equals(codeString)) 10662 return FHIRTypes.EXAMPLESCENARIO; 10663 if ("ExplanationOfBenefit".equals(codeString)) 10664 return FHIRTypes.EXPLANATIONOFBENEFIT; 10665 if ("FamilyMemberHistory".equals(codeString)) 10666 return FHIRTypes.FAMILYMEMBERHISTORY; 10667 if ("Flag".equals(codeString)) 10668 return FHIRTypes.FLAG; 10669 if ("FormularyItem".equals(codeString)) 10670 return FHIRTypes.FORMULARYITEM; 10671 if ("GenomicStudy".equals(codeString)) 10672 return FHIRTypes.GENOMICSTUDY; 10673 if ("Goal".equals(codeString)) 10674 return FHIRTypes.GOAL; 10675 if ("GraphDefinition".equals(codeString)) 10676 return FHIRTypes.GRAPHDEFINITION; 10677 if ("Group".equals(codeString)) 10678 return FHIRTypes.GROUP; 10679 if ("GuidanceResponse".equals(codeString)) 10680 return FHIRTypes.GUIDANCERESPONSE; 10681 if ("HealthcareService".equals(codeString)) 10682 return FHIRTypes.HEALTHCARESERVICE; 10683 if ("ImagingSelection".equals(codeString)) 10684 return FHIRTypes.IMAGINGSELECTION; 10685 if ("ImagingStudy".equals(codeString)) 10686 return FHIRTypes.IMAGINGSTUDY; 10687 if ("Immunization".equals(codeString)) 10688 return FHIRTypes.IMMUNIZATION; 10689 if ("ImmunizationEvaluation".equals(codeString)) 10690 return FHIRTypes.IMMUNIZATIONEVALUATION; 10691 if ("ImmunizationRecommendation".equals(codeString)) 10692 return FHIRTypes.IMMUNIZATIONRECOMMENDATION; 10693 if ("ImplementationGuide".equals(codeString)) 10694 return FHIRTypes.IMPLEMENTATIONGUIDE; 10695 if ("Ingredient".equals(codeString)) 10696 return FHIRTypes.INGREDIENT; 10697 if ("InsurancePlan".equals(codeString)) 10698 return FHIRTypes.INSURANCEPLAN; 10699 if ("InventoryItem".equals(codeString)) 10700 return FHIRTypes.INVENTORYITEM; 10701 if ("InventoryReport".equals(codeString)) 10702 return FHIRTypes.INVENTORYREPORT; 10703 if ("Invoice".equals(codeString)) 10704 return FHIRTypes.INVOICE; 10705 if ("Library".equals(codeString)) 10706 return FHIRTypes.LIBRARY; 10707 if ("Linkage".equals(codeString)) 10708 return FHIRTypes.LINKAGE; 10709 if ("List".equals(codeString)) 10710 return FHIRTypes.LIST; 10711 if ("Location".equals(codeString)) 10712 return FHIRTypes.LOCATION; 10713 if ("ManufacturedItemDefinition".equals(codeString)) 10714 return FHIRTypes.MANUFACTUREDITEMDEFINITION; 10715 if ("Measure".equals(codeString)) 10716 return FHIRTypes.MEASURE; 10717 if ("MeasureReport".equals(codeString)) 10718 return FHIRTypes.MEASUREREPORT; 10719 if ("Medication".equals(codeString)) 10720 return FHIRTypes.MEDICATION; 10721 if ("MedicationAdministration".equals(codeString)) 10722 return FHIRTypes.MEDICATIONADMINISTRATION; 10723 if ("MedicationDispense".equals(codeString)) 10724 return FHIRTypes.MEDICATIONDISPENSE; 10725 if ("MedicationKnowledge".equals(codeString)) 10726 return FHIRTypes.MEDICATIONKNOWLEDGE; 10727 if ("MedicationRequest".equals(codeString)) 10728 return FHIRTypes.MEDICATIONREQUEST; 10729 if ("MedicationStatement".equals(codeString)) 10730 return FHIRTypes.MEDICATIONSTATEMENT; 10731 if ("MedicinalProductDefinition".equals(codeString)) 10732 return FHIRTypes.MEDICINALPRODUCTDEFINITION; 10733 if ("MessageDefinition".equals(codeString)) 10734 return FHIRTypes.MESSAGEDEFINITION; 10735 if ("MessageHeader".equals(codeString)) 10736 return FHIRTypes.MESSAGEHEADER; 10737 if ("MetadataResource".equals(codeString)) 10738 return FHIRTypes.METADATARESOURCE; 10739 if ("MolecularSequence".equals(codeString)) 10740 return FHIRTypes.MOLECULARSEQUENCE; 10741 if ("NamingSystem".equals(codeString)) 10742 return FHIRTypes.NAMINGSYSTEM; 10743 if ("NutritionIntake".equals(codeString)) 10744 return FHIRTypes.NUTRITIONINTAKE; 10745 if ("NutritionOrder".equals(codeString)) 10746 return FHIRTypes.NUTRITIONORDER; 10747 if ("NutritionProduct".equals(codeString)) 10748 return FHIRTypes.NUTRITIONPRODUCT; 10749 if ("Observation".equals(codeString)) 10750 return FHIRTypes.OBSERVATION; 10751 if ("ObservationDefinition".equals(codeString)) 10752 return FHIRTypes.OBSERVATIONDEFINITION; 10753 if ("OperationDefinition".equals(codeString)) 10754 return FHIRTypes.OPERATIONDEFINITION; 10755 if ("OperationOutcome".equals(codeString)) 10756 return FHIRTypes.OPERATIONOUTCOME; 10757 if ("Organization".equals(codeString)) 10758 return FHIRTypes.ORGANIZATION; 10759 if ("OrganizationAffiliation".equals(codeString)) 10760 return FHIRTypes.ORGANIZATIONAFFILIATION; 10761 if ("PackagedProductDefinition".equals(codeString)) 10762 return FHIRTypes.PACKAGEDPRODUCTDEFINITION; 10763 if ("Patient".equals(codeString)) 10764 return FHIRTypes.PATIENT; 10765 if ("PaymentNotice".equals(codeString)) 10766 return FHIRTypes.PAYMENTNOTICE; 10767 if ("PaymentReconciliation".equals(codeString)) 10768 return FHIRTypes.PAYMENTRECONCILIATION; 10769 if ("Permission".equals(codeString)) 10770 return FHIRTypes.PERMISSION; 10771 if ("Person".equals(codeString)) 10772 return FHIRTypes.PERSON; 10773 if ("PlanDefinition".equals(codeString)) 10774 return FHIRTypes.PLANDEFINITION; 10775 if ("Practitioner".equals(codeString)) 10776 return FHIRTypes.PRACTITIONER; 10777 if ("PractitionerRole".equals(codeString)) 10778 return FHIRTypes.PRACTITIONERROLE; 10779 if ("Procedure".equals(codeString)) 10780 return FHIRTypes.PROCEDURE; 10781 if ("Provenance".equals(codeString)) 10782 return FHIRTypes.PROVENANCE; 10783 if ("Questionnaire".equals(codeString)) 10784 return FHIRTypes.QUESTIONNAIRE; 10785 if ("QuestionnaireResponse".equals(codeString)) 10786 return FHIRTypes.QUESTIONNAIRERESPONSE; 10787 if ("RegulatedAuthorization".equals(codeString)) 10788 return FHIRTypes.REGULATEDAUTHORIZATION; 10789 if ("RelatedPerson".equals(codeString)) 10790 return FHIRTypes.RELATEDPERSON; 10791 if ("RequestOrchestration".equals(codeString)) 10792 return FHIRTypes.REQUESTORCHESTRATION; 10793 if ("Requirements".equals(codeString)) 10794 return FHIRTypes.REQUIREMENTS; 10795 if ("ResearchStudy".equals(codeString)) 10796 return FHIRTypes.RESEARCHSTUDY; 10797 if ("ResearchSubject".equals(codeString)) 10798 return FHIRTypes.RESEARCHSUBJECT; 10799 if ("RiskAssessment".equals(codeString)) 10800 return FHIRTypes.RISKASSESSMENT; 10801 if ("Schedule".equals(codeString)) 10802 return FHIRTypes.SCHEDULE; 10803 if ("SearchParameter".equals(codeString)) 10804 return FHIRTypes.SEARCHPARAMETER; 10805 if ("ServiceRequest".equals(codeString)) 10806 return FHIRTypes.SERVICEREQUEST; 10807 if ("Slot".equals(codeString)) 10808 return FHIRTypes.SLOT; 10809 if ("Specimen".equals(codeString)) 10810 return FHIRTypes.SPECIMEN; 10811 if ("SpecimenDefinition".equals(codeString)) 10812 return FHIRTypes.SPECIMENDEFINITION; 10813 if ("StructureDefinition".equals(codeString)) 10814 return FHIRTypes.STRUCTUREDEFINITION; 10815 if ("StructureMap".equals(codeString)) 10816 return FHIRTypes.STRUCTUREMAP; 10817 if ("Subscription".equals(codeString)) 10818 return FHIRTypes.SUBSCRIPTION; 10819 if ("SubscriptionStatus".equals(codeString)) 10820 return FHIRTypes.SUBSCRIPTIONSTATUS; 10821 if ("SubscriptionTopic".equals(codeString)) 10822 return FHIRTypes.SUBSCRIPTIONTOPIC; 10823 if ("Substance".equals(codeString)) 10824 return FHIRTypes.SUBSTANCE; 10825 if ("SubstanceDefinition".equals(codeString)) 10826 return FHIRTypes.SUBSTANCEDEFINITION; 10827 if ("SubstanceNucleicAcid".equals(codeString)) 10828 return FHIRTypes.SUBSTANCENUCLEICACID; 10829 if ("SubstancePolymer".equals(codeString)) 10830 return FHIRTypes.SUBSTANCEPOLYMER; 10831 if ("SubstanceProtein".equals(codeString)) 10832 return FHIRTypes.SUBSTANCEPROTEIN; 10833 if ("SubstanceReferenceInformation".equals(codeString)) 10834 return FHIRTypes.SUBSTANCEREFERENCEINFORMATION; 10835 if ("SubstanceSourceMaterial".equals(codeString)) 10836 return FHIRTypes.SUBSTANCESOURCEMATERIAL; 10837 if ("SupplyDelivery".equals(codeString)) 10838 return FHIRTypes.SUPPLYDELIVERY; 10839 if ("SupplyRequest".equals(codeString)) 10840 return FHIRTypes.SUPPLYREQUEST; 10841 if ("Task".equals(codeString)) 10842 return FHIRTypes.TASK; 10843 if ("TerminologyCapabilities".equals(codeString)) 10844 return FHIRTypes.TERMINOLOGYCAPABILITIES; 10845 if ("TestPlan".equals(codeString)) 10846 return FHIRTypes.TESTPLAN; 10847 if ("TestReport".equals(codeString)) 10848 return FHIRTypes.TESTREPORT; 10849 if ("TestScript".equals(codeString)) 10850 return FHIRTypes.TESTSCRIPT; 10851 if ("Transport".equals(codeString)) 10852 return FHIRTypes.TRANSPORT; 10853 if ("ValueSet".equals(codeString)) 10854 return FHIRTypes.VALUESET; 10855 if ("VerificationResult".equals(codeString)) 10856 return FHIRTypes.VERIFICATIONRESULT; 10857 if ("VisionPrescription".equals(codeString)) 10858 return FHIRTypes.VISIONPRESCRIPTION; 10859 if ("Parameters".equals(codeString)) 10860 return FHIRTypes.PARAMETERS; 10861 throw new IllegalArgumentException("Unknown FHIRTypes code '"+codeString+"'"); 10862 } 10863 10864 public Enumeration<FHIRTypes> fromType(PrimitiveType<?> code) throws FHIRException { 10865 if (code == null) 10866 return null; 10867 if (code.isEmpty()) 10868 return new Enumeration<FHIRTypes>(this, FHIRTypes.NULL, code); 10869 String codeString = ((PrimitiveType) code).asStringValue(); 10870 if (codeString == null || "".equals(codeString)) 10871 return new Enumeration<FHIRTypes>(this, FHIRTypes.NULL, code); 10872 if ("Base".equals(codeString)) 10873 return new Enumeration<FHIRTypes>(this, FHIRTypes.BASE, code); 10874 if ("Element".equals(codeString)) 10875 return new Enumeration<FHIRTypes>(this, FHIRTypes.ELEMENT, code); 10876 if ("BackboneElement".equals(codeString)) 10877 return new Enumeration<FHIRTypes>(this, FHIRTypes.BACKBONEELEMENT, code); 10878 if ("DataType".equals(codeString)) 10879 return new Enumeration<FHIRTypes>(this, FHIRTypes.DATATYPE, code); 10880 if ("Address".equals(codeString)) 10881 return new Enumeration<FHIRTypes>(this, FHIRTypes.ADDRESS, code); 10882 if ("Annotation".equals(codeString)) 10883 return new Enumeration<FHIRTypes>(this, FHIRTypes.ANNOTATION, code); 10884 if ("Attachment".equals(codeString)) 10885 return new Enumeration<FHIRTypes>(this, FHIRTypes.ATTACHMENT, code); 10886 if ("Availability".equals(codeString)) 10887 return new Enumeration<FHIRTypes>(this, FHIRTypes.AVAILABILITY, code); 10888 if ("BackboneType".equals(codeString)) 10889 return new Enumeration<FHIRTypes>(this, FHIRTypes.BACKBONETYPE, code); 10890 if ("Dosage".equals(codeString)) 10891 return new Enumeration<FHIRTypes>(this, FHIRTypes.DOSAGE, code); 10892 if ("ElementDefinition".equals(codeString)) 10893 return new Enumeration<FHIRTypes>(this, FHIRTypes.ELEMENTDEFINITION, code); 10894 if ("MarketingStatus".equals(codeString)) 10895 return new Enumeration<FHIRTypes>(this, FHIRTypes.MARKETINGSTATUS, code); 10896 if ("ProductShelfLife".equals(codeString)) 10897 return new Enumeration<FHIRTypes>(this, FHIRTypes.PRODUCTSHELFLIFE, code); 10898 if ("Timing".equals(codeString)) 10899 return new Enumeration<FHIRTypes>(this, FHIRTypes.TIMING, code); 10900 if ("CodeableConcept".equals(codeString)) 10901 return new Enumeration<FHIRTypes>(this, FHIRTypes.CODEABLECONCEPT, code); 10902 if ("CodeableReference".equals(codeString)) 10903 return new Enumeration<FHIRTypes>(this, FHIRTypes.CODEABLEREFERENCE, code); 10904 if ("Coding".equals(codeString)) 10905 return new Enumeration<FHIRTypes>(this, FHIRTypes.CODING, code); 10906 if ("ContactDetail".equals(codeString)) 10907 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONTACTDETAIL, code); 10908 if ("ContactPoint".equals(codeString)) 10909 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONTACTPOINT, code); 10910 if ("Contributor".equals(codeString)) 10911 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONTRIBUTOR, code); 10912 if ("DataRequirement".equals(codeString)) 10913 return new Enumeration<FHIRTypes>(this, FHIRTypes.DATAREQUIREMENT, code); 10914 if ("Expression".equals(codeString)) 10915 return new Enumeration<FHIRTypes>(this, FHIRTypes.EXPRESSION, code); 10916 if ("ExtendedContactDetail".equals(codeString)) 10917 return new Enumeration<FHIRTypes>(this, FHIRTypes.EXTENDEDCONTACTDETAIL, code); 10918 if ("Extension".equals(codeString)) 10919 return new Enumeration<FHIRTypes>(this, FHIRTypes.EXTENSION, code); 10920 if ("HumanName".equals(codeString)) 10921 return new Enumeration<FHIRTypes>(this, FHIRTypes.HUMANNAME, code); 10922 if ("Identifier".equals(codeString)) 10923 return new Enumeration<FHIRTypes>(this, FHIRTypes.IDENTIFIER, code); 10924 if ("Meta".equals(codeString)) 10925 return new Enumeration<FHIRTypes>(this, FHIRTypes.META, code); 10926 if ("MonetaryComponent".equals(codeString)) 10927 return new Enumeration<FHIRTypes>(this, FHIRTypes.MONETARYCOMPONENT, code); 10928 if ("Money".equals(codeString)) 10929 return new Enumeration<FHIRTypes>(this, FHIRTypes.MONEY, code); 10930 if ("Narrative".equals(codeString)) 10931 return new Enumeration<FHIRTypes>(this, FHIRTypes.NARRATIVE, code); 10932 if ("ParameterDefinition".equals(codeString)) 10933 return new Enumeration<FHIRTypes>(this, FHIRTypes.PARAMETERDEFINITION, code); 10934 if ("Period".equals(codeString)) 10935 return new Enumeration<FHIRTypes>(this, FHIRTypes.PERIOD, code); 10936 if ("PrimitiveType".equals(codeString)) 10937 return new Enumeration<FHIRTypes>(this, FHIRTypes.PRIMITIVETYPE, code); 10938 if ("base64Binary".equals(codeString)) 10939 return new Enumeration<FHIRTypes>(this, FHIRTypes.BASE64BINARY, code); 10940 if ("boolean".equals(codeString)) 10941 return new Enumeration<FHIRTypes>(this, FHIRTypes.BOOLEAN, code); 10942 if ("date".equals(codeString)) 10943 return new Enumeration<FHIRTypes>(this, FHIRTypes.DATE, code); 10944 if ("dateTime".equals(codeString)) 10945 return new Enumeration<FHIRTypes>(this, FHIRTypes.DATETIME, code); 10946 if ("decimal".equals(codeString)) 10947 return new Enumeration<FHIRTypes>(this, FHIRTypes.DECIMAL, code); 10948 if ("instant".equals(codeString)) 10949 return new Enumeration<FHIRTypes>(this, FHIRTypes.INSTANT, code); 10950 if ("integer".equals(codeString)) 10951 return new Enumeration<FHIRTypes>(this, FHIRTypes.INTEGER, code); 10952 if ("positiveInt".equals(codeString)) 10953 return new Enumeration<FHIRTypes>(this, FHIRTypes.POSITIVEINT, code); 10954 if ("unsignedInt".equals(codeString)) 10955 return new Enumeration<FHIRTypes>(this, FHIRTypes.UNSIGNEDINT, code); 10956 if ("integer64".equals(codeString)) 10957 return new Enumeration<FHIRTypes>(this, FHIRTypes.INTEGER64, code); 10958 if ("string".equals(codeString)) 10959 return new Enumeration<FHIRTypes>(this, FHIRTypes.STRING, code); 10960 if ("code".equals(codeString)) 10961 return new Enumeration<FHIRTypes>(this, FHIRTypes.CODE, code); 10962 if ("id".equals(codeString)) 10963 return new Enumeration<FHIRTypes>(this, FHIRTypes.ID, code); 10964 if ("markdown".equals(codeString)) 10965 return new Enumeration<FHIRTypes>(this, FHIRTypes.MARKDOWN, code); 10966 if ("time".equals(codeString)) 10967 return new Enumeration<FHIRTypes>(this, FHIRTypes.TIME, code); 10968 if ("uri".equals(codeString)) 10969 return new Enumeration<FHIRTypes>(this, FHIRTypes.URI, code); 10970 if ("canonical".equals(codeString)) 10971 return new Enumeration<FHIRTypes>(this, FHIRTypes.CANONICAL, code); 10972 if ("oid".equals(codeString)) 10973 return new Enumeration<FHIRTypes>(this, FHIRTypes.OID, code); 10974 if ("url".equals(codeString)) 10975 return new Enumeration<FHIRTypes>(this, FHIRTypes.URL, code); 10976 if ("uuid".equals(codeString)) 10977 return new Enumeration<FHIRTypes>(this, FHIRTypes.UUID, code); 10978 if ("Quantity".equals(codeString)) 10979 return new Enumeration<FHIRTypes>(this, FHIRTypes.QUANTITY, code); 10980 if ("Age".equals(codeString)) 10981 return new Enumeration<FHIRTypes>(this, FHIRTypes.AGE, code); 10982 if ("Count".equals(codeString)) 10983 return new Enumeration<FHIRTypes>(this, FHIRTypes.COUNT, code); 10984 if ("Distance".equals(codeString)) 10985 return new Enumeration<FHIRTypes>(this, FHIRTypes.DISTANCE, code); 10986 if ("Duration".equals(codeString)) 10987 return new Enumeration<FHIRTypes>(this, FHIRTypes.DURATION, code); 10988 if ("Range".equals(codeString)) 10989 return new Enumeration<FHIRTypes>(this, FHIRTypes.RANGE, code); 10990 if ("Ratio".equals(codeString)) 10991 return new Enumeration<FHIRTypes>(this, FHIRTypes.RATIO, code); 10992 if ("RatioRange".equals(codeString)) 10993 return new Enumeration<FHIRTypes>(this, FHIRTypes.RATIORANGE, code); 10994 if ("Reference".equals(codeString)) 10995 return new Enumeration<FHIRTypes>(this, FHIRTypes.REFERENCE, code); 10996 if ("RelatedArtifact".equals(codeString)) 10997 return new Enumeration<FHIRTypes>(this, FHIRTypes.RELATEDARTIFACT, code); 10998 if ("SampledData".equals(codeString)) 10999 return new Enumeration<FHIRTypes>(this, FHIRTypes.SAMPLEDDATA, code); 11000 if ("Signature".equals(codeString)) 11001 return new Enumeration<FHIRTypes>(this, FHIRTypes.SIGNATURE, code); 11002 if ("TriggerDefinition".equals(codeString)) 11003 return new Enumeration<FHIRTypes>(this, FHIRTypes.TRIGGERDEFINITION, code); 11004 if ("UsageContext".equals(codeString)) 11005 return new Enumeration<FHIRTypes>(this, FHIRTypes.USAGECONTEXT, code); 11006 if ("VirtualServiceDetail".equals(codeString)) 11007 return new Enumeration<FHIRTypes>(this, FHIRTypes.VIRTUALSERVICEDETAIL, code); 11008 if ("xhtml".equals(codeString)) 11009 return new Enumeration<FHIRTypes>(this, FHIRTypes.XHTML, code); 11010 if ("Resource".equals(codeString)) 11011 return new Enumeration<FHIRTypes>(this, FHIRTypes.RESOURCE, code); 11012 if ("Binary".equals(codeString)) 11013 return new Enumeration<FHIRTypes>(this, FHIRTypes.BINARY, code); 11014 if ("Bundle".equals(codeString)) 11015 return new Enumeration<FHIRTypes>(this, FHIRTypes.BUNDLE, code); 11016 if ("DomainResource".equals(codeString)) 11017 return new Enumeration<FHIRTypes>(this, FHIRTypes.DOMAINRESOURCE, code); 11018 if ("Account".equals(codeString)) 11019 return new Enumeration<FHIRTypes>(this, FHIRTypes.ACCOUNT, code); 11020 if ("ActivityDefinition".equals(codeString)) 11021 return new Enumeration<FHIRTypes>(this, FHIRTypes.ACTIVITYDEFINITION, code); 11022 if ("ActorDefinition".equals(codeString)) 11023 return new Enumeration<FHIRTypes>(this, FHIRTypes.ACTORDEFINITION, code); 11024 if ("AdministrableProductDefinition".equals(codeString)) 11025 return new Enumeration<FHIRTypes>(this, FHIRTypes.ADMINISTRABLEPRODUCTDEFINITION, code); 11026 if ("AdverseEvent".equals(codeString)) 11027 return new Enumeration<FHIRTypes>(this, FHIRTypes.ADVERSEEVENT, code); 11028 if ("AllergyIntolerance".equals(codeString)) 11029 return new Enumeration<FHIRTypes>(this, FHIRTypes.ALLERGYINTOLERANCE, code); 11030 if ("Appointment".equals(codeString)) 11031 return new Enumeration<FHIRTypes>(this, FHIRTypes.APPOINTMENT, code); 11032 if ("AppointmentResponse".equals(codeString)) 11033 return new Enumeration<FHIRTypes>(this, FHIRTypes.APPOINTMENTRESPONSE, code); 11034 if ("ArtifactAssessment".equals(codeString)) 11035 return new Enumeration<FHIRTypes>(this, FHIRTypes.ARTIFACTASSESSMENT, code); 11036 if ("AuditEvent".equals(codeString)) 11037 return new Enumeration<FHIRTypes>(this, FHIRTypes.AUDITEVENT, code); 11038 if ("Basic".equals(codeString)) 11039 return new Enumeration<FHIRTypes>(this, FHIRTypes.BASIC, code); 11040 if ("BiologicallyDerivedProduct".equals(codeString)) 11041 return new Enumeration<FHIRTypes>(this, FHIRTypes.BIOLOGICALLYDERIVEDPRODUCT, code); 11042 if ("BiologicallyDerivedProductDispense".equals(codeString)) 11043 return new Enumeration<FHIRTypes>(this, FHIRTypes.BIOLOGICALLYDERIVEDPRODUCTDISPENSE, code); 11044 if ("BodyStructure".equals(codeString)) 11045 return new Enumeration<FHIRTypes>(this, FHIRTypes.BODYSTRUCTURE, code); 11046 if ("CanonicalResource".equals(codeString)) 11047 return new Enumeration<FHIRTypes>(this, FHIRTypes.CANONICALRESOURCE, code); 11048 if ("CapabilityStatement".equals(codeString)) 11049 return new Enumeration<FHIRTypes>(this, FHIRTypes.CAPABILITYSTATEMENT, code); 11050 if ("CarePlan".equals(codeString)) 11051 return new Enumeration<FHIRTypes>(this, FHIRTypes.CAREPLAN, code); 11052 if ("CareTeam".equals(codeString)) 11053 return new Enumeration<FHIRTypes>(this, FHIRTypes.CARETEAM, code); 11054 if ("ChargeItem".equals(codeString)) 11055 return new Enumeration<FHIRTypes>(this, FHIRTypes.CHARGEITEM, code); 11056 if ("ChargeItemDefinition".equals(codeString)) 11057 return new Enumeration<FHIRTypes>(this, FHIRTypes.CHARGEITEMDEFINITION, code); 11058 if ("Citation".equals(codeString)) 11059 return new Enumeration<FHIRTypes>(this, FHIRTypes.CITATION, code); 11060 if ("Claim".equals(codeString)) 11061 return new Enumeration<FHIRTypes>(this, FHIRTypes.CLAIM, code); 11062 if ("ClaimResponse".equals(codeString)) 11063 return new Enumeration<FHIRTypes>(this, FHIRTypes.CLAIMRESPONSE, code); 11064 if ("ClinicalImpression".equals(codeString)) 11065 return new Enumeration<FHIRTypes>(this, FHIRTypes.CLINICALIMPRESSION, code); 11066 if ("ClinicalUseDefinition".equals(codeString)) 11067 return new Enumeration<FHIRTypes>(this, FHIRTypes.CLINICALUSEDEFINITION, code); 11068 if ("CodeSystem".equals(codeString)) 11069 return new Enumeration<FHIRTypes>(this, FHIRTypes.CODESYSTEM, code); 11070 if ("Communication".equals(codeString)) 11071 return new Enumeration<FHIRTypes>(this, FHIRTypes.COMMUNICATION, code); 11072 if ("CommunicationRequest".equals(codeString)) 11073 return new Enumeration<FHIRTypes>(this, FHIRTypes.COMMUNICATIONREQUEST, code); 11074 if ("CompartmentDefinition".equals(codeString)) 11075 return new Enumeration<FHIRTypes>(this, FHIRTypes.COMPARTMENTDEFINITION, code); 11076 if ("Composition".equals(codeString)) 11077 return new Enumeration<FHIRTypes>(this, FHIRTypes.COMPOSITION, code); 11078 if ("ConceptMap".equals(codeString)) 11079 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONCEPTMAP, code); 11080 if ("Condition".equals(codeString)) 11081 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONDITION, code); 11082 if ("ConditionDefinition".equals(codeString)) 11083 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONDITIONDEFINITION, code); 11084 if ("Consent".equals(codeString)) 11085 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONSENT, code); 11086 if ("Contract".equals(codeString)) 11087 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONTRACT, code); 11088 if ("Coverage".equals(codeString)) 11089 return new Enumeration<FHIRTypes>(this, FHIRTypes.COVERAGE, code); 11090 if ("CoverageEligibilityRequest".equals(codeString)) 11091 return new Enumeration<FHIRTypes>(this, FHIRTypes.COVERAGEELIGIBILITYREQUEST, code); 11092 if ("CoverageEligibilityResponse".equals(codeString)) 11093 return new Enumeration<FHIRTypes>(this, FHIRTypes.COVERAGEELIGIBILITYRESPONSE, code); 11094 if ("DetectedIssue".equals(codeString)) 11095 return new Enumeration<FHIRTypes>(this, FHIRTypes.DETECTEDISSUE, code); 11096 if ("Device".equals(codeString)) 11097 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICE, code); 11098 if ("DeviceAssociation".equals(codeString)) 11099 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICEASSOCIATION, code); 11100 if ("DeviceDefinition".equals(codeString)) 11101 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICEDEFINITION, code); 11102 if ("DeviceDispense".equals(codeString)) 11103 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICEDISPENSE, code); 11104 if ("DeviceMetric".equals(codeString)) 11105 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICEMETRIC, code); 11106 if ("DeviceRequest".equals(codeString)) 11107 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICEREQUEST, code); 11108 if ("DeviceUsage".equals(codeString)) 11109 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICEUSAGE, code); 11110 if ("DiagnosticReport".equals(codeString)) 11111 return new Enumeration<FHIRTypes>(this, FHIRTypes.DIAGNOSTICREPORT, code); 11112 if ("DocumentReference".equals(codeString)) 11113 return new Enumeration<FHIRTypes>(this, FHIRTypes.DOCUMENTREFERENCE, code); 11114 if ("Encounter".equals(codeString)) 11115 return new Enumeration<FHIRTypes>(this, FHIRTypes.ENCOUNTER, code); 11116 if ("EncounterHistory".equals(codeString)) 11117 return new Enumeration<FHIRTypes>(this, FHIRTypes.ENCOUNTERHISTORY, code); 11118 if ("Endpoint".equals(codeString)) 11119 return new Enumeration<FHIRTypes>(this, FHIRTypes.ENDPOINT, code); 11120 if ("EnrollmentRequest".equals(codeString)) 11121 return new Enumeration<FHIRTypes>(this, FHIRTypes.ENROLLMENTREQUEST, code); 11122 if ("EnrollmentResponse".equals(codeString)) 11123 return new Enumeration<FHIRTypes>(this, FHIRTypes.ENROLLMENTRESPONSE, code); 11124 if ("EpisodeOfCare".equals(codeString)) 11125 return new Enumeration<FHIRTypes>(this, FHIRTypes.EPISODEOFCARE, code); 11126 if ("EventDefinition".equals(codeString)) 11127 return new Enumeration<FHIRTypes>(this, FHIRTypes.EVENTDEFINITION, code); 11128 if ("Evidence".equals(codeString)) 11129 return new Enumeration<FHIRTypes>(this, FHIRTypes.EVIDENCE, code); 11130 if ("EvidenceReport".equals(codeString)) 11131 return new Enumeration<FHIRTypes>(this, FHIRTypes.EVIDENCEREPORT, code); 11132 if ("EvidenceVariable".equals(codeString)) 11133 return new Enumeration<FHIRTypes>(this, FHIRTypes.EVIDENCEVARIABLE, code); 11134 if ("ExampleScenario".equals(codeString)) 11135 return new Enumeration<FHIRTypes>(this, FHIRTypes.EXAMPLESCENARIO, code); 11136 if ("ExplanationOfBenefit".equals(codeString)) 11137 return new Enumeration<FHIRTypes>(this, FHIRTypes.EXPLANATIONOFBENEFIT, code); 11138 if ("FamilyMemberHistory".equals(codeString)) 11139 return new Enumeration<FHIRTypes>(this, FHIRTypes.FAMILYMEMBERHISTORY, code); 11140 if ("Flag".equals(codeString)) 11141 return new Enumeration<FHIRTypes>(this, FHIRTypes.FLAG, code); 11142 if ("FormularyItem".equals(codeString)) 11143 return new Enumeration<FHIRTypes>(this, FHIRTypes.FORMULARYITEM, code); 11144 if ("GenomicStudy".equals(codeString)) 11145 return new Enumeration<FHIRTypes>(this, FHIRTypes.GENOMICSTUDY, code); 11146 if ("Goal".equals(codeString)) 11147 return new Enumeration<FHIRTypes>(this, FHIRTypes.GOAL, code); 11148 if ("GraphDefinition".equals(codeString)) 11149 return new Enumeration<FHIRTypes>(this, FHIRTypes.GRAPHDEFINITION, code); 11150 if ("Group".equals(codeString)) 11151 return new Enumeration<FHIRTypes>(this, FHIRTypes.GROUP, code); 11152 if ("GuidanceResponse".equals(codeString)) 11153 return new Enumeration<FHIRTypes>(this, FHIRTypes.GUIDANCERESPONSE, code); 11154 if ("HealthcareService".equals(codeString)) 11155 return new Enumeration<FHIRTypes>(this, FHIRTypes.HEALTHCARESERVICE, code); 11156 if ("ImagingSelection".equals(codeString)) 11157 return new Enumeration<FHIRTypes>(this, FHIRTypes.IMAGINGSELECTION, code); 11158 if ("ImagingStudy".equals(codeString)) 11159 return new Enumeration<FHIRTypes>(this, FHIRTypes.IMAGINGSTUDY, code); 11160 if ("Immunization".equals(codeString)) 11161 return new Enumeration<FHIRTypes>(this, FHIRTypes.IMMUNIZATION, code); 11162 if ("ImmunizationEvaluation".equals(codeString)) 11163 return new Enumeration<FHIRTypes>(this, FHIRTypes.IMMUNIZATIONEVALUATION, code); 11164 if ("ImmunizationRecommendation".equals(codeString)) 11165 return new Enumeration<FHIRTypes>(this, FHIRTypes.IMMUNIZATIONRECOMMENDATION, code); 11166 if ("ImplementationGuide".equals(codeString)) 11167 return new Enumeration<FHIRTypes>(this, FHIRTypes.IMPLEMENTATIONGUIDE, code); 11168 if ("Ingredient".equals(codeString)) 11169 return new Enumeration<FHIRTypes>(this, FHIRTypes.INGREDIENT, code); 11170 if ("InsurancePlan".equals(codeString)) 11171 return new Enumeration<FHIRTypes>(this, FHIRTypes.INSURANCEPLAN, code); 11172 if ("InventoryItem".equals(codeString)) 11173 return new Enumeration<FHIRTypes>(this, FHIRTypes.INVENTORYITEM, code); 11174 if ("InventoryReport".equals(codeString)) 11175 return new Enumeration<FHIRTypes>(this, FHIRTypes.INVENTORYREPORT, code); 11176 if ("Invoice".equals(codeString)) 11177 return new Enumeration<FHIRTypes>(this, FHIRTypes.INVOICE, code); 11178 if ("Library".equals(codeString)) 11179 return new Enumeration<FHIRTypes>(this, FHIRTypes.LIBRARY, code); 11180 if ("Linkage".equals(codeString)) 11181 return new Enumeration<FHIRTypes>(this, FHIRTypes.LINKAGE, code); 11182 if ("List".equals(codeString)) 11183 return new Enumeration<FHIRTypes>(this, FHIRTypes.LIST, code); 11184 if ("Location".equals(codeString)) 11185 return new Enumeration<FHIRTypes>(this, FHIRTypes.LOCATION, code); 11186 if ("ManufacturedItemDefinition".equals(codeString)) 11187 return new Enumeration<FHIRTypes>(this, FHIRTypes.MANUFACTUREDITEMDEFINITION, code); 11188 if ("Measure".equals(codeString)) 11189 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEASURE, code); 11190 if ("MeasureReport".equals(codeString)) 11191 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEASUREREPORT, code); 11192 if ("Medication".equals(codeString)) 11193 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICATION, code); 11194 if ("MedicationAdministration".equals(codeString)) 11195 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICATIONADMINISTRATION, code); 11196 if ("MedicationDispense".equals(codeString)) 11197 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICATIONDISPENSE, code); 11198 if ("MedicationKnowledge".equals(codeString)) 11199 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICATIONKNOWLEDGE, code); 11200 if ("MedicationRequest".equals(codeString)) 11201 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICATIONREQUEST, code); 11202 if ("MedicationStatement".equals(codeString)) 11203 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICATIONSTATEMENT, code); 11204 if ("MedicinalProductDefinition".equals(codeString)) 11205 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICINALPRODUCTDEFINITION, code); 11206 if ("MessageDefinition".equals(codeString)) 11207 return new Enumeration<FHIRTypes>(this, FHIRTypes.MESSAGEDEFINITION, code); 11208 if ("MessageHeader".equals(codeString)) 11209 return new Enumeration<FHIRTypes>(this, FHIRTypes.MESSAGEHEADER, code); 11210 if ("MetadataResource".equals(codeString)) 11211 return new Enumeration<FHIRTypes>(this, FHIRTypes.METADATARESOURCE, code); 11212 if ("MolecularSequence".equals(codeString)) 11213 return new Enumeration<FHIRTypes>(this, FHIRTypes.MOLECULARSEQUENCE, code); 11214 if ("NamingSystem".equals(codeString)) 11215 return new Enumeration<FHIRTypes>(this, FHIRTypes.NAMINGSYSTEM, code); 11216 if ("NutritionIntake".equals(codeString)) 11217 return new Enumeration<FHIRTypes>(this, FHIRTypes.NUTRITIONINTAKE, code); 11218 if ("NutritionOrder".equals(codeString)) 11219 return new Enumeration<FHIRTypes>(this, FHIRTypes.NUTRITIONORDER, code); 11220 if ("NutritionProduct".equals(codeString)) 11221 return new Enumeration<FHIRTypes>(this, FHIRTypes.NUTRITIONPRODUCT, code); 11222 if ("Observation".equals(codeString)) 11223 return new Enumeration<FHIRTypes>(this, FHIRTypes.OBSERVATION, code); 11224 if ("ObservationDefinition".equals(codeString)) 11225 return new Enumeration<FHIRTypes>(this, FHIRTypes.OBSERVATIONDEFINITION, code); 11226 if ("OperationDefinition".equals(codeString)) 11227 return new Enumeration<FHIRTypes>(this, FHIRTypes.OPERATIONDEFINITION, code); 11228 if ("OperationOutcome".equals(codeString)) 11229 return new Enumeration<FHIRTypes>(this, FHIRTypes.OPERATIONOUTCOME, code); 11230 if ("Organization".equals(codeString)) 11231 return new Enumeration<FHIRTypes>(this, FHIRTypes.ORGANIZATION, code); 11232 if ("OrganizationAffiliation".equals(codeString)) 11233 return new Enumeration<FHIRTypes>(this, FHIRTypes.ORGANIZATIONAFFILIATION, code); 11234 if ("PackagedProductDefinition".equals(codeString)) 11235 return new Enumeration<FHIRTypes>(this, FHIRTypes.PACKAGEDPRODUCTDEFINITION, code); 11236 if ("Patient".equals(codeString)) 11237 return new Enumeration<FHIRTypes>(this, FHIRTypes.PATIENT, code); 11238 if ("PaymentNotice".equals(codeString)) 11239 return new Enumeration<FHIRTypes>(this, FHIRTypes.PAYMENTNOTICE, code); 11240 if ("PaymentReconciliation".equals(codeString)) 11241 return new Enumeration<FHIRTypes>(this, FHIRTypes.PAYMENTRECONCILIATION, code); 11242 if ("Permission".equals(codeString)) 11243 return new Enumeration<FHIRTypes>(this, FHIRTypes.PERMISSION, code); 11244 if ("Person".equals(codeString)) 11245 return new Enumeration<FHIRTypes>(this, FHIRTypes.PERSON, code); 11246 if ("PlanDefinition".equals(codeString)) 11247 return new Enumeration<FHIRTypes>(this, FHIRTypes.PLANDEFINITION, code); 11248 if ("Practitioner".equals(codeString)) 11249 return new Enumeration<FHIRTypes>(this, FHIRTypes.PRACTITIONER, code); 11250 if ("PractitionerRole".equals(codeString)) 11251 return new Enumeration<FHIRTypes>(this, FHIRTypes.PRACTITIONERROLE, code); 11252 if ("Procedure".equals(codeString)) 11253 return new Enumeration<FHIRTypes>(this, FHIRTypes.PROCEDURE, code); 11254 if ("Provenance".equals(codeString)) 11255 return new Enumeration<FHIRTypes>(this, FHIRTypes.PROVENANCE, code); 11256 if ("Questionnaire".equals(codeString)) 11257 return new Enumeration<FHIRTypes>(this, FHIRTypes.QUESTIONNAIRE, code); 11258 if ("QuestionnaireResponse".equals(codeString)) 11259 return new Enumeration<FHIRTypes>(this, FHIRTypes.QUESTIONNAIRERESPONSE, code); 11260 if ("RegulatedAuthorization".equals(codeString)) 11261 return new Enumeration<FHIRTypes>(this, FHIRTypes.REGULATEDAUTHORIZATION, code); 11262 if ("RelatedPerson".equals(codeString)) 11263 return new Enumeration<FHIRTypes>(this, FHIRTypes.RELATEDPERSON, code); 11264 if ("RequestOrchestration".equals(codeString)) 11265 return new Enumeration<FHIRTypes>(this, FHIRTypes.REQUESTORCHESTRATION, code); 11266 if ("Requirements".equals(codeString)) 11267 return new Enumeration<FHIRTypes>(this, FHIRTypes.REQUIREMENTS, code); 11268 if ("ResearchStudy".equals(codeString)) 11269 return new Enumeration<FHIRTypes>(this, FHIRTypes.RESEARCHSTUDY, code); 11270 if ("ResearchSubject".equals(codeString)) 11271 return new Enumeration<FHIRTypes>(this, FHIRTypes.RESEARCHSUBJECT, code); 11272 if ("RiskAssessment".equals(codeString)) 11273 return new Enumeration<FHIRTypes>(this, FHIRTypes.RISKASSESSMENT, code); 11274 if ("Schedule".equals(codeString)) 11275 return new Enumeration<FHIRTypes>(this, FHIRTypes.SCHEDULE, code); 11276 if ("SearchParameter".equals(codeString)) 11277 return new Enumeration<FHIRTypes>(this, FHIRTypes.SEARCHPARAMETER, code); 11278 if ("ServiceRequest".equals(codeString)) 11279 return new Enumeration<FHIRTypes>(this, FHIRTypes.SERVICEREQUEST, code); 11280 if ("Slot".equals(codeString)) 11281 return new Enumeration<FHIRTypes>(this, FHIRTypes.SLOT, code); 11282 if ("Specimen".equals(codeString)) 11283 return new Enumeration<FHIRTypes>(this, FHIRTypes.SPECIMEN, code); 11284 if ("SpecimenDefinition".equals(codeString)) 11285 return new Enumeration<FHIRTypes>(this, FHIRTypes.SPECIMENDEFINITION, code); 11286 if ("StructureDefinition".equals(codeString)) 11287 return new Enumeration<FHIRTypes>(this, FHIRTypes.STRUCTUREDEFINITION, code); 11288 if ("StructureMap".equals(codeString)) 11289 return new Enumeration<FHIRTypes>(this, FHIRTypes.STRUCTUREMAP, code); 11290 if ("Subscription".equals(codeString)) 11291 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSCRIPTION, code); 11292 if ("SubscriptionStatus".equals(codeString)) 11293 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSCRIPTIONSTATUS, code); 11294 if ("SubscriptionTopic".equals(codeString)) 11295 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSCRIPTIONTOPIC, code); 11296 if ("Substance".equals(codeString)) 11297 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCE, code); 11298 if ("SubstanceDefinition".equals(codeString)) 11299 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCEDEFINITION, code); 11300 if ("SubstanceNucleicAcid".equals(codeString)) 11301 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCENUCLEICACID, code); 11302 if ("SubstancePolymer".equals(codeString)) 11303 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCEPOLYMER, code); 11304 if ("SubstanceProtein".equals(codeString)) 11305 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCEPROTEIN, code); 11306 if ("SubstanceReferenceInformation".equals(codeString)) 11307 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCEREFERENCEINFORMATION, code); 11308 if ("SubstanceSourceMaterial".equals(codeString)) 11309 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCESOURCEMATERIAL, code); 11310 if ("SupplyDelivery".equals(codeString)) 11311 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUPPLYDELIVERY, code); 11312 if ("SupplyRequest".equals(codeString)) 11313 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUPPLYREQUEST, code); 11314 if ("Task".equals(codeString)) 11315 return new Enumeration<FHIRTypes>(this, FHIRTypes.TASK, code); 11316 if ("TerminologyCapabilities".equals(codeString)) 11317 return new Enumeration<FHIRTypes>(this, FHIRTypes.TERMINOLOGYCAPABILITIES, code); 11318 if ("TestPlan".equals(codeString)) 11319 return new Enumeration<FHIRTypes>(this, FHIRTypes.TESTPLAN, code); 11320 if ("TestReport".equals(codeString)) 11321 return new Enumeration<FHIRTypes>(this, FHIRTypes.TESTREPORT, code); 11322 if ("TestScript".equals(codeString)) 11323 return new Enumeration<FHIRTypes>(this, FHIRTypes.TESTSCRIPT, code); 11324 if ("Transport".equals(codeString)) 11325 return new Enumeration<FHIRTypes>(this, FHIRTypes.TRANSPORT, code); 11326 if ("ValueSet".equals(codeString)) 11327 return new Enumeration<FHIRTypes>(this, FHIRTypes.VALUESET, code); 11328 if ("VerificationResult".equals(codeString)) 11329 return new Enumeration<FHIRTypes>(this, FHIRTypes.VERIFICATIONRESULT, code); 11330 if ("VisionPrescription".equals(codeString)) 11331 return new Enumeration<FHIRTypes>(this, FHIRTypes.VISIONPRESCRIPTION, code); 11332 if ("Parameters".equals(codeString)) 11333 return new Enumeration<FHIRTypes>(this, FHIRTypes.PARAMETERS, code); 11334 throw new FHIRException("Unknown FHIRTypes code '"+codeString+"'"); 11335 } 11336 public String toCode(FHIRTypes code) { 11337 if (code == FHIRTypes.BASE) 11338 return "Base"; 11339 if (code == FHIRTypes.ELEMENT) 11340 return "Element"; 11341 if (code == FHIRTypes.BACKBONEELEMENT) 11342 return "BackboneElement"; 11343 if (code == FHIRTypes.DATATYPE) 11344 return "DataType"; 11345 if (code == FHIRTypes.ADDRESS) 11346 return "Address"; 11347 if (code == FHIRTypes.ANNOTATION) 11348 return "Annotation"; 11349 if (code == FHIRTypes.ATTACHMENT) 11350 return "Attachment"; 11351 if (code == FHIRTypes.AVAILABILITY) 11352 return "Availability"; 11353 if (code == FHIRTypes.BACKBONETYPE) 11354 return "BackboneType"; 11355 if (code == FHIRTypes.DOSAGE) 11356 return "Dosage"; 11357 if (code == FHIRTypes.ELEMENTDEFINITION) 11358 return "ElementDefinition"; 11359 if (code == FHIRTypes.MARKETINGSTATUS) 11360 return "MarketingStatus"; 11361 if (code == FHIRTypes.PRODUCTSHELFLIFE) 11362 return "ProductShelfLife"; 11363 if (code == FHIRTypes.TIMING) 11364 return "Timing"; 11365 if (code == FHIRTypes.CODEABLECONCEPT) 11366 return "CodeableConcept"; 11367 if (code == FHIRTypes.CODEABLEREFERENCE) 11368 return "CodeableReference"; 11369 if (code == FHIRTypes.CODING) 11370 return "Coding"; 11371 if (code == FHIRTypes.CONTACTDETAIL) 11372 return "ContactDetail"; 11373 if (code == FHIRTypes.CONTACTPOINT) 11374 return "ContactPoint"; 11375 if (code == FHIRTypes.CONTRIBUTOR) 11376 return "Contributor"; 11377 if (code == FHIRTypes.DATAREQUIREMENT) 11378 return "DataRequirement"; 11379 if (code == FHIRTypes.EXPRESSION) 11380 return "Expression"; 11381 if (code == FHIRTypes.EXTENDEDCONTACTDETAIL) 11382 return "ExtendedContactDetail"; 11383 if (code == FHIRTypes.EXTENSION) 11384 return "Extension"; 11385 if (code == FHIRTypes.HUMANNAME) 11386 return "HumanName"; 11387 if (code == FHIRTypes.IDENTIFIER) 11388 return "Identifier"; 11389 if (code == FHIRTypes.META) 11390 return "Meta"; 11391 if (code == FHIRTypes.MONETARYCOMPONENT) 11392 return "MonetaryComponent"; 11393 if (code == FHIRTypes.MONEY) 11394 return "Money"; 11395 if (code == FHIRTypes.NARRATIVE) 11396 return "Narrative"; 11397 if (code == FHIRTypes.PARAMETERDEFINITION) 11398 return "ParameterDefinition"; 11399 if (code == FHIRTypes.PERIOD) 11400 return "Period"; 11401 if (code == FHIRTypes.PRIMITIVETYPE) 11402 return "PrimitiveType"; 11403 if (code == FHIRTypes.BASE64BINARY) 11404 return "base64Binary"; 11405 if (code == FHIRTypes.BOOLEAN) 11406 return "boolean"; 11407 if (code == FHIRTypes.DATE) 11408 return "date"; 11409 if (code == FHIRTypes.DATETIME) 11410 return "dateTime"; 11411 if (code == FHIRTypes.DECIMAL) 11412 return "decimal"; 11413 if (code == FHIRTypes.INSTANT) 11414 return "instant"; 11415 if (code == FHIRTypes.INTEGER) 11416 return "integer"; 11417 if (code == FHIRTypes.POSITIVEINT) 11418 return "positiveInt"; 11419 if (code == FHIRTypes.UNSIGNEDINT) 11420 return "unsignedInt"; 11421 if (code == FHIRTypes.INTEGER64) 11422 return "integer64"; 11423 if (code == FHIRTypes.STRING) 11424 return "string"; 11425 if (code == FHIRTypes.CODE) 11426 return "code"; 11427 if (code == FHIRTypes.ID) 11428 return "id"; 11429 if (code == FHIRTypes.MARKDOWN) 11430 return "markdown"; 11431 if (code == FHIRTypes.TIME) 11432 return "time"; 11433 if (code == FHIRTypes.URI) 11434 return "uri"; 11435 if (code == FHIRTypes.CANONICAL) 11436 return "canonical"; 11437 if (code == FHIRTypes.OID) 11438 return "oid"; 11439 if (code == FHIRTypes.URL) 11440 return "url"; 11441 if (code == FHIRTypes.UUID) 11442 return "uuid"; 11443 if (code == FHIRTypes.QUANTITY) 11444 return "Quantity"; 11445 if (code == FHIRTypes.AGE) 11446 return "Age"; 11447 if (code == FHIRTypes.COUNT) 11448 return "Count"; 11449 if (code == FHIRTypes.DISTANCE) 11450 return "Distance"; 11451 if (code == FHIRTypes.DURATION) 11452 return "Duration"; 11453 if (code == FHIRTypes.RANGE) 11454 return "Range"; 11455 if (code == FHIRTypes.RATIO) 11456 return "Ratio"; 11457 if (code == FHIRTypes.RATIORANGE) 11458 return "RatioRange"; 11459 if (code == FHIRTypes.REFERENCE) 11460 return "Reference"; 11461 if (code == FHIRTypes.RELATEDARTIFACT) 11462 return "RelatedArtifact"; 11463 if (code == FHIRTypes.SAMPLEDDATA) 11464 return "SampledData"; 11465 if (code == FHIRTypes.SIGNATURE) 11466 return "Signature"; 11467 if (code == FHIRTypes.TRIGGERDEFINITION) 11468 return "TriggerDefinition"; 11469 if (code == FHIRTypes.USAGECONTEXT) 11470 return "UsageContext"; 11471 if (code == FHIRTypes.VIRTUALSERVICEDETAIL) 11472 return "VirtualServiceDetail"; 11473 if (code == FHIRTypes.XHTML) 11474 return "xhtml"; 11475 if (code == FHIRTypes.RESOURCE) 11476 return "Resource"; 11477 if (code == FHIRTypes.BINARY) 11478 return "Binary"; 11479 if (code == FHIRTypes.BUNDLE) 11480 return "Bundle"; 11481 if (code == FHIRTypes.DOMAINRESOURCE) 11482 return "DomainResource"; 11483 if (code == FHIRTypes.ACCOUNT) 11484 return "Account"; 11485 if (code == FHIRTypes.ACTIVITYDEFINITION) 11486 return "ActivityDefinition"; 11487 if (code == FHIRTypes.ACTORDEFINITION) 11488 return "ActorDefinition"; 11489 if (code == FHIRTypes.ADMINISTRABLEPRODUCTDEFINITION) 11490 return "AdministrableProductDefinition"; 11491 if (code == FHIRTypes.ADVERSEEVENT) 11492 return "AdverseEvent"; 11493 if (code == FHIRTypes.ALLERGYINTOLERANCE) 11494 return "AllergyIntolerance"; 11495 if (code == FHIRTypes.APPOINTMENT) 11496 return "Appointment"; 11497 if (code == FHIRTypes.APPOINTMENTRESPONSE) 11498 return "AppointmentResponse"; 11499 if (code == FHIRTypes.ARTIFACTASSESSMENT) 11500 return "ArtifactAssessment"; 11501 if (code == FHIRTypes.AUDITEVENT) 11502 return "AuditEvent"; 11503 if (code == FHIRTypes.BASIC) 11504 return "Basic"; 11505 if (code == FHIRTypes.BIOLOGICALLYDERIVEDPRODUCT) 11506 return "BiologicallyDerivedProduct"; 11507 if (code == FHIRTypes.BIOLOGICALLYDERIVEDPRODUCTDISPENSE) 11508 return "BiologicallyDerivedProductDispense"; 11509 if (code == FHIRTypes.BODYSTRUCTURE) 11510 return "BodyStructure"; 11511 if (code == FHIRTypes.CANONICALRESOURCE) 11512 return "CanonicalResource"; 11513 if (code == FHIRTypes.CAPABILITYSTATEMENT) 11514 return "CapabilityStatement"; 11515 if (code == FHIRTypes.CAREPLAN) 11516 return "CarePlan"; 11517 if (code == FHIRTypes.CARETEAM) 11518 return "CareTeam"; 11519 if (code == FHIRTypes.CHARGEITEM) 11520 return "ChargeItem"; 11521 if (code == FHIRTypes.CHARGEITEMDEFINITION) 11522 return "ChargeItemDefinition"; 11523 if (code == FHIRTypes.CITATION) 11524 return "Citation"; 11525 if (code == FHIRTypes.CLAIM) 11526 return "Claim"; 11527 if (code == FHIRTypes.CLAIMRESPONSE) 11528 return "ClaimResponse"; 11529 if (code == FHIRTypes.CLINICALIMPRESSION) 11530 return "ClinicalImpression"; 11531 if (code == FHIRTypes.CLINICALUSEDEFINITION) 11532 return "ClinicalUseDefinition"; 11533 if (code == FHIRTypes.CODESYSTEM) 11534 return "CodeSystem"; 11535 if (code == FHIRTypes.COMMUNICATION) 11536 return "Communication"; 11537 if (code == FHIRTypes.COMMUNICATIONREQUEST) 11538 return "CommunicationRequest"; 11539 if (code == FHIRTypes.COMPARTMENTDEFINITION) 11540 return "CompartmentDefinition"; 11541 if (code == FHIRTypes.COMPOSITION) 11542 return "Composition"; 11543 if (code == FHIRTypes.CONCEPTMAP) 11544 return "ConceptMap"; 11545 if (code == FHIRTypes.CONDITION) 11546 return "Condition"; 11547 if (code == FHIRTypes.CONDITIONDEFINITION) 11548 return "ConditionDefinition"; 11549 if (code == FHIRTypes.CONSENT) 11550 return "Consent"; 11551 if (code == FHIRTypes.CONTRACT) 11552 return "Contract"; 11553 if (code == FHIRTypes.COVERAGE) 11554 return "Coverage"; 11555 if (code == FHIRTypes.COVERAGEELIGIBILITYREQUEST) 11556 return "CoverageEligibilityRequest"; 11557 if (code == FHIRTypes.COVERAGEELIGIBILITYRESPONSE) 11558 return "CoverageEligibilityResponse"; 11559 if (code == FHIRTypes.DETECTEDISSUE) 11560 return "DetectedIssue"; 11561 if (code == FHIRTypes.DEVICE) 11562 return "Device"; 11563 if (code == FHIRTypes.DEVICEASSOCIATION) 11564 return "DeviceAssociation"; 11565 if (code == FHIRTypes.DEVICEDEFINITION) 11566 return "DeviceDefinition"; 11567 if (code == FHIRTypes.DEVICEDISPENSE) 11568 return "DeviceDispense"; 11569 if (code == FHIRTypes.DEVICEMETRIC) 11570 return "DeviceMetric"; 11571 if (code == FHIRTypes.DEVICEREQUEST) 11572 return "DeviceRequest"; 11573 if (code == FHIRTypes.DEVICEUSAGE) 11574 return "DeviceUsage"; 11575 if (code == FHIRTypes.DIAGNOSTICREPORT) 11576 return "DiagnosticReport"; 11577 if (code == FHIRTypes.DOCUMENTREFERENCE) 11578 return "DocumentReference"; 11579 if (code == FHIRTypes.ENCOUNTER) 11580 return "Encounter"; 11581 if (code == FHIRTypes.ENCOUNTERHISTORY) 11582 return "EncounterHistory"; 11583 if (code == FHIRTypes.ENDPOINT) 11584 return "Endpoint"; 11585 if (code == FHIRTypes.ENROLLMENTREQUEST) 11586 return "EnrollmentRequest"; 11587 if (code == FHIRTypes.ENROLLMENTRESPONSE) 11588 return "EnrollmentResponse"; 11589 if (code == FHIRTypes.EPISODEOFCARE) 11590 return "EpisodeOfCare"; 11591 if (code == FHIRTypes.EVENTDEFINITION) 11592 return "EventDefinition"; 11593 if (code == FHIRTypes.EVIDENCE) 11594 return "Evidence"; 11595 if (code == FHIRTypes.EVIDENCEREPORT) 11596 return "EvidenceReport"; 11597 if (code == FHIRTypes.EVIDENCEVARIABLE) 11598 return "EvidenceVariable"; 11599 if (code == FHIRTypes.EXAMPLESCENARIO) 11600 return "ExampleScenario"; 11601 if (code == FHIRTypes.EXPLANATIONOFBENEFIT) 11602 return "ExplanationOfBenefit"; 11603 if (code == FHIRTypes.FAMILYMEMBERHISTORY) 11604 return "FamilyMemberHistory"; 11605 if (code == FHIRTypes.FLAG) 11606 return "Flag"; 11607 if (code == FHIRTypes.FORMULARYITEM) 11608 return "FormularyItem"; 11609 if (code == FHIRTypes.GENOMICSTUDY) 11610 return "GenomicStudy"; 11611 if (code == FHIRTypes.GOAL) 11612 return "Goal"; 11613 if (code == FHIRTypes.GRAPHDEFINITION) 11614 return "GraphDefinition"; 11615 if (code == FHIRTypes.GROUP) 11616 return "Group"; 11617 if (code == FHIRTypes.GUIDANCERESPONSE) 11618 return "GuidanceResponse"; 11619 if (code == FHIRTypes.HEALTHCARESERVICE) 11620 return "HealthcareService"; 11621 if (code == FHIRTypes.IMAGINGSELECTION) 11622 return "ImagingSelection"; 11623 if (code == FHIRTypes.IMAGINGSTUDY) 11624 return "ImagingStudy"; 11625 if (code == FHIRTypes.IMMUNIZATION) 11626 return "Immunization"; 11627 if (code == FHIRTypes.IMMUNIZATIONEVALUATION) 11628 return "ImmunizationEvaluation"; 11629 if (code == FHIRTypes.IMMUNIZATIONRECOMMENDATION) 11630 return "ImmunizationRecommendation"; 11631 if (code == FHIRTypes.IMPLEMENTATIONGUIDE) 11632 return "ImplementationGuide"; 11633 if (code == FHIRTypes.INGREDIENT) 11634 return "Ingredient"; 11635 if (code == FHIRTypes.INSURANCEPLAN) 11636 return "InsurancePlan"; 11637 if (code == FHIRTypes.INVENTORYITEM) 11638 return "InventoryItem"; 11639 if (code == FHIRTypes.INVENTORYREPORT) 11640 return "InventoryReport"; 11641 if (code == FHIRTypes.INVOICE) 11642 return "Invoice"; 11643 if (code == FHIRTypes.LIBRARY) 11644 return "Library"; 11645 if (code == FHIRTypes.LINKAGE) 11646 return "Linkage"; 11647 if (code == FHIRTypes.LIST) 11648 return "List"; 11649 if (code == FHIRTypes.LOCATION) 11650 return "Location"; 11651 if (code == FHIRTypes.MANUFACTUREDITEMDEFINITION) 11652 return "ManufacturedItemDefinition"; 11653 if (code == FHIRTypes.MEASURE) 11654 return "Measure"; 11655 if (code == FHIRTypes.MEASUREREPORT) 11656 return "MeasureReport"; 11657 if (code == FHIRTypes.MEDICATION) 11658 return "Medication"; 11659 if (code == FHIRTypes.MEDICATIONADMINISTRATION) 11660 return "MedicationAdministration"; 11661 if (code == FHIRTypes.MEDICATIONDISPENSE) 11662 return "MedicationDispense"; 11663 if (code == FHIRTypes.MEDICATIONKNOWLEDGE) 11664 return "MedicationKnowledge"; 11665 if (code == FHIRTypes.MEDICATIONREQUEST) 11666 return "MedicationRequest"; 11667 if (code == FHIRTypes.MEDICATIONSTATEMENT) 11668 return "MedicationStatement"; 11669 if (code == FHIRTypes.MEDICINALPRODUCTDEFINITION) 11670 return "MedicinalProductDefinition"; 11671 if (code == FHIRTypes.MESSAGEDEFINITION) 11672 return "MessageDefinition"; 11673 if (code == FHIRTypes.MESSAGEHEADER) 11674 return "MessageHeader"; 11675 if (code == FHIRTypes.METADATARESOURCE) 11676 return "MetadataResource"; 11677 if (code == FHIRTypes.MOLECULARSEQUENCE) 11678 return "MolecularSequence"; 11679 if (code == FHIRTypes.NAMINGSYSTEM) 11680 return "NamingSystem"; 11681 if (code == FHIRTypes.NUTRITIONINTAKE) 11682 return "NutritionIntake"; 11683 if (code == FHIRTypes.NUTRITIONORDER) 11684 return "NutritionOrder"; 11685 if (code == FHIRTypes.NUTRITIONPRODUCT) 11686 return "NutritionProduct"; 11687 if (code == FHIRTypes.OBSERVATION) 11688 return "Observation"; 11689 if (code == FHIRTypes.OBSERVATIONDEFINITION) 11690 return "ObservationDefinition"; 11691 if (code == FHIRTypes.OPERATIONDEFINITION) 11692 return "OperationDefinition"; 11693 if (code == FHIRTypes.OPERATIONOUTCOME) 11694 return "OperationOutcome"; 11695 if (code == FHIRTypes.ORGANIZATION) 11696 return "Organization"; 11697 if (code == FHIRTypes.ORGANIZATIONAFFILIATION) 11698 return "OrganizationAffiliation"; 11699 if (code == FHIRTypes.PACKAGEDPRODUCTDEFINITION) 11700 return "PackagedProductDefinition"; 11701 if (code == FHIRTypes.PATIENT) 11702 return "Patient"; 11703 if (code == FHIRTypes.PAYMENTNOTICE) 11704 return "PaymentNotice"; 11705 if (code == FHIRTypes.PAYMENTRECONCILIATION) 11706 return "PaymentReconciliation"; 11707 if (code == FHIRTypes.PERMISSION) 11708 return "Permission"; 11709 if (code == FHIRTypes.PERSON) 11710 return "Person"; 11711 if (code == FHIRTypes.PLANDEFINITION) 11712 return "PlanDefinition"; 11713 if (code == FHIRTypes.PRACTITIONER) 11714 return "Practitioner"; 11715 if (code == FHIRTypes.PRACTITIONERROLE) 11716 return "PractitionerRole"; 11717 if (code == FHIRTypes.PROCEDURE) 11718 return "Procedure"; 11719 if (code == FHIRTypes.PROVENANCE) 11720 return "Provenance"; 11721 if (code == FHIRTypes.QUESTIONNAIRE) 11722 return "Questionnaire"; 11723 if (code == FHIRTypes.QUESTIONNAIRERESPONSE) 11724 return "QuestionnaireResponse"; 11725 if (code == FHIRTypes.REGULATEDAUTHORIZATION) 11726 return "RegulatedAuthorization"; 11727 if (code == FHIRTypes.RELATEDPERSON) 11728 return "RelatedPerson"; 11729 if (code == FHIRTypes.REQUESTORCHESTRATION) 11730 return "RequestOrchestration"; 11731 if (code == FHIRTypes.REQUIREMENTS) 11732 return "Requirements"; 11733 if (code == FHIRTypes.RESEARCHSTUDY) 11734 return "ResearchStudy"; 11735 if (code == FHIRTypes.RESEARCHSUBJECT) 11736 return "ResearchSubject"; 11737 if (code == FHIRTypes.RISKASSESSMENT) 11738 return "RiskAssessment"; 11739 if (code == FHIRTypes.SCHEDULE) 11740 return "Schedule"; 11741 if (code == FHIRTypes.SEARCHPARAMETER) 11742 return "SearchParameter"; 11743 if (code == FHIRTypes.SERVICEREQUEST) 11744 return "ServiceRequest"; 11745 if (code == FHIRTypes.SLOT) 11746 return "Slot"; 11747 if (code == FHIRTypes.SPECIMEN) 11748 return "Specimen"; 11749 if (code == FHIRTypes.SPECIMENDEFINITION) 11750 return "SpecimenDefinition"; 11751 if (code == FHIRTypes.STRUCTUREDEFINITION) 11752 return "StructureDefinition"; 11753 if (code == FHIRTypes.STRUCTUREMAP) 11754 return "StructureMap"; 11755 if (code == FHIRTypes.SUBSCRIPTION) 11756 return "Subscription"; 11757 if (code == FHIRTypes.SUBSCRIPTIONSTATUS) 11758 return "SubscriptionStatus"; 11759 if (code == FHIRTypes.SUBSCRIPTIONTOPIC) 11760 return "SubscriptionTopic"; 11761 if (code == FHIRTypes.SUBSTANCE) 11762 return "Substance"; 11763 if (code == FHIRTypes.SUBSTANCEDEFINITION) 11764 return "SubstanceDefinition"; 11765 if (code == FHIRTypes.SUBSTANCENUCLEICACID) 11766 return "SubstanceNucleicAcid"; 11767 if (code == FHIRTypes.SUBSTANCEPOLYMER) 11768 return "SubstancePolymer"; 11769 if (code == FHIRTypes.SUBSTANCEPROTEIN) 11770 return "SubstanceProtein"; 11771 if (code == FHIRTypes.SUBSTANCEREFERENCEINFORMATION) 11772 return "SubstanceReferenceInformation"; 11773 if (code == FHIRTypes.SUBSTANCESOURCEMATERIAL) 11774 return "SubstanceSourceMaterial"; 11775 if (code == FHIRTypes.SUPPLYDELIVERY) 11776 return "SupplyDelivery"; 11777 if (code == FHIRTypes.SUPPLYREQUEST) 11778 return "SupplyRequest"; 11779 if (code == FHIRTypes.TASK) 11780 return "Task"; 11781 if (code == FHIRTypes.TERMINOLOGYCAPABILITIES) 11782 return "TerminologyCapabilities"; 11783 if (code == FHIRTypes.TESTPLAN) 11784 return "TestPlan"; 11785 if (code == FHIRTypes.TESTREPORT) 11786 return "TestReport"; 11787 if (code == FHIRTypes.TESTSCRIPT) 11788 return "TestScript"; 11789 if (code == FHIRTypes.TRANSPORT) 11790 return "Transport"; 11791 if (code == FHIRTypes.VALUESET) 11792 return "ValueSet"; 11793 if (code == FHIRTypes.VERIFICATIONRESULT) 11794 return "VerificationResult"; 11795 if (code == FHIRTypes.VISIONPRESCRIPTION) 11796 return "VisionPrescription"; 11797 if (code == FHIRTypes.PARAMETERS) 11798 return "Parameters"; 11799 return "?"; 11800 } 11801 public String toSystem(FHIRTypes code) { 11802 return code.getSystem(); 11803 } 11804 } 11805 11806 public enum FHIRVersion { 11807 /** 11808 * Oldest archived version of FHIR. 11809 */ 11810 _0_01, 11811 /** 11812 * 1st Draft for Comment (Sept 2012 Ballot). 11813 */ 11814 _0_05, 11815 /** 11816 * 2nd Draft for Comment (January 2013 Ballot). 11817 */ 11818 _0_06, 11819 /** 11820 * DSTU 1 Ballot version. 11821 */ 11822 _0_11, 11823 /** 11824 * DSTU 1 version. 11825 */ 11826 _0_0, 11827 /** 11828 * DSTU 1 Official version. 11829 */ 11830 _0_0_80, 11831 /** 11832 * DSTU 1 Official version Technical Errata #1. 11833 */ 11834 _0_0_81, 11835 /** 11836 * DSTU 1 Official version Technical Errata #2. 11837 */ 11838 _0_0_82, 11839 /** 11840 * January 2015 Ballot. 11841 */ 11842 _0_4, 11843 /** 11844 * Draft For Comment (January 2015 Ballot). 11845 */ 11846 _0_4_0, 11847 /** 11848 * May 2015 Ballot. 11849 */ 11850 _0_5, 11851 /** 11852 * DSTU 2 Ballot version (May 2015 Ballot). 11853 */ 11854 _0_5_0, 11855 /** 11856 * DSTU 2 version. 11857 */ 11858 _1_0, 11859 /** 11860 * DSTU 2 QA Preview + CQIF Ballot (Sep 2015). 11861 */ 11862 _1_0_0, 11863 /** 11864 * DSTU 2 (Official version). 11865 */ 11866 _1_0_1, 11867 /** 11868 * DSTU 2 (Official version) with 1 technical errata. 11869 */ 11870 _1_0_2, 11871 /** 11872 * GAO Ballot version. 11873 */ 11874 _1_1, 11875 /** 11876 * GAO Ballot + draft changes to main FHIR standard. 11877 */ 11878 _1_1_0, 11879 /** 11880 * Connectathon 12 (Montreal) version. 11881 */ 11882 _1_4, 11883 /** 11884 * CQF on FHIR Ballot + Connectathon 12 (Montreal). 11885 */ 11886 _1_4_0, 11887 /** 11888 * Connectathon 13 (Baltimore) version. 11889 */ 11890 _1_6, 11891 /** 11892 * FHIR STU3 Ballot + Connectathon 13 (Baltimore). 11893 */ 11894 _1_6_0, 11895 /** 11896 * Connectathon 14 (San Antonio) version. 11897 */ 11898 _1_8, 11899 /** 11900 * FHIR STU3 Candidate + Connectathon 14 (San Antonio). 11901 */ 11902 _1_8_0, 11903 /** 11904 * STU3 version. 11905 */ 11906 _3_0, 11907 /** 11908 * FHIR Release 3 (STU). 11909 */ 11910 _3_0_0, 11911 /** 11912 * FHIR Release 3 (STU) with 1 technical errata. 11913 */ 11914 _3_0_1, 11915 /** 11916 * FHIR Release 3 (STU) with 2 technical errata. 11917 */ 11918 _3_0_2, 11919 /** 11920 * R4 Ballot #1 version. 11921 */ 11922 _3_3, 11923 /** 11924 * R4 Ballot #1 + Connectaton 18 (Cologne). 11925 */ 11926 _3_3_0, 11927 /** 11928 * R4 Ballot #2 version. 11929 */ 11930 _3_5, 11931 /** 11932 * R4 Ballot #2 + Connectathon 19 (Baltimore). 11933 */ 11934 _3_5_0, 11935 /** 11936 * R4 version. 11937 */ 11938 _4_0, 11939 /** 11940 * FHIR Release 4 (Normative + STU). 11941 */ 11942 _4_0_0, 11943 /** 11944 * FHIR Release 4 (Normative + STU) with 1 technical errata. 11945 */ 11946 _4_0_1, 11947 /** 11948 * R4B Ballot #1 version. 11949 */ 11950 _4_1, 11951 /** 11952 * R4B Ballot #1 + Connectathon 27 (Virtual). 11953 */ 11954 _4_1_0, 11955 /** 11956 * R5 Preview #1 version. 11957 */ 11958 _4_2, 11959 /** 11960 * R5 Preview #1 + Connectathon 23 (Sydney). 11961 */ 11962 _4_2_0, 11963 /** 11964 * R4B version. 11965 */ 11966 _4_3, 11967 /** 11968 * FHIR Release 4B (Normative + STU). 11969 */ 11970 _4_3_0, 11971 /** 11972 * FHIR Release 4B CI-Builld. 11973 */ 11974 _4_3_0CIBUILD, 11975 /** 11976 * FHIR Release 4B Snapshot #1. 11977 */ 11978 _4_3_0SNAPSHOT1, 11979 /** 11980 * R5 Preview #2 version. 11981 */ 11982 _4_4, 11983 /** 11984 * R5 Preview #2 + Connectathon 24 (Virtual). 11985 */ 11986 _4_4_0, 11987 /** 11988 * R5 Preview #3 version. 11989 */ 11990 _4_5, 11991 /** 11992 * R5 Preview #3 + Connectathon 25 (Virtual). 11993 */ 11994 _4_5_0, 11995 /** 11996 * R5 Draft Ballot version. 11997 */ 11998 _4_6, 11999 /** 12000 * R5 Draft Ballot + Connectathon 27 (Virtual). 12001 */ 12002 _4_6_0, 12003 /** 12004 * R5 Versions. 12005 */ 12006 _5_0, 12007 /** 12008 * R5 Final Version. 12009 */ 12010 _5_0_0, 12011 /** 12012 * R5 Rolling ci-build. 12013 */ 12014 _5_0_0CIBUILD, 12015 /** 12016 * R5 Preview #2. 12017 */ 12018 _5_0_0SNAPSHOT1, 12019 /** 12020 * R5 Interim tooling stage. 12021 */ 12022 _5_0_0SNAPSHOT2, 12023 /** 12024 * R5 Ballot. 12025 */ 12026 _5_0_0BALLOT, 12027 /** 12028 * R5 January 2023 Staging Release + Connectathon 32. 12029 */ 12030 _5_0_0SNAPSHOT3, 12031 /** 12032 * R5 Final QA. 12033 */ 12034 _5_0_0DRAFTFINAL, 12035 /** 12036 * R6 Rolling ci-build. 12037 */ 12038 _6_0_0CIBUILD, 12039 /** 12040 * R6 Formal version (does not exist yet) 12041 */ 12042 _6_0_0, 12043 _6_0_0_BALLOT1, 12044 /** 12045 * added to help the parsers 12046 */ 12047 NULL; 12048 public static FHIRVersion fromCode(String codeString) throws FHIRException { 12049 if (codeString == null || "".equals(codeString)) 12050 return null; 12051 if ("0.01".equals(codeString)) 12052 return _0_01; 12053 if ("0.05".equals(codeString)) 12054 return _0_05; 12055 if ("0.06".equals(codeString)) 12056 return _0_06; 12057 if ("0.11".equals(codeString)) 12058 return _0_11; 12059 if ("0.0".equals(codeString)) 12060 return _0_0; 12061 if ("0.0.80".equals(codeString)) 12062 return _0_0_80; 12063 if ("0.0.81".equals(codeString)) 12064 return _0_0_81; 12065 if ("0.0.82".equals(codeString)) 12066 return _0_0_82; 12067 if ("0.4".equals(codeString)) 12068 return _0_4; 12069 if ("0.4.0".equals(codeString)) 12070 return _0_4_0; 12071 if ("0.5".equals(codeString)) 12072 return _0_5; 12073 if ("0.5.0".equals(codeString)) 12074 return _0_5_0; 12075 if ("1.0".equals(codeString)) 12076 return _1_0; 12077 if ("1.0.0".equals(codeString)) 12078 return _1_0_0; 12079 if ("1.0.1".equals(codeString)) 12080 return _1_0_1; 12081 if ("1.0.2".equals(codeString)) 12082 return _1_0_2; 12083 if ("1.1".equals(codeString)) 12084 return _1_1; 12085 if ("1.1.0".equals(codeString)) 12086 return _1_1_0; 12087 if ("1.4".equals(codeString)) 12088 return _1_4; 12089 if ("1.4.0".equals(codeString)) 12090 return _1_4_0; 12091 if ("1.6".equals(codeString)) 12092 return _1_6; 12093 if ("1.6.0".equals(codeString)) 12094 return _1_6_0; 12095 if ("1.8".equals(codeString)) 12096 return _1_8; 12097 if ("1.8.0".equals(codeString)) 12098 return _1_8_0; 12099 if ("3.0".equals(codeString)) 12100 return _3_0; 12101 if ("3.0.0".equals(codeString)) 12102 return _3_0_0; 12103 if ("3.0.1".equals(codeString)) 12104 return _3_0_1; 12105 if ("3.0.2".equals(codeString)) 12106 return _3_0_2; 12107 if ("3.3".equals(codeString)) 12108 return _3_3; 12109 if ("3.3.0".equals(codeString)) 12110 return _3_3_0; 12111 if ("3.5".equals(codeString)) 12112 return _3_5; 12113 if ("3.5.0".equals(codeString)) 12114 return _3_5_0; 12115 if ("4.0".equals(codeString)) 12116 return _4_0; 12117 if ("4.0.0".equals(codeString)) 12118 return _4_0_0; 12119 if ("4.0.1".equals(codeString)) 12120 return _4_0_1; 12121 if ("4.1".equals(codeString)) 12122 return _4_1; 12123 if ("4.1.0".equals(codeString)) 12124 return _4_1_0; 12125 if ("4.2".equals(codeString)) 12126 return _4_2; 12127 if ("4.2.0".equals(codeString)) 12128 return _4_2_0; 12129 if ("4.3".equals(codeString)) 12130 return _4_3; 12131 if ("4.3.0".equals(codeString)) 12132 return _4_3_0; 12133 if ("4.3.0-cibuild".equals(codeString)) 12134 return _4_3_0CIBUILD; 12135 if ("4.3.0-snapshot1".equals(codeString)) 12136 return _4_3_0SNAPSHOT1; 12137 if ("4.4".equals(codeString)) 12138 return _4_4; 12139 if ("4.4.0".equals(codeString)) 12140 return _4_4_0; 12141 if ("4.5".equals(codeString)) 12142 return _4_5; 12143 if ("4.5.0".equals(codeString)) 12144 return _4_5_0; 12145 if ("4.6".equals(codeString)) 12146 return _4_6; 12147 if ("4.6.0".equals(codeString)) 12148 return _4_6_0; 12149 if ("5.0".equals(codeString)) 12150 return _5_0; 12151 if ("5.0.0".equals(codeString)) 12152 return _5_0_0; 12153 if ("5.0.0-cibuild".equals(codeString)) 12154 return _5_0_0CIBUILD; 12155 if ("5.0.0-snapshot1".equals(codeString)) 12156 return _5_0_0SNAPSHOT1; 12157 if ("5.0.0-snapshot2".equals(codeString)) 12158 return _5_0_0SNAPSHOT2; 12159 if ("5.0.0-ballot".equals(codeString)) 12160 return _5_0_0BALLOT; 12161 if ("5.0.0-snapshot3".equals(codeString)) 12162 return _5_0_0SNAPSHOT3; 12163 if ("5.0.0-draft-final".equals(codeString)) 12164 return _5_0_0DRAFTFINAL; 12165 if ("6.0.0-cibuild".equals(codeString)) 12166 return _6_0_0CIBUILD; 12167 if ("6.0.0".equals(codeString)) 12168 return _6_0_0; 12169 if ("6.0.0-ballot1".equals(codeString)) 12170 return _6_0_0_BALLOT1; 12171 throw new FHIRException("Unknown FHIRVersion code '"+codeString+"'"); 12172 } 12173 public static boolean isValidCode(String codeString) { 12174 if (codeString == null || "".equals(codeString)) 12175 return false; 12176 return Utilities.existsInList(codeString, "0.01", "0.05", "0.06", "0.11", "0.0", "0.0.80", "0.0.81", "0.0.82", "0.4", "0.4.0", "0.5", "0.5.0", "1.0", "1.0.0", "1.0.1", "1.0.2", "1.1", "1.1.0", "1.4", "1.4.0", "1.6", "1.6.0", "1.8", "1.8.0", "3.0", "3.0.0", "3.0.1", "3.0.2", "3.3", "3.3.0", "3.5", "3.5.0", "4.0", "4.0.0", "4.0.1", "4.1", "4.1.0", "4.2", "4.2.0", "4.3", "4.3.0", "4.3.0-cibuild", "4.3.0-snapshot1", "4.4", "4.4.0", "4.5", "4.5.0", "4.6", "4.6.0", "5.0", "5.0.0", "5.0.0-cibuild", "5.0.0-snapshot1", "5.0.0-snapshot2", "5.0.0-ballot", "5.0.0-snapshot3", "5.0.0-draft-final"); 12177 } 12178 public String toCode() { 12179 switch (this) { 12180 case _0_01: return "0.01"; 12181 case _0_05: return "0.05"; 12182 case _0_06: return "0.06"; 12183 case _0_11: return "0.11"; 12184 case _0_0: return "0.0"; 12185 case _0_0_80: return "0.0.80"; 12186 case _0_0_81: return "0.0.81"; 12187 case _0_0_82: return "0.0.82"; 12188 case _0_4: return "0.4"; 12189 case _0_4_0: return "0.4.0"; 12190 case _0_5: return "0.5"; 12191 case _0_5_0: return "0.5.0"; 12192 case _1_0: return "1.0"; 12193 case _1_0_0: return "1.0.0"; 12194 case _1_0_1: return "1.0.1"; 12195 case _1_0_2: return "1.0.2"; 12196 case _1_1: return "1.1"; 12197 case _1_1_0: return "1.1.0"; 12198 case _1_4: return "1.4"; 12199 case _1_4_0: return "1.4.0"; 12200 case _1_6: return "1.6"; 12201 case _1_6_0: return "1.6.0"; 12202 case _1_8: return "1.8"; 12203 case _1_8_0: return "1.8.0"; 12204 case _3_0: return "3.0"; 12205 case _3_0_0: return "3.0.0"; 12206 case _3_0_1: return "3.0.1"; 12207 case _3_0_2: return "3.0.2"; 12208 case _3_3: return "3.3"; 12209 case _3_3_0: return "3.3.0"; 12210 case _3_5: return "3.5"; 12211 case _3_5_0: return "3.5.0"; 12212 case _4_0: return "4.0"; 12213 case _4_0_0: return "4.0.0"; 12214 case _4_0_1: return "4.0.1"; 12215 case _4_1: return "4.1"; 12216 case _4_1_0: return "4.1.0"; 12217 case _4_2: return "4.2"; 12218 case _4_2_0: return "4.2.0"; 12219 case _4_3: return "4.3"; 12220 case _4_3_0: return "4.3.0"; 12221 case _4_3_0CIBUILD: return "4.3.0-cibuild"; 12222 case _4_3_0SNAPSHOT1: return "4.3.0-snapshot1"; 12223 case _4_4: return "4.4"; 12224 case _4_4_0: return "4.4.0"; 12225 case _4_5: return "4.5"; 12226 case _4_5_0: return "4.5.0"; 12227 case _4_6: return "4.6"; 12228 case _4_6_0: return "4.6.0"; 12229 case _5_0: return "5.0"; 12230 case _5_0_0: return "5.0.0"; 12231 case _5_0_0CIBUILD: return "5.0.0-cibuild"; 12232 case _5_0_0SNAPSHOT1: return "5.0.0-snapshot1"; 12233 case _5_0_0SNAPSHOT2: return "5.0.0-snapshot2"; 12234 case _5_0_0BALLOT: return "5.0.0-ballot"; 12235 case _5_0_0SNAPSHOT3: return "5.0.0-snapshot3"; 12236 case _5_0_0DRAFTFINAL: return "5.0.0-draft-final"; 12237 case _6_0_0CIBUILD: return "6.0.0-cibuild"; 12238 case _6_0_0: return "6.0.0"; 12239 case _6_0_0_BALLOT1: return "6.0.0-ballot1"; 12240 case NULL: return null; 12241 default: return "?"; 12242 } 12243 } 12244 public String getSystem() { 12245 switch (this) { 12246 case _0_01: return "http://hl7.org/fhir/FHIR-version"; 12247 case _0_05: return "http://hl7.org/fhir/FHIR-version"; 12248 case _0_06: return "http://hl7.org/fhir/FHIR-version"; 12249 case _0_11: return "http://hl7.org/fhir/FHIR-version"; 12250 case _0_0: return "http://hl7.org/fhir/FHIR-version"; 12251 case _0_0_80: return "http://hl7.org/fhir/FHIR-version"; 12252 case _0_0_81: return "http://hl7.org/fhir/FHIR-version"; 12253 case _0_0_82: return "http://hl7.org/fhir/FHIR-version"; 12254 case _0_4: return "http://hl7.org/fhir/FHIR-version"; 12255 case _0_4_0: return "http://hl7.org/fhir/FHIR-version"; 12256 case _0_5: return "http://hl7.org/fhir/FHIR-version"; 12257 case _0_5_0: return "http://hl7.org/fhir/FHIR-version"; 12258 case _1_0: return "http://hl7.org/fhir/FHIR-version"; 12259 case _1_0_0: return "http://hl7.org/fhir/FHIR-version"; 12260 case _1_0_1: return "http://hl7.org/fhir/FHIR-version"; 12261 case _1_0_2: return "http://hl7.org/fhir/FHIR-version"; 12262 case _1_1: return "http://hl7.org/fhir/FHIR-version"; 12263 case _1_1_0: return "http://hl7.org/fhir/FHIR-version"; 12264 case _1_4: return "http://hl7.org/fhir/FHIR-version"; 12265 case _1_4_0: return "http://hl7.org/fhir/FHIR-version"; 12266 case _1_6: return "http://hl7.org/fhir/FHIR-version"; 12267 case _1_6_0: return "http://hl7.org/fhir/FHIR-version"; 12268 case _1_8: return "http://hl7.org/fhir/FHIR-version"; 12269 case _1_8_0: return "http://hl7.org/fhir/FHIR-version"; 12270 case _3_0: return "http://hl7.org/fhir/FHIR-version"; 12271 case _3_0_0: return "http://hl7.org/fhir/FHIR-version"; 12272 case _3_0_1: return "http://hl7.org/fhir/FHIR-version"; 12273 case _3_0_2: return "http://hl7.org/fhir/FHIR-version"; 12274 case _3_3: return "http://hl7.org/fhir/FHIR-version"; 12275 case _3_3_0: return "http://hl7.org/fhir/FHIR-version"; 12276 case _3_5: return "http://hl7.org/fhir/FHIR-version"; 12277 case _3_5_0: return "http://hl7.org/fhir/FHIR-version"; 12278 case _4_0: return "http://hl7.org/fhir/FHIR-version"; 12279 case _4_0_0: return "http://hl7.org/fhir/FHIR-version"; 12280 case _4_0_1: return "http://hl7.org/fhir/FHIR-version"; 12281 case _4_1: return "http://hl7.org/fhir/FHIR-version"; 12282 case _4_1_0: return "http://hl7.org/fhir/FHIR-version"; 12283 case _4_2: return "http://hl7.org/fhir/FHIR-version"; 12284 case _4_2_0: return "http://hl7.org/fhir/FHIR-version"; 12285 case _4_3: return "http://hl7.org/fhir/FHIR-version"; 12286 case _4_3_0: return "http://hl7.org/fhir/FHIR-version"; 12287 case _4_3_0CIBUILD: return "http://hl7.org/fhir/FHIR-version"; 12288 case _4_3_0SNAPSHOT1: return "http://hl7.org/fhir/FHIR-version"; 12289 case _4_4: return "http://hl7.org/fhir/FHIR-version"; 12290 case _4_4_0: return "http://hl7.org/fhir/FHIR-version"; 12291 case _4_5: return "http://hl7.org/fhir/FHIR-version"; 12292 case _4_5_0: return "http://hl7.org/fhir/FHIR-version"; 12293 case _4_6: return "http://hl7.org/fhir/FHIR-version"; 12294 case _4_6_0: return "http://hl7.org/fhir/FHIR-version"; 12295 case _5_0: return "http://hl7.org/fhir/FHIR-version"; 12296 case _5_0_0: return "http://hl7.org/fhir/FHIR-version"; 12297 case _5_0_0CIBUILD: return "http://hl7.org/fhir/FHIR-version"; 12298 case _5_0_0SNAPSHOT1: return "http://hl7.org/fhir/FHIR-version"; 12299 case _5_0_0SNAPSHOT2: return "http://hl7.org/fhir/FHIR-version"; 12300 case _5_0_0BALLOT: return "http://hl7.org/fhir/FHIR-version"; 12301 case _5_0_0SNAPSHOT3: return "http://hl7.org/fhir/FHIR-version"; 12302 case _5_0_0DRAFTFINAL: return "http://hl7.org/fhir/FHIR-version"; 12303 case _6_0_0CIBUILD: return "http://hl7.org/fhir/FHIR-version"; 12304 case _6_0_0: return "http://hl7.org/fhir/FHIR-version"; 12305 case _6_0_0_BALLOT1: return "http://hl7.org/fhir/FHIR-version"; 12306 case NULL: return null; 12307 default: return "?"; 12308 } 12309 } 12310 public String getDefinition() { 12311 switch (this) { 12312 case _0_01: return "Oldest archived version of FHIR."; 12313 case _0_05: return "1st Draft for Comment (Sept 2012 Ballot)."; 12314 case _0_06: return "2nd Draft for Comment (January 2013 Ballot)."; 12315 case _0_11: return "DSTU 1 Ballot version."; 12316 case _0_0: return "DSTU 1 version."; 12317 case _0_0_80: return "DSTU 1 Official version."; 12318 case _0_0_81: return "DSTU 1 Official version Technical Errata #1."; 12319 case _0_0_82: return "DSTU 1 Official version Technical Errata #2."; 12320 case _0_4: return "January 2015 Ballot."; 12321 case _0_4_0: return "Draft For Comment (January 2015 Ballot)."; 12322 case _0_5: return "May 2015 Ballot."; 12323 case _0_5_0: return "DSTU 2 Ballot version (May 2015 Ballot)."; 12324 case _1_0: return "DSTU 2 version."; 12325 case _1_0_0: return "DSTU 2 QA Preview + CQIF Ballot (Sep 2015)."; 12326 case _1_0_1: return "DSTU 2 (Official version)."; 12327 case _1_0_2: return "DSTU 2 (Official version) with 1 technical errata."; 12328 case _1_1: return "GAO Ballot version."; 12329 case _1_1_0: return "GAO Ballot + draft changes to main FHIR standard."; 12330 case _1_4: return "Connectathon 12 (Montreal) version."; 12331 case _1_4_0: return "CQF on FHIR Ballot + Connectathon 12 (Montreal)."; 12332 case _1_6: return "Connectathon 13 (Baltimore) version."; 12333 case _1_6_0: return "FHIR STU3 Ballot + Connectathon 13 (Baltimore)."; 12334 case _1_8: return "Connectathon 14 (San Antonio) version."; 12335 case _1_8_0: return "FHIR STU3 Candidate + Connectathon 14 (San Antonio)."; 12336 case _3_0: return "STU3 version."; 12337 case _3_0_0: return "FHIR Release 3 (STU)."; 12338 case _3_0_1: return "FHIR Release 3 (STU) with 1 technical errata."; 12339 case _3_0_2: return "FHIR Release 3 (STU) with 2 technical errata."; 12340 case _3_3: return "R4 Ballot #1 version."; 12341 case _3_3_0: return "R4 Ballot #1 + Connectaton 18 (Cologne)."; 12342 case _3_5: return "R4 Ballot #2 version."; 12343 case _3_5_0: return "R4 Ballot #2 + Connectathon 19 (Baltimore)."; 12344 case _4_0: return "R4 version."; 12345 case _4_0_0: return "FHIR Release 4 (Normative + STU)."; 12346 case _4_0_1: return "FHIR Release 4 (Normative + STU) with 1 technical errata."; 12347 case _4_1: return "R4B Ballot #1 version."; 12348 case _4_1_0: return "R4B Ballot #1 + Connectathon 27 (Virtual)."; 12349 case _4_2: return "R5 Preview #1 version."; 12350 case _4_2_0: return "R5 Preview #1 + Connectathon 23 (Sydney)."; 12351 case _4_3: return "R4B version."; 12352 case _4_3_0: return "FHIR Release 4B (Normative + STU)."; 12353 case _4_3_0CIBUILD: return "FHIR Release 4B CI-Builld."; 12354 case _4_3_0SNAPSHOT1: return "FHIR Release 4B Snapshot #1."; 12355 case _4_4: return "R5 Preview #2 version."; 12356 case _4_4_0: return "R5 Preview #2 + Connectathon 24 (Virtual)."; 12357 case _4_5: return "R5 Preview #3 version."; 12358 case _4_5_0: return "R5 Preview #3 + Connectathon 25 (Virtual)."; 12359 case _4_6: return "R5 Draft Ballot version."; 12360 case _4_6_0: return "R5 Draft Ballot + Connectathon 27 (Virtual)."; 12361 case _5_0: return "R5 Versions."; 12362 case _5_0_0: return "R5 Final Version."; 12363 case _5_0_0CIBUILD: return "R5 Rolling ci-build."; 12364 case _5_0_0SNAPSHOT1: return "R5 Preview #2."; 12365 case _5_0_0SNAPSHOT2: return "R5 Interim tooling stage."; 12366 case _5_0_0BALLOT: return "R5 Ballot."; 12367 case _5_0_0SNAPSHOT3: return "R5 January 2023 Staging Release + Connectathon 32."; 12368 case _5_0_0DRAFTFINAL: return "R5 Final QA."; 12369 case _6_0_0CIBUILD: return "R6 Rolling ci-build."; 12370 case _6_0_0: return "R6 Final Version."; 12371 case _6_0_0_BALLOT1: return "R6 Ballot #1."; 12372 case NULL: return null; 12373 default: return "?"; 12374 } 12375 } 12376 public String getDisplay() { 12377 switch (this) { 12378 case _0_01: return "0.01"; 12379 case _0_05: return "0.05"; 12380 case _0_06: return "0.06"; 12381 case _0_11: return "0.11"; 12382 case _0_0: return "0.0"; 12383 case _0_0_80: return "0.0.80"; 12384 case _0_0_81: return "0.0.81"; 12385 case _0_0_82: return "0.0.82"; 12386 case _0_4: return "0.4"; 12387 case _0_4_0: return "0.4.0"; 12388 case _0_5: return "0.5"; 12389 case _0_5_0: return "0.5.0"; 12390 case _1_0: return "1.0"; 12391 case _1_0_0: return "1.0.0"; 12392 case _1_0_1: return "1.0.1"; 12393 case _1_0_2: return "1.0.2"; 12394 case _1_1: return "1.1"; 12395 case _1_1_0: return "1.1.0"; 12396 case _1_4: return "1.4"; 12397 case _1_4_0: return "1.4.0"; 12398 case _1_6: return "1.6"; 12399 case _1_6_0: return "1.6.0"; 12400 case _1_8: return "1.8"; 12401 case _1_8_0: return "1.8.0"; 12402 case _3_0: return "3.0"; 12403 case _3_0_0: return "3.0.0"; 12404 case _3_0_1: return "3.0.1"; 12405 case _3_0_2: return "3.0.2"; 12406 case _3_3: return "3.3"; 12407 case _3_3_0: return "3.3.0"; 12408 case _3_5: return "3.5"; 12409 case _3_5_0: return "3.5.0"; 12410 case _4_0: return "4.0"; 12411 case _4_0_0: return "4.0.0"; 12412 case _4_0_1: return "4.0.1"; 12413 case _4_1: return "4.1"; 12414 case _4_1_0: return "4.1.0"; 12415 case _4_2: return "4.2"; 12416 case _4_2_0: return "4.2.0"; 12417 case _4_3: return "4.3"; 12418 case _4_3_0: return "4.3.0"; 12419 case _4_3_0CIBUILD: return "4.3.0-cibuild"; 12420 case _4_3_0SNAPSHOT1: return "4.3.0-snapshot1"; 12421 case _4_4: return "4.4"; 12422 case _4_4_0: return "4.4.0"; 12423 case _4_5: return "4.5"; 12424 case _4_5_0: return "4.5.0"; 12425 case _4_6: return "4.6"; 12426 case _4_6_0: return "4.6.0"; 12427 case _5_0: return "5.0"; 12428 case _5_0_0: return "5.0.0"; 12429 case _5_0_0CIBUILD: return "5.0.0-cibuild"; 12430 case _5_0_0SNAPSHOT1: return "5.0.0-snapshot1"; 12431 case _5_0_0SNAPSHOT2: return "5.0.0-snapshot2"; 12432 case _5_0_0BALLOT: return "5.0.0-ballot"; 12433 case _5_0_0SNAPSHOT3: return "5.0.0-snapshot3"; 12434 case _5_0_0DRAFTFINAL: return "5.0.0-draft-final"; 12435 case _6_0_0CIBUILD: return "6.0.0-cibuild"; 12436 case _6_0_0: return "6.0.0"; 12437 case _6_0_0_BALLOT1: return "6.0.0-ballot1"; 12438 case NULL: return null; 12439 default: return "?"; 12440 } 12441 } 12442// manual code from configuration.txt: 12443//public String toCode(int len) { 12444// return toCode().substring(0, len); 12445// } 12446// 12447// 12448// @Override 12449// public String toString() { 12450// return toCode(); 12451// } 12452// 12453// 12454// public boolean isR4B() { 12455// return toCode().startsWith("4.1"); 12456// } 12457// 12458// end addition 12459 } 12460 12461 public static class FHIRVersionEnumFactory implements EnumFactory<FHIRVersion> { 12462 public FHIRVersion fromCode(String codeString) throws IllegalArgumentException { 12463 if (codeString == null || "".equals(codeString)) 12464 if (codeString == null || "".equals(codeString)) 12465 return null; 12466 if ("0.01".equals(codeString)) 12467 return FHIRVersion._0_01; 12468 if ("0.05".equals(codeString)) 12469 return FHIRVersion._0_05; 12470 if ("0.06".equals(codeString)) 12471 return FHIRVersion._0_06; 12472 if ("0.11".equals(codeString)) 12473 return FHIRVersion._0_11; 12474 if ("0.0".equals(codeString)) 12475 return FHIRVersion._0_0; 12476 if ("0.0.80".equals(codeString)) 12477 return FHIRVersion._0_0_80; 12478 if ("0.0.81".equals(codeString)) 12479 return FHIRVersion._0_0_81; 12480 if ("0.0.82".equals(codeString)) 12481 return FHIRVersion._0_0_82; 12482 if ("0.4".equals(codeString)) 12483 return FHIRVersion._0_4; 12484 if ("0.4.0".equals(codeString)) 12485 return FHIRVersion._0_4_0; 12486 if ("0.5".equals(codeString)) 12487 return FHIRVersion._0_5; 12488 if ("0.5.0".equals(codeString)) 12489 return FHIRVersion._0_5_0; 12490 if ("1.0".equals(codeString)) 12491 return FHIRVersion._1_0; 12492 if ("1.0.0".equals(codeString)) 12493 return FHIRVersion._1_0_0; 12494 if ("1.0.1".equals(codeString)) 12495 return FHIRVersion._1_0_1; 12496 if ("1.0.2".equals(codeString)) 12497 return FHIRVersion._1_0_2; 12498 if ("1.1".equals(codeString)) 12499 return FHIRVersion._1_1; 12500 if ("1.1.0".equals(codeString)) 12501 return FHIRVersion._1_1_0; 12502 if ("1.4".equals(codeString)) 12503 return FHIRVersion._1_4; 12504 if ("1.4.0".equals(codeString)) 12505 return FHIRVersion._1_4_0; 12506 if ("1.6".equals(codeString)) 12507 return FHIRVersion._1_6; 12508 if ("1.6.0".equals(codeString)) 12509 return FHIRVersion._1_6_0; 12510 if ("1.8".equals(codeString)) 12511 return FHIRVersion._1_8; 12512 if ("1.8.0".equals(codeString)) 12513 return FHIRVersion._1_8_0; 12514 if ("3.0".equals(codeString)) 12515 return FHIRVersion._3_0; 12516 if ("3.0.0".equals(codeString)) 12517 return FHIRVersion._3_0_0; 12518 if ("3.0.1".equals(codeString)) 12519 return FHIRVersion._3_0_1; 12520 if ("3.0.2".equals(codeString)) 12521 return FHIRVersion._3_0_2; 12522 if ("3.3".equals(codeString)) 12523 return FHIRVersion._3_3; 12524 if ("3.3.0".equals(codeString)) 12525 return FHIRVersion._3_3_0; 12526 if ("3.5".equals(codeString)) 12527 return FHIRVersion._3_5; 12528 if ("3.5.0".equals(codeString)) 12529 return FHIRVersion._3_5_0; 12530 if ("4.0".equals(codeString)) 12531 return FHIRVersion._4_0; 12532 if ("4.0.0".equals(codeString)) 12533 return FHIRVersion._4_0_0; 12534 if ("4.0.1".equals(codeString)) 12535 return FHIRVersion._4_0_1; 12536 if ("4.1".equals(codeString)) 12537 return FHIRVersion._4_1; 12538 if ("4.1.0".equals(codeString)) 12539 return FHIRVersion._4_1_0; 12540 if ("4.2".equals(codeString)) 12541 return FHIRVersion._4_2; 12542 if ("4.2.0".equals(codeString)) 12543 return FHIRVersion._4_2_0; 12544 if ("4.3".equals(codeString)) 12545 return FHIRVersion._4_3; 12546 if ("4.3.0".equals(codeString)) 12547 return FHIRVersion._4_3_0; 12548 if ("4.3.0-cibuild".equals(codeString)) 12549 return FHIRVersion._4_3_0CIBUILD; 12550 if ("4.3.0-snapshot1".equals(codeString)) 12551 return FHIRVersion._4_3_0SNAPSHOT1; 12552 if ("4.4".equals(codeString)) 12553 return FHIRVersion._4_4; 12554 if ("4.4.0".equals(codeString)) 12555 return FHIRVersion._4_4_0; 12556 if ("4.5".equals(codeString)) 12557 return FHIRVersion._4_5; 12558 if ("4.5.0".equals(codeString)) 12559 return FHIRVersion._4_5_0; 12560 if ("4.6".equals(codeString)) 12561 return FHIRVersion._4_6; 12562 if ("4.6.0".equals(codeString)) 12563 return FHIRVersion._4_6_0; 12564 if ("5.0".equals(codeString)) 12565 return FHIRVersion._5_0; 12566 if ("5.0.0".equals(codeString)) 12567 return FHIRVersion._5_0_0; 12568 if ("5.0.0-cibuild".equals(codeString)) 12569 return FHIRVersion._5_0_0CIBUILD; 12570 if ("5.0.0-snapshot1".equals(codeString)) 12571 return FHIRVersion._5_0_0SNAPSHOT1; 12572 if ("5.0.0-snapshot2".equals(codeString)) 12573 return FHIRVersion._5_0_0SNAPSHOT2; 12574 if ("5.0.0-ballot".equals(codeString)) 12575 return FHIRVersion._5_0_0BALLOT; 12576 if ("5.0.0-snapshot3".equals(codeString)) 12577 return FHIRVersion._5_0_0SNAPSHOT3; 12578 if ("5.0.0-draft-final".equals(codeString)) 12579 return FHIRVersion._5_0_0DRAFTFINAL; 12580 if ("6.0.0-cibuild".equals(codeString)) 12581 return FHIRVersion._6_0_0CIBUILD; 12582 if ("6.0.0".equals(codeString)) 12583 return FHIRVersion._6_0_0; 12584 if ("6.0.0-ballot1".equals(codeString)) 12585 return FHIRVersion._6_0_0_BALLOT1; 12586 throw new IllegalArgumentException("Unknown FHIRVersion code '"+codeString+"'"); 12587 } 12588 12589 public Enumeration<FHIRVersion> fromType(PrimitiveType<?> code) throws FHIRException { 12590 if (code == null) 12591 return null; 12592 if (code.isEmpty()) 12593 return new Enumeration<FHIRVersion>(this, FHIRVersion.NULL, code); 12594 String codeString = ((PrimitiveType) code).asStringValue(); 12595 if (codeString == null || "".equals(codeString)) 12596 return new Enumeration<FHIRVersion>(this, FHIRVersion.NULL, code); 12597 if ("0.01".equals(codeString)) 12598 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_01, code); 12599 if ("0.05".equals(codeString)) 12600 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_05, code); 12601 if ("0.06".equals(codeString)) 12602 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_06, code); 12603 if ("0.11".equals(codeString)) 12604 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_11, code); 12605 if ("0.0".equals(codeString)) 12606 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_0, code); 12607 if ("0.0.80".equals(codeString)) 12608 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_0_80, code); 12609 if ("0.0.81".equals(codeString)) 12610 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_0_81, code); 12611 if ("0.0.82".equals(codeString)) 12612 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_0_82, code); 12613 if ("0.4".equals(codeString)) 12614 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_4, code); 12615 if ("0.4.0".equals(codeString)) 12616 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_4_0, code); 12617 if ("0.5".equals(codeString)) 12618 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_5, code); 12619 if ("0.5.0".equals(codeString)) 12620 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_5_0, code); 12621 if ("1.0".equals(codeString)) 12622 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_0, code); 12623 if ("1.0.0".equals(codeString)) 12624 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_0_0, code); 12625 if ("1.0.1".equals(codeString)) 12626 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_0_1, code); 12627 if ("1.0.2".equals(codeString)) 12628 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_0_2, code); 12629 if ("1.1".equals(codeString)) 12630 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_1, code); 12631 if ("1.1.0".equals(codeString)) 12632 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_1_0, code); 12633 if ("1.4".equals(codeString)) 12634 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_4, code); 12635 if ("1.4.0".equals(codeString)) 12636 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_4_0, code); 12637 if ("1.6".equals(codeString)) 12638 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_6, code); 12639 if ("1.6.0".equals(codeString)) 12640 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_6_0, code); 12641 if ("1.8".equals(codeString)) 12642 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_8, code); 12643 if ("1.8.0".equals(codeString)) 12644 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_8_0, code); 12645 if ("3.0".equals(codeString)) 12646 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_0, code); 12647 if ("3.0.0".equals(codeString)) 12648 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_0_0, code); 12649 if ("3.0.1".equals(codeString)) 12650 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_0_1, code); 12651 if ("3.0.2".equals(codeString)) 12652 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_0_2, code); 12653 if ("3.3".equals(codeString)) 12654 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_3, code); 12655 if ("3.3.0".equals(codeString)) 12656 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_3_0, code); 12657 if ("3.5".equals(codeString)) 12658 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_5, code); 12659 if ("3.5.0".equals(codeString)) 12660 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_5_0, code); 12661 if ("4.0".equals(codeString)) 12662 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_0, code); 12663 if ("4.0.0".equals(codeString)) 12664 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_0_0, code); 12665 if ("4.0.1".equals(codeString)) 12666 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_0_1, code); 12667 if ("4.1".equals(codeString)) 12668 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_1, code); 12669 if ("4.1.0".equals(codeString)) 12670 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_1_0, code); 12671 if ("4.2".equals(codeString)) 12672 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_2, code); 12673 if ("4.2.0".equals(codeString)) 12674 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_2_0, code); 12675 if ("4.3".equals(codeString)) 12676 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_3, code); 12677 if ("4.3.0".equals(codeString)) 12678 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_3_0, code); 12679 if ("4.3.0-cibuild".equals(codeString)) 12680 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_3_0CIBUILD, code); 12681 if ("4.3.0-snapshot1".equals(codeString)) 12682 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_3_0SNAPSHOT1, code); 12683 if ("4.4".equals(codeString)) 12684 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_4, code); 12685 if ("4.4.0".equals(codeString)) 12686 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_4_0, code); 12687 if ("4.5".equals(codeString)) 12688 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_5, code); 12689 if ("4.5.0".equals(codeString)) 12690 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_5_0, code); 12691 if ("4.6".equals(codeString)) 12692 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_6, code); 12693 if ("4.6.0".equals(codeString)) 12694 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_6_0, code); 12695 if ("5.0".equals(codeString)) 12696 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0, code); 12697 if ("5.0.0".equals(codeString)) 12698 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0, code); 12699 if ("5.0.0-cibuild".equals(codeString)) 12700 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0CIBUILD, code); 12701 if ("5.0.0-snapshot1".equals(codeString)) 12702 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0SNAPSHOT1, code); 12703 if ("5.0.0-snapshot2".equals(codeString)) 12704 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0SNAPSHOT2, code); 12705 if ("5.0.0-ballot".equals(codeString)) 12706 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0BALLOT, code); 12707 if ("5.0.0-snapshot3".equals(codeString)) 12708 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0SNAPSHOT3, code); 12709 if ("5.0.0-draft-final".equals(codeString)) 12710 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0DRAFTFINAL, code); 12711 if ("6.0.0-cibuild".equals(codeString)) 12712 return new Enumeration<FHIRVersion>(this, FHIRVersion._6_0_0CIBUILD, code); 12713 if ("6.0.0".equals(codeString)) 12714 return new Enumeration<FHIRVersion>(this, FHIRVersion._6_0_0, code); 12715 if ("6.0.0-ballot1".equals(codeString)) 12716 return new Enumeration<FHIRVersion>(this, FHIRVersion._6_0_0_BALLOT1, code); 12717 throw new FHIRException("Unknown FHIRVersion code '"+codeString+"'"); 12718 } 12719 public String toCode(FHIRVersion code) { 12720 if (code == FHIRVersion._0_01) 12721 return "0.01"; 12722 if (code == FHIRVersion._0_05) 12723 return "0.05"; 12724 if (code == FHIRVersion._0_06) 12725 return "0.06"; 12726 if (code == FHIRVersion._0_11) 12727 return "0.11"; 12728 if (code == FHIRVersion._0_0) 12729 return "0.0"; 12730 if (code == FHIRVersion._0_0_80) 12731 return "0.0.80"; 12732 if (code == FHIRVersion._0_0_81) 12733 return "0.0.81"; 12734 if (code == FHIRVersion._0_0_82) 12735 return "0.0.82"; 12736 if (code == FHIRVersion._0_4) 12737 return "0.4"; 12738 if (code == FHIRVersion._0_4_0) 12739 return "0.4.0"; 12740 if (code == FHIRVersion._0_5) 12741 return "0.5"; 12742 if (code == FHIRVersion._0_5_0) 12743 return "0.5.0"; 12744 if (code == FHIRVersion._1_0) 12745 return "1.0"; 12746 if (code == FHIRVersion._1_0_0) 12747 return "1.0.0"; 12748 if (code == FHIRVersion._1_0_1) 12749 return "1.0.1"; 12750 if (code == FHIRVersion._1_0_2) 12751 return "1.0.2"; 12752 if (code == FHIRVersion._1_1) 12753 return "1.1"; 12754 if (code == FHIRVersion._1_1_0) 12755 return "1.1.0"; 12756 if (code == FHIRVersion._1_4) 12757 return "1.4"; 12758 if (code == FHIRVersion._1_4_0) 12759 return "1.4.0"; 12760 if (code == FHIRVersion._1_6) 12761 return "1.6"; 12762 if (code == FHIRVersion._1_6_0) 12763 return "1.6.0"; 12764 if (code == FHIRVersion._1_8) 12765 return "1.8"; 12766 if (code == FHIRVersion._1_8_0) 12767 return "1.8.0"; 12768 if (code == FHIRVersion._3_0) 12769 return "3.0"; 12770 if (code == FHIRVersion._3_0_0) 12771 return "3.0.0"; 12772 if (code == FHIRVersion._3_0_1) 12773 return "3.0.1"; 12774 if (code == FHIRVersion._3_0_2) 12775 return "3.0.2"; 12776 if (code == FHIRVersion._3_3) 12777 return "3.3"; 12778 if (code == FHIRVersion._3_3_0) 12779 return "3.3.0"; 12780 if (code == FHIRVersion._3_5) 12781 return "3.5"; 12782 if (code == FHIRVersion._3_5_0) 12783 return "3.5.0"; 12784 if (code == FHIRVersion._4_0) 12785 return "4.0"; 12786 if (code == FHIRVersion._4_0_0) 12787 return "4.0.0"; 12788 if (code == FHIRVersion._4_0_1) 12789 return "4.0.1"; 12790 if (code == FHIRVersion._4_1) 12791 return "4.1"; 12792 if (code == FHIRVersion._4_1_0) 12793 return "4.1.0"; 12794 if (code == FHIRVersion._4_2) 12795 return "4.2"; 12796 if (code == FHIRVersion._4_2_0) 12797 return "4.2.0"; 12798 if (code == FHIRVersion._4_3) 12799 return "4.3"; 12800 if (code == FHIRVersion._4_3_0) 12801 return "4.3.0"; 12802 if (code == FHIRVersion._4_3_0CIBUILD) 12803 return "4.3.0-cibuild"; 12804 if (code == FHIRVersion._4_3_0SNAPSHOT1) 12805 return "4.3.0-snapshot1"; 12806 if (code == FHIRVersion._4_4) 12807 return "4.4"; 12808 if (code == FHIRVersion._4_4_0) 12809 return "4.4.0"; 12810 if (code == FHIRVersion._4_5) 12811 return "4.5"; 12812 if (code == FHIRVersion._4_5_0) 12813 return "4.5.0"; 12814 if (code == FHIRVersion._4_6) 12815 return "4.6"; 12816 if (code == FHIRVersion._4_6_0) 12817 return "4.6.0"; 12818 if (code == FHIRVersion._5_0) 12819 return "5.0"; 12820 if (code == FHIRVersion._5_0_0) 12821 return "5.0.0"; 12822 if (code == FHIRVersion._5_0_0CIBUILD) 12823 return "5.0.0-cibuild"; 12824 if (code == FHIRVersion._5_0_0SNAPSHOT1) 12825 return "5.0.0-snapshot1"; 12826 if (code == FHIRVersion._5_0_0SNAPSHOT2) 12827 return "5.0.0-snapshot2"; 12828 if (code == FHIRVersion._5_0_0BALLOT) 12829 return "5.0.0-ballot"; 12830 if (code == FHIRVersion._5_0_0SNAPSHOT3) 12831 return "5.0.0-snapshot3"; 12832 if (code == FHIRVersion._5_0_0DRAFTFINAL) 12833 return "5.0.0-draft-final"; 12834 if (code == FHIRVersion._6_0_0CIBUILD) 12835 return "6.0.0-cibuild"; 12836 if (code == FHIRVersion._6_0_0) 12837 return "6.0.0"; 12838 if (code == FHIRVersion._6_0_0_BALLOT1) { 12839 return "6.0.0-ballot1"; 12840 } 12841 return "?"; 12842 } 12843 public String toSystem(FHIRVersion code) { 12844 return code.getSystem(); 12845 } 12846 } 12847 12848 public enum FilterOperator { 12849 /** 12850 * The specified property of the code equals the provided value. 12851 */ 12852 EQUAL, 12853 /** 12854 * Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, including the provided concept itself (include descendant codes and self). 12855 */ 12856 ISA, 12857 /** 12858 * Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, excluding the provided concept itself (i.e. include descendant codes only). 12859 */ 12860 DESCENDENTOF, 12861 /** 12862 * The specified property of the code does not have an is-a relationship with the provided value. 12863 */ 12864 ISNOTA, 12865 /** 12866 * The specified property of the code matches the regex specified in the provided value. 12867 */ 12868 REGEX, 12869 /** 12870 * The specified property of the code is in the set of codes or concepts specified in the provided value (comma-separated list). 12871 */ 12872 IN, 12873 /** 12874 * The specified property of the code is not in the set of codes or concepts specified in the provided value (comma-separated list). 12875 */ 12876 NOTIN, 12877 /** 12878 * Includes all concept ids that have a transitive is-a relationship from the concept Id provided as the value, including the provided concept itself (i.e. include ancestor codes and self). 12879 */ 12880 GENERALIZES, 12881 /** 12882 * Only concepts with a direct hierarchical relationship to the index code and no other concepts. This does not include the index code in the output. 12883 */ 12884 CHILDOF, 12885 /** 12886 * Includes concept ids that have a transitive is-a relationship with the concept Id provided as the value, but which do not have any concept ids with transitive is-a relationships with themselves. 12887 */ 12888 DESCENDENTLEAF, 12889 /** 12890 * The specified property of the code has at least one value (if the specified value is true; if the specified value is false, then matches when the specified property of the code has no values). 12891 */ 12892 EXISTS, 12893 /** 12894 * added to help the parsers 12895 */ 12896 NULL; 12897 public static FilterOperator fromCode(String codeString) throws FHIRException { 12898 if (codeString == null || "".equals(codeString)) 12899 return null; 12900 if ("=".equals(codeString)) 12901 return EQUAL; 12902 if ("is-a".equals(codeString)) 12903 return ISA; 12904 if ("descendent-of".equals(codeString)) 12905 return DESCENDENTOF; 12906 if ("is-not-a".equals(codeString)) 12907 return ISNOTA; 12908 if ("regex".equals(codeString)) 12909 return REGEX; 12910 if ("in".equals(codeString)) 12911 return IN; 12912 if ("not-in".equals(codeString)) 12913 return NOTIN; 12914 if ("generalizes".equals(codeString)) 12915 return GENERALIZES; 12916 if ("child-of".equals(codeString)) 12917 return CHILDOF; 12918 if ("descendent-leaf".equals(codeString)) 12919 return DESCENDENTLEAF; 12920 if ("exists".equals(codeString)) 12921 return EXISTS; 12922 throw new FHIRException("Unknown FilterOperator code '"+codeString+"'"); 12923 } 12924 public static boolean isValidCode(String codeString) { 12925 if (codeString == null || "".equals(codeString)) 12926 return false; 12927 return Utilities.existsInList(codeString, "=", "is-a", "descendent-of", "is-not-a", "regex", "in", "not-in", "generalizes", "child-of", "descendent-leaf", "exists"); 12928 } 12929 public String toCode() { 12930 switch (this) { 12931 case EQUAL: return "="; 12932 case ISA: return "is-a"; 12933 case DESCENDENTOF: return "descendent-of"; 12934 case ISNOTA: return "is-not-a"; 12935 case REGEX: return "regex"; 12936 case IN: return "in"; 12937 case NOTIN: return "not-in"; 12938 case GENERALIZES: return "generalizes"; 12939 case CHILDOF: return "child-of"; 12940 case DESCENDENTLEAF: return "descendent-leaf"; 12941 case EXISTS: return "exists"; 12942 case NULL: return null; 12943 default: return "?"; 12944 } 12945 } 12946 public String getSystem() { 12947 switch (this) { 12948 case EQUAL: return "http://hl7.org/fhir/filter-operator"; 12949 case ISA: return "http://hl7.org/fhir/filter-operator"; 12950 case DESCENDENTOF: return "http://hl7.org/fhir/filter-operator"; 12951 case ISNOTA: return "http://hl7.org/fhir/filter-operator"; 12952 case REGEX: return "http://hl7.org/fhir/filter-operator"; 12953 case IN: return "http://hl7.org/fhir/filter-operator"; 12954 case NOTIN: return "http://hl7.org/fhir/filter-operator"; 12955 case GENERALIZES: return "http://hl7.org/fhir/filter-operator"; 12956 case CHILDOF: return "http://hl7.org/fhir/filter-operator"; 12957 case DESCENDENTLEAF: return "http://hl7.org/fhir/filter-operator"; 12958 case EXISTS: return "http://hl7.org/fhir/filter-operator"; 12959 case NULL: return null; 12960 default: return "?"; 12961 } 12962 } 12963 public String getDefinition() { 12964 switch (this) { 12965 case EQUAL: return "The specified property of the code equals the provided value."; 12966 case ISA: return "Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, including the provided concept itself (include descendant codes and self)."; 12967 case DESCENDENTOF: return "Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, excluding the provided concept itself (i.e. include descendant codes only)."; 12968 case ISNOTA: return "The specified property of the code does not have an is-a relationship with the provided value."; 12969 case REGEX: return "The specified property of the code matches the regex specified in the provided value."; 12970 case IN: return "The specified property of the code is in the set of codes or concepts specified in the provided value (comma-separated list)."; 12971 case NOTIN: return "The specified property of the code is not in the set of codes or concepts specified in the provided value (comma-separated list)."; 12972 case GENERALIZES: return "Includes all concept ids that have a transitive is-a relationship from the concept Id provided as the value, including the provided concept itself (i.e. include ancestor codes and self)."; 12973 case CHILDOF: return "Only concepts with a direct hierarchical relationship to the index code and no other concepts. This does not include the index code in the output."; 12974 case DESCENDENTLEAF: return "Includes concept ids that have a transitive is-a relationship with the concept Id provided as the value, but which do not have any concept ids with transitive is-a relationships with themselves."; 12975 case EXISTS: return "The specified property of the code has at least one value (if the specified value is true; if the specified value is false, then matches when the specified property of the code has no values)."; 12976 case NULL: return null; 12977 default: return "?"; 12978 } 12979 } 12980 public String getDisplay() { 12981 switch (this) { 12982 case EQUAL: return "Equals"; 12983 case ISA: return "Is A (by subsumption)"; 12984 case DESCENDENTOF: return "Descendent Of (by subsumption)"; 12985 case ISNOTA: return "Not (Is A) (by subsumption)"; 12986 case REGEX: return "Regular Expression"; 12987 case IN: return "In Set"; 12988 case NOTIN: return "Not in Set"; 12989 case GENERALIZES: return "Generalizes (by Subsumption)"; 12990 case CHILDOF: return "Child Of"; 12991 case DESCENDENTLEAF: return "Descendent Leaf"; 12992 case EXISTS: return "Exists"; 12993 case NULL: return null; 12994 default: return "?"; 12995 } 12996 } 12997 } 12998 12999 public static class FilterOperatorEnumFactory implements EnumFactory<FilterOperator> { 13000 public FilterOperator fromCode(String codeString) throws IllegalArgumentException { 13001 if (codeString == null || "".equals(codeString)) 13002 if (codeString == null || "".equals(codeString)) 13003 return null; 13004 if ("=".equals(codeString)) 13005 return FilterOperator.EQUAL; 13006 if ("is-a".equals(codeString)) 13007 return FilterOperator.ISA; 13008 if ("descendent-of".equals(codeString)) 13009 return FilterOperator.DESCENDENTOF; 13010 if ("is-not-a".equals(codeString)) 13011 return FilterOperator.ISNOTA; 13012 if ("regex".equals(codeString)) 13013 return FilterOperator.REGEX; 13014 if ("in".equals(codeString)) 13015 return FilterOperator.IN; 13016 if ("not-in".equals(codeString)) 13017 return FilterOperator.NOTIN; 13018 if ("generalizes".equals(codeString)) 13019 return FilterOperator.GENERALIZES; 13020 if ("child-of".equals(codeString)) 13021 return FilterOperator.CHILDOF; 13022 if ("descendent-leaf".equals(codeString)) 13023 return FilterOperator.DESCENDENTLEAF; 13024 if ("exists".equals(codeString)) 13025 return FilterOperator.EXISTS; 13026 throw new IllegalArgumentException("Unknown FilterOperator code '"+codeString+"'"); 13027 } 13028 13029 public Enumeration<FilterOperator> fromType(PrimitiveType<?> code) throws FHIRException { 13030 if (code == null) 13031 return null; 13032 if (code.isEmpty()) 13033 return new Enumeration<FilterOperator>(this, FilterOperator.NULL, code); 13034 String codeString = ((PrimitiveType) code).asStringValue(); 13035 if (codeString == null || "".equals(codeString)) 13036 return new Enumeration<FilterOperator>(this, FilterOperator.NULL, code); 13037 if ("=".equals(codeString)) 13038 return new Enumeration<FilterOperator>(this, FilterOperator.EQUAL, code); 13039 if ("is-a".equals(codeString)) 13040 return new Enumeration<FilterOperator>(this, FilterOperator.ISA, code); 13041 if ("descendent-of".equals(codeString)) 13042 return new Enumeration<FilterOperator>(this, FilterOperator.DESCENDENTOF, code); 13043 if ("is-not-a".equals(codeString)) 13044 return new Enumeration<FilterOperator>(this, FilterOperator.ISNOTA, code); 13045 if ("regex".equals(codeString)) 13046 return new Enumeration<FilterOperator>(this, FilterOperator.REGEX, code); 13047 if ("in".equals(codeString)) 13048 return new Enumeration<FilterOperator>(this, FilterOperator.IN, code); 13049 if ("not-in".equals(codeString)) 13050 return new Enumeration<FilterOperator>(this, FilterOperator.NOTIN, code); 13051 if ("generalizes".equals(codeString)) 13052 return new Enumeration<FilterOperator>(this, FilterOperator.GENERALIZES, code); 13053 if ("child-of".equals(codeString)) 13054 return new Enumeration<FilterOperator>(this, FilterOperator.CHILDOF, code); 13055 if ("descendent-leaf".equals(codeString)) 13056 return new Enumeration<FilterOperator>(this, FilterOperator.DESCENDENTLEAF, code); 13057 if ("exists".equals(codeString)) 13058 return new Enumeration<FilterOperator>(this, FilterOperator.EXISTS, code); 13059 throw new FHIRException("Unknown FilterOperator code '"+codeString+"'"); 13060 } 13061 public String toCode(FilterOperator code) { 13062 if (code == FilterOperator.EQUAL) 13063 return "="; 13064 if (code == FilterOperator.ISA) 13065 return "is-a"; 13066 if (code == FilterOperator.DESCENDENTOF) 13067 return "descendent-of"; 13068 if (code == FilterOperator.ISNOTA) 13069 return "is-not-a"; 13070 if (code == FilterOperator.REGEX) 13071 return "regex"; 13072 if (code == FilterOperator.IN) 13073 return "in"; 13074 if (code == FilterOperator.NOTIN) 13075 return "not-in"; 13076 if (code == FilterOperator.GENERALIZES) 13077 return "generalizes"; 13078 if (code == FilterOperator.CHILDOF) 13079 return "child-of"; 13080 if (code == FilterOperator.DESCENDENTLEAF) 13081 return "descendent-leaf"; 13082 if (code == FilterOperator.EXISTS) 13083 return "exists"; 13084 return "?"; 13085 } 13086 public String toSystem(FilterOperator code) { 13087 return code.getSystem(); 13088 } 13089 } 13090 13091 public enum FinancialResourceStatusCodes { 13092 /** 13093 * The instance is currently in-force. 13094 */ 13095 ACTIVE, 13096 /** 13097 * The instance is withdrawn, rescinded or reversed. 13098 */ 13099 CANCELLED, 13100 /** 13101 * A new instance the contents of which is not complete. 13102 */ 13103 DRAFT, 13104 /** 13105 * The instance was entered in error. 13106 */ 13107 ENTEREDINERROR, 13108 /** 13109 * added to help the parsers 13110 */ 13111 NULL; 13112 public static FinancialResourceStatusCodes fromCode(String codeString) throws FHIRException { 13113 if (codeString == null || "".equals(codeString)) 13114 return null; 13115 if ("active".equals(codeString)) 13116 return ACTIVE; 13117 if ("cancelled".equals(codeString)) 13118 return CANCELLED; 13119 if ("draft".equals(codeString)) 13120 return DRAFT; 13121 if ("entered-in-error".equals(codeString)) 13122 return ENTEREDINERROR; 13123 throw new FHIRException("Unknown FinancialResourceStatusCodes code '"+codeString+"'"); 13124 } 13125 public static boolean isValidCode(String codeString) { 13126 if (codeString == null || "".equals(codeString)) 13127 return false; 13128 return Utilities.existsInList(codeString, "active", "cancelled", "draft", "entered-in-error"); 13129 } 13130 public String toCode() { 13131 switch (this) { 13132 case ACTIVE: return "active"; 13133 case CANCELLED: return "cancelled"; 13134 case DRAFT: return "draft"; 13135 case ENTEREDINERROR: return "entered-in-error"; 13136 case NULL: return null; 13137 default: return "?"; 13138 } 13139 } 13140 public String getSystem() { 13141 switch (this) { 13142 case ACTIVE: return "http://hl7.org/fhir/fm-status"; 13143 case CANCELLED: return "http://hl7.org/fhir/fm-status"; 13144 case DRAFT: return "http://hl7.org/fhir/fm-status"; 13145 case ENTEREDINERROR: return "http://hl7.org/fhir/fm-status"; 13146 case NULL: return null; 13147 default: return "?"; 13148 } 13149 } 13150 public String getDefinition() { 13151 switch (this) { 13152 case ACTIVE: return "The instance is currently in-force."; 13153 case CANCELLED: return "The instance is withdrawn, rescinded or reversed."; 13154 case DRAFT: return "A new instance the contents of which is not complete."; 13155 case ENTEREDINERROR: return "The instance was entered in error."; 13156 case NULL: return null; 13157 default: return "?"; 13158 } 13159 } 13160 public String getDisplay() { 13161 switch (this) { 13162 case ACTIVE: return "Active"; 13163 case CANCELLED: return "Cancelled"; 13164 case DRAFT: return "Draft"; 13165 case ENTEREDINERROR: return "Entered in Error"; 13166 case NULL: return null; 13167 default: return "?"; 13168 } 13169 } 13170 } 13171 13172 public static class FinancialResourceStatusCodesEnumFactory implements EnumFactory<FinancialResourceStatusCodes> { 13173 public FinancialResourceStatusCodes fromCode(String codeString) throws IllegalArgumentException { 13174 if (codeString == null || "".equals(codeString)) 13175 if (codeString == null || "".equals(codeString)) 13176 return null; 13177 if ("active".equals(codeString)) 13178 return FinancialResourceStatusCodes.ACTIVE; 13179 if ("cancelled".equals(codeString)) 13180 return FinancialResourceStatusCodes.CANCELLED; 13181 if ("draft".equals(codeString)) 13182 return FinancialResourceStatusCodes.DRAFT; 13183 if ("entered-in-error".equals(codeString)) 13184 return FinancialResourceStatusCodes.ENTEREDINERROR; 13185 throw new IllegalArgumentException("Unknown FinancialResourceStatusCodes code '"+codeString+"'"); 13186 } 13187 13188 public Enumeration<FinancialResourceStatusCodes> fromType(PrimitiveType<?> code) throws FHIRException { 13189 if (code == null) 13190 return null; 13191 if (code.isEmpty()) 13192 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.NULL, code); 13193 String codeString = ((PrimitiveType) code).asStringValue(); 13194 if (codeString == null || "".equals(codeString)) 13195 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.NULL, code); 13196 if ("active".equals(codeString)) 13197 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.ACTIVE, code); 13198 if ("cancelled".equals(codeString)) 13199 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.CANCELLED, code); 13200 if ("draft".equals(codeString)) 13201 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.DRAFT, code); 13202 if ("entered-in-error".equals(codeString)) 13203 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.ENTEREDINERROR, code); 13204 throw new FHIRException("Unknown FinancialResourceStatusCodes code '"+codeString+"'"); 13205 } 13206 public String toCode(FinancialResourceStatusCodes code) { 13207 if (code == FinancialResourceStatusCodes.ACTIVE) 13208 return "active"; 13209 if (code == FinancialResourceStatusCodes.CANCELLED) 13210 return "cancelled"; 13211 if (code == FinancialResourceStatusCodes.DRAFT) 13212 return "draft"; 13213 if (code == FinancialResourceStatusCodes.ENTEREDINERROR) 13214 return "entered-in-error"; 13215 return "?"; 13216 } 13217 public String toSystem(FinancialResourceStatusCodes code) { 13218 return code.getSystem(); 13219 } 13220 } 13221 13222 public enum ListMode { 13223 /** 13224 * This list is the master list, maintained in an ongoing fashion with regular updates as the real-world list it is tracking changes. 13225 */ 13226 WORKING, 13227 /** 13228 * This list was prepared as a snapshot. It should not be assumed to be current. 13229 */ 13230 SNAPSHOT, 13231 /** 13232 * A point-in-time list that shows what changes have been made or recommended. E.g. a discharge medication list showing what was added and removed during an encounter. 13233 */ 13234 CHANGES, 13235 /** 13236 * added to help the parsers 13237 */ 13238 NULL; 13239 public static ListMode fromCode(String codeString) throws FHIRException { 13240 if (codeString == null || "".equals(codeString)) 13241 return null; 13242 if ("working".equals(codeString)) 13243 return WORKING; 13244 if ("snapshot".equals(codeString)) 13245 return SNAPSHOT; 13246 if ("changes".equals(codeString)) 13247 return CHANGES; 13248 throw new FHIRException("Unknown ListMode code '"+codeString+"'"); 13249 } 13250 public static boolean isValidCode(String codeString) { 13251 if (codeString == null || "".equals(codeString)) 13252 return false; 13253 return Utilities.existsInList(codeString, "working", "snapshot", "changes"); 13254 } 13255 public String toCode() { 13256 switch (this) { 13257 case WORKING: return "working"; 13258 case SNAPSHOT: return "snapshot"; 13259 case CHANGES: return "changes"; 13260 case NULL: return null; 13261 default: return "?"; 13262 } 13263 } 13264 public String getSystem() { 13265 switch (this) { 13266 case WORKING: return "http://hl7.org/fhir/list-mode"; 13267 case SNAPSHOT: return "http://hl7.org/fhir/list-mode"; 13268 case CHANGES: return "http://hl7.org/fhir/list-mode"; 13269 case NULL: return null; 13270 default: return "?"; 13271 } 13272 } 13273 public String getDefinition() { 13274 switch (this) { 13275 case WORKING: return "This list is the master list, maintained in an ongoing fashion with regular updates as the real-world list it is tracking changes."; 13276 case SNAPSHOT: return "This list was prepared as a snapshot. It should not be assumed to be current."; 13277 case CHANGES: return "A point-in-time list that shows what changes have been made or recommended. E.g. a discharge medication list showing what was added and removed during an encounter."; 13278 case NULL: return null; 13279 default: return "?"; 13280 } 13281 } 13282 public String getDisplay() { 13283 switch (this) { 13284 case WORKING: return "Working List"; 13285 case SNAPSHOT: return "Snapshot List"; 13286 case CHANGES: return "Change List"; 13287 case NULL: return null; 13288 default: return "?"; 13289 } 13290 } 13291 } 13292 13293 public static class ListModeEnumFactory implements EnumFactory<ListMode> { 13294 public ListMode fromCode(String codeString) throws IllegalArgumentException { 13295 if (codeString == null || "".equals(codeString)) 13296 if (codeString == null || "".equals(codeString)) 13297 return null; 13298 if ("working".equals(codeString)) 13299 return ListMode.WORKING; 13300 if ("snapshot".equals(codeString)) 13301 return ListMode.SNAPSHOT; 13302 if ("changes".equals(codeString)) 13303 return ListMode.CHANGES; 13304 throw new IllegalArgumentException("Unknown ListMode code '"+codeString+"'"); 13305 } 13306 13307 public Enumeration<ListMode> fromType(PrimitiveType<?> code) throws FHIRException { 13308 if (code == null) 13309 return null; 13310 if (code.isEmpty()) 13311 return new Enumeration<ListMode>(this, ListMode.NULL, code); 13312 String codeString = ((PrimitiveType) code).asStringValue(); 13313 if (codeString == null || "".equals(codeString)) 13314 return new Enumeration<ListMode>(this, ListMode.NULL, code); 13315 if ("working".equals(codeString)) 13316 return new Enumeration<ListMode>(this, ListMode.WORKING, code); 13317 if ("snapshot".equals(codeString)) 13318 return new Enumeration<ListMode>(this, ListMode.SNAPSHOT, code); 13319 if ("changes".equals(codeString)) 13320 return new Enumeration<ListMode>(this, ListMode.CHANGES, code); 13321 throw new FHIRException("Unknown ListMode code '"+codeString+"'"); 13322 } 13323 public String toCode(ListMode code) { 13324 if (code == ListMode.WORKING) 13325 return "working"; 13326 if (code == ListMode.SNAPSHOT) 13327 return "snapshot"; 13328 if (code == ListMode.CHANGES) 13329 return "changes"; 13330 return "?"; 13331 } 13332 public String toSystem(ListMode code) { 13333 return code.getSystem(); 13334 } 13335 } 13336 13337 public enum MeasureImprovementNotation { 13338 /** 13339 * null 13340 */ 13341 INCREASE, 13342 /** 13343 * null 13344 */ 13345 DECREASE, 13346 /** 13347 * added to help the parsers 13348 */ 13349 NULL; 13350 public static MeasureImprovementNotation fromCode(String codeString) throws FHIRException { 13351 if (codeString == null || "".equals(codeString)) 13352 return null; 13353 if ("increase".equals(codeString)) 13354 return INCREASE; 13355 if ("decrease".equals(codeString)) 13356 return DECREASE; 13357 throw new FHIRException("Unknown MeasureImprovementNotation code '"+codeString+"'"); 13358 } 13359 public static boolean isValidCode(String codeString) { 13360 if (codeString == null || "".equals(codeString)) 13361 return false; 13362 return Utilities.existsInList(codeString, "increase", "decrease"); 13363 } 13364 public String toCode() { 13365 switch (this) { 13366 case INCREASE: return "increase"; 13367 case DECREASE: return "decrease"; 13368 case NULL: return null; 13369 default: return "?"; 13370 } 13371 } 13372 public String getSystem() { 13373 switch (this) { 13374 case INCREASE: return "http://terminology.hl7.org/CodeSystem/measure-improvement-notation"; 13375 case DECREASE: return "http://terminology.hl7.org/CodeSystem/measure-improvement-notation"; 13376 case NULL: return null; 13377 default: return "?"; 13378 } 13379 } 13380 public String getDefinition() { 13381 switch (this) { 13382 case INCREASE: return ""; 13383 case DECREASE: return ""; 13384 case NULL: return null; 13385 default: return "?"; 13386 } 13387 } 13388 public String getDisplay() { 13389 switch (this) { 13390 case INCREASE: return "Increased score indicates improvement"; 13391 case DECREASE: return "Decreased score indicates improvement"; 13392 case NULL: return null; 13393 default: return "?"; 13394 } 13395 } 13396 } 13397 13398 public static class MeasureImprovementNotationEnumFactory implements EnumFactory<MeasureImprovementNotation> { 13399 public MeasureImprovementNotation fromCode(String codeString) throws IllegalArgumentException { 13400 if (codeString == null || "".equals(codeString)) 13401 if (codeString == null || "".equals(codeString)) 13402 return null; 13403 if ("increase".equals(codeString)) 13404 return MeasureImprovementNotation.INCREASE; 13405 if ("decrease".equals(codeString)) 13406 return MeasureImprovementNotation.DECREASE; 13407 throw new IllegalArgumentException("Unknown MeasureImprovementNotation code '"+codeString+"'"); 13408 } 13409 13410 public Enumeration<MeasureImprovementNotation> fromType(PrimitiveType<?> code) throws FHIRException { 13411 if (code == null) 13412 return null; 13413 if (code.isEmpty()) 13414 return new Enumeration<MeasureImprovementNotation>(this, MeasureImprovementNotation.NULL, code); 13415 String codeString = ((PrimitiveType) code).asStringValue(); 13416 if (codeString == null || "".equals(codeString)) 13417 return new Enumeration<MeasureImprovementNotation>(this, MeasureImprovementNotation.NULL, code); 13418 if ("increase".equals(codeString)) 13419 return new Enumeration<MeasureImprovementNotation>(this, MeasureImprovementNotation.INCREASE, code); 13420 if ("decrease".equals(codeString)) 13421 return new Enumeration<MeasureImprovementNotation>(this, MeasureImprovementNotation.DECREASE, code); 13422 throw new FHIRException("Unknown MeasureImprovementNotation code '"+codeString+"'"); 13423 } 13424 public String toCode(MeasureImprovementNotation code) { 13425 if (code == MeasureImprovementNotation.INCREASE) 13426 return "increase"; 13427 if (code == MeasureImprovementNotation.DECREASE) 13428 return "decrease"; 13429 return "?"; 13430 } 13431 public String toSystem(MeasureImprovementNotation code) { 13432 return code.getSystem(); 13433 } 13434 } 13435 13436 public enum MimeTypes { 13437 /** 13438 * added to help the parsers 13439 */ 13440 NULL; 13441 public static MimeTypes fromCode(String codeString) throws FHIRException { 13442 if (codeString == null || "".equals(codeString)) 13443 return null; 13444 throw new FHIRException("Unknown MimeTypes code '"+codeString+"'"); 13445 } 13446 public static boolean isValidCode(String codeString) { 13447 if (codeString == null || "".equals(codeString)) 13448 return false; 13449 return Utilities.existsInList(codeString); 13450 } 13451 public String toCode() { 13452 switch (this) { 13453 case NULL: return null; 13454 default: return "?"; 13455 } 13456 } 13457 public String getSystem() { 13458 switch (this) { 13459 case NULL: return null; 13460 default: return "?"; 13461 } 13462 } 13463 public String getDefinition() { 13464 switch (this) { 13465 case NULL: return null; 13466 default: return "?"; 13467 } 13468 } 13469 public String getDisplay() { 13470 switch (this) { 13471 case NULL: return null; 13472 default: return "?"; 13473 } 13474 } 13475 } 13476 13477 public static class MimeTypesEnumFactory implements EnumFactory<MimeTypes> { 13478 public MimeTypes fromCode(String codeString) throws IllegalArgumentException { 13479 if (codeString == null || "".equals(codeString)) 13480 if (codeString == null || "".equals(codeString)) 13481 return null; 13482 throw new IllegalArgumentException("Unknown MimeTypes code '"+codeString+"'"); 13483 } 13484 13485 public Enumeration<MimeTypes> fromType(PrimitiveType<?> code) throws FHIRException { 13486 if (code == null) 13487 return null; 13488 if (code.isEmpty()) 13489 return new Enumeration<MimeTypes>(this, MimeTypes.NULL, code); 13490 String codeString = ((PrimitiveType) code).asStringValue(); 13491 if (codeString == null || "".equals(codeString)) 13492 return new Enumeration<MimeTypes>(this, MimeTypes.NULL, code); 13493 throw new FHIRException("Unknown MimeTypes code '"+codeString+"'"); 13494 } 13495 public String toCode(MimeTypes code) { 13496 return "?"; 13497 } 13498 public String toSystem(MimeTypes code) { 13499 return code.getSystem(); 13500 } 13501 } 13502 13503 public enum ObservationStatus { 13504 /** 13505 * The existence of the observation is registered, but there is no result yet available. 13506 */ 13507 REGISTERED, 13508 /** 13509 * This is an initial or interim observation: data may be incomplete or unverified. 13510 */ 13511 PRELIMINARY, 13512 /** 13513 * The observation is complete and there are no further actions needed. Additional information such "released", "signed", etc. would be represented using [Provenance](provenance.html) which provides not only the act but also the actors and dates and other related data. These act states would be associated with an observation status of `preliminary` until they are all completed and then a status of `final` would be applied. 13514 */ 13515 FINAL, 13516 /** 13517 * Subsequent to being Final, the observation has been modified subsequent. This includes updates/new information and corrections. 13518 */ 13519 AMENDED, 13520 /** 13521 * Subsequent to being Final, the observation has been modified to correct an error in the test result. 13522 */ 13523 CORRECTED, 13524 /** 13525 * The observation is unavailable because the measurement was not started or not completed (also sometimes called "aborted"). 13526 */ 13527 CANCELLED, 13528 /** 13529 * The observation has been withdrawn following previous final release. This electronic record should never have existed, though it is possible that real-world decisions were based on it. (If real-world activity has occurred, the status should be "cancelled" rather than "entered-in-error".). 13530 */ 13531 ENTEREDINERROR, 13532 /** 13533 * 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. 13534 */ 13535 UNKNOWN, 13536 /** 13537 * added to help the parsers 13538 */ 13539 NULL; 13540 public static ObservationStatus fromCode(String codeString) throws FHIRException { 13541 if (codeString == null || "".equals(codeString)) 13542 return null; 13543 if ("registered".equals(codeString)) 13544 return REGISTERED; 13545 if ("preliminary".equals(codeString)) 13546 return PRELIMINARY; 13547 if ("final".equals(codeString)) 13548 return FINAL; 13549 if ("amended".equals(codeString)) 13550 return AMENDED; 13551 if ("corrected".equals(codeString)) 13552 return CORRECTED; 13553 if ("cancelled".equals(codeString)) 13554 return CANCELLED; 13555 if ("entered-in-error".equals(codeString)) 13556 return ENTEREDINERROR; 13557 if ("unknown".equals(codeString)) 13558 return UNKNOWN; 13559 throw new FHIRException("Unknown ObservationStatus code '"+codeString+"'"); 13560 } 13561 public static boolean isValidCode(String codeString) { 13562 if (codeString == null || "".equals(codeString)) 13563 return false; 13564 return Utilities.existsInList(codeString, "registered", "preliminary", "final", "amended", "corrected", "cancelled", "entered-in-error", "unknown"); 13565 } 13566 public String toCode() { 13567 switch (this) { 13568 case REGISTERED: return "registered"; 13569 case PRELIMINARY: return "preliminary"; 13570 case FINAL: return "final"; 13571 case AMENDED: return "amended"; 13572 case CORRECTED: return "corrected"; 13573 case CANCELLED: return "cancelled"; 13574 case ENTEREDINERROR: return "entered-in-error"; 13575 case UNKNOWN: return "unknown"; 13576 case NULL: return null; 13577 default: return "?"; 13578 } 13579 } 13580 public String getSystem() { 13581 switch (this) { 13582 case REGISTERED: return "http://hl7.org/fhir/observation-status"; 13583 case PRELIMINARY: return "http://hl7.org/fhir/observation-status"; 13584 case FINAL: return "http://hl7.org/fhir/observation-status"; 13585 case AMENDED: return "http://hl7.org/fhir/observation-status"; 13586 case CORRECTED: return "http://hl7.org/fhir/observation-status"; 13587 case CANCELLED: return "http://hl7.org/fhir/observation-status"; 13588 case ENTEREDINERROR: return "http://hl7.org/fhir/observation-status"; 13589 case UNKNOWN: return "http://hl7.org/fhir/observation-status"; 13590 case NULL: return null; 13591 default: return "?"; 13592 } 13593 } 13594 public String getDefinition() { 13595 switch (this) { 13596 case REGISTERED: return "The existence of the observation is registered, but there is no result yet available."; 13597 case PRELIMINARY: return "This is an initial or interim observation: data may be incomplete or unverified."; 13598 case FINAL: return "The observation is complete and there are no further actions needed. Additional information such \"released\", \"signed\", etc. would be represented using [Provenance](provenance.html) which provides not only the act but also the actors and dates and other related data. These act states would be associated with an observation status of `preliminary` until they are all completed and then a status of `final` would be applied."; 13599 case AMENDED: return "Subsequent to being Final, the observation has been modified subsequent. This includes updates/new information and corrections."; 13600 case CORRECTED: return "Subsequent to being Final, the observation has been modified to correct an error in the test result."; 13601 case CANCELLED: return "The observation is unavailable because the measurement was not started or not completed (also sometimes called \"aborted\")."; 13602 case ENTEREDINERROR: return "The observation has been withdrawn following previous final release. This electronic record should never have existed, though it is possible that real-world decisions were based on it. (If real-world activity has occurred, the status should be \"cancelled\" rather than \"entered-in-error\".)."; 13603 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."; 13604 case NULL: return null; 13605 default: return "?"; 13606 } 13607 } 13608 public String getDisplay() { 13609 switch (this) { 13610 case REGISTERED: return "Registered"; 13611 case PRELIMINARY: return "Preliminary"; 13612 case FINAL: return "Final"; 13613 case AMENDED: return "Amended"; 13614 case CORRECTED: return "Corrected"; 13615 case CANCELLED: return "Cancelled"; 13616 case ENTEREDINERROR: return "Entered in Error"; 13617 case UNKNOWN: return "Unknown"; 13618 case NULL: return null; 13619 default: return "?"; 13620 } 13621 } 13622 } 13623 13624 public static class ObservationStatusEnumFactory implements EnumFactory<ObservationStatus> { 13625 public ObservationStatus fromCode(String codeString) throws IllegalArgumentException { 13626 if (codeString == null || "".equals(codeString)) 13627 if (codeString == null || "".equals(codeString)) 13628 return null; 13629 if ("registered".equals(codeString)) 13630 return ObservationStatus.REGISTERED; 13631 if ("preliminary".equals(codeString)) 13632 return ObservationStatus.PRELIMINARY; 13633 if ("final".equals(codeString)) 13634 return ObservationStatus.FINAL; 13635 if ("amended".equals(codeString)) 13636 return ObservationStatus.AMENDED; 13637 if ("corrected".equals(codeString)) 13638 return ObservationStatus.CORRECTED; 13639 if ("cancelled".equals(codeString)) 13640 return ObservationStatus.CANCELLED; 13641 if ("entered-in-error".equals(codeString)) 13642 return ObservationStatus.ENTEREDINERROR; 13643 if ("unknown".equals(codeString)) 13644 return ObservationStatus.UNKNOWN; 13645 throw new IllegalArgumentException("Unknown ObservationStatus code '"+codeString+"'"); 13646 } 13647 13648 public Enumeration<ObservationStatus> fromType(PrimitiveType<?> code) throws FHIRException { 13649 if (code == null) 13650 return null; 13651 if (code.isEmpty()) 13652 return new Enumeration<ObservationStatus>(this, ObservationStatus.NULL, code); 13653 String codeString = ((PrimitiveType) code).asStringValue(); 13654 if (codeString == null || "".equals(codeString)) 13655 return new Enumeration<ObservationStatus>(this, ObservationStatus.NULL, code); 13656 if ("registered".equals(codeString)) 13657 return new Enumeration<ObservationStatus>(this, ObservationStatus.REGISTERED, code); 13658 if ("preliminary".equals(codeString)) 13659 return new Enumeration<ObservationStatus>(this, ObservationStatus.PRELIMINARY, code); 13660 if ("final".equals(codeString)) 13661 return new Enumeration<ObservationStatus>(this, ObservationStatus.FINAL, code); 13662 if ("amended".equals(codeString)) 13663 return new Enumeration<ObservationStatus>(this, ObservationStatus.AMENDED, code); 13664 if ("corrected".equals(codeString)) 13665 return new Enumeration<ObservationStatus>(this, ObservationStatus.CORRECTED, code); 13666 if ("cancelled".equals(codeString)) 13667 return new Enumeration<ObservationStatus>(this, ObservationStatus.CANCELLED, code); 13668 if ("entered-in-error".equals(codeString)) 13669 return new Enumeration<ObservationStatus>(this, ObservationStatus.ENTEREDINERROR, code); 13670 if ("unknown".equals(codeString)) 13671 return new Enumeration<ObservationStatus>(this, ObservationStatus.UNKNOWN, code); 13672 throw new FHIRException("Unknown ObservationStatus code '"+codeString+"'"); 13673 } 13674 public String toCode(ObservationStatus code) { 13675 if (code == ObservationStatus.REGISTERED) 13676 return "registered"; 13677 if (code == ObservationStatus.PRELIMINARY) 13678 return "preliminary"; 13679 if (code == ObservationStatus.FINAL) 13680 return "final"; 13681 if (code == ObservationStatus.AMENDED) 13682 return "amended"; 13683 if (code == ObservationStatus.CORRECTED) 13684 return "corrected"; 13685 if (code == ObservationStatus.CANCELLED) 13686 return "cancelled"; 13687 if (code == ObservationStatus.ENTEREDINERROR) 13688 return "entered-in-error"; 13689 if (code == ObservationStatus.UNKNOWN) 13690 return "unknown"; 13691 return "?"; 13692 } 13693 public String toSystem(ObservationStatus code) { 13694 return code.getSystem(); 13695 } 13696 } 13697 13698 public enum OperationParameterUse { 13699 /** 13700 * This is an input parameter. 13701 */ 13702 IN, 13703 /** 13704 * This is an output parameter. 13705 */ 13706 OUT, 13707 /** 13708 * added to help the parsers 13709 */ 13710 NULL; 13711 public static OperationParameterUse fromCode(String codeString) throws FHIRException { 13712 if (codeString == null || "".equals(codeString)) 13713 return null; 13714 if ("in".equals(codeString)) 13715 return IN; 13716 if ("out".equals(codeString)) 13717 return OUT; 13718 throw new FHIRException("Unknown OperationParameterUse code '"+codeString+"'"); 13719 } 13720 public static boolean isValidCode(String codeString) { 13721 if (codeString == null || "".equals(codeString)) 13722 return false; 13723 return Utilities.existsInList(codeString, "in", "out"); 13724 } 13725 public String toCode() { 13726 switch (this) { 13727 case IN: return "in"; 13728 case OUT: return "out"; 13729 case NULL: return null; 13730 default: return "?"; 13731 } 13732 } 13733 public String getSystem() { 13734 switch (this) { 13735 case IN: return "http://hl7.org/fhir/operation-parameter-use"; 13736 case OUT: return "http://hl7.org/fhir/operation-parameter-use"; 13737 case NULL: return null; 13738 default: return "?"; 13739 } 13740 } 13741 public String getDefinition() { 13742 switch (this) { 13743 case IN: return "This is an input parameter."; 13744 case OUT: return "This is an output parameter."; 13745 case NULL: return null; 13746 default: return "?"; 13747 } 13748 } 13749 public String getDisplay() { 13750 switch (this) { 13751 case IN: return "In"; 13752 case OUT: return "Out"; 13753 case NULL: return null; 13754 default: return "?"; 13755 } 13756 } 13757 } 13758 13759 public static class OperationParameterUseEnumFactory implements EnumFactory<OperationParameterUse> { 13760 public OperationParameterUse fromCode(String codeString) throws IllegalArgumentException { 13761 if (codeString == null || "".equals(codeString)) 13762 if (codeString == null || "".equals(codeString)) 13763 return null; 13764 if ("in".equals(codeString)) 13765 return OperationParameterUse.IN; 13766 if ("out".equals(codeString)) 13767 return OperationParameterUse.OUT; 13768 throw new IllegalArgumentException("Unknown OperationParameterUse code '"+codeString+"'"); 13769 } 13770 13771 public Enumeration<OperationParameterUse> fromType(PrimitiveType<?> code) throws FHIRException { 13772 if (code == null) 13773 return null; 13774 if (code.isEmpty()) 13775 return new Enumeration<OperationParameterUse>(this, OperationParameterUse.NULL, code); 13776 String codeString = ((PrimitiveType) code).asStringValue(); 13777 if (codeString == null || "".equals(codeString)) 13778 return new Enumeration<OperationParameterUse>(this, OperationParameterUse.NULL, code); 13779 if ("in".equals(codeString)) 13780 return new Enumeration<OperationParameterUse>(this, OperationParameterUse.IN, code); 13781 if ("out".equals(codeString)) 13782 return new Enumeration<OperationParameterUse>(this, OperationParameterUse.OUT, code); 13783 throw new FHIRException("Unknown OperationParameterUse code '"+codeString+"'"); 13784 } 13785 public String toCode(OperationParameterUse code) { 13786 if (code == OperationParameterUse.IN) 13787 return "in"; 13788 if (code == OperationParameterUse.OUT) 13789 return "out"; 13790 return "?"; 13791 } 13792 public String toSystem(OperationParameterUse code) { 13793 return code.getSystem(); 13794 } 13795 } 13796 13797 public enum PublicationStatus { 13798 /** 13799 * This resource is still under development and is not yet considered to be ready for normal use. 13800 */ 13801 DRAFT, 13802 /** 13803 * This resource is ready for normal use. 13804 */ 13805 ACTIVE, 13806 /** 13807 * This resource has been withdrawn or superseded and should no longer be used. 13808 */ 13809 RETIRED, 13810 /** 13811 * The authoring system does not know which of the status values currently applies for this resource. Note: This concept is not to be used for "other" - one of the listed statuses is presumed to apply, it's just not known which one. 13812 */ 13813 UNKNOWN, 13814 /** 13815 * added to help the parsers 13816 */ 13817 NULL; 13818 public static PublicationStatus fromCode(String codeString) throws FHIRException { 13819 if (codeString == null || "".equals(codeString)) 13820 return null; 13821 if ("draft".equals(codeString)) 13822 return DRAFT; 13823 if ("active".equals(codeString)) 13824 return ACTIVE; 13825 if ("retired".equals(codeString)) 13826 return RETIRED; 13827 if ("unknown".equals(codeString)) 13828 return UNKNOWN; 13829 throw new FHIRException("Unknown PublicationStatus code '"+codeString+"'"); 13830 } 13831 public static boolean isValidCode(String codeString) { 13832 if (codeString == null || "".equals(codeString)) 13833 return false; 13834 return Utilities.existsInList(codeString, "draft", "active", "retired", "unknown"); 13835 } 13836 public String toCode() { 13837 switch (this) { 13838 case DRAFT: return "draft"; 13839 case ACTIVE: return "active"; 13840 case RETIRED: return "retired"; 13841 case UNKNOWN: return "unknown"; 13842 case NULL: return null; 13843 default: return "?"; 13844 } 13845 } 13846 public String getSystem() { 13847 switch (this) { 13848 case DRAFT: return "http://hl7.org/fhir/publication-status"; 13849 case ACTIVE: return "http://hl7.org/fhir/publication-status"; 13850 case RETIRED: return "http://hl7.org/fhir/publication-status"; 13851 case UNKNOWN: return "http://hl7.org/fhir/publication-status"; 13852 case NULL: return null; 13853 default: return "?"; 13854 } 13855 } 13856 public String getDefinition() { 13857 switch (this) { 13858 case DRAFT: return "This resource is still under development and is not yet considered to be ready for normal use."; 13859 case ACTIVE: return "This resource is ready for normal use."; 13860 case RETIRED: return "This resource has been withdrawn or superseded and should no longer be used."; 13861 case UNKNOWN: return "The authoring system does not know which of the status values currently applies for this resource. Note: This concept is not to be used for \"other\" - one of the listed statuses is presumed to apply, it's just not known which one."; 13862 case NULL: return null; 13863 default: return "?"; 13864 } 13865 } 13866 public String getDisplay() { 13867 switch (this) { 13868 case DRAFT: return "Draft"; 13869 case ACTIVE: return "Active"; 13870 case RETIRED: return "Retired"; 13871 case UNKNOWN: return "Unknown"; 13872 case NULL: return null; 13873 default: return "?"; 13874 } 13875 } 13876 } 13877 13878 public static class PublicationStatusEnumFactory implements EnumFactory<PublicationStatus> { 13879 public PublicationStatus fromCode(String codeString) throws IllegalArgumentException { 13880 if (codeString == null || "".equals(codeString)) 13881 if (codeString == null || "".equals(codeString)) 13882 return null; 13883 if ("draft".equals(codeString)) 13884 return PublicationStatus.DRAFT; 13885 if ("active".equals(codeString)) 13886 return PublicationStatus.ACTIVE; 13887 if ("retired".equals(codeString)) 13888 return PublicationStatus.RETIRED; 13889 if ("unknown".equals(codeString)) 13890 return PublicationStatus.UNKNOWN; 13891 throw new IllegalArgumentException("Unknown PublicationStatus code '"+codeString+"'"); 13892 } 13893 13894 public Enumeration<PublicationStatus> fromType(PrimitiveType<?> code) throws FHIRException { 13895 if (code == null) 13896 return null; 13897 if (code.isEmpty()) 13898 return new Enumeration<PublicationStatus>(this, PublicationStatus.NULL, code); 13899 String codeString = ((PrimitiveType) code).asStringValue(); 13900 if (codeString == null || "".equals(codeString)) 13901 return new Enumeration<PublicationStatus>(this, PublicationStatus.NULL, code); 13902 if ("draft".equals(codeString)) 13903 return new Enumeration<PublicationStatus>(this, PublicationStatus.DRAFT, code); 13904 if ("active".equals(codeString)) 13905 return new Enumeration<PublicationStatus>(this, PublicationStatus.ACTIVE, code); 13906 if ("retired".equals(codeString)) 13907 return new Enumeration<PublicationStatus>(this, PublicationStatus.RETIRED, code); 13908 if ("unknown".equals(codeString)) 13909 return new Enumeration<PublicationStatus>(this, PublicationStatus.UNKNOWN, code); 13910 throw new FHIRException("Unknown PublicationStatus code '"+codeString+"'"); 13911 } 13912 public String toCode(PublicationStatus code) { 13913 if (code == PublicationStatus.DRAFT) 13914 return "draft"; 13915 if (code == PublicationStatus.ACTIVE) 13916 return "active"; 13917 if (code == PublicationStatus.RETIRED) 13918 return "retired"; 13919 if (code == PublicationStatus.UNKNOWN) 13920 return "unknown"; 13921 return "?"; 13922 } 13923 public String toSystem(PublicationStatus code) { 13924 return code.getSystem(); 13925 } 13926 } 13927 13928 public enum QuantityComparator { 13929 /** 13930 * The actual value is less than the given value. 13931 */ 13932 LESS_THAN, 13933 /** 13934 * The actual value is less than or equal to the given value. 13935 */ 13936 LESS_OR_EQUAL, 13937 /** 13938 * The actual value is greater than or equal to the given value. 13939 */ 13940 GREATER_OR_EQUAL, 13941 /** 13942 * The actual value is greater than the given value. 13943 */ 13944 GREATER_THAN, 13945 /** 13946 * The actual value is sufficient for the total quantity to equal the given value. 13947 */ 13948 AD, 13949 /** 13950 * added to help the parsers 13951 */ 13952 NULL; 13953 public static QuantityComparator fromCode(String codeString) throws FHIRException { 13954 if (codeString == null || "".equals(codeString)) 13955 return null; 13956 if ("<".equals(codeString)) 13957 return LESS_THAN; 13958 if ("<=".equals(codeString)) 13959 return LESS_OR_EQUAL; 13960 if (">=".equals(codeString)) 13961 return GREATER_OR_EQUAL; 13962 if (">".equals(codeString)) 13963 return GREATER_THAN; 13964 if ("ad".equals(codeString)) 13965 return AD; 13966 throw new FHIRException("Unknown QuantityComparator code '"+codeString+"'"); 13967 } 13968 public static boolean isValidCode(String codeString) { 13969 if (codeString == null || "".equals(codeString)) 13970 return false; 13971 return Utilities.existsInList(codeString, "<", "<=", ">=", ">", "ad"); 13972 } 13973 public String toCode() { 13974 switch (this) { 13975 case LESS_THAN: return "<"; 13976 case LESS_OR_EQUAL: return "<="; 13977 case GREATER_OR_EQUAL: return ">="; 13978 case GREATER_THAN: return ">"; 13979 case AD: return "ad"; 13980 case NULL: return null; 13981 default: return "?"; 13982 } 13983 } 13984 public String getSystem() { 13985 switch (this) { 13986 case LESS_THAN: return "http://hl7.org/fhir/quantity-comparator"; 13987 case LESS_OR_EQUAL: return "http://hl7.org/fhir/quantity-comparator"; 13988 case GREATER_OR_EQUAL: return "http://hl7.org/fhir/quantity-comparator"; 13989 case GREATER_THAN: return "http://hl7.org/fhir/quantity-comparator"; 13990 case AD: return "http://hl7.org/fhir/quantity-comparator"; 13991 case NULL: return null; 13992 default: return "?"; 13993 } 13994 } 13995 public String getDefinition() { 13996 switch (this) { 13997 case LESS_THAN: return "The actual value is less than the given value."; 13998 case LESS_OR_EQUAL: return "The actual value is less than or equal to the given value."; 13999 case GREATER_OR_EQUAL: return "The actual value is greater than or equal to the given value."; 14000 case GREATER_THAN: return "The actual value is greater than the given value."; 14001 case AD: return "The actual value is sufficient for the total quantity to equal the given value."; 14002 case NULL: return null; 14003 default: return "?"; 14004 } 14005 } 14006 public String getDisplay() { 14007 switch (this) { 14008 case LESS_THAN: return "Less than"; 14009 case LESS_OR_EQUAL: return "Less or Equal to"; 14010 case GREATER_OR_EQUAL: return "Greater or Equal to"; 14011 case GREATER_THAN: return "Greater than"; 14012 case AD: return "Sufficient to achieve this total quantity"; 14013 case NULL: return null; 14014 default: return "?"; 14015 } 14016 } 14017 } 14018 14019 public static class QuantityComparatorEnumFactory implements EnumFactory<QuantityComparator> { 14020 public QuantityComparator fromCode(String codeString) throws IllegalArgumentException { 14021 if (codeString == null || "".equals(codeString)) 14022 if (codeString == null || "".equals(codeString)) 14023 return null; 14024 if ("<".equals(codeString)) 14025 return QuantityComparator.LESS_THAN; 14026 if ("<=".equals(codeString)) 14027 return QuantityComparator.LESS_OR_EQUAL; 14028 if (">=".equals(codeString)) 14029 return QuantityComparator.GREATER_OR_EQUAL; 14030 if (">".equals(codeString)) 14031 return QuantityComparator.GREATER_THAN; 14032 if ("ad".equals(codeString)) 14033 return QuantityComparator.AD; 14034 throw new IllegalArgumentException("Unknown QuantityComparator code '"+codeString+"'"); 14035 } 14036 14037 public Enumeration<QuantityComparator> fromType(PrimitiveType<?> code) throws FHIRException { 14038 if (code == null) 14039 return null; 14040 if (code.isEmpty()) 14041 return new Enumeration<QuantityComparator>(this, QuantityComparator.NULL, code); 14042 String codeString = ((PrimitiveType) code).asStringValue(); 14043 if (codeString == null || "".equals(codeString)) 14044 return new Enumeration<QuantityComparator>(this, QuantityComparator.NULL, code); 14045 if ("<".equals(codeString)) 14046 return new Enumeration<QuantityComparator>(this, QuantityComparator.LESS_THAN, code); 14047 if ("<=".equals(codeString)) 14048 return new Enumeration<QuantityComparator>(this, QuantityComparator.LESS_OR_EQUAL, code); 14049 if (">=".equals(codeString)) 14050 return new Enumeration<QuantityComparator>(this, QuantityComparator.GREATER_OR_EQUAL, code); 14051 if (">".equals(codeString)) 14052 return new Enumeration<QuantityComparator>(this, QuantityComparator.GREATER_THAN, code); 14053 if ("ad".equals(codeString)) 14054 return new Enumeration<QuantityComparator>(this, QuantityComparator.AD, code); 14055 throw new FHIRException("Unknown QuantityComparator code '"+codeString+"'"); 14056 } 14057 public String toCode(QuantityComparator code) { 14058 if (code == QuantityComparator.LESS_THAN) 14059 return "<"; 14060 if (code == QuantityComparator.LESS_OR_EQUAL) 14061 return "<="; 14062 if (code == QuantityComparator.GREATER_OR_EQUAL) 14063 return ">="; 14064 if (code == QuantityComparator.GREATER_THAN) 14065 return ">"; 14066 if (code == QuantityComparator.AD) 14067 return "ad"; 14068 return "?"; 14069 } 14070 public String toSystem(QuantityComparator code) { 14071 return code.getSystem(); 14072 } 14073 } 14074 14075 public enum RequestIntent { 14076 /** 14077 * The request is a suggestion made by someone/something that does not have an intention to ensure it occurs and without providing an authorization to act. 14078 */ 14079 PROPOSAL, 14080 /** 14081 * The request represents an intention to ensure something occurs without providing an authorization for others to act. 14082 */ 14083 PLAN, 14084 /** 14085 * The request represents a legally binding instruction authored by a Patient or RelatedPerson. 14086 */ 14087 DIRECTIVE, 14088 /** 14089 * The request represents a request/demand and authorization for action by the requestor. 14090 */ 14091 ORDER, 14092 /** 14093 * The request represents an original authorization for action. 14094 */ 14095 ORIGINALORDER, 14096 /** 14097 * The request represents an automatically generated supplemental authorization for action based on a parent authorization together with initial results of the action taken against that parent authorization. 14098 */ 14099 REFLEXORDER, 14100 /** 14101 * The request represents the view of an authorization instantiated by a fulfilling system representing the details of the fulfiller's intention to act upon a submitted order. 14102 */ 14103 FILLERORDER, 14104 /** 14105 * An order created in fulfillment of a broader order that represents the authorization for a single activity occurrence. E.g. The administration of a single dose of a drug. 14106 */ 14107 INSTANCEORDER, 14108 /** 14109 * The request represents a component or option for a RequestOrchestration that establishes timing, conditionality and/or other constraints among a set of requests. Refer to [[[RequestOrchestration]]] for additional information on how this status is used. 14110 */ 14111 OPTION, 14112 /** 14113 * added to help the parsers 14114 */ 14115 NULL; 14116 public static RequestIntent fromCode(String codeString) throws FHIRException { 14117 if (codeString == null || "".equals(codeString)) 14118 return null; 14119 if ("proposal".equals(codeString)) 14120 return PROPOSAL; 14121 if ("plan".equals(codeString)) 14122 return PLAN; 14123 if ("directive".equals(codeString)) 14124 return DIRECTIVE; 14125 if ("order".equals(codeString)) 14126 return ORDER; 14127 if ("original-order".equals(codeString)) 14128 return ORIGINALORDER; 14129 if ("reflex-order".equals(codeString)) 14130 return REFLEXORDER; 14131 if ("filler-order".equals(codeString)) 14132 return FILLERORDER; 14133 if ("instance-order".equals(codeString)) 14134 return INSTANCEORDER; 14135 if ("option".equals(codeString)) 14136 return OPTION; 14137 throw new FHIRException("Unknown RequestIntent code '"+codeString+"'"); 14138 } 14139 public static boolean isValidCode(String codeString) { 14140 if (codeString == null || "".equals(codeString)) 14141 return false; 14142 return Utilities.existsInList(codeString, "proposal", "plan", "directive", "order", "original-order", "reflex-order", "filler-order", "instance-order", "option"); 14143 } 14144 public String toCode() { 14145 switch (this) { 14146 case PROPOSAL: return "proposal"; 14147 case PLAN: return "plan"; 14148 case DIRECTIVE: return "directive"; 14149 case ORDER: return "order"; 14150 case ORIGINALORDER: return "original-order"; 14151 case REFLEXORDER: return "reflex-order"; 14152 case FILLERORDER: return "filler-order"; 14153 case INSTANCEORDER: return "instance-order"; 14154 case OPTION: return "option"; 14155 case NULL: return null; 14156 default: return "?"; 14157 } 14158 } 14159 public String getSystem() { 14160 switch (this) { 14161 case PROPOSAL: return "http://hl7.org/fhir/request-intent"; 14162 case PLAN: return "http://hl7.org/fhir/request-intent"; 14163 case DIRECTIVE: return "http://hl7.org/fhir/request-intent"; 14164 case ORDER: return "http://hl7.org/fhir/request-intent"; 14165 case ORIGINALORDER: return "http://hl7.org/fhir/request-intent"; 14166 case REFLEXORDER: return "http://hl7.org/fhir/request-intent"; 14167 case FILLERORDER: return "http://hl7.org/fhir/request-intent"; 14168 case INSTANCEORDER: return "http://hl7.org/fhir/request-intent"; 14169 case OPTION: return "http://hl7.org/fhir/request-intent"; 14170 case NULL: return null; 14171 default: return "?"; 14172 } 14173 } 14174 public String getDefinition() { 14175 switch (this) { 14176 case PROPOSAL: return "The request is a suggestion made by someone/something that does not have an intention to ensure it occurs and without providing an authorization to act."; 14177 case PLAN: return "The request represents an intention to ensure something occurs without providing an authorization for others to act."; 14178 case DIRECTIVE: return "The request represents a legally binding instruction authored by a Patient or RelatedPerson."; 14179 case ORDER: return "The request represents a request/demand and authorization for action by the requestor."; 14180 case ORIGINALORDER: return "The request represents an original authorization for action."; 14181 case REFLEXORDER: return "The request represents an automatically generated supplemental authorization for action based on a parent authorization together with initial results of the action taken against that parent authorization."; 14182 case FILLERORDER: return "The request represents the view of an authorization instantiated by a fulfilling system representing the details of the fulfiller's intention to act upon a submitted order."; 14183 case INSTANCEORDER: return "An order created in fulfillment of a broader order that represents the authorization for a single activity occurrence. E.g. The administration of a single dose of a drug."; 14184 case OPTION: return "The request represents a component or option for a RequestOrchestration that establishes timing, conditionality and/or other constraints among a set of requests. Refer to [[[RequestOrchestration]]] for additional information on how this status is used."; 14185 case NULL: return null; 14186 default: return "?"; 14187 } 14188 } 14189 public String getDisplay() { 14190 switch (this) { 14191 case PROPOSAL: return "Proposal"; 14192 case PLAN: return "Plan"; 14193 case DIRECTIVE: return "Directive"; 14194 case ORDER: return "Order"; 14195 case ORIGINALORDER: return "Original Order"; 14196 case REFLEXORDER: return "Reflex Order"; 14197 case FILLERORDER: return "Filler Order"; 14198 case INSTANCEORDER: return "Instance Order"; 14199 case OPTION: return "Option"; 14200 case NULL: return null; 14201 default: return "?"; 14202 } 14203 } 14204 } 14205 14206 public static class RequestIntentEnumFactory implements EnumFactory<RequestIntent> { 14207 public RequestIntent fromCode(String codeString) throws IllegalArgumentException { 14208 if (codeString == null || "".equals(codeString)) 14209 if (codeString == null || "".equals(codeString)) 14210 return null; 14211 if ("proposal".equals(codeString)) 14212 return RequestIntent.PROPOSAL; 14213 if ("plan".equals(codeString)) 14214 return RequestIntent.PLAN; 14215 if ("directive".equals(codeString)) 14216 return RequestIntent.DIRECTIVE; 14217 if ("order".equals(codeString)) 14218 return RequestIntent.ORDER; 14219 if ("original-order".equals(codeString)) 14220 return RequestIntent.ORIGINALORDER; 14221 if ("reflex-order".equals(codeString)) 14222 return RequestIntent.REFLEXORDER; 14223 if ("filler-order".equals(codeString)) 14224 return RequestIntent.FILLERORDER; 14225 if ("instance-order".equals(codeString)) 14226 return RequestIntent.INSTANCEORDER; 14227 if ("option".equals(codeString)) 14228 return RequestIntent.OPTION; 14229 throw new IllegalArgumentException("Unknown RequestIntent code '"+codeString+"'"); 14230 } 14231 14232 public Enumeration<RequestIntent> fromType(PrimitiveType<?> code) throws FHIRException { 14233 if (code == null) 14234 return null; 14235 if (code.isEmpty()) 14236 return new Enumeration<RequestIntent>(this, RequestIntent.NULL, code); 14237 String codeString = ((PrimitiveType) code).asStringValue(); 14238 if (codeString == null || "".equals(codeString)) 14239 return new Enumeration<RequestIntent>(this, RequestIntent.NULL, code); 14240 if ("proposal".equals(codeString)) 14241 return new Enumeration<RequestIntent>(this, RequestIntent.PROPOSAL, code); 14242 if ("plan".equals(codeString)) 14243 return new Enumeration<RequestIntent>(this, RequestIntent.PLAN, code); 14244 if ("directive".equals(codeString)) 14245 return new Enumeration<RequestIntent>(this, RequestIntent.DIRECTIVE, code); 14246 if ("order".equals(codeString)) 14247 return new Enumeration<RequestIntent>(this, RequestIntent.ORDER, code); 14248 if ("original-order".equals(codeString)) 14249 return new Enumeration<RequestIntent>(this, RequestIntent.ORIGINALORDER, code); 14250 if ("reflex-order".equals(codeString)) 14251 return new Enumeration<RequestIntent>(this, RequestIntent.REFLEXORDER, code); 14252 if ("filler-order".equals(codeString)) 14253 return new Enumeration<RequestIntent>(this, RequestIntent.FILLERORDER, code); 14254 if ("instance-order".equals(codeString)) 14255 return new Enumeration<RequestIntent>(this, RequestIntent.INSTANCEORDER, code); 14256 if ("option".equals(codeString)) 14257 return new Enumeration<RequestIntent>(this, RequestIntent.OPTION, code); 14258 throw new FHIRException("Unknown RequestIntent code '"+codeString+"'"); 14259 } 14260 public String toCode(RequestIntent code) { 14261 if (code == RequestIntent.PROPOSAL) 14262 return "proposal"; 14263 if (code == RequestIntent.PLAN) 14264 return "plan"; 14265 if (code == RequestIntent.DIRECTIVE) 14266 return "directive"; 14267 if (code == RequestIntent.ORDER) 14268 return "order"; 14269 if (code == RequestIntent.ORIGINALORDER) 14270 return "original-order"; 14271 if (code == RequestIntent.REFLEXORDER) 14272 return "reflex-order"; 14273 if (code == RequestIntent.FILLERORDER) 14274 return "filler-order"; 14275 if (code == RequestIntent.INSTANCEORDER) 14276 return "instance-order"; 14277 if (code == RequestIntent.OPTION) 14278 return "option"; 14279 return "?"; 14280 } 14281 public String toSystem(RequestIntent code) { 14282 return code.getSystem(); 14283 } 14284 } 14285 14286 public enum RequestPriority { 14287 /** 14288 * The request has normal priority. 14289 */ 14290 ROUTINE, 14291 /** 14292 * The request should be actioned promptly - higher priority than routine. 14293 */ 14294 URGENT, 14295 /** 14296 * The request should be actioned as soon as possible - higher priority than urgent. 14297 */ 14298 ASAP, 14299 /** 14300 * The request should be actioned immediately - highest possible priority. E.g. an emergency. 14301 */ 14302 STAT, 14303 /** 14304 * added to help the parsers 14305 */ 14306 NULL; 14307 public static RequestPriority fromCode(String codeString) throws FHIRException { 14308 if (codeString == null || "".equals(codeString)) 14309 return null; 14310 if ("routine".equals(codeString)) 14311 return ROUTINE; 14312 if ("urgent".equals(codeString)) 14313 return URGENT; 14314 if ("asap".equals(codeString)) 14315 return ASAP; 14316 if ("stat".equals(codeString)) 14317 return STAT; 14318 throw new FHIRException("Unknown RequestPriority code '"+codeString+"'"); 14319 } 14320 public static boolean isValidCode(String codeString) { 14321 if (codeString == null || "".equals(codeString)) 14322 return false; 14323 return Utilities.existsInList(codeString, "routine", "urgent", "asap", "stat"); 14324 } 14325 public String toCode() { 14326 switch (this) { 14327 case ROUTINE: return "routine"; 14328 case URGENT: return "urgent"; 14329 case ASAP: return "asap"; 14330 case STAT: return "stat"; 14331 case NULL: return null; 14332 default: return "?"; 14333 } 14334 } 14335 public String getSystem() { 14336 switch (this) { 14337 case ROUTINE: return "http://hl7.org/fhir/request-priority"; 14338 case URGENT: return "http://hl7.org/fhir/request-priority"; 14339 case ASAP: return "http://hl7.org/fhir/request-priority"; 14340 case STAT: return "http://hl7.org/fhir/request-priority"; 14341 case NULL: return null; 14342 default: return "?"; 14343 } 14344 } 14345 public String getDefinition() { 14346 switch (this) { 14347 case ROUTINE: return "The request has normal priority."; 14348 case URGENT: return "The request should be actioned promptly - higher priority than routine."; 14349 case ASAP: return "The request should be actioned as soon as possible - higher priority than urgent."; 14350 case STAT: return "The request should be actioned immediately - highest possible priority. E.g. an emergency."; 14351 case NULL: return null; 14352 default: return "?"; 14353 } 14354 } 14355 public String getDisplay() { 14356 switch (this) { 14357 case ROUTINE: return "Routine"; 14358 case URGENT: return "Urgent"; 14359 case ASAP: return "ASAP"; 14360 case STAT: return "STAT"; 14361 case NULL: return null; 14362 default: return "?"; 14363 } 14364 } 14365 } 14366 14367 public static class RequestPriorityEnumFactory implements EnumFactory<RequestPriority> { 14368 public RequestPriority fromCode(String codeString) throws IllegalArgumentException { 14369 if (codeString == null || "".equals(codeString)) 14370 if (codeString == null || "".equals(codeString)) 14371 return null; 14372 if ("routine".equals(codeString)) 14373 return RequestPriority.ROUTINE; 14374 if ("urgent".equals(codeString)) 14375 return RequestPriority.URGENT; 14376 if ("asap".equals(codeString)) 14377 return RequestPriority.ASAP; 14378 if ("stat".equals(codeString)) 14379 return RequestPriority.STAT; 14380 throw new IllegalArgumentException("Unknown RequestPriority code '"+codeString+"'"); 14381 } 14382 14383 public Enumeration<RequestPriority> fromType(PrimitiveType<?> code) throws FHIRException { 14384 if (code == null) 14385 return null; 14386 if (code.isEmpty()) 14387 return new Enumeration<RequestPriority>(this, RequestPriority.NULL, code); 14388 String codeString = ((PrimitiveType) code).asStringValue(); 14389 if (codeString == null || "".equals(codeString)) 14390 return new Enumeration<RequestPriority>(this, RequestPriority.NULL, code); 14391 if ("routine".equals(codeString)) 14392 return new Enumeration<RequestPriority>(this, RequestPriority.ROUTINE, code); 14393 if ("urgent".equals(codeString)) 14394 return new Enumeration<RequestPriority>(this, RequestPriority.URGENT, code); 14395 if ("asap".equals(codeString)) 14396 return new Enumeration<RequestPriority>(this, RequestPriority.ASAP, code); 14397 if ("stat".equals(codeString)) 14398 return new Enumeration<RequestPriority>(this, RequestPriority.STAT, code); 14399 throw new FHIRException("Unknown RequestPriority code '"+codeString+"'"); 14400 } 14401 public String toCode(RequestPriority code) { 14402 if (code == RequestPriority.ROUTINE) 14403 return "routine"; 14404 if (code == RequestPriority.URGENT) 14405 return "urgent"; 14406 if (code == RequestPriority.ASAP) 14407 return "asap"; 14408 if (code == RequestPriority.STAT) 14409 return "stat"; 14410 return "?"; 14411 } 14412 public String toSystem(RequestPriority code) { 14413 return code.getSystem(); 14414 } 14415 } 14416 14417 public enum RequestStatus { 14418 /** 14419 * The request has been created but is not yet complete or ready for action. 14420 */ 14421 DRAFT, 14422 /** 14423 * The request is in force and ready to be acted upon. 14424 */ 14425 ACTIVE, 14426 /** 14427 * The request (and any implicit authorization to act) has been temporarily withdrawn but is expected to resume in the future. 14428 */ 14429 ONHOLD, 14430 /** 14431 * The request (and any implicit authorization to act) has been terminated prior to the known full completion of the intended actions. No further activity should occur. 14432 */ 14433 REVOKED, 14434 /** 14435 * The activity described by the request has been fully performed. No further activity will occur. 14436 */ 14437 COMPLETED, 14438 /** 14439 * This request should never have existed and should be considered 'void'. (It is possible that real-world decisions were based on it. If real-world activity has occurred, the status should be "revoked" rather than "entered-in-error".). 14440 */ 14441 ENTEREDINERROR, 14442 /** 14443 * The authoring/source system does not know which of the status values currently applies for this request. Note: This concept is not to be used for "other" - one of the listed statuses is presumed to apply, but the authoring/source system does not know which. 14444 */ 14445 UNKNOWN, 14446 /** 14447 * added to help the parsers 14448 */ 14449 NULL; 14450 public static RequestStatus fromCode(String codeString) throws FHIRException { 14451 if (codeString == null || "".equals(codeString)) 14452 return null; 14453 if ("draft".equals(codeString)) 14454 return DRAFT; 14455 if ("active".equals(codeString)) 14456 return ACTIVE; 14457 if ("on-hold".equals(codeString)) 14458 return ONHOLD; 14459 if ("revoked".equals(codeString)) 14460 return REVOKED; 14461 if ("completed".equals(codeString)) 14462 return COMPLETED; 14463 if ("entered-in-error".equals(codeString)) 14464 return ENTEREDINERROR; 14465 if ("unknown".equals(codeString)) 14466 return UNKNOWN; 14467 throw new FHIRException("Unknown RequestStatus code '"+codeString+"'"); 14468 } 14469 public static boolean isValidCode(String codeString) { 14470 if (codeString == null || "".equals(codeString)) 14471 return false; 14472 return Utilities.existsInList(codeString, "draft", "active", "on-hold", "revoked", "completed", "entered-in-error", "unknown"); 14473 } 14474 public String toCode() { 14475 switch (this) { 14476 case DRAFT: return "draft"; 14477 case ACTIVE: return "active"; 14478 case ONHOLD: return "on-hold"; 14479 case REVOKED: return "revoked"; 14480 case COMPLETED: return "completed"; 14481 case ENTEREDINERROR: return "entered-in-error"; 14482 case UNKNOWN: return "unknown"; 14483 case NULL: return null; 14484 default: return "?"; 14485 } 14486 } 14487 public String getSystem() { 14488 switch (this) { 14489 case DRAFT: return "http://hl7.org/fhir/request-status"; 14490 case ACTIVE: return "http://hl7.org/fhir/request-status"; 14491 case ONHOLD: return "http://hl7.org/fhir/request-status"; 14492 case REVOKED: return "http://hl7.org/fhir/request-status"; 14493 case COMPLETED: return "http://hl7.org/fhir/request-status"; 14494 case ENTEREDINERROR: return "http://hl7.org/fhir/request-status"; 14495 case UNKNOWN: return "http://hl7.org/fhir/request-status"; 14496 case NULL: return null; 14497 default: return "?"; 14498 } 14499 } 14500 public String getDefinition() { 14501 switch (this) { 14502 case DRAFT: return "The request has been created but is not yet complete or ready for action."; 14503 case ACTIVE: return "The request is in force and ready to be acted upon."; 14504 case ONHOLD: return "The request (and any implicit authorization to act) has been temporarily withdrawn but is expected to resume in the future."; 14505 case REVOKED: return "The request (and any implicit authorization to act) has been terminated prior to the known full completion of the intended actions. No further activity should occur."; 14506 case COMPLETED: return "The activity described by the request has been fully performed. No further activity will occur."; 14507 case ENTEREDINERROR: return "This request should never have existed and should be considered 'void'. (It is possible that real-world decisions were based on it. If real-world activity has occurred, the status should be \"revoked\" rather than \"entered-in-error\".)."; 14508 case UNKNOWN: return "The authoring/source system does not know which of the status values currently applies for this request. Note: This concept is not to be used for \"other\" - one of the listed statuses is presumed to apply, but the authoring/source system does not know which."; 14509 case NULL: return null; 14510 default: return "?"; 14511 } 14512 } 14513 public String getDisplay() { 14514 switch (this) { 14515 case DRAFT: return "Draft"; 14516 case ACTIVE: return "Active"; 14517 case ONHOLD: return "On Hold"; 14518 case REVOKED: return "Revoked"; 14519 case COMPLETED: return "Completed"; 14520 case ENTEREDINERROR: return "Entered in Error"; 14521 case UNKNOWN: return "Unknown"; 14522 case NULL: return null; 14523 default: return "?"; 14524 } 14525 } 14526 } 14527 14528 public static class RequestStatusEnumFactory implements EnumFactory<RequestStatus> { 14529 public RequestStatus fromCode(String codeString) throws IllegalArgumentException { 14530 if (codeString == null || "".equals(codeString)) 14531 if (codeString == null || "".equals(codeString)) 14532 return null; 14533 if ("draft".equals(codeString)) 14534 return RequestStatus.DRAFT; 14535 if ("active".equals(codeString)) 14536 return RequestStatus.ACTIVE; 14537 if ("on-hold".equals(codeString)) 14538 return RequestStatus.ONHOLD; 14539 if ("revoked".equals(codeString)) 14540 return RequestStatus.REVOKED; 14541 if ("completed".equals(codeString)) 14542 return RequestStatus.COMPLETED; 14543 if ("entered-in-error".equals(codeString)) 14544 return RequestStatus.ENTEREDINERROR; 14545 if ("unknown".equals(codeString)) 14546 return RequestStatus.UNKNOWN; 14547 throw new IllegalArgumentException("Unknown RequestStatus code '"+codeString+"'"); 14548 } 14549 14550 public Enumeration<RequestStatus> fromType(PrimitiveType<?> code) throws FHIRException { 14551 if (code == null) 14552 return null; 14553 if (code.isEmpty()) 14554 return new Enumeration<RequestStatus>(this, RequestStatus.NULL, code); 14555 String codeString = ((PrimitiveType) code).asStringValue(); 14556 if (codeString == null || "".equals(codeString)) 14557 return new Enumeration<RequestStatus>(this, RequestStatus.NULL, code); 14558 if ("draft".equals(codeString)) 14559 return new Enumeration<RequestStatus>(this, RequestStatus.DRAFT, code); 14560 if ("active".equals(codeString)) 14561 return new Enumeration<RequestStatus>(this, RequestStatus.ACTIVE, code); 14562 if ("on-hold".equals(codeString)) 14563 return new Enumeration<RequestStatus>(this, RequestStatus.ONHOLD, code); 14564 if ("revoked".equals(codeString)) 14565 return new Enumeration<RequestStatus>(this, RequestStatus.REVOKED, code); 14566 if ("completed".equals(codeString)) 14567 return new Enumeration<RequestStatus>(this, RequestStatus.COMPLETED, code); 14568 if ("entered-in-error".equals(codeString)) 14569 return new Enumeration<RequestStatus>(this, RequestStatus.ENTEREDINERROR, code); 14570 if ("unknown".equals(codeString)) 14571 return new Enumeration<RequestStatus>(this, RequestStatus.UNKNOWN, code); 14572 throw new FHIRException("Unknown RequestStatus code '"+codeString+"'"); 14573 } 14574 public String toCode(RequestStatus code) { 14575 if (code == RequestStatus.DRAFT) 14576 return "draft"; 14577 if (code == RequestStatus.ACTIVE) 14578 return "active"; 14579 if (code == RequestStatus.ONHOLD) 14580 return "on-hold"; 14581 if (code == RequestStatus.REVOKED) 14582 return "revoked"; 14583 if (code == RequestStatus.COMPLETED) 14584 return "completed"; 14585 if (code == RequestStatus.ENTEREDINERROR) 14586 return "entered-in-error"; 14587 if (code == RequestStatus.UNKNOWN) 14588 return "unknown"; 14589 return "?"; 14590 } 14591 public String toSystem(RequestStatus code) { 14592 return code.getSystem(); 14593 } 14594 } 14595 14596 public enum ResourceTypeEnum { 14597 /** 14598 * 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. 14599 */ 14600 ACCOUNT, 14601 /** 14602 * This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context. 14603 */ 14604 ACTIVITYDEFINITION, 14605 /** 14606 * 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. 14607 */ 14608 ACTORDEFINITION, 14609 /** 14610 * 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). 14611 */ 14612 ADMINISTRABLEPRODUCTDEFINITION, 14613 /** 14614 * 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. 14615 */ 14616 ADVERSEEVENT, 14617 /** 14618 * Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance. 14619 */ 14620 ALLERGYINTOLERANCE, 14621 /** 14622 * 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). 14623 */ 14624 APPOINTMENT, 14625 /** 14626 * A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection. 14627 */ 14628 APPOINTMENTRESPONSE, 14629 /** 14630 * This Resource provides one or more comments, classifiers or ratings about a Resource and supports attribution and rights management metadata for the added content. 14631 */ 14632 ARTIFACTASSESSMENT, 14633 /** 14634 * A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis. 14635 */ 14636 AUDITEVENT, 14637 /** 14638 * 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. 14639 */ 14640 BASIC, 14641 /** 14642 * 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. 14643 */ 14644 BINARY, 14645 /** 14646 * A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity. 14647 */ 14648 BIOLOGICALLYDERIVEDPRODUCT, 14649 /** 14650 * A record of dispensation of a biologically derived product. 14651 */ 14652 BIOLOGICALLYDERIVEDPRODUCTDISPENSE, 14653 /** 14654 * 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. 14655 */ 14656 BODYSTRUCTURE, 14657 /** 14658 * A container for a collection of resources. 14659 */ 14660 BUNDLE, 14661 /** 14662 * 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. 14663 */ 14664 CAPABILITYSTATEMENT, 14665 /** 14666 * 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. 14667 */ 14668 CAREPLAN, 14669 /** 14670 * The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care. 14671 */ 14672 CARETEAM, 14673 /** 14674 * 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. 14675 */ 14676 CHARGEITEM, 14677 /** 14678 * 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. 14679 */ 14680 CHARGEITEMDEFINITION, 14681 /** 14682 * 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. 14683 */ 14684 CITATION, 14685 /** 14686 * 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. 14687 */ 14688 CLAIM, 14689 /** 14690 * This resource provides the adjudication details from the processing of a Claim resource. 14691 */ 14692 CLAIMRESPONSE, 14693 /** 14694 * 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. 14695 */ 14696 CLINICALIMPRESSION, 14697 /** 14698 * A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure. 14699 */ 14700 CLINICALUSEDEFINITION, 14701 /** 14702 * 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. 14703 */ 14704 CODESYSTEM, 14705 /** 14706 * 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. 14707 */ 14708 COMMUNICATION, 14709 /** 14710 * 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. 14711 */ 14712 COMMUNICATIONREQUEST, 14713 /** 14714 * A compartment definition that defines how resources are accessed on a server. 14715 */ 14716 COMPARTMENTDEFINITION, 14717 /** 14718 * 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.). 14719 */ 14720 COMPOSITION, 14721 /** 14722 * 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. 14723 */ 14724 CONCEPTMAP, 14725 /** 14726 * A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern. 14727 */ 14728 CONDITION, 14729 /** 14730 * A definition of a condition and information relevant to managing it. 14731 */ 14732 CONDITIONDEFINITION, 14733 /** 14734 * 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. 14735 */ 14736 CONSENT, 14737 /** 14738 * Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement. 14739 */ 14740 CONTRACT, 14741 /** 14742 * Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment. 14743 */ 14744 COVERAGE, 14745 /** 14746 * 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. 14747 */ 14748 COVERAGEELIGIBILITYREQUEST, 14749 /** 14750 * This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource. 14751 */ 14752 COVERAGEELIGIBILITYRESPONSE, 14753 /** 14754 * 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. 14755 */ 14756 DETECTEDISSUE, 14757 /** 14758 * 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. 14759 */ 14760 DEVICE, 14761 /** 14762 * A record of association of a device. 14763 */ 14764 DEVICEASSOCIATION, 14765 /** 14766 * This is a specialized resource that defines the characteristics and capabilities of a device. 14767 */ 14768 DEVICEDEFINITION, 14769 /** 14770 * 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. 14771 */ 14772 DEVICEDISPENSE, 14773 /** 14774 * 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. 14775 */ 14776 DEVICEMETRIC, 14777 /** 14778 * 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. 14779 */ 14780 DEVICEREQUEST, 14781 /** 14782 * 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. 14783 */ 14784 DEVICEUSAGE, 14785 /** 14786 * 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. 14787 */ 14788 DIAGNOSTICREPORT, 14789 /** 14790 * 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. 14791 */ 14792 DOCUMENTREFERENCE, 14793 /** 14794 * 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). 14795 */ 14796 ENCOUNTER, 14797 /** 14798 * A record of significant events/milestones key data throughout the history of an Encounter 14799 */ 14800 ENCOUNTERHISTORY, 14801 /** 14802 * 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. 14803 */ 14804 ENDPOINT, 14805 /** 14806 * This resource provides the insurance enrollment details to the insurer regarding a specified coverage. 14807 */ 14808 ENROLLMENTREQUEST, 14809 /** 14810 * This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource. 14811 */ 14812 ENROLLMENTRESPONSE, 14813 /** 14814 * 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. 14815 */ 14816 EPISODEOFCARE, 14817 /** 14818 * The EventDefinition resource provides a reusable description of when a particular event can occur. 14819 */ 14820 EVENTDEFINITION, 14821 /** 14822 * 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. 14823 */ 14824 EVIDENCE, 14825 /** 14826 * 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. 14827 */ 14828 EVIDENCEREPORT, 14829 /** 14830 * The EvidenceVariable resource describes an element that knowledge (Evidence) is about. 14831 */ 14832 EVIDENCEVARIABLE, 14833 /** 14834 * A walkthrough of a workflow showing the interaction between systems and the instances shared, possibly including the evolution of instances over time. 14835 */ 14836 EXAMPLESCENARIO, 14837 /** 14838 * 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. 14839 */ 14840 EXPLANATIONOFBENEFIT, 14841 /** 14842 * Significant health conditions for a person related to the patient relevant in the context of care for the patient. 14843 */ 14844 FAMILYMEMBERHISTORY, 14845 /** 14846 * Prospective warnings of potential issues when providing care to the patient. 14847 */ 14848 FLAG, 14849 /** 14850 * 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. 14851 */ 14852 FORMULARYITEM, 14853 /** 14854 * A set of analyses performed to analyze and generate genomic data. 14855 */ 14856 GENOMICSTUDY, 14857 /** 14858 * 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. 14859 */ 14860 GOAL, 14861 /** 14862 * 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. 14863 */ 14864 GRAPHDEFINITION, 14865 /** 14866 * 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. 14867 */ 14868 GROUP, 14869 /** 14870 * 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. 14871 */ 14872 GUIDANCERESPONSE, 14873 /** 14874 * 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. 14875 */ 14876 HEALTHCARESERVICE, 14877 /** 14878 * 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. 14879 */ 14880 IMAGINGSELECTION, 14881 /** 14882 * 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. 14883 */ 14884 IMAGINGSTUDY, 14885 /** 14886 * 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. 14887 */ 14888 IMMUNIZATION, 14889 /** 14890 * Describes a comparison of an immunization event against published recommendations to determine if the administration is "valid" in relation to those recommendations. 14891 */ 14892 IMMUNIZATIONEVALUATION, 14893 /** 14894 * A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification. 14895 */ 14896 IMMUNIZATIONRECOMMENDATION, 14897 /** 14898 * 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. 14899 */ 14900 IMPLEMENTATIONGUIDE, 14901 /** 14902 * An ingredient of a manufactured item or pharmaceutical product. 14903 */ 14904 INGREDIENT, 14905 /** 14906 * Details of a Health Insurance product/plan provided by an organization. 14907 */ 14908 INSURANCEPLAN, 14909 /** 14910 * functional description of an inventory item used in inventory and supply-related workflows. 14911 */ 14912 INVENTORYITEM, 14913 /** 14914 * A report of inventory or stock items. 14915 */ 14916 INVENTORYREPORT, 14917 /** 14918 * Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose. 14919 */ 14920 INVOICE, 14921 /** 14922 * 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. 14923 */ 14924 LIBRARY, 14925 /** 14926 * Identifies two or more records (resource instances) that refer to the same real-world "occurrence". 14927 */ 14928 LINKAGE, 14929 /** 14930 * A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc. 14931 */ 14932 LIST, 14933 /** 14934 * Details and position information for a place where services are provided and resources and participants may be stored, found, contained, or accommodated. 14935 */ 14936 LOCATION, 14937 /** 14938 * The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product. 14939 */ 14940 MANUFACTUREDITEMDEFINITION, 14941 /** 14942 * The Measure resource provides the definition of a quality measure. 14943 */ 14944 MEASURE, 14945 /** 14946 * The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation. 14947 */ 14948 MEASUREREPORT, 14949 /** 14950 * 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. 14951 */ 14952 MEDICATION, 14953 /** 14954 * 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. 14955 */ 14956 MEDICATIONADMINISTRATION, 14957 /** 14958 * 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. 14959 */ 14960 MEDICATIONDISPENSE, 14961 /** 14962 * Information about a medication that is used to support knowledge. 14963 */ 14964 MEDICATIONKNOWLEDGE, 14965 /** 14966 * 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. 14967 */ 14968 MEDICATIONREQUEST, 14969 /** 14970 * 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. 14971 14972The 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. 14973 */ 14974 MEDICATIONSTATEMENT, 14975 /** 14976 * 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.). 14977 */ 14978 MEDICINALPRODUCTDEFINITION, 14979 /** 14980 * 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. 14981 */ 14982 MESSAGEDEFINITION, 14983 /** 14984 * 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. 14985 */ 14986 MESSAGEHEADER, 14987 /** 14988 * Representation of a molecular sequence. 14989 */ 14990 MOLECULARSEQUENCE, 14991 /** 14992 * 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. 14993 */ 14994 NAMINGSYSTEM, 14995 /** 14996 * 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. 14997 */ 14998 NUTRITIONINTAKE, 14999 /** 15000 * A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident. 15001 */ 15002 NUTRITIONORDER, 15003 /** 15004 * A food or supplement that is consumed by patients. 15005 */ 15006 NUTRITIONPRODUCT, 15007 /** 15008 * Measurements and simple assertions made about a patient, device or other subject. 15009 */ 15010 OBSERVATION, 15011 /** 15012 * Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service. 15013 */ 15014 OBSERVATIONDEFINITION, 15015 /** 15016 * A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction). 15017 */ 15018 OPERATIONDEFINITION, 15019 /** 15020 * A collection of error, warning, or information messages that result from a system action. 15021 */ 15022 OPERATIONOUTCOME, 15023 /** 15024 * 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. 15025 */ 15026 ORGANIZATION, 15027 /** 15028 * Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship. 15029 */ 15030 ORGANIZATIONAFFILIATION, 15031 /** 15032 * A medically related item or items, in a container or package. 15033 */ 15034 PACKAGEDPRODUCTDEFINITION, 15035 /** 15036 * 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. 15037 */ 15038 PARAMETERS, 15039 /** 15040 * Demographics and other administrative information about an individual or animal receiving care or other health-related services. 15041 */ 15042 PATIENT, 15043 /** 15044 * This resource provides the status of the payment for goods and services rendered, and the request and response resource references. 15045 */ 15046 PAYMENTNOTICE, 15047 /** 15048 * This resource provides the details including amount of a payment and allocates the payment items being paid. 15049 */ 15050 PAYMENTRECONCILIATION, 15051 /** 15052 * Permission resource holds access rules for a given data and context. 15053 */ 15054 PERMISSION, 15055 /** 15056 * Demographics and administrative information about a person independent of a specific health-related context. 15057 */ 15058 PERSON, 15059 /** 15060 * 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. 15061 */ 15062 PLANDEFINITION, 15063 /** 15064 * A person who is directly or indirectly involved in the provisioning of healthcare or related services. 15065 */ 15066 PRACTITIONER, 15067 /** 15068 * A specific set of Roles/Locations/specialties/services that a practitioner may perform, or has performed at an organization during a period of time. 15069 */ 15070 PRACTITIONERROLE, 15071 /** 15072 * 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. 15073 */ 15074 PROCEDURE, 15075 /** 15076 * 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. 15077 */ 15078 PROVENANCE, 15079 /** 15080 * 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. 15081 */ 15082 QUESTIONNAIRE, 15083 /** 15084 * 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. 15085 */ 15086 QUESTIONNAIRERESPONSE, 15087 /** 15088 * 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. 15089 */ 15090 REGULATEDAUTHORIZATION, 15091 /** 15092 * 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. 15093 */ 15094 RELATEDPERSON, 15095 /** 15096 * 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". 15097 */ 15098 REQUESTORCHESTRATION, 15099 /** 15100 * 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. 15101 */ 15102 REQUIREMENTS, 15103 /** 15104 * 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. 15105 */ 15106 RESEARCHSTUDY, 15107 /** 15108 * A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study. 15109 */ 15110 RESEARCHSUBJECT, 15111 /** 15112 * An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome. 15113 */ 15114 RISKASSESSMENT, 15115 /** 15116 * A container for slots of time that may be available for booking appointments. 15117 */ 15118 SCHEDULE, 15119 /** 15120 * A search parameter that defines a named search item that can be used to search/filter on a resource. 15121 */ 15122 SEARCHPARAMETER, 15123 /** 15124 * A record of a request for service such as diagnostic investigations, treatments, or operations to be performed. 15125 */ 15126 SERVICEREQUEST, 15127 /** 15128 * A slot of time on a schedule that may be available for booking appointments. 15129 */ 15130 SLOT, 15131 /** 15132 * A sample to be used for analysis. 15133 */ 15134 SPECIMEN, 15135 /** 15136 * A kind of specimen with associated set of requirements. 15137 */ 15138 SPECIMENDEFINITION, 15139 /** 15140 * 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. 15141 */ 15142 STRUCTUREDEFINITION, 15143 /** 15144 * A Map of relationships between 2 structures that can be used to transform data. 15145 */ 15146 STRUCTUREMAP, 15147 /** 15148 * The subscription resource describes a particular client's request to be notified about a SubscriptionTopic. 15149 */ 15150 SUBSCRIPTION, 15151 /** 15152 * The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted. 15153 */ 15154 SUBSCRIPTIONSTATUS, 15155 /** 15156 * Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic. 15157 */ 15158 SUBSCRIPTIONTOPIC, 15159 /** 15160 * A homogeneous material with a definite composition. 15161 */ 15162 SUBSTANCE, 15163 /** 15164 * The detailed description of a substance, typically at a level beyond what is used for prescribing. 15165 */ 15166 SUBSTANCEDEFINITION, 15167 /** 15168 * 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. 15169 */ 15170 SUBSTANCENUCLEICACID, 15171 /** 15172 * Properties of a substance specific to it being a polymer. 15173 */ 15174 SUBSTANCEPOLYMER, 15175 /** 15176 * 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. 15177 */ 15178 SUBSTANCEPROTEIN, 15179 /** 15180 * Todo. 15181 */ 15182 SUBSTANCEREFERENCEINFORMATION, 15183 /** 15184 * 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. 15185 */ 15186 SUBSTANCESOURCEMATERIAL, 15187 /** 15188 * Record of delivery of what is supplied. 15189 */ 15190 SUPPLYDELIVERY, 15191 /** 15192 * 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. 15193 */ 15194 SUPPLYREQUEST, 15195 /** 15196 * A task to be performed. 15197 */ 15198 TASK, 15199 /** 15200 * 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. 15201 */ 15202 TERMINOLOGYCAPABILITIES, 15203 /** 15204 * A plan for executing testing on an artifact or specifications 15205 */ 15206 TESTPLAN, 15207 /** 15208 * A summary of information based on the results of executing a TestScript. 15209 */ 15210 TESTREPORT, 15211 /** 15212 * A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification. 15213 */ 15214 TESTSCRIPT, 15215 /** 15216 * Record of transport. 15217 */ 15218 TRANSPORT, 15219 /** 15220 * 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). 15221 */ 15222 VALUESET, 15223 /** 15224 * Describes validation requirements, source(s), status and dates for one or more elements. 15225 */ 15226 VERIFICATIONRESULT, 15227 /** 15228 * An authorization for the provision of glasses and/or contact lenses to a patient. 15229 */ 15230 VISIONPRESCRIPTION, 15231 /** 15232 * added to help the parsers 15233 */ 15234 NULL; 15235 public static ResourceTypeEnum fromCode(String codeString) throws FHIRException { 15236 if (codeString == null || "".equals(codeString)) 15237 return null; 15238 if ("Account".equals(codeString)) 15239 return ACCOUNT; 15240 if ("ActivityDefinition".equals(codeString)) 15241 return ACTIVITYDEFINITION; 15242 if ("ActorDefinition".equals(codeString)) 15243 return ACTORDEFINITION; 15244 if ("AdministrableProductDefinition".equals(codeString)) 15245 return ADMINISTRABLEPRODUCTDEFINITION; 15246 if ("AdverseEvent".equals(codeString)) 15247 return ADVERSEEVENT; 15248 if ("AllergyIntolerance".equals(codeString)) 15249 return ALLERGYINTOLERANCE; 15250 if ("Appointment".equals(codeString)) 15251 return APPOINTMENT; 15252 if ("AppointmentResponse".equals(codeString)) 15253 return APPOINTMENTRESPONSE; 15254 if ("ArtifactAssessment".equals(codeString)) 15255 return ARTIFACTASSESSMENT; 15256 if ("AuditEvent".equals(codeString)) 15257 return AUDITEVENT; 15258 if ("Basic".equals(codeString)) 15259 return BASIC; 15260 if ("Binary".equals(codeString)) 15261 return BINARY; 15262 if ("BiologicallyDerivedProduct".equals(codeString)) 15263 return BIOLOGICALLYDERIVEDPRODUCT; 15264 if ("BiologicallyDerivedProductDispense".equals(codeString)) 15265 return BIOLOGICALLYDERIVEDPRODUCTDISPENSE; 15266 if ("BodyStructure".equals(codeString)) 15267 return BODYSTRUCTURE; 15268 if ("Bundle".equals(codeString)) 15269 return BUNDLE; 15270 if ("CapabilityStatement".equals(codeString)) 15271 return CAPABILITYSTATEMENT; 15272 if ("CarePlan".equals(codeString)) 15273 return CAREPLAN; 15274 if ("CareTeam".equals(codeString)) 15275 return CARETEAM; 15276 if ("ChargeItem".equals(codeString)) 15277 return CHARGEITEM; 15278 if ("ChargeItemDefinition".equals(codeString)) 15279 return CHARGEITEMDEFINITION; 15280 if ("Citation".equals(codeString)) 15281 return CITATION; 15282 if ("Claim".equals(codeString)) 15283 return CLAIM; 15284 if ("ClaimResponse".equals(codeString)) 15285 return CLAIMRESPONSE; 15286 if ("ClinicalImpression".equals(codeString)) 15287 return CLINICALIMPRESSION; 15288 if ("ClinicalUseDefinition".equals(codeString)) 15289 return CLINICALUSEDEFINITION; 15290 if ("CodeSystem".equals(codeString)) 15291 return CODESYSTEM; 15292 if ("Communication".equals(codeString)) 15293 return COMMUNICATION; 15294 if ("CommunicationRequest".equals(codeString)) 15295 return COMMUNICATIONREQUEST; 15296 if ("CompartmentDefinition".equals(codeString)) 15297 return COMPARTMENTDEFINITION; 15298 if ("Composition".equals(codeString)) 15299 return COMPOSITION; 15300 if ("ConceptMap".equals(codeString)) 15301 return CONCEPTMAP; 15302 if ("Condition".equals(codeString)) 15303 return CONDITION; 15304 if ("ConditionDefinition".equals(codeString)) 15305 return CONDITIONDEFINITION; 15306 if ("Consent".equals(codeString)) 15307 return CONSENT; 15308 if ("Contract".equals(codeString)) 15309 return CONTRACT; 15310 if ("Coverage".equals(codeString)) 15311 return COVERAGE; 15312 if ("CoverageEligibilityRequest".equals(codeString)) 15313 return COVERAGEELIGIBILITYREQUEST; 15314 if ("CoverageEligibilityResponse".equals(codeString)) 15315 return COVERAGEELIGIBILITYRESPONSE; 15316 if ("DetectedIssue".equals(codeString)) 15317 return DETECTEDISSUE; 15318 if ("Device".equals(codeString)) 15319 return DEVICE; 15320 if ("DeviceAssociation".equals(codeString)) 15321 return DEVICEASSOCIATION; 15322 if ("DeviceDefinition".equals(codeString)) 15323 return DEVICEDEFINITION; 15324 if ("DeviceDispense".equals(codeString)) 15325 return DEVICEDISPENSE; 15326 if ("DeviceMetric".equals(codeString)) 15327 return DEVICEMETRIC; 15328 if ("DeviceRequest".equals(codeString)) 15329 return DEVICEREQUEST; 15330 if ("DeviceUsage".equals(codeString)) 15331 return DEVICEUSAGE; 15332 if ("DiagnosticReport".equals(codeString)) 15333 return DIAGNOSTICREPORT; 15334 if ("DocumentReference".equals(codeString)) 15335 return DOCUMENTREFERENCE; 15336 if ("Encounter".equals(codeString)) 15337 return ENCOUNTER; 15338 if ("EncounterHistory".equals(codeString)) 15339 return ENCOUNTERHISTORY; 15340 if ("Endpoint".equals(codeString)) 15341 return ENDPOINT; 15342 if ("EnrollmentRequest".equals(codeString)) 15343 return ENROLLMENTREQUEST; 15344 if ("EnrollmentResponse".equals(codeString)) 15345 return ENROLLMENTRESPONSE; 15346 if ("EpisodeOfCare".equals(codeString)) 15347 return EPISODEOFCARE; 15348 if ("EventDefinition".equals(codeString)) 15349 return EVENTDEFINITION; 15350 if ("Evidence".equals(codeString)) 15351 return EVIDENCE; 15352 if ("EvidenceReport".equals(codeString)) 15353 return EVIDENCEREPORT; 15354 if ("EvidenceVariable".equals(codeString)) 15355 return EVIDENCEVARIABLE; 15356 if ("ExampleScenario".equals(codeString)) 15357 return EXAMPLESCENARIO; 15358 if ("ExplanationOfBenefit".equals(codeString)) 15359 return EXPLANATIONOFBENEFIT; 15360 if ("FamilyMemberHistory".equals(codeString)) 15361 return FAMILYMEMBERHISTORY; 15362 if ("Flag".equals(codeString)) 15363 return FLAG; 15364 if ("FormularyItem".equals(codeString)) 15365 return FORMULARYITEM; 15366 if ("GenomicStudy".equals(codeString)) 15367 return GENOMICSTUDY; 15368 if ("Goal".equals(codeString)) 15369 return GOAL; 15370 if ("GraphDefinition".equals(codeString)) 15371 return GRAPHDEFINITION; 15372 if ("Group".equals(codeString)) 15373 return GROUP; 15374 if ("GuidanceResponse".equals(codeString)) 15375 return GUIDANCERESPONSE; 15376 if ("HealthcareService".equals(codeString)) 15377 return HEALTHCARESERVICE; 15378 if ("ImagingSelection".equals(codeString)) 15379 return IMAGINGSELECTION; 15380 if ("ImagingStudy".equals(codeString)) 15381 return IMAGINGSTUDY; 15382 if ("Immunization".equals(codeString)) 15383 return IMMUNIZATION; 15384 if ("ImmunizationEvaluation".equals(codeString)) 15385 return IMMUNIZATIONEVALUATION; 15386 if ("ImmunizationRecommendation".equals(codeString)) 15387 return IMMUNIZATIONRECOMMENDATION; 15388 if ("ImplementationGuide".equals(codeString)) 15389 return IMPLEMENTATIONGUIDE; 15390 if ("Ingredient".equals(codeString)) 15391 return INGREDIENT; 15392 if ("InsurancePlan".equals(codeString)) 15393 return INSURANCEPLAN; 15394 if ("InventoryItem".equals(codeString)) 15395 return INVENTORYITEM; 15396 if ("InventoryReport".equals(codeString)) 15397 return INVENTORYREPORT; 15398 if ("Invoice".equals(codeString)) 15399 return INVOICE; 15400 if ("Library".equals(codeString)) 15401 return LIBRARY; 15402 if ("Linkage".equals(codeString)) 15403 return LINKAGE; 15404 if ("List".equals(codeString)) 15405 return LIST; 15406 if ("Location".equals(codeString)) 15407 return LOCATION; 15408 if ("ManufacturedItemDefinition".equals(codeString)) 15409 return MANUFACTUREDITEMDEFINITION; 15410 if ("Measure".equals(codeString)) 15411 return MEASURE; 15412 if ("MeasureReport".equals(codeString)) 15413 return MEASUREREPORT; 15414 if ("Medication".equals(codeString)) 15415 return MEDICATION; 15416 if ("MedicationAdministration".equals(codeString)) 15417 return MEDICATIONADMINISTRATION; 15418 if ("MedicationDispense".equals(codeString)) 15419 return MEDICATIONDISPENSE; 15420 if ("MedicationKnowledge".equals(codeString)) 15421 return MEDICATIONKNOWLEDGE; 15422 if ("MedicationRequest".equals(codeString)) 15423 return MEDICATIONREQUEST; 15424 if ("MedicationStatement".equals(codeString)) 15425 return MEDICATIONSTATEMENT; 15426 if ("MedicinalProductDefinition".equals(codeString)) 15427 return MEDICINALPRODUCTDEFINITION; 15428 if ("MessageDefinition".equals(codeString)) 15429 return MESSAGEDEFINITION; 15430 if ("MessageHeader".equals(codeString)) 15431 return MESSAGEHEADER; 15432 if ("MolecularSequence".equals(codeString)) 15433 return MOLECULARSEQUENCE; 15434 if ("NamingSystem".equals(codeString)) 15435 return NAMINGSYSTEM; 15436 if ("NutritionIntake".equals(codeString)) 15437 return NUTRITIONINTAKE; 15438 if ("NutritionOrder".equals(codeString)) 15439 return NUTRITIONORDER; 15440 if ("NutritionProduct".equals(codeString)) 15441 return NUTRITIONPRODUCT; 15442 if ("Observation".equals(codeString)) 15443 return OBSERVATION; 15444 if ("ObservationDefinition".equals(codeString)) 15445 return OBSERVATIONDEFINITION; 15446 if ("OperationDefinition".equals(codeString)) 15447 return OPERATIONDEFINITION; 15448 if ("OperationOutcome".equals(codeString)) 15449 return OPERATIONOUTCOME; 15450 if ("Organization".equals(codeString)) 15451 return ORGANIZATION; 15452 if ("OrganizationAffiliation".equals(codeString)) 15453 return ORGANIZATIONAFFILIATION; 15454 if ("PackagedProductDefinition".equals(codeString)) 15455 return PACKAGEDPRODUCTDEFINITION; 15456 if ("Parameters".equals(codeString)) 15457 return PARAMETERS; 15458 if ("Patient".equals(codeString)) 15459 return PATIENT; 15460 if ("PaymentNotice".equals(codeString)) 15461 return PAYMENTNOTICE; 15462 if ("PaymentReconciliation".equals(codeString)) 15463 return PAYMENTRECONCILIATION; 15464 if ("Permission".equals(codeString)) 15465 return PERMISSION; 15466 if ("Person".equals(codeString)) 15467 return PERSON; 15468 if ("PlanDefinition".equals(codeString)) 15469 return PLANDEFINITION; 15470 if ("Practitioner".equals(codeString)) 15471 return PRACTITIONER; 15472 if ("PractitionerRole".equals(codeString)) 15473 return PRACTITIONERROLE; 15474 if ("Procedure".equals(codeString)) 15475 return PROCEDURE; 15476 if ("Provenance".equals(codeString)) 15477 return PROVENANCE; 15478 if ("Questionnaire".equals(codeString)) 15479 return QUESTIONNAIRE; 15480 if ("QuestionnaireResponse".equals(codeString)) 15481 return QUESTIONNAIRERESPONSE; 15482 if ("RegulatedAuthorization".equals(codeString)) 15483 return REGULATEDAUTHORIZATION; 15484 if ("RelatedPerson".equals(codeString)) 15485 return RELATEDPERSON; 15486 if ("RequestOrchestration".equals(codeString)) 15487 return REQUESTORCHESTRATION; 15488 if ("Requirements".equals(codeString)) 15489 return REQUIREMENTS; 15490 if ("ResearchStudy".equals(codeString)) 15491 return RESEARCHSTUDY; 15492 if ("ResearchSubject".equals(codeString)) 15493 return RESEARCHSUBJECT; 15494 if ("RiskAssessment".equals(codeString)) 15495 return RISKASSESSMENT; 15496 if ("Schedule".equals(codeString)) 15497 return SCHEDULE; 15498 if ("SearchParameter".equals(codeString)) 15499 return SEARCHPARAMETER; 15500 if ("ServiceRequest".equals(codeString)) 15501 return SERVICEREQUEST; 15502 if ("Slot".equals(codeString)) 15503 return SLOT; 15504 if ("Specimen".equals(codeString)) 15505 return SPECIMEN; 15506 if ("SpecimenDefinition".equals(codeString)) 15507 return SPECIMENDEFINITION; 15508 if ("StructureDefinition".equals(codeString)) 15509 return STRUCTUREDEFINITION; 15510 if ("StructureMap".equals(codeString)) 15511 return STRUCTUREMAP; 15512 if ("Subscription".equals(codeString)) 15513 return SUBSCRIPTION; 15514 if ("SubscriptionStatus".equals(codeString)) 15515 return SUBSCRIPTIONSTATUS; 15516 if ("SubscriptionTopic".equals(codeString)) 15517 return SUBSCRIPTIONTOPIC; 15518 if ("Substance".equals(codeString)) 15519 return SUBSTANCE; 15520 if ("SubstanceDefinition".equals(codeString)) 15521 return SUBSTANCEDEFINITION; 15522 if ("SubstanceNucleicAcid".equals(codeString)) 15523 return SUBSTANCENUCLEICACID; 15524 if ("SubstancePolymer".equals(codeString)) 15525 return SUBSTANCEPOLYMER; 15526 if ("SubstanceProtein".equals(codeString)) 15527 return SUBSTANCEPROTEIN; 15528 if ("SubstanceReferenceInformation".equals(codeString)) 15529 return SUBSTANCEREFERENCEINFORMATION; 15530 if ("SubstanceSourceMaterial".equals(codeString)) 15531 return SUBSTANCESOURCEMATERIAL; 15532 if ("SupplyDelivery".equals(codeString)) 15533 return SUPPLYDELIVERY; 15534 if ("SupplyRequest".equals(codeString)) 15535 return SUPPLYREQUEST; 15536 if ("Task".equals(codeString)) 15537 return TASK; 15538 if ("TerminologyCapabilities".equals(codeString)) 15539 return TERMINOLOGYCAPABILITIES; 15540 if ("TestPlan".equals(codeString)) 15541 return TESTPLAN; 15542 if ("TestReport".equals(codeString)) 15543 return TESTREPORT; 15544 if ("TestScript".equals(codeString)) 15545 return TESTSCRIPT; 15546 if ("Transport".equals(codeString)) 15547 return TRANSPORT; 15548 if ("ValueSet".equals(codeString)) 15549 return VALUESET; 15550 if ("VerificationResult".equals(codeString)) 15551 return VERIFICATIONRESULT; 15552 if ("VisionPrescription".equals(codeString)) 15553 return VISIONPRESCRIPTION; 15554 throw new FHIRException("Unknown ResourceTypeEnum code '"+codeString+"'"); 15555 } 15556 public static boolean isValidCode(String codeString) { 15557 if (codeString == null || "".equals(codeString)) 15558 return false; 15559 return Utilities.existsInList(codeString, "Account", "ActivityDefinition", "ActorDefinition", "AdministrableProductDefinition", "AdverseEvent", "AllergyIntolerance", "Appointment", "AppointmentResponse", "ArtifactAssessment", "AuditEvent", "Basic", "Binary", "BiologicallyDerivedProduct", "BiologicallyDerivedProductDispense", "BodyStructure", "Bundle", "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", "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", "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", "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"); 15560 } 15561 public String toCode() { 15562 switch (this) { 15563 case ACCOUNT: return "Account"; 15564 case ACTIVITYDEFINITION: return "ActivityDefinition"; 15565 case ACTORDEFINITION: return "ActorDefinition"; 15566 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 15567 case ADVERSEEVENT: return "AdverseEvent"; 15568 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 15569 case APPOINTMENT: return "Appointment"; 15570 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 15571 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 15572 case AUDITEVENT: return "AuditEvent"; 15573 case BASIC: return "Basic"; 15574 case BINARY: return "Binary"; 15575 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 15576 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "BiologicallyDerivedProductDispense"; 15577 case BODYSTRUCTURE: return "BodyStructure"; 15578 case BUNDLE: return "Bundle"; 15579 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 15580 case CAREPLAN: return "CarePlan"; 15581 case CARETEAM: return "CareTeam"; 15582 case CHARGEITEM: return "ChargeItem"; 15583 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 15584 case CITATION: return "Citation"; 15585 case CLAIM: return "Claim"; 15586 case CLAIMRESPONSE: return "ClaimResponse"; 15587 case CLINICALIMPRESSION: return "ClinicalImpression"; 15588 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 15589 case CODESYSTEM: return "CodeSystem"; 15590 case COMMUNICATION: return "Communication"; 15591 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 15592 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 15593 case COMPOSITION: return "Composition"; 15594 case CONCEPTMAP: return "ConceptMap"; 15595 case CONDITION: return "Condition"; 15596 case CONDITIONDEFINITION: return "ConditionDefinition"; 15597 case CONSENT: return "Consent"; 15598 case CONTRACT: return "Contract"; 15599 case COVERAGE: return "Coverage"; 15600 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 15601 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 15602 case DETECTEDISSUE: return "DetectedIssue"; 15603 case DEVICE: return "Device"; 15604 case DEVICEASSOCIATION: return "DeviceAssociation"; 15605 case DEVICEDEFINITION: return "DeviceDefinition"; 15606 case DEVICEDISPENSE: return "DeviceDispense"; 15607 case DEVICEMETRIC: return "DeviceMetric"; 15608 case DEVICEREQUEST: return "DeviceRequest"; 15609 case DEVICEUSAGE: return "DeviceUsage"; 15610 case DIAGNOSTICREPORT: return "DiagnosticReport"; 15611 case DOCUMENTREFERENCE: return "DocumentReference"; 15612 case ENCOUNTER: return "Encounter"; 15613 case ENCOUNTERHISTORY: return "EncounterHistory"; 15614 case ENDPOINT: return "Endpoint"; 15615 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 15616 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 15617 case EPISODEOFCARE: return "EpisodeOfCare"; 15618 case EVENTDEFINITION: return "EventDefinition"; 15619 case EVIDENCE: return "Evidence"; 15620 case EVIDENCEREPORT: return "EvidenceReport"; 15621 case EVIDENCEVARIABLE: return "EvidenceVariable"; 15622 case EXAMPLESCENARIO: return "ExampleScenario"; 15623 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 15624 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 15625 case FLAG: return "Flag"; 15626 case FORMULARYITEM: return "FormularyItem"; 15627 case GENOMICSTUDY: return "GenomicStudy"; 15628 case GOAL: return "Goal"; 15629 case GRAPHDEFINITION: return "GraphDefinition"; 15630 case GROUP: return "Group"; 15631 case GUIDANCERESPONSE: return "GuidanceResponse"; 15632 case HEALTHCARESERVICE: return "HealthcareService"; 15633 case IMAGINGSELECTION: return "ImagingSelection"; 15634 case IMAGINGSTUDY: return "ImagingStudy"; 15635 case IMMUNIZATION: return "Immunization"; 15636 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 15637 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 15638 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 15639 case INGREDIENT: return "Ingredient"; 15640 case INSURANCEPLAN: return "InsurancePlan"; 15641 case INVENTORYITEM: return "InventoryItem"; 15642 case INVENTORYREPORT: return "InventoryReport"; 15643 case INVOICE: return "Invoice"; 15644 case LIBRARY: return "Library"; 15645 case LINKAGE: return "Linkage"; 15646 case LIST: return "List"; 15647 case LOCATION: return "Location"; 15648 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 15649 case MEASURE: return "Measure"; 15650 case MEASUREREPORT: return "MeasureReport"; 15651 case MEDICATION: return "Medication"; 15652 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 15653 case MEDICATIONDISPENSE: return "MedicationDispense"; 15654 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 15655 case MEDICATIONREQUEST: return "MedicationRequest"; 15656 case MEDICATIONSTATEMENT: return "MedicationStatement"; 15657 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 15658 case MESSAGEDEFINITION: return "MessageDefinition"; 15659 case MESSAGEHEADER: return "MessageHeader"; 15660 case MOLECULARSEQUENCE: return "MolecularSequence"; 15661 case NAMINGSYSTEM: return "NamingSystem"; 15662 case NUTRITIONINTAKE: return "NutritionIntake"; 15663 case NUTRITIONORDER: return "NutritionOrder"; 15664 case NUTRITIONPRODUCT: return "NutritionProduct"; 15665 case OBSERVATION: return "Observation"; 15666 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 15667 case OPERATIONDEFINITION: return "OperationDefinition"; 15668 case OPERATIONOUTCOME: return "OperationOutcome"; 15669 case ORGANIZATION: return "Organization"; 15670 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 15671 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 15672 case PARAMETERS: return "Parameters"; 15673 case PATIENT: return "Patient"; 15674 case PAYMENTNOTICE: return "PaymentNotice"; 15675 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 15676 case PERMISSION: return "Permission"; 15677 case PERSON: return "Person"; 15678 case PLANDEFINITION: return "PlanDefinition"; 15679 case PRACTITIONER: return "Practitioner"; 15680 case PRACTITIONERROLE: return "PractitionerRole"; 15681 case PROCEDURE: return "Procedure"; 15682 case PROVENANCE: return "Provenance"; 15683 case QUESTIONNAIRE: return "Questionnaire"; 15684 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 15685 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 15686 case RELATEDPERSON: return "RelatedPerson"; 15687 case REQUESTORCHESTRATION: return "RequestOrchestration"; 15688 case REQUIREMENTS: return "Requirements"; 15689 case RESEARCHSTUDY: return "ResearchStudy"; 15690 case RESEARCHSUBJECT: return "ResearchSubject"; 15691 case RISKASSESSMENT: return "RiskAssessment"; 15692 case SCHEDULE: return "Schedule"; 15693 case SEARCHPARAMETER: return "SearchParameter"; 15694 case SERVICEREQUEST: return "ServiceRequest"; 15695 case SLOT: return "Slot"; 15696 case SPECIMEN: return "Specimen"; 15697 case SPECIMENDEFINITION: return "SpecimenDefinition"; 15698 case STRUCTUREDEFINITION: return "StructureDefinition"; 15699 case STRUCTUREMAP: return "StructureMap"; 15700 case SUBSCRIPTION: return "Subscription"; 15701 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 15702 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 15703 case SUBSTANCE: return "Substance"; 15704 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 15705 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 15706 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 15707 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 15708 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 15709 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 15710 case SUPPLYDELIVERY: return "SupplyDelivery"; 15711 case SUPPLYREQUEST: return "SupplyRequest"; 15712 case TASK: return "Task"; 15713 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 15714 case TESTPLAN: return "TestPlan"; 15715 case TESTREPORT: return "TestReport"; 15716 case TESTSCRIPT: return "TestScript"; 15717 case TRANSPORT: return "Transport"; 15718 case VALUESET: return "ValueSet"; 15719 case VERIFICATIONRESULT: return "VerificationResult"; 15720 case VISIONPRESCRIPTION: return "VisionPrescription"; 15721 case NULL: return null; 15722 default: return "?"; 15723 } 15724 } 15725 public String getSystem() { 15726 switch (this) { 15727 case ACCOUNT: return "http://hl7.org/fhir/fhir-types"; 15728 case ACTIVITYDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15729 case ACTORDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15730 case ADMINISTRABLEPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15731 case ADVERSEEVENT: return "http://hl7.org/fhir/fhir-types"; 15732 case ALLERGYINTOLERANCE: return "http://hl7.org/fhir/fhir-types"; 15733 case APPOINTMENT: return "http://hl7.org/fhir/fhir-types"; 15734 case APPOINTMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 15735 case ARTIFACTASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 15736 case AUDITEVENT: return "http://hl7.org/fhir/fhir-types"; 15737 case BASIC: return "http://hl7.org/fhir/fhir-types"; 15738 case BINARY: return "http://hl7.org/fhir/fhir-types"; 15739 case BIOLOGICALLYDERIVEDPRODUCT: return "http://hl7.org/fhir/fhir-types"; 15740 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "http://hl7.org/fhir/fhir-types"; 15741 case BODYSTRUCTURE: return "http://hl7.org/fhir/fhir-types"; 15742 case BUNDLE: return "http://hl7.org/fhir/fhir-types"; 15743 case CAPABILITYSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 15744 case CAREPLAN: return "http://hl7.org/fhir/fhir-types"; 15745 case CARETEAM: return "http://hl7.org/fhir/fhir-types"; 15746 case CHARGEITEM: return "http://hl7.org/fhir/fhir-types"; 15747 case CHARGEITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15748 case CITATION: return "http://hl7.org/fhir/fhir-types"; 15749 case CLAIM: return "http://hl7.org/fhir/fhir-types"; 15750 case CLAIMRESPONSE: return "http://hl7.org/fhir/fhir-types"; 15751 case CLINICALIMPRESSION: return "http://hl7.org/fhir/fhir-types"; 15752 case CLINICALUSEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15753 case CODESYSTEM: return "http://hl7.org/fhir/fhir-types"; 15754 case COMMUNICATION: return "http://hl7.org/fhir/fhir-types"; 15755 case COMMUNICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 15756 case COMPARTMENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15757 case COMPOSITION: return "http://hl7.org/fhir/fhir-types"; 15758 case CONCEPTMAP: return "http://hl7.org/fhir/fhir-types"; 15759 case CONDITION: return "http://hl7.org/fhir/fhir-types"; 15760 case CONDITIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15761 case CONSENT: return "http://hl7.org/fhir/fhir-types"; 15762 case CONTRACT: return "http://hl7.org/fhir/fhir-types"; 15763 case COVERAGE: return "http://hl7.org/fhir/fhir-types"; 15764 case COVERAGEELIGIBILITYREQUEST: return "http://hl7.org/fhir/fhir-types"; 15765 case COVERAGEELIGIBILITYRESPONSE: return "http://hl7.org/fhir/fhir-types"; 15766 case DETECTEDISSUE: return "http://hl7.org/fhir/fhir-types"; 15767 case DEVICE: return "http://hl7.org/fhir/fhir-types"; 15768 case DEVICEASSOCIATION: return "http://hl7.org/fhir/fhir-types"; 15769 case DEVICEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15770 case DEVICEDISPENSE: return "http://hl7.org/fhir/fhir-types"; 15771 case DEVICEMETRIC: return "http://hl7.org/fhir/fhir-types"; 15772 case DEVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 15773 case DEVICEUSAGE: return "http://hl7.org/fhir/fhir-types"; 15774 case DIAGNOSTICREPORT: return "http://hl7.org/fhir/fhir-types"; 15775 case DOCUMENTREFERENCE: return "http://hl7.org/fhir/fhir-types"; 15776 case ENCOUNTER: return "http://hl7.org/fhir/fhir-types"; 15777 case ENCOUNTERHISTORY: return "http://hl7.org/fhir/fhir-types"; 15778 case ENDPOINT: return "http://hl7.org/fhir/fhir-types"; 15779 case ENROLLMENTREQUEST: return "http://hl7.org/fhir/fhir-types"; 15780 case ENROLLMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 15781 case EPISODEOFCARE: return "http://hl7.org/fhir/fhir-types"; 15782 case EVENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15783 case EVIDENCE: return "http://hl7.org/fhir/fhir-types"; 15784 case EVIDENCEREPORT: return "http://hl7.org/fhir/fhir-types"; 15785 case EVIDENCEVARIABLE: return "http://hl7.org/fhir/fhir-types"; 15786 case EXAMPLESCENARIO: return "http://hl7.org/fhir/fhir-types"; 15787 case EXPLANATIONOFBENEFIT: return "http://hl7.org/fhir/fhir-types"; 15788 case FAMILYMEMBERHISTORY: return "http://hl7.org/fhir/fhir-types"; 15789 case FLAG: return "http://hl7.org/fhir/fhir-types"; 15790 case FORMULARYITEM: return "http://hl7.org/fhir/fhir-types"; 15791 case GENOMICSTUDY: return "http://hl7.org/fhir/fhir-types"; 15792 case GOAL: return "http://hl7.org/fhir/fhir-types"; 15793 case GRAPHDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15794 case GROUP: return "http://hl7.org/fhir/fhir-types"; 15795 case GUIDANCERESPONSE: return "http://hl7.org/fhir/fhir-types"; 15796 case HEALTHCARESERVICE: return "http://hl7.org/fhir/fhir-types"; 15797 case IMAGINGSELECTION: return "http://hl7.org/fhir/fhir-types"; 15798 case IMAGINGSTUDY: return "http://hl7.org/fhir/fhir-types"; 15799 case IMMUNIZATION: return "http://hl7.org/fhir/fhir-types"; 15800 case IMMUNIZATIONEVALUATION: return "http://hl7.org/fhir/fhir-types"; 15801 case IMMUNIZATIONRECOMMENDATION: return "http://hl7.org/fhir/fhir-types"; 15802 case IMPLEMENTATIONGUIDE: return "http://hl7.org/fhir/fhir-types"; 15803 case INGREDIENT: return "http://hl7.org/fhir/fhir-types"; 15804 case INSURANCEPLAN: return "http://hl7.org/fhir/fhir-types"; 15805 case INVENTORYITEM: return "http://hl7.org/fhir/fhir-types"; 15806 case INVENTORYREPORT: return "http://hl7.org/fhir/fhir-types"; 15807 case INVOICE: return "http://hl7.org/fhir/fhir-types"; 15808 case LIBRARY: return "http://hl7.org/fhir/fhir-types"; 15809 case LINKAGE: return "http://hl7.org/fhir/fhir-types"; 15810 case LIST: return "http://hl7.org/fhir/fhir-types"; 15811 case LOCATION: return "http://hl7.org/fhir/fhir-types"; 15812 case MANUFACTUREDITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15813 case MEASURE: return "http://hl7.org/fhir/fhir-types"; 15814 case MEASUREREPORT: return "http://hl7.org/fhir/fhir-types"; 15815 case MEDICATION: return "http://hl7.org/fhir/fhir-types"; 15816 case MEDICATIONADMINISTRATION: return "http://hl7.org/fhir/fhir-types"; 15817 case MEDICATIONDISPENSE: return "http://hl7.org/fhir/fhir-types"; 15818 case MEDICATIONKNOWLEDGE: return "http://hl7.org/fhir/fhir-types"; 15819 case MEDICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 15820 case MEDICATIONSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 15821 case MEDICINALPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15822 case MESSAGEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15823 case MESSAGEHEADER: return "http://hl7.org/fhir/fhir-types"; 15824 case MOLECULARSEQUENCE: return "http://hl7.org/fhir/fhir-types"; 15825 case NAMINGSYSTEM: return "http://hl7.org/fhir/fhir-types"; 15826 case NUTRITIONINTAKE: return "http://hl7.org/fhir/fhir-types"; 15827 case NUTRITIONORDER: return "http://hl7.org/fhir/fhir-types"; 15828 case NUTRITIONPRODUCT: return "http://hl7.org/fhir/fhir-types"; 15829 case OBSERVATION: return "http://hl7.org/fhir/fhir-types"; 15830 case OBSERVATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15831 case OPERATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15832 case OPERATIONOUTCOME: return "http://hl7.org/fhir/fhir-types"; 15833 case ORGANIZATION: return "http://hl7.org/fhir/fhir-types"; 15834 case ORGANIZATIONAFFILIATION: return "http://hl7.org/fhir/fhir-types"; 15835 case PACKAGEDPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15836 case PARAMETERS: return "http://hl7.org/fhir/fhir-types"; 15837 case PATIENT: return "http://hl7.org/fhir/fhir-types"; 15838 case PAYMENTNOTICE: return "http://hl7.org/fhir/fhir-types"; 15839 case PAYMENTRECONCILIATION: return "http://hl7.org/fhir/fhir-types"; 15840 case PERMISSION: return "http://hl7.org/fhir/fhir-types"; 15841 case PERSON: return "http://hl7.org/fhir/fhir-types"; 15842 case PLANDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15843 case PRACTITIONER: return "http://hl7.org/fhir/fhir-types"; 15844 case PRACTITIONERROLE: return "http://hl7.org/fhir/fhir-types"; 15845 case PROCEDURE: return "http://hl7.org/fhir/fhir-types"; 15846 case PROVENANCE: return "http://hl7.org/fhir/fhir-types"; 15847 case QUESTIONNAIRE: return "http://hl7.org/fhir/fhir-types"; 15848 case QUESTIONNAIRERESPONSE: return "http://hl7.org/fhir/fhir-types"; 15849 case REGULATEDAUTHORIZATION: return "http://hl7.org/fhir/fhir-types"; 15850 case RELATEDPERSON: return "http://hl7.org/fhir/fhir-types"; 15851 case REQUESTORCHESTRATION: return "http://hl7.org/fhir/fhir-types"; 15852 case REQUIREMENTS: return "http://hl7.org/fhir/fhir-types"; 15853 case RESEARCHSTUDY: return "http://hl7.org/fhir/fhir-types"; 15854 case RESEARCHSUBJECT: return "http://hl7.org/fhir/fhir-types"; 15855 case RISKASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 15856 case SCHEDULE: return "http://hl7.org/fhir/fhir-types"; 15857 case SEARCHPARAMETER: return "http://hl7.org/fhir/fhir-types"; 15858 case SERVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 15859 case SLOT: return "http://hl7.org/fhir/fhir-types"; 15860 case SPECIMEN: return "http://hl7.org/fhir/fhir-types"; 15861 case SPECIMENDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15862 case STRUCTUREDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15863 case STRUCTUREMAP: return "http://hl7.org/fhir/fhir-types"; 15864 case SUBSCRIPTION: return "http://hl7.org/fhir/fhir-types"; 15865 case SUBSCRIPTIONSTATUS: return "http://hl7.org/fhir/fhir-types"; 15866 case SUBSCRIPTIONTOPIC: return "http://hl7.org/fhir/fhir-types"; 15867 case SUBSTANCE: return "http://hl7.org/fhir/fhir-types"; 15868 case SUBSTANCEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15869 case SUBSTANCENUCLEICACID: return "http://hl7.org/fhir/fhir-types"; 15870 case SUBSTANCEPOLYMER: return "http://hl7.org/fhir/fhir-types"; 15871 case SUBSTANCEPROTEIN: return "http://hl7.org/fhir/fhir-types"; 15872 case SUBSTANCEREFERENCEINFORMATION: return "http://hl7.org/fhir/fhir-types"; 15873 case SUBSTANCESOURCEMATERIAL: return "http://hl7.org/fhir/fhir-types"; 15874 case SUPPLYDELIVERY: return "http://hl7.org/fhir/fhir-types"; 15875 case SUPPLYREQUEST: return "http://hl7.org/fhir/fhir-types"; 15876 case TASK: return "http://hl7.org/fhir/fhir-types"; 15877 case TERMINOLOGYCAPABILITIES: return "http://hl7.org/fhir/fhir-types"; 15878 case TESTPLAN: return "http://hl7.org/fhir/fhir-types"; 15879 case TESTREPORT: return "http://hl7.org/fhir/fhir-types"; 15880 case TESTSCRIPT: return "http://hl7.org/fhir/fhir-types"; 15881 case TRANSPORT: return "http://hl7.org/fhir/fhir-types"; 15882 case VALUESET: return "http://hl7.org/fhir/fhir-types"; 15883 case VERIFICATIONRESULT: return "http://hl7.org/fhir/fhir-types"; 15884 case VISIONPRESCRIPTION: return "http://hl7.org/fhir/fhir-types"; 15885 case NULL: return null; 15886 default: return "?"; 15887 } 15888 } 15889 public String getDefinition() { 15890 switch (this) { 15891 case ACCOUNT: return "A financial tool for tracking value accrued for a particular purpose. In the healthcare field, used to track charges for a patient, cost centers, etc."; 15892 case ACTIVITYDEFINITION: return "This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context."; 15893 case ACTORDEFINITION: return "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."; 15894 case ADMINISTRABLEPRODUCTDEFINITION: return "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)."; 15895 case ADVERSEEVENT: return "An event (i.e. any change to current patient status) that may be related to unintended effects on a patient or research 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."; 15896 case ALLERGYINTOLERANCE: return "Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance."; 15897 case APPOINTMENT: return "A booking of a healthcare event among patient(s), practitioner(s), related person(s) and/or device(s) for a specific date/time. This may result in one or more Encounter(s)."; 15898 case APPOINTMENTRESPONSE: return "A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection."; 15899 case ARTIFACTASSESSMENT: return "This Resource provides one or more comments, classifiers or ratings about a Resource and supports attribution and rights management metadata for the added content."; 15900 case AUDITEVENT: return "A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis."; 15901 case BASIC: return "Basic is used for handling concepts not yet defined in FHIR, narrative-only resources that don't map to an existing resource, and custom resources not appropriate for inclusion in the FHIR specification."; 15902 case BINARY: return "A resource that represents the data of a single raw artifact as digital content accessible in its native format. A Binary resource can contain any content, whether text, image, pdf, zip archive, etc."; 15903 case BIOLOGICALLYDERIVEDPRODUCT: return "A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity."; 15904 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "A record of dispensation of a biologically derived product."; 15905 case BODYSTRUCTURE: return "Record details about an anatomical structure. This resource may be used when a coded concept does not provide the necessary detail needed for the use case."; 15906 case BUNDLE: return "A container for a collection of resources."; 15907 case CAPABILITYSTATEMENT: return "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."; 15908 case CAREPLAN: return "Describes the intention of how one or more practitioners intend to deliver care for a particular patient, group or community for a period of time, possibly limited to care for a specific condition or set of conditions."; 15909 case CARETEAM: return "The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care."; 15910 case CHARGEITEM: return "The resource ChargeItem describes the provision of healthcare provider products for a certain patient, therefore referring not only to the product, but containing in addition details of the provision, like date, time, amounts and participating organizations and persons. Main Usage of the ChargeItem is to enable the billing process and internal cost allocation."; 15911 case CHARGEITEMDEFINITION: return "The ChargeItemDefinition resource provides the properties that apply to the (billing) codes necessary to calculate costs and prices. The properties may differ largely depending on type and realm, therefore this resource gives only a rough structure and requires profiling for each type of billing code system."; 15912 case CITATION: return "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."; 15913 case CLAIM: return "A provider issued list of professional services and products which have been provided, or are to be provided, to a patient which is sent to an insurer for reimbursement."; 15914 case CLAIMRESPONSE: return "This resource provides the adjudication details from the processing of a Claim resource."; 15915 case CLINICALIMPRESSION: return "A record of a clinical assessment performed to determine what problem(s) may affect the patient and before planning the treatments or management strategies that are best to manage a patient's condition. Assessments are often 1:1 with a clinical consultation / encounter, but this varies greatly depending on the clinical workflow. This resource is called \"ClinicalImpression\" rather than \"ClinicalAssessment\" to avoid confusion with the recording of assessment tools such as Apgar score."; 15916 case CLINICALUSEDEFINITION: return "A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure."; 15917 case CODESYSTEM: return "The CodeSystem resource is used to declare the existence of and describe a code system or code system supplement and its key properties, and optionally define a part or all of its content."; 15918 case COMMUNICATION: return "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."; 15919 case COMMUNICATIONREQUEST: return "A request to convey information; e.g. the CDS system proposes that an alert be sent to a responsible provider, the CDS system proposes that the public health agency be notified about a reportable condition."; 15920 case COMPARTMENTDEFINITION: return "A compartment definition that defines how resources are accessed on a server."; 15921 case COMPOSITION: return "A set of healthcare-related information that is assembled together into a single logical package that provides a single coherent statement of meaning, establishes its own context and that has clinical attestation with regard to who is making the statement. A Composition defines the structure and narrative content necessary for a document. However, a Composition alone does not constitute a document. Rather, the Composition must be the first entry in a Bundle where Bundle.type=document, and any other resources referenced from Composition must be included as subsequent entries in the Bundle (for example Patient, Practitioner, Encounter, etc.)."; 15922 case CONCEPTMAP: return "A statement of relationships from one set of concepts to one or more other concepts - either concepts in code systems, or data element/data element concepts, or classes in class models."; 15923 case CONDITION: return "A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern."; 15924 case CONDITIONDEFINITION: return "A definition of a condition and information relevant to managing it."; 15925 case CONSENT: return "A record of a healthcare consumer?s choices or choices made on their behalf by a third party, which permits or denies identified recipient(s) or recipient role(s) to perform one or more actions within a given policy context, for specific purposes and periods of time."; 15926 case CONTRACT: return "Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement."; 15927 case COVERAGE: return "Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment."; 15928 case COVERAGEELIGIBILITYREQUEST: return "The CoverageEligibilityRequest provides patient and insurance coverage information to an insurer for them to respond, in the form of an CoverageEligibilityResponse, with information regarding whether the stated coverage is valid and in-force and optionally to provide the insurance details of the policy."; 15929 case COVERAGEELIGIBILITYRESPONSE: return "This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource."; 15930 case DETECTEDISSUE: return "Indicates an actual or potential clinical issue with or between one or more active or proposed clinical actions for a patient; e.g. Drug-drug interaction, Ineffective treatment frequency, Procedure-condition conflict, gaps in care, etc."; 15931 case DEVICE: return "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."; 15932 case DEVICEASSOCIATION: return "A record of association of a device."; 15933 case DEVICEDEFINITION: return "This is a specialized resource that defines the characteristics and capabilities of a device."; 15934 case DEVICEDISPENSE: return "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."; 15935 case DEVICEMETRIC: return "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. "; 15936 case DEVICEREQUEST: return "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."; 15937 case DEVICEUSAGE: return "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."; 15938 case DIAGNOSTICREPORT: return "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."; 15939 case DOCUMENTREFERENCE: return "A reference to a document of any kind for any purpose. While the term ?document? implies a more narrow focus, for this resource this ?document? encompasses *any* serialized object with a mime-type, it includes formal patient-centric documents (CDA), clinical notes, scanned paper, non-patient specific documents like policy text, as well as a photo, video, or audio recording acquired or used in healthcare. The DocumentReference resource provides metadata about the document so that the document can be discovered and managed. The actual content may be inline base64 encoded data or provided by direct reference."; 15940 case ENCOUNTER: return "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)."; 15941 case ENCOUNTERHISTORY: return "A record of significant events/milestones key data throughout the history of an Encounter"; 15942 case ENDPOINT: return "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."; 15943 case ENROLLMENTREQUEST: return "This resource provides the insurance enrollment details to the insurer regarding a specified coverage."; 15944 case ENROLLMENTRESPONSE: return "This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource."; 15945 case EPISODEOFCARE: return "An association between a patient and an organization / healthcare provider(s) during which time encounters may occur. The managing organization assumes a level of responsibility for the patient during this time."; 15946 case EVENTDEFINITION: return "The EventDefinition resource provides a reusable description of when a particular event can occur."; 15947 case EVIDENCE: return "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."; 15948 case EVIDENCEREPORT: return "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."; 15949 case EVIDENCEVARIABLE: return "The EvidenceVariable resource describes an element that knowledge (Evidence) is about."; 15950 case EXAMPLESCENARIO: return "A walkthrough of a workflow showing the interaction between systems and the instances shared, possibly including the evolution of instances over time."; 15951 case EXPLANATIONOFBENEFIT: return "This resource provides: the claim details; adjudication details from the processing of a Claim; and optionally account balance information, for informing the subscriber of the benefits provided."; 15952 case FAMILYMEMBERHISTORY: return "Significant health conditions for a person related to the patient relevant in the context of care for the patient."; 15953 case FLAG: return "Prospective warnings of potential issues when providing care to the patient."; 15954 case FORMULARYITEM: return "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."; 15955 case GENOMICSTUDY: return "A set of analyses performed to analyze and generate genomic data."; 15956 case GOAL: return "Describes the intended objective(s) for a patient, group or organization care, for example, weight loss, restoring an activity of daily living, obtaining herd immunity via immunization, meeting a process improvement objective, etc."; 15957 case GRAPHDEFINITION: return "A formal computable definition of a graph of resources - that is, a coherent set of resources that form a graph by following references. The Graph Definition resource defines a set and makes rules about the set."; 15958 case GROUP: return "Represents a defined collection of entities that may be discussed or acted upon collectively but which are not expected to act collectively, and are not formally or legally recognized; i.e. a collection of entities that isn't an Organization."; 15959 case GUIDANCERESPONSE: return "A guidance response is the formal response to a guidance request, including any output parameters returned by the evaluation, as well as the description of any proposed actions to be taken."; 15960 case HEALTHCARESERVICE: return "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."; 15961 case IMAGINGSELECTION: return "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."; 15962 case IMAGINGSTUDY: return "Representation of the content produced in a DICOM imaging study. A study comprises a set of series, each of which includes a set of Service-Object Pair Instances (SOP Instances - images or other data) acquired or produced in a common context. A series is of only one modality (e.g. X-ray, CT, MR, ultrasound), but a study may have multiple series of different modalities."; 15963 case IMMUNIZATION: return "Describes the event of a patient being administered a vaccine or a record of an immunization as reported by a patient, a clinician or another party."; 15964 case IMMUNIZATIONEVALUATION: return "Describes a comparison of an immunization event against published recommendations to determine if the administration is \"valid\" in relation to those recommendations."; 15965 case IMMUNIZATIONRECOMMENDATION: return "A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification."; 15966 case IMPLEMENTATIONGUIDE: return "A set of rules of how a particular interoperability or standards problem is solved - typically through the use of FHIR resources. This resource is used to gather all the parts of an implementation guide into a logical whole and to publish a computable definition of all the parts."; 15967 case INGREDIENT: return "An ingredient of a manufactured item or pharmaceutical product."; 15968 case INSURANCEPLAN: return "Details of a Health Insurance product/plan provided by an organization."; 15969 case INVENTORYITEM: return "functional description of an inventory item used in inventory and supply-related workflows."; 15970 case INVENTORYREPORT: return "A report of inventory or stock items."; 15971 case INVOICE: return "Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose."; 15972 case LIBRARY: return "The Library resource is a general-purpose container for knowledge asset definitions. It can be used to describe and expose existing knowledge assets such as logic libraries and information model descriptions, as well as to describe a collection of knowledge assets."; 15973 case LINKAGE: return "Identifies two or more records (resource instances) that refer to the same real-world \"occurrence\"."; 15974 case LIST: return "A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc."; 15975 case LOCATION: return "Details and position information for a place where services are provided and resources and participants may be stored, found, contained, or accommodated."; 15976 case MANUFACTUREDITEMDEFINITION: return "The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product."; 15977 case MEASURE: return "The Measure resource provides the definition of a quality measure."; 15978 case MEASUREREPORT: return "The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation."; 15979 case MEDICATION: return "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."; 15980 case MEDICATIONADMINISTRATION: return "Describes the event of a patient consuming or otherwise being administered a medication. This may be as simple as swallowing a tablet or it may be a long running infusion. Related resources tie this event to the authorizing prescription, and the specific encounter between patient and health care practitioner. This event can also be used to record waste using a status of not-done and the appropriate statusReason."; 15981 case MEDICATIONDISPENSE: return "Indicates that a medication product is to be or has been dispensed for a named person/patient. This includes a description of the medication product (supply) provided and the instructions for administering the medication. The medication dispense is the result of a pharmacy system responding to a medication order."; 15982 case MEDICATIONKNOWLEDGE: return "Information about a medication that is used to support knowledge."; 15983 case MEDICATIONREQUEST: return "An order or request for both supply of the medication and the instructions for administration of the medication to a patient. The resource is called \"MedicationRequest\" rather than \"MedicationPrescription\" or \"MedicationOrder\" to generalize the use across inpatient and outpatient settings, including care plans, etc., and to harmonize with workflow patterns."; 15984 case MEDICATIONSTATEMENT: return "A record of a medication that is being consumed by a patient. A MedicationStatement may indicate that the patient may be taking the medication now or has taken the medication in the past or will be taking the medication in the future. The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician. A common scenario where this information is captured is during the history taking process during a patient visit or stay. The medication information may come from sources such as the patient's memory, from a prescription bottle, or from a list of medications the patient, clinician or other party maintains. \n\nThe primary difference between a 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."; 15985 case MEDICINALPRODUCTDEFINITION: return "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.)."; 15986 case MESSAGEDEFINITION: return "Defines the characteristics of a message that can be shared between systems, including the type of event that initiates the message, the content to be transmitted and what response(s), if any, are permitted."; 15987 case MESSAGEHEADER: return "The header for a message exchange that is either requesting or responding to an action. The reference(s) that are the subject of the action as well as other information related to the action are typically transmitted in a bundle in which the MessageHeader resource instance is the first resource in the bundle."; 15988 case MOLECULARSEQUENCE: return "Representation of a molecular sequence."; 15989 case NAMINGSYSTEM: return "A curated namespace that issues unique symbols within that namespace for the identification of concepts, people, devices, etc. Represents a \"System\" used within the Identifier and Coding data types."; 15990 case NUTRITIONINTAKE: return "A record of food or fluid that is being consumed by a patient. A NutritionIntake may indicate that the patient may be consuming the food or fluid now or has consumed the food or fluid in the past. The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician. A common scenario where this information is captured is during the history taking process during a patient visit or stay or through an app that tracks food or fluids consumed. The consumption information may come from sources such as the patient's memory, from a nutrition label, or from a clinician documenting observed intake."; 15991 case NUTRITIONORDER: return "A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident."; 15992 case NUTRITIONPRODUCT: return "A food or supplement that is consumed by patients."; 15993 case OBSERVATION: return "Measurements and simple assertions made about a patient, device or other subject."; 15994 case OBSERVATIONDEFINITION: return "Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service."; 15995 case OPERATIONDEFINITION: return "A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction)."; 15996 case OPERATIONOUTCOME: return "A collection of error, warning, or information messages that result from a system action."; 15997 case ORGANIZATION: return "A formally or informally recognized grouping of people or organizations formed for the purpose of achieving some form of collective action. Includes companies, institutions, corporations, departments, community groups, healthcare practice groups, payer/insurer, etc."; 15998 case ORGANIZATIONAFFILIATION: return "Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship."; 15999 case PACKAGEDPRODUCTDEFINITION: return "A medically related item or items, in a container or package."; 16000 case PARAMETERS: return "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."; 16001 case PATIENT: return "Demographics and other administrative information about an individual or animal receiving care or other health-related services."; 16002 case PAYMENTNOTICE: return "This resource provides the status of the payment for goods and services rendered, and the request and response resource references."; 16003 case PAYMENTRECONCILIATION: return "This resource provides the details including amount of a payment and allocates the payment items being paid."; 16004 case PERMISSION: return "Permission resource holds access rules for a given data and context."; 16005 case PERSON: return "Demographics and administrative information about a person independent of a specific health-related context."; 16006 case PLANDEFINITION: return "This resource allows for the definition of various types of plans as a sharable, consumable, and executable artifact. The resource is general enough to support the description of a broad range of clinical and non-clinical artifacts such as clinical decision support rules, order sets, protocols, and drug quality specifications."; 16007 case PRACTITIONER: return "A person who is directly or indirectly involved in the provisioning of healthcare or related services."; 16008 case PRACTITIONERROLE: return "A specific set of Roles/Locations/specialties/services that a practitioner may perform, or has performed at an organization during a period of time."; 16009 case PROCEDURE: return "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."; 16010 case PROVENANCE: return "Provenance of a resource is a record that describes entities and processes involved in producing and delivering or otherwise influencing that resource. Provenance provides a critical foundation for assessing authenticity, enabling trust, and allowing reproducibility. Provenance assertions are a form of contextual metadata and can themselves become important records with their own provenance. Provenance statement indicates clinical significance in terms of confidence in authenticity, reliability, and trustworthiness, integrity, and stage in lifecycle (e.g. Document Completion - has the artifact been legally authenticated), all of which may impact security, privacy, and trust policies."; 16011 case QUESTIONNAIRE: return "A structured set of questions intended to guide the collection of answers from end-users. Questionnaires provide detailed control over order, presentation, phraseology and grouping to allow coherent, consistent data collection."; 16012 case QUESTIONNAIRERESPONSE: return "A structured set of questions and their answers. The questions are ordered and grouped into coherent subsets, corresponding to the structure of the grouping of the questionnaire being responded to."; 16013 case REGULATEDAUTHORIZATION: return "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."; 16014 case RELATEDPERSON: return "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."; 16015 case REQUESTORCHESTRATION: return "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\"."; 16016 case REQUIREMENTS: return "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."; 16017 case RESEARCHSTUDY: return "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."; 16018 case RESEARCHSUBJECT: return "A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study."; 16019 case RISKASSESSMENT: return "An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome."; 16020 case SCHEDULE: return "A container for slots of time that may be available for booking appointments."; 16021 case SEARCHPARAMETER: return "A search parameter that defines a named search item that can be used to search/filter on a resource."; 16022 case SERVICEREQUEST: return "A record of a request for service such as diagnostic investigations, treatments, or operations to be performed."; 16023 case SLOT: return "A slot of time on a schedule that may be available for booking appointments."; 16024 case SPECIMEN: return "A sample to be used for analysis."; 16025 case SPECIMENDEFINITION: return "A kind of specimen with associated set of requirements."; 16026 case STRUCTUREDEFINITION: return "A definition of a FHIR structure. This resource is used to describe the underlying resources, data types defined in FHIR, and also for describing extensions and constraints on resources and data types."; 16027 case STRUCTUREMAP: return "A Map of relationships between 2 structures that can be used to transform data."; 16028 case SUBSCRIPTION: return "The subscription resource describes a particular client's request to be notified about a SubscriptionTopic."; 16029 case SUBSCRIPTIONSTATUS: return "The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted."; 16030 case SUBSCRIPTIONTOPIC: return "Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic."; 16031 case SUBSTANCE: return "A homogeneous material with a definite composition."; 16032 case SUBSTANCEDEFINITION: return "The detailed description of a substance, typically at a level beyond what is used for prescribing."; 16033 case SUBSTANCENUCLEICACID: return "Nucleic acids are defined by three distinct elements: the base, sugar and linkage. Individual substance/moiety IDs will be created for each of these elements. The nucleotide sequence will be always entered in the 5?-3? direction."; 16034 case SUBSTANCEPOLYMER: return "Properties of a substance specific to it being a polymer."; 16035 case SUBSTANCEPROTEIN: return "A SubstanceProtein is defined as a single unit of a linear amino acid sequence, or a combination of subunits that are either covalently linked or have a defined invariant stoichiometric relationship. This includes all synthetic, recombinant and purified SubstanceProteins of defined sequence, whether the use is therapeutic or prophylactic. This set of elements will be used to describe albumins, coagulation factors, cytokines, growth factors, peptide/SubstanceProtein hormones, enzymes, toxins, toxoids, recombinant vaccines, and immunomodulators."; 16036 case SUBSTANCEREFERENCEINFORMATION: return "Todo."; 16037 case SUBSTANCESOURCEMATERIAL: return "Source material shall capture information on the taxonomic and anatomical origins as well as the fraction of a material that can result in or can be modified to form a substance. This set of data elements shall be used to define polymer substances isolated from biological matrices. Taxonomic and anatomical origins shall be described using a controlled vocabulary as required. This information is captured for naturally derived polymers ( . starch) and structurally diverse substances. For Organisms belonging to the Kingdom Plantae the Substance level defines the fresh material of a single species or infraspecies, the Herbal Drug and the Herbal preparation. For Herbal preparations, the fraction information will be captured at the Substance information level and additional information for herbal extracts will be captured at the Specified Substance Group 1 information level. See for further explanation the Substance Class: Structurally Diverse and the herbal annex."; 16038 case SUPPLYDELIVERY: return "Record of delivery of what is supplied."; 16039 case SUPPLYREQUEST: return "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."; 16040 case TASK: return "A task to be performed."; 16041 case TERMINOLOGYCAPABILITIES: return "A TerminologyCapabilities resource documents a set of capabilities (behaviors) of a FHIR Terminology Server that may be used as a statement of actual server functionality or a statement of required or desired server implementation."; 16042 case TESTPLAN: return "A plan for executing testing on an artifact or specifications"; 16043 case TESTREPORT: return "A summary of information based on the results of executing a TestScript."; 16044 case TESTSCRIPT: return "A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification."; 16045 case TRANSPORT: return "Record of transport."; 16046 case VALUESET: return "A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html)."; 16047 case VERIFICATIONRESULT: return "Describes validation requirements, source(s), status and dates for one or more elements."; 16048 case VISIONPRESCRIPTION: return "An authorization for the provision of glasses and/or contact lenses to a patient."; 16049 case NULL: return null; 16050 default: return "?"; 16051 } 16052 } 16053 public String getDisplay() { 16054 switch (this) { 16055 case ACCOUNT: return "Account"; 16056 case ACTIVITYDEFINITION: return "ActivityDefinition"; 16057 case ACTORDEFINITION: return "ActorDefinition"; 16058 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 16059 case ADVERSEEVENT: return "AdverseEvent"; 16060 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 16061 case APPOINTMENT: return "Appointment"; 16062 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 16063 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 16064 case AUDITEVENT: return "AuditEvent"; 16065 case BASIC: return "Basic"; 16066 case BINARY: return "Binary"; 16067 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 16068 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "BiologicallyDerivedProductDispense"; 16069 case BODYSTRUCTURE: return "BodyStructure"; 16070 case BUNDLE: return "Bundle"; 16071 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 16072 case CAREPLAN: return "CarePlan"; 16073 case CARETEAM: return "CareTeam"; 16074 case CHARGEITEM: return "ChargeItem"; 16075 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 16076 case CITATION: return "Citation"; 16077 case CLAIM: return "Claim"; 16078 case CLAIMRESPONSE: return "ClaimResponse"; 16079 case CLINICALIMPRESSION: return "ClinicalImpression"; 16080 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 16081 case CODESYSTEM: return "CodeSystem"; 16082 case COMMUNICATION: return "Communication"; 16083 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 16084 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 16085 case COMPOSITION: return "Composition"; 16086 case CONCEPTMAP: return "ConceptMap"; 16087 case CONDITION: return "Condition"; 16088 case CONDITIONDEFINITION: return "ConditionDefinition"; 16089 case CONSENT: return "Consent"; 16090 case CONTRACT: return "Contract"; 16091 case COVERAGE: return "Coverage"; 16092 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 16093 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 16094 case DETECTEDISSUE: return "DetectedIssue"; 16095 case DEVICE: return "Device"; 16096 case DEVICEASSOCIATION: return "DeviceAssociation"; 16097 case DEVICEDEFINITION: return "DeviceDefinition"; 16098 case DEVICEDISPENSE: return "DeviceDispense"; 16099 case DEVICEMETRIC: return "DeviceMetric"; 16100 case DEVICEREQUEST: return "DeviceRequest"; 16101 case DEVICEUSAGE: return "DeviceUsage"; 16102 case DIAGNOSTICREPORT: return "DiagnosticReport"; 16103 case DOCUMENTREFERENCE: return "DocumentReference"; 16104 case ENCOUNTER: return "Encounter"; 16105 case ENCOUNTERHISTORY: return "EncounterHistory"; 16106 case ENDPOINT: return "Endpoint"; 16107 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 16108 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 16109 case EPISODEOFCARE: return "EpisodeOfCare"; 16110 case EVENTDEFINITION: return "EventDefinition"; 16111 case EVIDENCE: return "Evidence"; 16112 case EVIDENCEREPORT: return "EvidenceReport"; 16113 case EVIDENCEVARIABLE: return "EvidenceVariable"; 16114 case EXAMPLESCENARIO: return "ExampleScenario"; 16115 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 16116 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 16117 case FLAG: return "Flag"; 16118 case FORMULARYITEM: return "FormularyItem"; 16119 case GENOMICSTUDY: return "GenomicStudy"; 16120 case GOAL: return "Goal"; 16121 case GRAPHDEFINITION: return "GraphDefinition"; 16122 case GROUP: return "Group"; 16123 case GUIDANCERESPONSE: return "GuidanceResponse"; 16124 case HEALTHCARESERVICE: return "HealthcareService"; 16125 case IMAGINGSELECTION: return "ImagingSelection"; 16126 case IMAGINGSTUDY: return "ImagingStudy"; 16127 case IMMUNIZATION: return "Immunization"; 16128 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 16129 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 16130 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 16131 case INGREDIENT: return "Ingredient"; 16132 case INSURANCEPLAN: return "InsurancePlan"; 16133 case INVENTORYITEM: return "InventoryItem"; 16134 case INVENTORYREPORT: return "InventoryReport"; 16135 case INVOICE: return "Invoice"; 16136 case LIBRARY: return "Library"; 16137 case LINKAGE: return "Linkage"; 16138 case LIST: return "List"; 16139 case LOCATION: return "Location"; 16140 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 16141 case MEASURE: return "Measure"; 16142 case MEASUREREPORT: return "MeasureReport"; 16143 case MEDICATION: return "Medication"; 16144 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 16145 case MEDICATIONDISPENSE: return "MedicationDispense"; 16146 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 16147 case MEDICATIONREQUEST: return "MedicationRequest"; 16148 case MEDICATIONSTATEMENT: return "MedicationStatement"; 16149 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 16150 case MESSAGEDEFINITION: return "MessageDefinition"; 16151 case MESSAGEHEADER: return "MessageHeader"; 16152 case MOLECULARSEQUENCE: return "MolecularSequence"; 16153 case NAMINGSYSTEM: return "NamingSystem"; 16154 case NUTRITIONINTAKE: return "NutritionIntake"; 16155 case NUTRITIONORDER: return "NutritionOrder"; 16156 case NUTRITIONPRODUCT: return "NutritionProduct"; 16157 case OBSERVATION: return "Observation"; 16158 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 16159 case OPERATIONDEFINITION: return "OperationDefinition"; 16160 case OPERATIONOUTCOME: return "OperationOutcome"; 16161 case ORGANIZATION: return "Organization"; 16162 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 16163 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 16164 case PARAMETERS: return "Parameters"; 16165 case PATIENT: return "Patient"; 16166 case PAYMENTNOTICE: return "PaymentNotice"; 16167 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 16168 case PERMISSION: return "Permission"; 16169 case PERSON: return "Person"; 16170 case PLANDEFINITION: return "PlanDefinition"; 16171 case PRACTITIONER: return "Practitioner"; 16172 case PRACTITIONERROLE: return "PractitionerRole"; 16173 case PROCEDURE: return "Procedure"; 16174 case PROVENANCE: return "Provenance"; 16175 case QUESTIONNAIRE: return "Questionnaire"; 16176 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 16177 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 16178 case RELATEDPERSON: return "RelatedPerson"; 16179 case REQUESTORCHESTRATION: return "RequestOrchestration"; 16180 case REQUIREMENTS: return "Requirements"; 16181 case RESEARCHSTUDY: return "ResearchStudy"; 16182 case RESEARCHSUBJECT: return "ResearchSubject"; 16183 case RISKASSESSMENT: return "RiskAssessment"; 16184 case SCHEDULE: return "Schedule"; 16185 case SEARCHPARAMETER: return "SearchParameter"; 16186 case SERVICEREQUEST: return "ServiceRequest"; 16187 case SLOT: return "Slot"; 16188 case SPECIMEN: return "Specimen"; 16189 case SPECIMENDEFINITION: return "SpecimenDefinition"; 16190 case STRUCTUREDEFINITION: return "StructureDefinition"; 16191 case STRUCTUREMAP: return "StructureMap"; 16192 case SUBSCRIPTION: return "Subscription"; 16193 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 16194 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 16195 case SUBSTANCE: return "Substance"; 16196 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 16197 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 16198 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 16199 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 16200 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 16201 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 16202 case SUPPLYDELIVERY: return "SupplyDelivery"; 16203 case SUPPLYREQUEST: return "SupplyRequest"; 16204 case TASK: return "Task"; 16205 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 16206 case TESTPLAN: return "TestPlan"; 16207 case TESTREPORT: return "TestReport"; 16208 case TESTSCRIPT: return "TestScript"; 16209 case TRANSPORT: return "Transport"; 16210 case VALUESET: return "ValueSet"; 16211 case VERIFICATIONRESULT: return "VerificationResult"; 16212 case VISIONPRESCRIPTION: return "VisionPrescription"; 16213 case NULL: return null; 16214 default: return "?"; 16215 } 16216 } 16217 } 16218 16219 public static class ResourceTypeEnumEnumFactory implements EnumFactory<ResourceTypeEnum> { 16220 public ResourceTypeEnum fromCode(String codeString) throws IllegalArgumentException { 16221 if (codeString == null || "".equals(codeString)) 16222 if (codeString == null || "".equals(codeString)) 16223 return null; 16224 if ("Account".equals(codeString)) 16225 return ResourceTypeEnum.ACCOUNT; 16226 if ("ActivityDefinition".equals(codeString)) 16227 return ResourceTypeEnum.ACTIVITYDEFINITION; 16228 if ("ActorDefinition".equals(codeString)) 16229 return ResourceTypeEnum.ACTORDEFINITION; 16230 if ("AdministrableProductDefinition".equals(codeString)) 16231 return ResourceTypeEnum.ADMINISTRABLEPRODUCTDEFINITION; 16232 if ("AdverseEvent".equals(codeString)) 16233 return ResourceTypeEnum.ADVERSEEVENT; 16234 if ("AllergyIntolerance".equals(codeString)) 16235 return ResourceTypeEnum.ALLERGYINTOLERANCE; 16236 if ("Appointment".equals(codeString)) 16237 return ResourceTypeEnum.APPOINTMENT; 16238 if ("AppointmentResponse".equals(codeString)) 16239 return ResourceTypeEnum.APPOINTMENTRESPONSE; 16240 if ("ArtifactAssessment".equals(codeString)) 16241 return ResourceTypeEnum.ARTIFACTASSESSMENT; 16242 if ("AuditEvent".equals(codeString)) 16243 return ResourceTypeEnum.AUDITEVENT; 16244 if ("Basic".equals(codeString)) 16245 return ResourceTypeEnum.BASIC; 16246 if ("Binary".equals(codeString)) 16247 return ResourceTypeEnum.BINARY; 16248 if ("BiologicallyDerivedProduct".equals(codeString)) 16249 return ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCT; 16250 if ("BiologicallyDerivedProductDispense".equals(codeString)) 16251 return ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCTDISPENSE; 16252 if ("BodyStructure".equals(codeString)) 16253 return ResourceTypeEnum.BODYSTRUCTURE; 16254 if ("Bundle".equals(codeString)) 16255 return ResourceTypeEnum.BUNDLE; 16256 if ("CapabilityStatement".equals(codeString)) 16257 return ResourceTypeEnum.CAPABILITYSTATEMENT; 16258 if ("CarePlan".equals(codeString)) 16259 return ResourceTypeEnum.CAREPLAN; 16260 if ("CareTeam".equals(codeString)) 16261 return ResourceTypeEnum.CARETEAM; 16262 if ("ChargeItem".equals(codeString)) 16263 return ResourceTypeEnum.CHARGEITEM; 16264 if ("ChargeItemDefinition".equals(codeString)) 16265 return ResourceTypeEnum.CHARGEITEMDEFINITION; 16266 if ("Citation".equals(codeString)) 16267 return ResourceTypeEnum.CITATION; 16268 if ("Claim".equals(codeString)) 16269 return ResourceTypeEnum.CLAIM; 16270 if ("ClaimResponse".equals(codeString)) 16271 return ResourceTypeEnum.CLAIMRESPONSE; 16272 if ("ClinicalImpression".equals(codeString)) 16273 return ResourceTypeEnum.CLINICALIMPRESSION; 16274 if ("ClinicalUseDefinition".equals(codeString)) 16275 return ResourceTypeEnum.CLINICALUSEDEFINITION; 16276 if ("CodeSystem".equals(codeString)) 16277 return ResourceTypeEnum.CODESYSTEM; 16278 if ("Communication".equals(codeString)) 16279 return ResourceTypeEnum.COMMUNICATION; 16280 if ("CommunicationRequest".equals(codeString)) 16281 return ResourceTypeEnum.COMMUNICATIONREQUEST; 16282 if ("CompartmentDefinition".equals(codeString)) 16283 return ResourceTypeEnum.COMPARTMENTDEFINITION; 16284 if ("Composition".equals(codeString)) 16285 return ResourceTypeEnum.COMPOSITION; 16286 if ("ConceptMap".equals(codeString)) 16287 return ResourceTypeEnum.CONCEPTMAP; 16288 if ("Condition".equals(codeString)) 16289 return ResourceTypeEnum.CONDITION; 16290 if ("ConditionDefinition".equals(codeString)) 16291 return ResourceTypeEnum.CONDITIONDEFINITION; 16292 if ("Consent".equals(codeString)) 16293 return ResourceTypeEnum.CONSENT; 16294 if ("Contract".equals(codeString)) 16295 return ResourceTypeEnum.CONTRACT; 16296 if ("Coverage".equals(codeString)) 16297 return ResourceTypeEnum.COVERAGE; 16298 if ("CoverageEligibilityRequest".equals(codeString)) 16299 return ResourceTypeEnum.COVERAGEELIGIBILITYREQUEST; 16300 if ("CoverageEligibilityResponse".equals(codeString)) 16301 return ResourceTypeEnum.COVERAGEELIGIBILITYRESPONSE; 16302 if ("DetectedIssue".equals(codeString)) 16303 return ResourceTypeEnum.DETECTEDISSUE; 16304 if ("Device".equals(codeString)) 16305 return ResourceTypeEnum.DEVICE; 16306 if ("DeviceAssociation".equals(codeString)) 16307 return ResourceTypeEnum.DEVICEASSOCIATION; 16308 if ("DeviceDefinition".equals(codeString)) 16309 return ResourceTypeEnum.DEVICEDEFINITION; 16310 if ("DeviceDispense".equals(codeString)) 16311 return ResourceTypeEnum.DEVICEDISPENSE; 16312 if ("DeviceMetric".equals(codeString)) 16313 return ResourceTypeEnum.DEVICEMETRIC; 16314 if ("DeviceRequest".equals(codeString)) 16315 return ResourceTypeEnum.DEVICEREQUEST; 16316 if ("DeviceUsage".equals(codeString)) 16317 return ResourceTypeEnum.DEVICEUSAGE; 16318 if ("DiagnosticReport".equals(codeString)) 16319 return ResourceTypeEnum.DIAGNOSTICREPORT; 16320 if ("DocumentReference".equals(codeString)) 16321 return ResourceTypeEnum.DOCUMENTREFERENCE; 16322 if ("Encounter".equals(codeString)) 16323 return ResourceTypeEnum.ENCOUNTER; 16324 if ("EncounterHistory".equals(codeString)) 16325 return ResourceTypeEnum.ENCOUNTERHISTORY; 16326 if ("Endpoint".equals(codeString)) 16327 return ResourceTypeEnum.ENDPOINT; 16328 if ("EnrollmentRequest".equals(codeString)) 16329 return ResourceTypeEnum.ENROLLMENTREQUEST; 16330 if ("EnrollmentResponse".equals(codeString)) 16331 return ResourceTypeEnum.ENROLLMENTRESPONSE; 16332 if ("EpisodeOfCare".equals(codeString)) 16333 return ResourceTypeEnum.EPISODEOFCARE; 16334 if ("EventDefinition".equals(codeString)) 16335 return ResourceTypeEnum.EVENTDEFINITION; 16336 if ("Evidence".equals(codeString)) 16337 return ResourceTypeEnum.EVIDENCE; 16338 if ("EvidenceReport".equals(codeString)) 16339 return ResourceTypeEnum.EVIDENCEREPORT; 16340 if ("EvidenceVariable".equals(codeString)) 16341 return ResourceTypeEnum.EVIDENCEVARIABLE; 16342 if ("ExampleScenario".equals(codeString)) 16343 return ResourceTypeEnum.EXAMPLESCENARIO; 16344 if ("ExplanationOfBenefit".equals(codeString)) 16345 return ResourceTypeEnum.EXPLANATIONOFBENEFIT; 16346 if ("FamilyMemberHistory".equals(codeString)) 16347 return ResourceTypeEnum.FAMILYMEMBERHISTORY; 16348 if ("Flag".equals(codeString)) 16349 return ResourceTypeEnum.FLAG; 16350 if ("FormularyItem".equals(codeString)) 16351 return ResourceTypeEnum.FORMULARYITEM; 16352 if ("GenomicStudy".equals(codeString)) 16353 return ResourceTypeEnum.GENOMICSTUDY; 16354 if ("Goal".equals(codeString)) 16355 return ResourceTypeEnum.GOAL; 16356 if ("GraphDefinition".equals(codeString)) 16357 return ResourceTypeEnum.GRAPHDEFINITION; 16358 if ("Group".equals(codeString)) 16359 return ResourceTypeEnum.GROUP; 16360 if ("GuidanceResponse".equals(codeString)) 16361 return ResourceTypeEnum.GUIDANCERESPONSE; 16362 if ("HealthcareService".equals(codeString)) 16363 return ResourceTypeEnum.HEALTHCARESERVICE; 16364 if ("ImagingSelection".equals(codeString)) 16365 return ResourceTypeEnum.IMAGINGSELECTION; 16366 if ("ImagingStudy".equals(codeString)) 16367 return ResourceTypeEnum.IMAGINGSTUDY; 16368 if ("Immunization".equals(codeString)) 16369 return ResourceTypeEnum.IMMUNIZATION; 16370 if ("ImmunizationEvaluation".equals(codeString)) 16371 return ResourceTypeEnum.IMMUNIZATIONEVALUATION; 16372 if ("ImmunizationRecommendation".equals(codeString)) 16373 return ResourceTypeEnum.IMMUNIZATIONRECOMMENDATION; 16374 if ("ImplementationGuide".equals(codeString)) 16375 return ResourceTypeEnum.IMPLEMENTATIONGUIDE; 16376 if ("Ingredient".equals(codeString)) 16377 return ResourceTypeEnum.INGREDIENT; 16378 if ("InsurancePlan".equals(codeString)) 16379 return ResourceTypeEnum.INSURANCEPLAN; 16380 if ("InventoryItem".equals(codeString)) 16381 return ResourceTypeEnum.INVENTORYITEM; 16382 if ("InventoryReport".equals(codeString)) 16383 return ResourceTypeEnum.INVENTORYREPORT; 16384 if ("Invoice".equals(codeString)) 16385 return ResourceTypeEnum.INVOICE; 16386 if ("Library".equals(codeString)) 16387 return ResourceTypeEnum.LIBRARY; 16388 if ("Linkage".equals(codeString)) 16389 return ResourceTypeEnum.LINKAGE; 16390 if ("List".equals(codeString)) 16391 return ResourceTypeEnum.LIST; 16392 if ("Location".equals(codeString)) 16393 return ResourceTypeEnum.LOCATION; 16394 if ("ManufacturedItemDefinition".equals(codeString)) 16395 return ResourceTypeEnum.MANUFACTUREDITEMDEFINITION; 16396 if ("Measure".equals(codeString)) 16397 return ResourceTypeEnum.MEASURE; 16398 if ("MeasureReport".equals(codeString)) 16399 return ResourceTypeEnum.MEASUREREPORT; 16400 if ("Medication".equals(codeString)) 16401 return ResourceTypeEnum.MEDICATION; 16402 if ("MedicationAdministration".equals(codeString)) 16403 return ResourceTypeEnum.MEDICATIONADMINISTRATION; 16404 if ("MedicationDispense".equals(codeString)) 16405 return ResourceTypeEnum.MEDICATIONDISPENSE; 16406 if ("MedicationKnowledge".equals(codeString)) 16407 return ResourceTypeEnum.MEDICATIONKNOWLEDGE; 16408 if ("MedicationRequest".equals(codeString)) 16409 return ResourceTypeEnum.MEDICATIONREQUEST; 16410 if ("MedicationStatement".equals(codeString)) 16411 return ResourceTypeEnum.MEDICATIONSTATEMENT; 16412 if ("MedicinalProductDefinition".equals(codeString)) 16413 return ResourceTypeEnum.MEDICINALPRODUCTDEFINITION; 16414 if ("MessageDefinition".equals(codeString)) 16415 return ResourceTypeEnum.MESSAGEDEFINITION; 16416 if ("MessageHeader".equals(codeString)) 16417 return ResourceTypeEnum.MESSAGEHEADER; 16418 if ("MolecularSequence".equals(codeString)) 16419 return ResourceTypeEnum.MOLECULARSEQUENCE; 16420 if ("NamingSystem".equals(codeString)) 16421 return ResourceTypeEnum.NAMINGSYSTEM; 16422 if ("NutritionIntake".equals(codeString)) 16423 return ResourceTypeEnum.NUTRITIONINTAKE; 16424 if ("NutritionOrder".equals(codeString)) 16425 return ResourceTypeEnum.NUTRITIONORDER; 16426 if ("NutritionProduct".equals(codeString)) 16427 return ResourceTypeEnum.NUTRITIONPRODUCT; 16428 if ("Observation".equals(codeString)) 16429 return ResourceTypeEnum.OBSERVATION; 16430 if ("ObservationDefinition".equals(codeString)) 16431 return ResourceTypeEnum.OBSERVATIONDEFINITION; 16432 if ("OperationDefinition".equals(codeString)) 16433 return ResourceTypeEnum.OPERATIONDEFINITION; 16434 if ("OperationOutcome".equals(codeString)) 16435 return ResourceTypeEnum.OPERATIONOUTCOME; 16436 if ("Organization".equals(codeString)) 16437 return ResourceTypeEnum.ORGANIZATION; 16438 if ("OrganizationAffiliation".equals(codeString)) 16439 return ResourceTypeEnum.ORGANIZATIONAFFILIATION; 16440 if ("PackagedProductDefinition".equals(codeString)) 16441 return ResourceTypeEnum.PACKAGEDPRODUCTDEFINITION; 16442 if ("Parameters".equals(codeString)) 16443 return ResourceTypeEnum.PARAMETERS; 16444 if ("Patient".equals(codeString)) 16445 return ResourceTypeEnum.PATIENT; 16446 if ("PaymentNotice".equals(codeString)) 16447 return ResourceTypeEnum.PAYMENTNOTICE; 16448 if ("PaymentReconciliation".equals(codeString)) 16449 return ResourceTypeEnum.PAYMENTRECONCILIATION; 16450 if ("Permission".equals(codeString)) 16451 return ResourceTypeEnum.PERMISSION; 16452 if ("Person".equals(codeString)) 16453 return ResourceTypeEnum.PERSON; 16454 if ("PlanDefinition".equals(codeString)) 16455 return ResourceTypeEnum.PLANDEFINITION; 16456 if ("Practitioner".equals(codeString)) 16457 return ResourceTypeEnum.PRACTITIONER; 16458 if ("PractitionerRole".equals(codeString)) 16459 return ResourceTypeEnum.PRACTITIONERROLE; 16460 if ("Procedure".equals(codeString)) 16461 return ResourceTypeEnum.PROCEDURE; 16462 if ("Provenance".equals(codeString)) 16463 return ResourceTypeEnum.PROVENANCE; 16464 if ("Questionnaire".equals(codeString)) 16465 return ResourceTypeEnum.QUESTIONNAIRE; 16466 if ("QuestionnaireResponse".equals(codeString)) 16467 return ResourceTypeEnum.QUESTIONNAIRERESPONSE; 16468 if ("RegulatedAuthorization".equals(codeString)) 16469 return ResourceTypeEnum.REGULATEDAUTHORIZATION; 16470 if ("RelatedPerson".equals(codeString)) 16471 return ResourceTypeEnum.RELATEDPERSON; 16472 if ("RequestOrchestration".equals(codeString)) 16473 return ResourceTypeEnum.REQUESTORCHESTRATION; 16474 if ("Requirements".equals(codeString)) 16475 return ResourceTypeEnum.REQUIREMENTS; 16476 if ("ResearchStudy".equals(codeString)) 16477 return ResourceTypeEnum.RESEARCHSTUDY; 16478 if ("ResearchSubject".equals(codeString)) 16479 return ResourceTypeEnum.RESEARCHSUBJECT; 16480 if ("RiskAssessment".equals(codeString)) 16481 return ResourceTypeEnum.RISKASSESSMENT; 16482 if ("Schedule".equals(codeString)) 16483 return ResourceTypeEnum.SCHEDULE; 16484 if ("SearchParameter".equals(codeString)) 16485 return ResourceTypeEnum.SEARCHPARAMETER; 16486 if ("ServiceRequest".equals(codeString)) 16487 return ResourceTypeEnum.SERVICEREQUEST; 16488 if ("Slot".equals(codeString)) 16489 return ResourceTypeEnum.SLOT; 16490 if ("Specimen".equals(codeString)) 16491 return ResourceTypeEnum.SPECIMEN; 16492 if ("SpecimenDefinition".equals(codeString)) 16493 return ResourceTypeEnum.SPECIMENDEFINITION; 16494 if ("StructureDefinition".equals(codeString)) 16495 return ResourceTypeEnum.STRUCTUREDEFINITION; 16496 if ("StructureMap".equals(codeString)) 16497 return ResourceTypeEnum.STRUCTUREMAP; 16498 if ("Subscription".equals(codeString)) 16499 return ResourceTypeEnum.SUBSCRIPTION; 16500 if ("SubscriptionStatus".equals(codeString)) 16501 return ResourceTypeEnum.SUBSCRIPTIONSTATUS; 16502 if ("SubscriptionTopic".equals(codeString)) 16503 return ResourceTypeEnum.SUBSCRIPTIONTOPIC; 16504 if ("Substance".equals(codeString)) 16505 return ResourceTypeEnum.SUBSTANCE; 16506 if ("SubstanceDefinition".equals(codeString)) 16507 return ResourceTypeEnum.SUBSTANCEDEFINITION; 16508 if ("SubstanceNucleicAcid".equals(codeString)) 16509 return ResourceTypeEnum.SUBSTANCENUCLEICACID; 16510 if ("SubstancePolymer".equals(codeString)) 16511 return ResourceTypeEnum.SUBSTANCEPOLYMER; 16512 if ("SubstanceProtein".equals(codeString)) 16513 return ResourceTypeEnum.SUBSTANCEPROTEIN; 16514 if ("SubstanceReferenceInformation".equals(codeString)) 16515 return ResourceTypeEnum.SUBSTANCEREFERENCEINFORMATION; 16516 if ("SubstanceSourceMaterial".equals(codeString)) 16517 return ResourceTypeEnum.SUBSTANCESOURCEMATERIAL; 16518 if ("SupplyDelivery".equals(codeString)) 16519 return ResourceTypeEnum.SUPPLYDELIVERY; 16520 if ("SupplyRequest".equals(codeString)) 16521 return ResourceTypeEnum.SUPPLYREQUEST; 16522 if ("Task".equals(codeString)) 16523 return ResourceTypeEnum.TASK; 16524 if ("TerminologyCapabilities".equals(codeString)) 16525 return ResourceTypeEnum.TERMINOLOGYCAPABILITIES; 16526 if ("TestPlan".equals(codeString)) 16527 return ResourceTypeEnum.TESTPLAN; 16528 if ("TestReport".equals(codeString)) 16529 return ResourceTypeEnum.TESTREPORT; 16530 if ("TestScript".equals(codeString)) 16531 return ResourceTypeEnum.TESTSCRIPT; 16532 if ("Transport".equals(codeString)) 16533 return ResourceTypeEnum.TRANSPORT; 16534 if ("ValueSet".equals(codeString)) 16535 return ResourceTypeEnum.VALUESET; 16536 if ("VerificationResult".equals(codeString)) 16537 return ResourceTypeEnum.VERIFICATIONRESULT; 16538 if ("VisionPrescription".equals(codeString)) 16539 return ResourceTypeEnum.VISIONPRESCRIPTION; 16540 throw new IllegalArgumentException("Unknown ResourceTypeEnum code '"+codeString+"'"); 16541 } 16542 16543 public Enumeration<ResourceTypeEnum> fromType(PrimitiveType<?> code) throws FHIRException { 16544 if (code == null) 16545 return null; 16546 if (code.isEmpty()) 16547 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NULL, code); 16548 String codeString = ((PrimitiveType) code).asStringValue(); 16549 if (codeString == null || "".equals(codeString)) 16550 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NULL, code); 16551 if ("Account".equals(codeString)) 16552 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ACCOUNT, code); 16553 if ("ActivityDefinition".equals(codeString)) 16554 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ACTIVITYDEFINITION, code); 16555 if ("ActorDefinition".equals(codeString)) 16556 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ACTORDEFINITION, code); 16557 if ("AdministrableProductDefinition".equals(codeString)) 16558 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ADMINISTRABLEPRODUCTDEFINITION, code); 16559 if ("AdverseEvent".equals(codeString)) 16560 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ADVERSEEVENT, code); 16561 if ("AllergyIntolerance".equals(codeString)) 16562 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ALLERGYINTOLERANCE, code); 16563 if ("Appointment".equals(codeString)) 16564 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.APPOINTMENT, code); 16565 if ("AppointmentResponse".equals(codeString)) 16566 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.APPOINTMENTRESPONSE, code); 16567 if ("ArtifactAssessment".equals(codeString)) 16568 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ARTIFACTASSESSMENT, code); 16569 if ("AuditEvent".equals(codeString)) 16570 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.AUDITEVENT, code); 16571 if ("Basic".equals(codeString)) 16572 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BASIC, code); 16573 if ("Binary".equals(codeString)) 16574 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BINARY, code); 16575 if ("BiologicallyDerivedProduct".equals(codeString)) 16576 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCT, code); 16577 if ("BiologicallyDerivedProductDispense".equals(codeString)) 16578 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCTDISPENSE, code); 16579 if ("BodyStructure".equals(codeString)) 16580 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BODYSTRUCTURE, code); 16581 if ("Bundle".equals(codeString)) 16582 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BUNDLE, code); 16583 if ("CapabilityStatement".equals(codeString)) 16584 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CAPABILITYSTATEMENT, code); 16585 if ("CarePlan".equals(codeString)) 16586 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CAREPLAN, code); 16587 if ("CareTeam".equals(codeString)) 16588 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CARETEAM, code); 16589 if ("ChargeItem".equals(codeString)) 16590 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CHARGEITEM, code); 16591 if ("ChargeItemDefinition".equals(codeString)) 16592 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CHARGEITEMDEFINITION, code); 16593 if ("Citation".equals(codeString)) 16594 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CITATION, code); 16595 if ("Claim".equals(codeString)) 16596 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLAIM, code); 16597 if ("ClaimResponse".equals(codeString)) 16598 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLAIMRESPONSE, code); 16599 if ("ClinicalImpression".equals(codeString)) 16600 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLINICALIMPRESSION, code); 16601 if ("ClinicalUseDefinition".equals(codeString)) 16602 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLINICALUSEDEFINITION, code); 16603 if ("CodeSystem".equals(codeString)) 16604 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CODESYSTEM, code); 16605 if ("Communication".equals(codeString)) 16606 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMMUNICATION, code); 16607 if ("CommunicationRequest".equals(codeString)) 16608 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMMUNICATIONREQUEST, code); 16609 if ("CompartmentDefinition".equals(codeString)) 16610 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMPARTMENTDEFINITION, code); 16611 if ("Composition".equals(codeString)) 16612 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMPOSITION, code); 16613 if ("ConceptMap".equals(codeString)) 16614 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONCEPTMAP, code); 16615 if ("Condition".equals(codeString)) 16616 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONDITION, code); 16617 if ("ConditionDefinition".equals(codeString)) 16618 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONDITIONDEFINITION, code); 16619 if ("Consent".equals(codeString)) 16620 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONSENT, code); 16621 if ("Contract".equals(codeString)) 16622 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONTRACT, code); 16623 if ("Coverage".equals(codeString)) 16624 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COVERAGE, code); 16625 if ("CoverageEligibilityRequest".equals(codeString)) 16626 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COVERAGEELIGIBILITYREQUEST, code); 16627 if ("CoverageEligibilityResponse".equals(codeString)) 16628 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COVERAGEELIGIBILITYRESPONSE, code); 16629 if ("DetectedIssue".equals(codeString)) 16630 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DETECTEDISSUE, code); 16631 if ("Device".equals(codeString)) 16632 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICE, code); 16633 if ("DeviceAssociation".equals(codeString)) 16634 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEASSOCIATION, code); 16635 if ("DeviceDefinition".equals(codeString)) 16636 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEDEFINITION, code); 16637 if ("DeviceDispense".equals(codeString)) 16638 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEDISPENSE, code); 16639 if ("DeviceMetric".equals(codeString)) 16640 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEMETRIC, code); 16641 if ("DeviceRequest".equals(codeString)) 16642 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEREQUEST, code); 16643 if ("DeviceUsage".equals(codeString)) 16644 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEUSAGE, code); 16645 if ("DiagnosticReport".equals(codeString)) 16646 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DIAGNOSTICREPORT, code); 16647 if ("DocumentReference".equals(codeString)) 16648 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DOCUMENTREFERENCE, code); 16649 if ("Encounter".equals(codeString)) 16650 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENCOUNTER, code); 16651 if ("EncounterHistory".equals(codeString)) 16652 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENCOUNTERHISTORY, code); 16653 if ("Endpoint".equals(codeString)) 16654 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENDPOINT, code); 16655 if ("EnrollmentRequest".equals(codeString)) 16656 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENROLLMENTREQUEST, code); 16657 if ("EnrollmentResponse".equals(codeString)) 16658 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENROLLMENTRESPONSE, code); 16659 if ("EpisodeOfCare".equals(codeString)) 16660 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EPISODEOFCARE, code); 16661 if ("EventDefinition".equals(codeString)) 16662 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EVENTDEFINITION, code); 16663 if ("Evidence".equals(codeString)) 16664 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EVIDENCE, code); 16665 if ("EvidenceReport".equals(codeString)) 16666 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EVIDENCEREPORT, code); 16667 if ("EvidenceVariable".equals(codeString)) 16668 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EVIDENCEVARIABLE, code); 16669 if ("ExampleScenario".equals(codeString)) 16670 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EXAMPLESCENARIO, code); 16671 if ("ExplanationOfBenefit".equals(codeString)) 16672 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EXPLANATIONOFBENEFIT, code); 16673 if ("FamilyMemberHistory".equals(codeString)) 16674 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.FAMILYMEMBERHISTORY, code); 16675 if ("Flag".equals(codeString)) 16676 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.FLAG, code); 16677 if ("FormularyItem".equals(codeString)) 16678 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.FORMULARYITEM, code); 16679 if ("GenomicStudy".equals(codeString)) 16680 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GENOMICSTUDY, code); 16681 if ("Goal".equals(codeString)) 16682 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GOAL, code); 16683 if ("GraphDefinition".equals(codeString)) 16684 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GRAPHDEFINITION, code); 16685 if ("Group".equals(codeString)) 16686 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GROUP, code); 16687 if ("GuidanceResponse".equals(codeString)) 16688 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GUIDANCERESPONSE, code); 16689 if ("HealthcareService".equals(codeString)) 16690 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.HEALTHCARESERVICE, code); 16691 if ("ImagingSelection".equals(codeString)) 16692 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMAGINGSELECTION, code); 16693 if ("ImagingStudy".equals(codeString)) 16694 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMAGINGSTUDY, code); 16695 if ("Immunization".equals(codeString)) 16696 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMMUNIZATION, code); 16697 if ("ImmunizationEvaluation".equals(codeString)) 16698 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMMUNIZATIONEVALUATION, code); 16699 if ("ImmunizationRecommendation".equals(codeString)) 16700 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMMUNIZATIONRECOMMENDATION, code); 16701 if ("ImplementationGuide".equals(codeString)) 16702 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMPLEMENTATIONGUIDE, code); 16703 if ("Ingredient".equals(codeString)) 16704 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INGREDIENT, code); 16705 if ("InsurancePlan".equals(codeString)) 16706 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INSURANCEPLAN, code); 16707 if ("InventoryItem".equals(codeString)) 16708 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INVENTORYITEM, code); 16709 if ("InventoryReport".equals(codeString)) 16710 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INVENTORYREPORT, code); 16711 if ("Invoice".equals(codeString)) 16712 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INVOICE, code); 16713 if ("Library".equals(codeString)) 16714 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LIBRARY, code); 16715 if ("Linkage".equals(codeString)) 16716 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LINKAGE, code); 16717 if ("List".equals(codeString)) 16718 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LIST, code); 16719 if ("Location".equals(codeString)) 16720 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LOCATION, code); 16721 if ("ManufacturedItemDefinition".equals(codeString)) 16722 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MANUFACTUREDITEMDEFINITION, code); 16723 if ("Measure".equals(codeString)) 16724 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEASURE, code); 16725 if ("MeasureReport".equals(codeString)) 16726 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEASUREREPORT, code); 16727 if ("Medication".equals(codeString)) 16728 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATION, code); 16729 if ("MedicationAdministration".equals(codeString)) 16730 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONADMINISTRATION, code); 16731 if ("MedicationDispense".equals(codeString)) 16732 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONDISPENSE, code); 16733 if ("MedicationKnowledge".equals(codeString)) 16734 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONKNOWLEDGE, code); 16735 if ("MedicationRequest".equals(codeString)) 16736 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONREQUEST, code); 16737 if ("MedicationStatement".equals(codeString)) 16738 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONSTATEMENT, code); 16739 if ("MedicinalProductDefinition".equals(codeString)) 16740 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICINALPRODUCTDEFINITION, code); 16741 if ("MessageDefinition".equals(codeString)) 16742 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MESSAGEDEFINITION, code); 16743 if ("MessageHeader".equals(codeString)) 16744 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MESSAGEHEADER, code); 16745 if ("MolecularSequence".equals(codeString)) 16746 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MOLECULARSEQUENCE, code); 16747 if ("NamingSystem".equals(codeString)) 16748 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NAMINGSYSTEM, code); 16749 if ("NutritionIntake".equals(codeString)) 16750 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NUTRITIONINTAKE, code); 16751 if ("NutritionOrder".equals(codeString)) 16752 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NUTRITIONORDER, code); 16753 if ("NutritionProduct".equals(codeString)) 16754 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NUTRITIONPRODUCT, code); 16755 if ("Observation".equals(codeString)) 16756 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OBSERVATION, code); 16757 if ("ObservationDefinition".equals(codeString)) 16758 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OBSERVATIONDEFINITION, code); 16759 if ("OperationDefinition".equals(codeString)) 16760 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OPERATIONDEFINITION, code); 16761 if ("OperationOutcome".equals(codeString)) 16762 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OPERATIONOUTCOME, code); 16763 if ("Organization".equals(codeString)) 16764 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ORGANIZATION, code); 16765 if ("OrganizationAffiliation".equals(codeString)) 16766 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ORGANIZATIONAFFILIATION, code); 16767 if ("PackagedProductDefinition".equals(codeString)) 16768 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PACKAGEDPRODUCTDEFINITION, code); 16769 if ("Parameters".equals(codeString)) 16770 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PARAMETERS, code); 16771 if ("Patient".equals(codeString)) 16772 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PATIENT, code); 16773 if ("PaymentNotice".equals(codeString)) 16774 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PAYMENTNOTICE, code); 16775 if ("PaymentReconciliation".equals(codeString)) 16776 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PAYMENTRECONCILIATION, code); 16777 if ("Permission".equals(codeString)) 16778 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PERMISSION, code); 16779 if ("Person".equals(codeString)) 16780 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PERSON, code); 16781 if ("PlanDefinition".equals(codeString)) 16782 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PLANDEFINITION, code); 16783 if ("Practitioner".equals(codeString)) 16784 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PRACTITIONER, code); 16785 if ("PractitionerRole".equals(codeString)) 16786 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PRACTITIONERROLE, code); 16787 if ("Procedure".equals(codeString)) 16788 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PROCEDURE, code); 16789 if ("Provenance".equals(codeString)) 16790 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PROVENANCE, code); 16791 if ("Questionnaire".equals(codeString)) 16792 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.QUESTIONNAIRE, code); 16793 if ("QuestionnaireResponse".equals(codeString)) 16794 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.QUESTIONNAIRERESPONSE, code); 16795 if ("RegulatedAuthorization".equals(codeString)) 16796 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.REGULATEDAUTHORIZATION, code); 16797 if ("RelatedPerson".equals(codeString)) 16798 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RELATEDPERSON, code); 16799 if ("RequestOrchestration".equals(codeString)) 16800 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.REQUESTORCHESTRATION, code); 16801 if ("Requirements".equals(codeString)) 16802 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.REQUIREMENTS, code); 16803 if ("ResearchStudy".equals(codeString)) 16804 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RESEARCHSTUDY, code); 16805 if ("ResearchSubject".equals(codeString)) 16806 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RESEARCHSUBJECT, code); 16807 if ("RiskAssessment".equals(codeString)) 16808 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RISKASSESSMENT, code); 16809 if ("Schedule".equals(codeString)) 16810 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SCHEDULE, code); 16811 if ("SearchParameter".equals(codeString)) 16812 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SEARCHPARAMETER, code); 16813 if ("ServiceRequest".equals(codeString)) 16814 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SERVICEREQUEST, code); 16815 if ("Slot".equals(codeString)) 16816 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SLOT, code); 16817 if ("Specimen".equals(codeString)) 16818 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SPECIMEN, code); 16819 if ("SpecimenDefinition".equals(codeString)) 16820 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SPECIMENDEFINITION, code); 16821 if ("StructureDefinition".equals(codeString)) 16822 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.STRUCTUREDEFINITION, code); 16823 if ("StructureMap".equals(codeString)) 16824 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.STRUCTUREMAP, code); 16825 if ("Subscription".equals(codeString)) 16826 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSCRIPTION, code); 16827 if ("SubscriptionStatus".equals(codeString)) 16828 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSCRIPTIONSTATUS, code); 16829 if ("SubscriptionTopic".equals(codeString)) 16830 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSCRIPTIONTOPIC, code); 16831 if ("Substance".equals(codeString)) 16832 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCE, code); 16833 if ("SubstanceDefinition".equals(codeString)) 16834 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEDEFINITION, code); 16835 if ("SubstanceNucleicAcid".equals(codeString)) 16836 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCENUCLEICACID, code); 16837 if ("SubstancePolymer".equals(codeString)) 16838 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEPOLYMER, code); 16839 if ("SubstanceProtein".equals(codeString)) 16840 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEPROTEIN, code); 16841 if ("SubstanceReferenceInformation".equals(codeString)) 16842 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEREFERENCEINFORMATION, code); 16843 if ("SubstanceSourceMaterial".equals(codeString)) 16844 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCESOURCEMATERIAL, code); 16845 if ("SupplyDelivery".equals(codeString)) 16846 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUPPLYDELIVERY, code); 16847 if ("SupplyRequest".equals(codeString)) 16848 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUPPLYREQUEST, code); 16849 if ("Task".equals(codeString)) 16850 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TASK, code); 16851 if ("TerminologyCapabilities".equals(codeString)) 16852 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TERMINOLOGYCAPABILITIES, code); 16853 if ("TestPlan".equals(codeString)) 16854 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TESTPLAN, code); 16855 if ("TestReport".equals(codeString)) 16856 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TESTREPORT, code); 16857 if ("TestScript".equals(codeString)) 16858 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TESTSCRIPT, code); 16859 if ("Transport".equals(codeString)) 16860 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TRANSPORT, code); 16861 if ("ValueSet".equals(codeString)) 16862 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.VALUESET, code); 16863 if ("VerificationResult".equals(codeString)) 16864 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.VERIFICATIONRESULT, code); 16865 if ("VisionPrescription".equals(codeString)) 16866 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.VISIONPRESCRIPTION, code); 16867 throw new FHIRException("Unknown ResourceTypeEnum code '"+codeString+"'"); 16868 } 16869 public String toCode(ResourceTypeEnum code) { 16870 if (code == ResourceTypeEnum.ACCOUNT) 16871 return "Account"; 16872 if (code == ResourceTypeEnum.ACTIVITYDEFINITION) 16873 return "ActivityDefinition"; 16874 if (code == ResourceTypeEnum.ACTORDEFINITION) 16875 return "ActorDefinition"; 16876 if (code == ResourceTypeEnum.ADMINISTRABLEPRODUCTDEFINITION) 16877 return "AdministrableProductDefinition"; 16878 if (code == ResourceTypeEnum.ADVERSEEVENT) 16879 return "AdverseEvent"; 16880 if (code == ResourceTypeEnum.ALLERGYINTOLERANCE) 16881 return "AllergyIntolerance"; 16882 if (code == ResourceTypeEnum.APPOINTMENT) 16883 return "Appointment"; 16884 if (code == ResourceTypeEnum.APPOINTMENTRESPONSE) 16885 return "AppointmentResponse"; 16886 if (code == ResourceTypeEnum.ARTIFACTASSESSMENT) 16887 return "ArtifactAssessment"; 16888 if (code == ResourceTypeEnum.AUDITEVENT) 16889 return "AuditEvent"; 16890 if (code == ResourceTypeEnum.BASIC) 16891 return "Basic"; 16892 if (code == ResourceTypeEnum.BINARY) 16893 return "Binary"; 16894 if (code == ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCT) 16895 return "BiologicallyDerivedProduct"; 16896 if (code == ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCTDISPENSE) 16897 return "BiologicallyDerivedProductDispense"; 16898 if (code == ResourceTypeEnum.BODYSTRUCTURE) 16899 return "BodyStructure"; 16900 if (code == ResourceTypeEnum.BUNDLE) 16901 return "Bundle"; 16902 if (code == ResourceTypeEnum.CAPABILITYSTATEMENT) 16903 return "CapabilityStatement"; 16904 if (code == ResourceTypeEnum.CAREPLAN) 16905 return "CarePlan"; 16906 if (code == ResourceTypeEnum.CARETEAM) 16907 return "CareTeam"; 16908 if (code == ResourceTypeEnum.CHARGEITEM) 16909 return "ChargeItem"; 16910 if (code == ResourceTypeEnum.CHARGEITEMDEFINITION) 16911 return "ChargeItemDefinition"; 16912 if (code == ResourceTypeEnum.CITATION) 16913 return "Citation"; 16914 if (code == ResourceTypeEnum.CLAIM) 16915 return "Claim"; 16916 if (code == ResourceTypeEnum.CLAIMRESPONSE) 16917 return "ClaimResponse"; 16918 if (code == ResourceTypeEnum.CLINICALIMPRESSION) 16919 return "ClinicalImpression"; 16920 if (code == ResourceTypeEnum.CLINICALUSEDEFINITION) 16921 return "ClinicalUseDefinition"; 16922 if (code == ResourceTypeEnum.CODESYSTEM) 16923 return "CodeSystem"; 16924 if (code == ResourceTypeEnum.COMMUNICATION) 16925 return "Communication"; 16926 if (code == ResourceTypeEnum.COMMUNICATIONREQUEST) 16927 return "CommunicationRequest"; 16928 if (code == ResourceTypeEnum.COMPARTMENTDEFINITION) 16929 return "CompartmentDefinition"; 16930 if (code == ResourceTypeEnum.COMPOSITION) 16931 return "Composition"; 16932 if (code == ResourceTypeEnum.CONCEPTMAP) 16933 return "ConceptMap"; 16934 if (code == ResourceTypeEnum.CONDITION) 16935 return "Condition"; 16936 if (code == ResourceTypeEnum.CONDITIONDEFINITION) 16937 return "ConditionDefinition"; 16938 if (code == ResourceTypeEnum.CONSENT) 16939 return "Consent"; 16940 if (code == ResourceTypeEnum.CONTRACT) 16941 return "Contract"; 16942 if (code == ResourceTypeEnum.COVERAGE) 16943 return "Coverage"; 16944 if (code == ResourceTypeEnum.COVERAGEELIGIBILITYREQUEST) 16945 return "CoverageEligibilityRequest"; 16946 if (code == ResourceTypeEnum.COVERAGEELIGIBILITYRESPONSE) 16947 return "CoverageEligibilityResponse"; 16948 if (code == ResourceTypeEnum.DETECTEDISSUE) 16949 return "DetectedIssue"; 16950 if (code == ResourceTypeEnum.DEVICE) 16951 return "Device"; 16952 if (code == ResourceTypeEnum.DEVICEASSOCIATION) 16953 return "DeviceAssociation"; 16954 if (code == ResourceTypeEnum.DEVICEDEFINITION) 16955 return "DeviceDefinition"; 16956 if (code == ResourceTypeEnum.DEVICEDISPENSE) 16957 return "DeviceDispense"; 16958 if (code == ResourceTypeEnum.DEVICEMETRIC) 16959 return "DeviceMetric"; 16960 if (code == ResourceTypeEnum.DEVICEREQUEST) 16961 return "DeviceRequest"; 16962 if (code == ResourceTypeEnum.DEVICEUSAGE) 16963 return "DeviceUsage"; 16964 if (code == ResourceTypeEnum.DIAGNOSTICREPORT) 16965 return "DiagnosticReport"; 16966 if (code == ResourceTypeEnum.DOCUMENTREFERENCE) 16967 return "DocumentReference"; 16968 if (code == ResourceTypeEnum.ENCOUNTER) 16969 return "Encounter"; 16970 if (code == ResourceTypeEnum.ENCOUNTERHISTORY) 16971 return "EncounterHistory"; 16972 if (code == ResourceTypeEnum.ENDPOINT) 16973 return "Endpoint"; 16974 if (code == ResourceTypeEnum.ENROLLMENTREQUEST) 16975 return "EnrollmentRequest"; 16976 if (code == ResourceTypeEnum.ENROLLMENTRESPONSE) 16977 return "EnrollmentResponse"; 16978 if (code == ResourceTypeEnum.EPISODEOFCARE) 16979 return "EpisodeOfCare"; 16980 if (code == ResourceTypeEnum.EVENTDEFINITION) 16981 return "EventDefinition"; 16982 if (code == ResourceTypeEnum.EVIDENCE) 16983 return "Evidence"; 16984 if (code == ResourceTypeEnum.EVIDENCEREPORT) 16985 return "EvidenceReport"; 16986 if (code == ResourceTypeEnum.EVIDENCEVARIABLE) 16987 return "EvidenceVariable"; 16988 if (code == ResourceTypeEnum.EXAMPLESCENARIO) 16989 return "ExampleScenario"; 16990 if (code == ResourceTypeEnum.EXPLANATIONOFBENEFIT) 16991 return "ExplanationOfBenefit"; 16992 if (code == ResourceTypeEnum.FAMILYMEMBERHISTORY) 16993 return "FamilyMemberHistory"; 16994 if (code == ResourceTypeEnum.FLAG) 16995 return "Flag"; 16996 if (code == ResourceTypeEnum.FORMULARYITEM) 16997 return "FormularyItem"; 16998 if (code == ResourceTypeEnum.GENOMICSTUDY) 16999 return "GenomicStudy"; 17000 if (code == ResourceTypeEnum.GOAL) 17001 return "Goal"; 17002 if (code == ResourceTypeEnum.GRAPHDEFINITION) 17003 return "GraphDefinition"; 17004 if (code == ResourceTypeEnum.GROUP) 17005 return "Group"; 17006 if (code == ResourceTypeEnum.GUIDANCERESPONSE) 17007 return "GuidanceResponse"; 17008 if (code == ResourceTypeEnum.HEALTHCARESERVICE) 17009 return "HealthcareService"; 17010 if (code == ResourceTypeEnum.IMAGINGSELECTION) 17011 return "ImagingSelection"; 17012 if (code == ResourceTypeEnum.IMAGINGSTUDY) 17013 return "ImagingStudy"; 17014 if (code == ResourceTypeEnum.IMMUNIZATION) 17015 return "Immunization"; 17016 if (code == ResourceTypeEnum.IMMUNIZATIONEVALUATION) 17017 return "ImmunizationEvaluation"; 17018 if (code == ResourceTypeEnum.IMMUNIZATIONRECOMMENDATION) 17019 return "ImmunizationRecommendation"; 17020 if (code == ResourceTypeEnum.IMPLEMENTATIONGUIDE) 17021 return "ImplementationGuide"; 17022 if (code == ResourceTypeEnum.INGREDIENT) 17023 return "Ingredient"; 17024 if (code == ResourceTypeEnum.INSURANCEPLAN) 17025 return "InsurancePlan"; 17026 if (code == ResourceTypeEnum.INVENTORYITEM) 17027 return "InventoryItem"; 17028 if (code == ResourceTypeEnum.INVENTORYREPORT) 17029 return "InventoryReport"; 17030 if (code == ResourceTypeEnum.INVOICE) 17031 return "Invoice"; 17032 if (code == ResourceTypeEnum.LIBRARY) 17033 return "Library"; 17034 if (code == ResourceTypeEnum.LINKAGE) 17035 return "Linkage"; 17036 if (code == ResourceTypeEnum.LIST) 17037 return "List"; 17038 if (code == ResourceTypeEnum.LOCATION) 17039 return "Location"; 17040 if (code == ResourceTypeEnum.MANUFACTUREDITEMDEFINITION) 17041 return "ManufacturedItemDefinition"; 17042 if (code == ResourceTypeEnum.MEASURE) 17043 return "Measure"; 17044 if (code == ResourceTypeEnum.MEASUREREPORT) 17045 return "MeasureReport"; 17046 if (code == ResourceTypeEnum.MEDICATION) 17047 return "Medication"; 17048 if (code == ResourceTypeEnum.MEDICATIONADMINISTRATION) 17049 return "MedicationAdministration"; 17050 if (code == ResourceTypeEnum.MEDICATIONDISPENSE) 17051 return "MedicationDispense"; 17052 if (code == ResourceTypeEnum.MEDICATIONKNOWLEDGE) 17053 return "MedicationKnowledge"; 17054 if (code == ResourceTypeEnum.MEDICATIONREQUEST) 17055 return "MedicationRequest"; 17056 if (code == ResourceTypeEnum.MEDICATIONSTATEMENT) 17057 return "MedicationStatement"; 17058 if (code == ResourceTypeEnum.MEDICINALPRODUCTDEFINITION) 17059 return "MedicinalProductDefinition"; 17060 if (code == ResourceTypeEnum.MESSAGEDEFINITION) 17061 return "MessageDefinition"; 17062 if (code == ResourceTypeEnum.MESSAGEHEADER) 17063 return "MessageHeader"; 17064 if (code == ResourceTypeEnum.MOLECULARSEQUENCE) 17065 return "MolecularSequence"; 17066 if (code == ResourceTypeEnum.NAMINGSYSTEM) 17067 return "NamingSystem"; 17068 if (code == ResourceTypeEnum.NUTRITIONINTAKE) 17069 return "NutritionIntake"; 17070 if (code == ResourceTypeEnum.NUTRITIONORDER) 17071 return "NutritionOrder"; 17072 if (code == ResourceTypeEnum.NUTRITIONPRODUCT) 17073 return "NutritionProduct"; 17074 if (code == ResourceTypeEnum.OBSERVATION) 17075 return "Observation"; 17076 if (code == ResourceTypeEnum.OBSERVATIONDEFINITION) 17077 return "ObservationDefinition"; 17078 if (code == ResourceTypeEnum.OPERATIONDEFINITION) 17079 return "OperationDefinition"; 17080 if (code == ResourceTypeEnum.OPERATIONOUTCOME) 17081 return "OperationOutcome"; 17082 if (code == ResourceTypeEnum.ORGANIZATION) 17083 return "Organization"; 17084 if (code == ResourceTypeEnum.ORGANIZATIONAFFILIATION) 17085 return "OrganizationAffiliation"; 17086 if (code == ResourceTypeEnum.PACKAGEDPRODUCTDEFINITION) 17087 return "PackagedProductDefinition"; 17088 if (code == ResourceTypeEnum.PARAMETERS) 17089 return "Parameters"; 17090 if (code == ResourceTypeEnum.PATIENT) 17091 return "Patient"; 17092 if (code == ResourceTypeEnum.PAYMENTNOTICE) 17093 return "PaymentNotice"; 17094 if (code == ResourceTypeEnum.PAYMENTRECONCILIATION) 17095 return "PaymentReconciliation"; 17096 if (code == ResourceTypeEnum.PERMISSION) 17097 return "Permission"; 17098 if (code == ResourceTypeEnum.PERSON) 17099 return "Person"; 17100 if (code == ResourceTypeEnum.PLANDEFINITION) 17101 return "PlanDefinition"; 17102 if (code == ResourceTypeEnum.PRACTITIONER) 17103 return "Practitioner"; 17104 if (code == ResourceTypeEnum.PRACTITIONERROLE) 17105 return "PractitionerRole"; 17106 if (code == ResourceTypeEnum.PROCEDURE) 17107 return "Procedure"; 17108 if (code == ResourceTypeEnum.PROVENANCE) 17109 return "Provenance"; 17110 if (code == ResourceTypeEnum.QUESTIONNAIRE) 17111 return "Questionnaire"; 17112 if (code == ResourceTypeEnum.QUESTIONNAIRERESPONSE) 17113 return "QuestionnaireResponse"; 17114 if (code == ResourceTypeEnum.REGULATEDAUTHORIZATION) 17115 return "RegulatedAuthorization"; 17116 if (code == ResourceTypeEnum.RELATEDPERSON) 17117 return "RelatedPerson"; 17118 if (code == ResourceTypeEnum.REQUESTORCHESTRATION) 17119 return "RequestOrchestration"; 17120 if (code == ResourceTypeEnum.REQUIREMENTS) 17121 return "Requirements"; 17122 if (code == ResourceTypeEnum.RESEARCHSTUDY) 17123 return "ResearchStudy"; 17124 if (code == ResourceTypeEnum.RESEARCHSUBJECT) 17125 return "ResearchSubject"; 17126 if (code == ResourceTypeEnum.RISKASSESSMENT) 17127 return "RiskAssessment"; 17128 if (code == ResourceTypeEnum.SCHEDULE) 17129 return "Schedule"; 17130 if (code == ResourceTypeEnum.SEARCHPARAMETER) 17131 return "SearchParameter"; 17132 if (code == ResourceTypeEnum.SERVICEREQUEST) 17133 return "ServiceRequest"; 17134 if (code == ResourceTypeEnum.SLOT) 17135 return "Slot"; 17136 if (code == ResourceTypeEnum.SPECIMEN) 17137 return "Specimen"; 17138 if (code == ResourceTypeEnum.SPECIMENDEFINITION) 17139 return "SpecimenDefinition"; 17140 if (code == ResourceTypeEnum.STRUCTUREDEFINITION) 17141 return "StructureDefinition"; 17142 if (code == ResourceTypeEnum.STRUCTUREMAP) 17143 return "StructureMap"; 17144 if (code == ResourceTypeEnum.SUBSCRIPTION) 17145 return "Subscription"; 17146 if (code == ResourceTypeEnum.SUBSCRIPTIONSTATUS) 17147 return "SubscriptionStatus"; 17148 if (code == ResourceTypeEnum.SUBSCRIPTIONTOPIC) 17149 return "SubscriptionTopic"; 17150 if (code == ResourceTypeEnum.SUBSTANCE) 17151 return "Substance"; 17152 if (code == ResourceTypeEnum.SUBSTANCEDEFINITION) 17153 return "SubstanceDefinition"; 17154 if (code == ResourceTypeEnum.SUBSTANCENUCLEICACID) 17155 return "SubstanceNucleicAcid"; 17156 if (code == ResourceTypeEnum.SUBSTANCEPOLYMER) 17157 return "SubstancePolymer"; 17158 if (code == ResourceTypeEnum.SUBSTANCEPROTEIN) 17159 return "SubstanceProtein"; 17160 if (code == ResourceTypeEnum.SUBSTANCEREFERENCEINFORMATION) 17161 return "SubstanceReferenceInformation"; 17162 if (code == ResourceTypeEnum.SUBSTANCESOURCEMATERIAL) 17163 return "SubstanceSourceMaterial"; 17164 if (code == ResourceTypeEnum.SUPPLYDELIVERY) 17165 return "SupplyDelivery"; 17166 if (code == ResourceTypeEnum.SUPPLYREQUEST) 17167 return "SupplyRequest"; 17168 if (code == ResourceTypeEnum.TASK) 17169 return "Task"; 17170 if (code == ResourceTypeEnum.TERMINOLOGYCAPABILITIES) 17171 return "TerminologyCapabilities"; 17172 if (code == ResourceTypeEnum.TESTPLAN) 17173 return "TestPlan"; 17174 if (code == ResourceTypeEnum.TESTREPORT) 17175 return "TestReport"; 17176 if (code == ResourceTypeEnum.TESTSCRIPT) 17177 return "TestScript"; 17178 if (code == ResourceTypeEnum.TRANSPORT) 17179 return "Transport"; 17180 if (code == ResourceTypeEnum.VALUESET) 17181 return "ValueSet"; 17182 if (code == ResourceTypeEnum.VERIFICATIONRESULT) 17183 return "VerificationResult"; 17184 if (code == ResourceTypeEnum.VISIONPRESCRIPTION) 17185 return "VisionPrescription"; 17186 return "?"; 17187 } 17188 public String toSystem(ResourceTypeEnum code) { 17189 return code.getSystem(); 17190 } 17191 } 17192 17193 public enum SearchComparator { 17194 /** 17195 * the value for the parameter in the resource is equal to the provided value. 17196 */ 17197 EQ, 17198 /** 17199 * the value for the parameter in the resource is not equal to the provided value. 17200 */ 17201 NE, 17202 /** 17203 * the value for the parameter in the resource is greater than the provided value. 17204 */ 17205 GT, 17206 /** 17207 * the value for the parameter in the resource is less than the provided value. 17208 */ 17209 LT, 17210 /** 17211 * the value for the parameter in the resource is greater or equal to the provided value. 17212 */ 17213 GE, 17214 /** 17215 * the value for the parameter in the resource is less or equal to the provided value. 17216 */ 17217 LE, 17218 /** 17219 * the value for the parameter in the resource starts after the provided value. 17220 */ 17221 SA, 17222 /** 17223 * the value for the parameter in the resource ends before the provided value. 17224 */ 17225 EB, 17226 /** 17227 * the value for the parameter in the resource is approximately the same to the provided value. 17228 */ 17229 AP, 17230 /** 17231 * added to help the parsers 17232 */ 17233 NULL; 17234 public static SearchComparator fromCode(String codeString) throws FHIRException { 17235 if (codeString == null || "".equals(codeString)) 17236 return null; 17237 if ("eq".equals(codeString)) 17238 return EQ; 17239 if ("ne".equals(codeString)) 17240 return NE; 17241 if ("gt".equals(codeString)) 17242 return GT; 17243 if ("lt".equals(codeString)) 17244 return LT; 17245 if ("ge".equals(codeString)) 17246 return GE; 17247 if ("le".equals(codeString)) 17248 return LE; 17249 if ("sa".equals(codeString)) 17250 return SA; 17251 if ("eb".equals(codeString)) 17252 return EB; 17253 if ("ap".equals(codeString)) 17254 return AP; 17255 throw new FHIRException("Unknown SearchComparator code '"+codeString+"'"); 17256 } 17257 public static boolean isValidCode(String codeString) { 17258 if (codeString == null || "".equals(codeString)) 17259 return false; 17260 return Utilities.existsInList(codeString, "eq", "ne", "gt", "lt", "ge", "le", "sa", "eb", "ap"); 17261 } 17262 public String toCode() { 17263 switch (this) { 17264 case EQ: return "eq"; 17265 case NE: return "ne"; 17266 case GT: return "gt"; 17267 case LT: return "lt"; 17268 case GE: return "ge"; 17269 case LE: return "le"; 17270 case SA: return "sa"; 17271 case EB: return "eb"; 17272 case AP: return "ap"; 17273 case NULL: return null; 17274 default: return "?"; 17275 } 17276 } 17277 public String getSystem() { 17278 switch (this) { 17279 case EQ: return "http://hl7.org/fhir/search-comparator"; 17280 case NE: return "http://hl7.org/fhir/search-comparator"; 17281 case GT: return "http://hl7.org/fhir/search-comparator"; 17282 case LT: return "http://hl7.org/fhir/search-comparator"; 17283 case GE: return "http://hl7.org/fhir/search-comparator"; 17284 case LE: return "http://hl7.org/fhir/search-comparator"; 17285 case SA: return "http://hl7.org/fhir/search-comparator"; 17286 case EB: return "http://hl7.org/fhir/search-comparator"; 17287 case AP: return "http://hl7.org/fhir/search-comparator"; 17288 case NULL: return null; 17289 default: return "?"; 17290 } 17291 } 17292 public String getDefinition() { 17293 switch (this) { 17294 case EQ: return "the value for the parameter in the resource is equal to the provided value."; 17295 case NE: return "the value for the parameter in the resource is not equal to the provided value."; 17296 case GT: return "the value for the parameter in the resource is greater than the provided value."; 17297 case LT: return "the value for the parameter in the resource is less than the provided value."; 17298 case GE: return "the value for the parameter in the resource is greater or equal to the provided value."; 17299 case LE: return "the value for the parameter in the resource is less or equal to the provided value."; 17300 case SA: return "the value for the parameter in the resource starts after the provided value."; 17301 case EB: return "the value for the parameter in the resource ends before the provided value."; 17302 case AP: return "the value for the parameter in the resource is approximately the same to the provided value."; 17303 case NULL: return null; 17304 default: return "?"; 17305 } 17306 } 17307 public String getDisplay() { 17308 switch (this) { 17309 case EQ: return "Equals"; 17310 case NE: return "Not Equals"; 17311 case GT: return "Greater Than"; 17312 case LT: return "Less Than"; 17313 case GE: return "Greater or Equals"; 17314 case LE: return "Less of Equal"; 17315 case SA: return "Starts After"; 17316 case EB: return "Ends Before"; 17317 case AP: return "Approximately"; 17318 case NULL: return null; 17319 default: return "?"; 17320 } 17321 } 17322 } 17323 17324 public static class SearchComparatorEnumFactory implements EnumFactory<SearchComparator> { 17325 public SearchComparator fromCode(String codeString) throws IllegalArgumentException { 17326 if (codeString == null || "".equals(codeString)) 17327 if (codeString == null || "".equals(codeString)) 17328 return null; 17329 if ("eq".equals(codeString)) 17330 return SearchComparator.EQ; 17331 if ("ne".equals(codeString)) 17332 return SearchComparator.NE; 17333 if ("gt".equals(codeString)) 17334 return SearchComparator.GT; 17335 if ("lt".equals(codeString)) 17336 return SearchComparator.LT; 17337 if ("ge".equals(codeString)) 17338 return SearchComparator.GE; 17339 if ("le".equals(codeString)) 17340 return SearchComparator.LE; 17341 if ("sa".equals(codeString)) 17342 return SearchComparator.SA; 17343 if ("eb".equals(codeString)) 17344 return SearchComparator.EB; 17345 if ("ap".equals(codeString)) 17346 return SearchComparator.AP; 17347 throw new IllegalArgumentException("Unknown SearchComparator code '"+codeString+"'"); 17348 } 17349 17350 public Enumeration<SearchComparator> fromType(PrimitiveType<?> code) throws FHIRException { 17351 if (code == null) 17352 return null; 17353 if (code.isEmpty()) 17354 return new Enumeration<SearchComparator>(this, SearchComparator.NULL, code); 17355 String codeString = ((PrimitiveType) code).asStringValue(); 17356 if (codeString == null || "".equals(codeString)) 17357 return new Enumeration<SearchComparator>(this, SearchComparator.NULL, code); 17358 if ("eq".equals(codeString)) 17359 return new Enumeration<SearchComparator>(this, SearchComparator.EQ, code); 17360 if ("ne".equals(codeString)) 17361 return new Enumeration<SearchComparator>(this, SearchComparator.NE, code); 17362 if ("gt".equals(codeString)) 17363 return new Enumeration<SearchComparator>(this, SearchComparator.GT, code); 17364 if ("lt".equals(codeString)) 17365 return new Enumeration<SearchComparator>(this, SearchComparator.LT, code); 17366 if ("ge".equals(codeString)) 17367 return new Enumeration<SearchComparator>(this, SearchComparator.GE, code); 17368 if ("le".equals(codeString)) 17369 return new Enumeration<SearchComparator>(this, SearchComparator.LE, code); 17370 if ("sa".equals(codeString)) 17371 return new Enumeration<SearchComparator>(this, SearchComparator.SA, code); 17372 if ("eb".equals(codeString)) 17373 return new Enumeration<SearchComparator>(this, SearchComparator.EB, code); 17374 if ("ap".equals(codeString)) 17375 return new Enumeration<SearchComparator>(this, SearchComparator.AP, code); 17376 throw new FHIRException("Unknown SearchComparator code '"+codeString+"'"); 17377 } 17378 public String toCode(SearchComparator code) { 17379 if (code == SearchComparator.EQ) 17380 return "eq"; 17381 if (code == SearchComparator.NE) 17382 return "ne"; 17383 if (code == SearchComparator.GT) 17384 return "gt"; 17385 if (code == SearchComparator.LT) 17386 return "lt"; 17387 if (code == SearchComparator.GE) 17388 return "ge"; 17389 if (code == SearchComparator.LE) 17390 return "le"; 17391 if (code == SearchComparator.SA) 17392 return "sa"; 17393 if (code == SearchComparator.EB) 17394 return "eb"; 17395 if (code == SearchComparator.AP) 17396 return "ap"; 17397 return "?"; 17398 } 17399 public String toSystem(SearchComparator code) { 17400 return code.getSystem(); 17401 } 17402 } 17403 17404 public enum SearchModifierCode { 17405 /** 17406 * The search parameter returns resources that have a value or not. 17407 */ 17408 MISSING, 17409 /** 17410 * The search parameter returns resources that have a value that exactly matches the supplied parameter (the whole string, including casing and accents). 17411 */ 17412 EXACT, 17413 /** 17414 * The search parameter returns resources that include the supplied parameter value anywhere within the field being searched. 17415 */ 17416 CONTAINS, 17417 /** 17418 * The search parameter returns resources that do not contain a match. 17419 */ 17420 NOT, 17421 /** 17422 * The search parameter is processed as a string that searches text associated with the code/value - either CodeableConcept.text, Coding.display, Identifier.type.text, or Reference.display. 17423 */ 17424 TEXT, 17425 /** 17426 * The search parameter is a URI (relative or absolute) that identifies a value set, and the search parameter tests whether the coding is in the specified value set. 17427 */ 17428 IN, 17429 /** 17430 * The search parameter is a URI (relative or absolute) that identifies a value set, and the search parameter tests whether the coding is not in the specified value set. 17431 */ 17432 NOTIN, 17433 /** 17434 * The search parameter tests whether the value in a resource is subsumed by the specified value (is-a, or hierarchical relationships). 17435 */ 17436 BELOW, 17437 /** 17438 * The search parameter tests whether the value in a resource subsumes the specified value (is-a, or hierarchical relationships). 17439 */ 17440 ABOVE, 17441 /** 17442 * The search parameter only applies to the Resource Type specified as a modifier (e.g. the modifier is not actually :type, but :Patient etc.). 17443 */ 17444 TYPE, 17445 /** 17446 * The search parameter applies to the identifier on the resource, not the reference. 17447 */ 17448 IDENTIFIER, 17449 /** 17450 * The search parameter has the format system|code|value, where the system and code refer to an Identifier.type.coding.system and .code, and match if any of the type codes match. All 3 parts must be present. 17451 */ 17452 OFTYPE, 17453 /** 17454 * Tests whether the textual display value in a resource (e.g., CodeableConcept.text, Coding.display, or Reference.display) matches the supplied parameter value. 17455 */ 17456 CODETEXT, 17457 /** 17458 * Tests whether the value in a resource matches the supplied parameter value using advanced text handling that searches text associated with the code/value - e.g., CodeableConcept.text, Coding.display, or Identifier.type.text. 17459 */ 17460 TEXTADVANCED, 17461 /** 17462 * The search parameter indicates an inclusion directive (_include, _revinclude) that is applied to an included resource instead of the matching resource. 17463 */ 17464 ITERATE, 17465 /** 17466 * added to help the parsers 17467 */ 17468 NULL; 17469 public static SearchModifierCode fromCode(String codeString) throws FHIRException { 17470 if (codeString == null || "".equals(codeString)) 17471 return null; 17472 if ("missing".equals(codeString)) 17473 return MISSING; 17474 if ("exact".equals(codeString)) 17475 return EXACT; 17476 if ("contains".equals(codeString)) 17477 return CONTAINS; 17478 if ("not".equals(codeString)) 17479 return NOT; 17480 if ("text".equals(codeString)) 17481 return TEXT; 17482 if ("in".equals(codeString)) 17483 return IN; 17484 if ("not-in".equals(codeString)) 17485 return NOTIN; 17486 if ("below".equals(codeString)) 17487 return BELOW; 17488 if ("above".equals(codeString)) 17489 return ABOVE; 17490 if ("type".equals(codeString)) 17491 return TYPE; 17492 if ("identifier".equals(codeString)) 17493 return IDENTIFIER; 17494 if ("of-type".equals(codeString)) 17495 return OFTYPE; 17496 if ("code-text".equals(codeString)) 17497 return CODETEXT; 17498 if ("text-advanced".equals(codeString)) 17499 return TEXTADVANCED; 17500 if ("iterate".equals(codeString)) 17501 return ITERATE; 17502 throw new FHIRException("Unknown SearchModifierCode code '"+codeString+"'"); 17503 } 17504 public static boolean isValidCode(String codeString) { 17505 if (codeString == null || "".equals(codeString)) 17506 return false; 17507 return Utilities.existsInList(codeString, "missing", "exact", "contains", "not", "text", "in", "not-in", "below", "above", "type", "identifier", "of-type", "code-text", "text-advanced", "iterate"); 17508 } 17509 public String toCode() { 17510 switch (this) { 17511 case MISSING: return "missing"; 17512 case EXACT: return "exact"; 17513 case CONTAINS: return "contains"; 17514 case NOT: return "not"; 17515 case TEXT: return "text"; 17516 case IN: return "in"; 17517 case NOTIN: return "not-in"; 17518 case BELOW: return "below"; 17519 case ABOVE: return "above"; 17520 case TYPE: return "type"; 17521 case IDENTIFIER: return "identifier"; 17522 case OFTYPE: return "of-type"; 17523 case CODETEXT: return "code-text"; 17524 case TEXTADVANCED: return "text-advanced"; 17525 case ITERATE: return "iterate"; 17526 case NULL: return null; 17527 default: return "?"; 17528 } 17529 } 17530 public String getSystem() { 17531 switch (this) { 17532 case MISSING: return "http://hl7.org/fhir/search-modifier-code"; 17533 case EXACT: return "http://hl7.org/fhir/search-modifier-code"; 17534 case CONTAINS: return "http://hl7.org/fhir/search-modifier-code"; 17535 case NOT: return "http://hl7.org/fhir/search-modifier-code"; 17536 case TEXT: return "http://hl7.org/fhir/search-modifier-code"; 17537 case IN: return "http://hl7.org/fhir/search-modifier-code"; 17538 case NOTIN: return "http://hl7.org/fhir/search-modifier-code"; 17539 case BELOW: return "http://hl7.org/fhir/search-modifier-code"; 17540 case ABOVE: return "http://hl7.org/fhir/search-modifier-code"; 17541 case TYPE: return "http://hl7.org/fhir/search-modifier-code"; 17542 case IDENTIFIER: return "http://hl7.org/fhir/search-modifier-code"; 17543 case OFTYPE: return "http://hl7.org/fhir/search-modifier-code"; 17544 case CODETEXT: return "http://hl7.org/fhir/search-modifier-code"; 17545 case TEXTADVANCED: return "http://hl7.org/fhir/search-modifier-code"; 17546 case ITERATE: return "http://hl7.org/fhir/search-modifier-code"; 17547 case NULL: return null; 17548 default: return "?"; 17549 } 17550 } 17551 public String getDefinition() { 17552 switch (this) { 17553 case MISSING: return "The search parameter returns resources that have a value or not."; 17554 case EXACT: return "The search parameter returns resources that have a value that exactly matches the supplied parameter (the whole string, including casing and accents)."; 17555 case CONTAINS: return "The search parameter returns resources that include the supplied parameter value anywhere within the field being searched."; 17556 case NOT: return "The search parameter returns resources that do not contain a match."; 17557 case TEXT: return "The search parameter is processed as a string that searches text associated with the code/value - either CodeableConcept.text, Coding.display, Identifier.type.text, or Reference.display."; 17558 case IN: return "The search parameter is a URI (relative or absolute) that identifies a value set, and the search parameter tests whether the coding is in the specified value set."; 17559 case NOTIN: return "The search parameter is a URI (relative or absolute) that identifies a value set, and the search parameter tests whether the coding is not in the specified value set."; 17560 case BELOW: return "The search parameter tests whether the value in a resource is subsumed by the specified value (is-a, or hierarchical relationships)."; 17561 case ABOVE: return "The search parameter tests whether the value in a resource subsumes the specified value (is-a, or hierarchical relationships)."; 17562 case TYPE: return "The search parameter only applies to the Resource Type specified as a modifier (e.g. the modifier is not actually :type, but :Patient etc.)."; 17563 case IDENTIFIER: return "The search parameter applies to the identifier on the resource, not the reference."; 17564 case OFTYPE: return "The search parameter has the format system|code|value, where the system and code refer to an Identifier.type.coding.system and .code, and match if any of the type codes match. All 3 parts must be present."; 17565 case CODETEXT: return "Tests whether the textual display value in a resource (e.g., CodeableConcept.text, Coding.display, or Reference.display) matches the supplied parameter value."; 17566 case TEXTADVANCED: return "Tests whether the value in a resource matches the supplied parameter value using advanced text handling that searches text associated with the code/value - e.g., CodeableConcept.text, Coding.display, or Identifier.type.text."; 17567 case ITERATE: return "The search parameter indicates an inclusion directive (_include, _revinclude) that is applied to an included resource instead of the matching resource."; 17568 case NULL: return null; 17569 default: return "?"; 17570 } 17571 } 17572 public String getDisplay() { 17573 switch (this) { 17574 case MISSING: return "Missing"; 17575 case EXACT: return "Exact"; 17576 case CONTAINS: return "Contains"; 17577 case NOT: return "Not"; 17578 case TEXT: return "Text"; 17579 case IN: return "In"; 17580 case NOTIN: return "Not In"; 17581 case BELOW: return "Below"; 17582 case ABOVE: return "Above"; 17583 case TYPE: return "Type"; 17584 case IDENTIFIER: return "Identifier"; 17585 case OFTYPE: return "Of Type"; 17586 case CODETEXT: return "Code Text"; 17587 case TEXTADVANCED: return "Text Advanced"; 17588 case ITERATE: return "Iterate"; 17589 case NULL: return null; 17590 default: return "?"; 17591 } 17592 } 17593 } 17594 17595 public static class SearchModifierCodeEnumFactory implements EnumFactory<SearchModifierCode> { 17596 public SearchModifierCode fromCode(String codeString) throws IllegalArgumentException { 17597 if (codeString == null || "".equals(codeString)) 17598 if (codeString == null || "".equals(codeString)) 17599 return null; 17600 if ("missing".equals(codeString)) 17601 return SearchModifierCode.MISSING; 17602 if ("exact".equals(codeString)) 17603 return SearchModifierCode.EXACT; 17604 if ("contains".equals(codeString)) 17605 return SearchModifierCode.CONTAINS; 17606 if ("not".equals(codeString)) 17607 return SearchModifierCode.NOT; 17608 if ("text".equals(codeString)) 17609 return SearchModifierCode.TEXT; 17610 if ("in".equals(codeString)) 17611 return SearchModifierCode.IN; 17612 if ("not-in".equals(codeString)) 17613 return SearchModifierCode.NOTIN; 17614 if ("below".equals(codeString)) 17615 return SearchModifierCode.BELOW; 17616 if ("above".equals(codeString)) 17617 return SearchModifierCode.ABOVE; 17618 if ("type".equals(codeString)) 17619 return SearchModifierCode.TYPE; 17620 if ("identifier".equals(codeString)) 17621 return SearchModifierCode.IDENTIFIER; 17622 if ("of-type".equals(codeString)) 17623 return SearchModifierCode.OFTYPE; 17624 if ("code-text".equals(codeString)) 17625 return SearchModifierCode.CODETEXT; 17626 if ("text-advanced".equals(codeString)) 17627 return SearchModifierCode.TEXTADVANCED; 17628 if ("iterate".equals(codeString)) 17629 return SearchModifierCode.ITERATE; 17630 throw new IllegalArgumentException("Unknown SearchModifierCode code '"+codeString+"'"); 17631 } 17632 17633 public Enumeration<SearchModifierCode> fromType(PrimitiveType<?> code) throws FHIRException { 17634 if (code == null) 17635 return null; 17636 if (code.isEmpty()) 17637 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.NULL, code); 17638 String codeString = ((PrimitiveType) code).asStringValue(); 17639 if (codeString == null || "".equals(codeString)) 17640 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.NULL, code); 17641 if ("missing".equals(codeString)) 17642 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.MISSING, code); 17643 if ("exact".equals(codeString)) 17644 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.EXACT, code); 17645 if ("contains".equals(codeString)) 17646 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.CONTAINS, code); 17647 if ("not".equals(codeString)) 17648 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.NOT, code); 17649 if ("text".equals(codeString)) 17650 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.TEXT, code); 17651 if ("in".equals(codeString)) 17652 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.IN, code); 17653 if ("not-in".equals(codeString)) 17654 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.NOTIN, code); 17655 if ("below".equals(codeString)) 17656 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.BELOW, code); 17657 if ("above".equals(codeString)) 17658 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.ABOVE, code); 17659 if ("type".equals(codeString)) 17660 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.TYPE, code); 17661 if ("identifier".equals(codeString)) 17662 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.IDENTIFIER, code); 17663 if ("of-type".equals(codeString)) 17664 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.OFTYPE, code); 17665 if ("code-text".equals(codeString)) 17666 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.CODETEXT, code); 17667 if ("text-advanced".equals(codeString)) 17668 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.TEXTADVANCED, code); 17669 if ("iterate".equals(codeString)) 17670 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.ITERATE, code); 17671 throw new FHIRException("Unknown SearchModifierCode code '"+codeString+"'"); 17672 } 17673 public String toCode(SearchModifierCode code) { 17674 if (code == SearchModifierCode.MISSING) 17675 return "missing"; 17676 if (code == SearchModifierCode.EXACT) 17677 return "exact"; 17678 if (code == SearchModifierCode.CONTAINS) 17679 return "contains"; 17680 if (code == SearchModifierCode.NOT) 17681 return "not"; 17682 if (code == SearchModifierCode.TEXT) 17683 return "text"; 17684 if (code == SearchModifierCode.IN) 17685 return "in"; 17686 if (code == SearchModifierCode.NOTIN) 17687 return "not-in"; 17688 if (code == SearchModifierCode.BELOW) 17689 return "below"; 17690 if (code == SearchModifierCode.ABOVE) 17691 return "above"; 17692 if (code == SearchModifierCode.TYPE) 17693 return "type"; 17694 if (code == SearchModifierCode.IDENTIFIER) 17695 return "identifier"; 17696 if (code == SearchModifierCode.OFTYPE) 17697 return "of-type"; 17698 if (code == SearchModifierCode.CODETEXT) 17699 return "code-text"; 17700 if (code == SearchModifierCode.TEXTADVANCED) 17701 return "text-advanced"; 17702 if (code == SearchModifierCode.ITERATE) 17703 return "iterate"; 17704 return "?"; 17705 } 17706 public String toSystem(SearchModifierCode code) { 17707 return code.getSystem(); 17708 } 17709 } 17710 17711 public enum SearchParamType { 17712 /** 17713 * Search parameter SHALL be a number (a whole number, or a decimal). 17714 */ 17715 NUMBER, 17716 /** 17717 * Search parameter is on a date/time. The date format is the standard XML format, though other formats may be supported. 17718 */ 17719 DATE, 17720 /** 17721 * Search parameter is a simple string, like a name part. Search is case-insensitive and accent-insensitive. May match just the start of a string. String parameters may contain spaces. 17722 */ 17723 STRING, 17724 /** 17725 * Search parameter on a coded element or identifier. May be used to search through the text, display, code and code/codesystem (for codes) and label, system and key (for identifier). Its value is either a string or a pair of namespace and value, separated by a "|", depending on the modifier used. 17726 */ 17727 TOKEN, 17728 /** 17729 * A reference to another resource (Reference or canonical). 17730 */ 17731 REFERENCE, 17732 /** 17733 * A composite search parameter that combines a search on two values together. 17734 */ 17735 COMPOSITE, 17736 /** 17737 * A search parameter that searches on a quantity. 17738 */ 17739 QUANTITY, 17740 /** 17741 * A search parameter that searches on a URI (RFC 3986). 17742 */ 17743 URI, 17744 /** 17745 * Special logic applies to this parameter per the description of the search parameter. 17746 */ 17747 SPECIAL, 17748 /** 17749 * added to help the parsers 17750 */ 17751 NULL; 17752 public static SearchParamType fromCode(String codeString) throws FHIRException { 17753 if (codeString == null || "".equals(codeString)) 17754 return null; 17755 if ("number".equals(codeString)) 17756 return NUMBER; 17757 if ("date".equals(codeString)) 17758 return DATE; 17759 if ("string".equals(codeString)) 17760 return STRING; 17761 if ("token".equals(codeString)) 17762 return TOKEN; 17763 if ("reference".equals(codeString)) 17764 return REFERENCE; 17765 if ("composite".equals(codeString)) 17766 return COMPOSITE; 17767 if ("quantity".equals(codeString)) 17768 return QUANTITY; 17769 if ("uri".equals(codeString)) 17770 return URI; 17771 if ("special".equals(codeString)) 17772 return SPECIAL; 17773 throw new FHIRException("Unknown SearchParamType code '"+codeString+"'"); 17774 } 17775 public static boolean isValidCode(String codeString) { 17776 if (codeString == null || "".equals(codeString)) 17777 return false; 17778 return Utilities.existsInList(codeString, "number", "date", "string", "token", "reference", "composite", "quantity", "uri", "special"); 17779 } 17780 public String toCode() { 17781 switch (this) { 17782 case NUMBER: return "number"; 17783 case DATE: return "date"; 17784 case STRING: return "string"; 17785 case TOKEN: return "token"; 17786 case REFERENCE: return "reference"; 17787 case COMPOSITE: return "composite"; 17788 case QUANTITY: return "quantity"; 17789 case URI: return "uri"; 17790 case SPECIAL: return "special"; 17791 case NULL: return null; 17792 default: return "?"; 17793 } 17794 } 17795 public String getSystem() { 17796 switch (this) { 17797 case NUMBER: return "http://hl7.org/fhir/search-param-type"; 17798 case DATE: return "http://hl7.org/fhir/search-param-type"; 17799 case STRING: return "http://hl7.org/fhir/search-param-type"; 17800 case TOKEN: return "http://hl7.org/fhir/search-param-type"; 17801 case REFERENCE: return "http://hl7.org/fhir/search-param-type"; 17802 case COMPOSITE: return "http://hl7.org/fhir/search-param-type"; 17803 case QUANTITY: return "http://hl7.org/fhir/search-param-type"; 17804 case URI: return "http://hl7.org/fhir/search-param-type"; 17805 case SPECIAL: return "http://hl7.org/fhir/search-param-type"; 17806 case NULL: return null; 17807 default: return "?"; 17808 } 17809 } 17810 public String getDefinition() { 17811 switch (this) { 17812 case NUMBER: return "Search parameter SHALL be a number (a whole number, or a decimal)."; 17813 case DATE: return "Search parameter is on a date/time. The date format is the standard XML format, though other formats may be supported."; 17814 case STRING: return "Search parameter is a simple string, like a name part. Search is case-insensitive and accent-insensitive. May match just the start of a string. String parameters may contain spaces."; 17815 case TOKEN: return "Search parameter on a coded element or identifier. May be used to search through the text, display, code and code/codesystem (for codes) and label, system and key (for identifier). Its value is either a string or a pair of namespace and value, separated by a \"|\", depending on the modifier used."; 17816 case REFERENCE: return "A reference to another resource (Reference or canonical)."; 17817 case COMPOSITE: return "A composite search parameter that combines a search on two values together."; 17818 case QUANTITY: return "A search parameter that searches on a quantity."; 17819 case URI: return "A search parameter that searches on a URI (RFC 3986)."; 17820 case SPECIAL: return "Special logic applies to this parameter per the description of the search parameter."; 17821 case NULL: return null; 17822 default: return "?"; 17823 } 17824 } 17825 public String getDisplay() { 17826 switch (this) { 17827 case NUMBER: return "Number"; 17828 case DATE: return "Date/DateTime"; 17829 case STRING: return "String"; 17830 case TOKEN: return "Token"; 17831 case REFERENCE: return "Reference"; 17832 case COMPOSITE: return "Composite"; 17833 case QUANTITY: return "Quantity"; 17834 case URI: return "URI"; 17835 case SPECIAL: return "Special"; 17836 case NULL: return null; 17837 default: return "?"; 17838 } 17839 } 17840 } 17841 17842 public static class SearchParamTypeEnumFactory implements EnumFactory<SearchParamType> { 17843 public SearchParamType fromCode(String codeString) throws IllegalArgumentException { 17844 if (codeString == null || "".equals(codeString)) 17845 if (codeString == null || "".equals(codeString)) 17846 return null; 17847 if ("number".equals(codeString)) 17848 return SearchParamType.NUMBER; 17849 if ("date".equals(codeString)) 17850 return SearchParamType.DATE; 17851 if ("string".equals(codeString)) 17852 return SearchParamType.STRING; 17853 if ("token".equals(codeString)) 17854 return SearchParamType.TOKEN; 17855 if ("reference".equals(codeString)) 17856 return SearchParamType.REFERENCE; 17857 if ("composite".equals(codeString)) 17858 return SearchParamType.COMPOSITE; 17859 if ("quantity".equals(codeString)) 17860 return SearchParamType.QUANTITY; 17861 if ("uri".equals(codeString)) 17862 return SearchParamType.URI; 17863 if ("special".equals(codeString)) 17864 return SearchParamType.SPECIAL; 17865 throw new IllegalArgumentException("Unknown SearchParamType code '"+codeString+"'"); 17866 } 17867 17868 public Enumeration<SearchParamType> fromType(PrimitiveType<?> code) throws FHIRException { 17869 if (code == null) 17870 return null; 17871 if (code.isEmpty()) 17872 return new Enumeration<SearchParamType>(this, SearchParamType.NULL, code); 17873 String codeString = ((PrimitiveType) code).asStringValue(); 17874 if (codeString == null || "".equals(codeString)) 17875 return new Enumeration<SearchParamType>(this, SearchParamType.NULL, code); 17876 if ("number".equals(codeString)) 17877 return new Enumeration<SearchParamType>(this, SearchParamType.NUMBER, code); 17878 if ("date".equals(codeString)) 17879 return new Enumeration<SearchParamType>(this, SearchParamType.DATE, code); 17880 if ("string".equals(codeString)) 17881 return new Enumeration<SearchParamType>(this, SearchParamType.STRING, code); 17882 if ("token".equals(codeString)) 17883 return new Enumeration<SearchParamType>(this, SearchParamType.TOKEN, code); 17884 if ("reference".equals(codeString)) 17885 return new Enumeration<SearchParamType>(this, SearchParamType.REFERENCE, code); 17886 if ("composite".equals(codeString)) 17887 return new Enumeration<SearchParamType>(this, SearchParamType.COMPOSITE, code); 17888 if ("quantity".equals(codeString)) 17889 return new Enumeration<SearchParamType>(this, SearchParamType.QUANTITY, code); 17890 if ("uri".equals(codeString)) 17891 return new Enumeration<SearchParamType>(this, SearchParamType.URI, code); 17892 if ("special".equals(codeString)) 17893 return new Enumeration<SearchParamType>(this, SearchParamType.SPECIAL, code); 17894 throw new FHIRException("Unknown SearchParamType code '"+codeString+"'"); 17895 } 17896 public String toCode(SearchParamType code) { 17897 if (code == SearchParamType.NUMBER) 17898 return "number"; 17899 if (code == SearchParamType.DATE) 17900 return "date"; 17901 if (code == SearchParamType.STRING) 17902 return "string"; 17903 if (code == SearchParamType.TOKEN) 17904 return "token"; 17905 if (code == SearchParamType.REFERENCE) 17906 return "reference"; 17907 if (code == SearchParamType.COMPOSITE) 17908 return "composite"; 17909 if (code == SearchParamType.QUANTITY) 17910 return "quantity"; 17911 if (code == SearchParamType.URI) 17912 return "uri"; 17913 if (code == SearchParamType.SPECIAL) 17914 return "special"; 17915 return "?"; 17916 } 17917 public String toSystem(SearchParamType code) { 17918 return code.getSystem(); 17919 } 17920 } 17921 17922 public enum SubscriptionStatusCodes { 17923 /** 17924 * The client has requested the subscription, and the server has not yet set it up. 17925 */ 17926 REQUESTED, 17927 /** 17928 * The subscription is active. 17929 */ 17930 ACTIVE, 17931 /** 17932 * The server has an error executing the notification. 17933 */ 17934 ERROR, 17935 /** 17936 * Too many errors have occurred or the subscription has expired. 17937 */ 17938 OFF, 17939 /** 17940 * This subscription has been flagged as incorrect. 17941 */ 17942 ENTEREDINERROR, 17943 /** 17944 * added to help the parsers 17945 */ 17946 NULL; 17947 public static SubscriptionStatusCodes fromCode(String codeString) throws FHIRException { 17948 if (codeString == null || "".equals(codeString)) 17949 return null; 17950 if ("requested".equals(codeString)) 17951 return REQUESTED; 17952 if ("active".equals(codeString)) 17953 return ACTIVE; 17954 if ("error".equals(codeString)) 17955 return ERROR; 17956 if ("off".equals(codeString)) 17957 return OFF; 17958 if ("entered-in-error".equals(codeString)) 17959 return ENTEREDINERROR; 17960 throw new FHIRException("Unknown SubscriptionStatusCodes code '"+codeString+"'"); 17961 } 17962 public static boolean isValidCode(String codeString) { 17963 if (codeString == null || "".equals(codeString)) 17964 return false; 17965 return Utilities.existsInList(codeString, "requested", "active", "error", "off", "entered-in-error"); 17966 } 17967 public String toCode() { 17968 switch (this) { 17969 case REQUESTED: return "requested"; 17970 case ACTIVE: return "active"; 17971 case ERROR: return "error"; 17972 case OFF: return "off"; 17973 case ENTEREDINERROR: return "entered-in-error"; 17974 case NULL: return null; 17975 default: return "?"; 17976 } 17977 } 17978 public String getSystem() { 17979 switch (this) { 17980 case REQUESTED: return "http://hl7.org/fhir/subscription-status"; 17981 case ACTIVE: return "http://hl7.org/fhir/subscription-status"; 17982 case ERROR: return "http://hl7.org/fhir/subscription-status"; 17983 case OFF: return "http://hl7.org/fhir/subscription-status"; 17984 case ENTEREDINERROR: return "http://hl7.org/fhir/subscription-status"; 17985 case NULL: return null; 17986 default: return "?"; 17987 } 17988 } 17989 public String getDefinition() { 17990 switch (this) { 17991 case REQUESTED: return "The client has requested the subscription, and the server has not yet set it up."; 17992 case ACTIVE: return "The subscription is active."; 17993 case ERROR: return "The server has an error executing the notification."; 17994 case OFF: return "Too many errors have occurred or the subscription has expired."; 17995 case ENTEREDINERROR: return "This subscription has been flagged as incorrect."; 17996 case NULL: return null; 17997 default: return "?"; 17998 } 17999 } 18000 public String getDisplay() { 18001 switch (this) { 18002 case REQUESTED: return "Requested"; 18003 case ACTIVE: return "Active"; 18004 case ERROR: return "Error"; 18005 case OFF: return "Off"; 18006 case ENTEREDINERROR: return "Entered in Error"; 18007 case NULL: return null; 18008 default: return "?"; 18009 } 18010 } 18011 } 18012 18013 public static class SubscriptionStatusCodesEnumFactory implements EnumFactory<SubscriptionStatusCodes> { 18014 public SubscriptionStatusCodes fromCode(String codeString) throws IllegalArgumentException { 18015 if (codeString == null || "".equals(codeString)) 18016 if (codeString == null || "".equals(codeString)) 18017 return null; 18018 if ("requested".equals(codeString)) 18019 return SubscriptionStatusCodes.REQUESTED; 18020 if ("active".equals(codeString)) 18021 return SubscriptionStatusCodes.ACTIVE; 18022 if ("error".equals(codeString)) 18023 return SubscriptionStatusCodes.ERROR; 18024 if ("off".equals(codeString)) 18025 return SubscriptionStatusCodes.OFF; 18026 if ("entered-in-error".equals(codeString)) 18027 return SubscriptionStatusCodes.ENTEREDINERROR; 18028 throw new IllegalArgumentException("Unknown SubscriptionStatusCodes code '"+codeString+"'"); 18029 } 18030 18031 public Enumeration<SubscriptionStatusCodes> fromType(PrimitiveType<?> code) throws FHIRException { 18032 if (code == null) 18033 return null; 18034 if (code.isEmpty()) 18035 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.NULL, code); 18036 String codeString = ((PrimitiveType) code).asStringValue(); 18037 if (codeString == null || "".equals(codeString)) 18038 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.NULL, code); 18039 if ("requested".equals(codeString)) 18040 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.REQUESTED, code); 18041 if ("active".equals(codeString)) 18042 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.ACTIVE, code); 18043 if ("error".equals(codeString)) 18044 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.ERROR, code); 18045 if ("off".equals(codeString)) 18046 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.OFF, code); 18047 if ("entered-in-error".equals(codeString)) 18048 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.ENTEREDINERROR, code); 18049 throw new FHIRException("Unknown SubscriptionStatusCodes code '"+codeString+"'"); 18050 } 18051 public String toCode(SubscriptionStatusCodes code) { 18052 if (code == SubscriptionStatusCodes.REQUESTED) 18053 return "requested"; 18054 if (code == SubscriptionStatusCodes.ACTIVE) 18055 return "active"; 18056 if (code == SubscriptionStatusCodes.ERROR) 18057 return "error"; 18058 if (code == SubscriptionStatusCodes.OFF) 18059 return "off"; 18060 if (code == SubscriptionStatusCodes.ENTEREDINERROR) 18061 return "entered-in-error"; 18062 return "?"; 18063 } 18064 public String toSystem(SubscriptionStatusCodes code) { 18065 return code.getSystem(); 18066 } 18067 } 18068 18069 public enum Use { 18070 /** 18071 * The treatment is complete and this represents a Claim for the services. 18072 */ 18073 CLAIM, 18074 /** 18075 * The treatment is proposed and this represents a Pre-authorization for the services. 18076 */ 18077 PREAUTHORIZATION, 18078 /** 18079 * The treatment is proposed and this represents a Pre-determination for the services. 18080 */ 18081 PREDETERMINATION, 18082 /** 18083 * added to help the parsers 18084 */ 18085 NULL; 18086 public static Use fromCode(String codeString) throws FHIRException { 18087 if (codeString == null || "".equals(codeString)) 18088 return null; 18089 if ("claim".equals(codeString)) 18090 return CLAIM; 18091 if ("preauthorization".equals(codeString)) 18092 return PREAUTHORIZATION; 18093 if ("predetermination".equals(codeString)) 18094 return PREDETERMINATION; 18095 throw new FHIRException("Unknown Use code '"+codeString+"'"); 18096 } 18097 public static boolean isValidCode(String codeString) { 18098 if (codeString == null || "".equals(codeString)) 18099 return false; 18100 return Utilities.existsInList(codeString, "claim", "preauthorization", "predetermination"); 18101 } 18102 public String toCode() { 18103 switch (this) { 18104 case CLAIM: return "claim"; 18105 case PREAUTHORIZATION: return "preauthorization"; 18106 case PREDETERMINATION: return "predetermination"; 18107 case NULL: return null; 18108 default: return "?"; 18109 } 18110 } 18111 public String getSystem() { 18112 switch (this) { 18113 case CLAIM: return "http://hl7.org/fhir/claim-use"; 18114 case PREAUTHORIZATION: return "http://hl7.org/fhir/claim-use"; 18115 case PREDETERMINATION: return "http://hl7.org/fhir/claim-use"; 18116 case NULL: return null; 18117 default: return "?"; 18118 } 18119 } 18120 public String getDefinition() { 18121 switch (this) { 18122 case CLAIM: return "The treatment is complete and this represents a Claim for the services."; 18123 case PREAUTHORIZATION: return "The treatment is proposed and this represents a Pre-authorization for the services."; 18124 case PREDETERMINATION: return "The treatment is proposed and this represents a Pre-determination for the services."; 18125 case NULL: return null; 18126 default: return "?"; 18127 } 18128 } 18129 public String getDisplay() { 18130 switch (this) { 18131 case CLAIM: return "Claim"; 18132 case PREAUTHORIZATION: return "Preauthorization"; 18133 case PREDETERMINATION: return "Predetermination"; 18134 case NULL: return null; 18135 default: return "?"; 18136 } 18137 } 18138 } 18139 18140 public static class UseEnumFactory implements EnumFactory<Use> { 18141 public Use fromCode(String codeString) throws IllegalArgumentException { 18142 if (codeString == null || "".equals(codeString)) 18143 if (codeString == null || "".equals(codeString)) 18144 return null; 18145 if ("claim".equals(codeString)) 18146 return Use.CLAIM; 18147 if ("preauthorization".equals(codeString)) 18148 return Use.PREAUTHORIZATION; 18149 if ("predetermination".equals(codeString)) 18150 return Use.PREDETERMINATION; 18151 throw new IllegalArgumentException("Unknown Use code '"+codeString+"'"); 18152 } 18153 18154 public Enumeration<Use> fromType(PrimitiveType<?> code) throws FHIRException { 18155 if (code == null) 18156 return null; 18157 if (code.isEmpty()) 18158 return new Enumeration<Use>(this, Use.NULL, code); 18159 String codeString = ((PrimitiveType) code).asStringValue(); 18160 if (codeString == null || "".equals(codeString)) 18161 return new Enumeration<Use>(this, Use.NULL, code); 18162 if ("claim".equals(codeString)) 18163 return new Enumeration<Use>(this, Use.CLAIM, code); 18164 if ("preauthorization".equals(codeString)) 18165 return new Enumeration<Use>(this, Use.PREAUTHORIZATION, code); 18166 if ("predetermination".equals(codeString)) 18167 return new Enumeration<Use>(this, Use.PREDETERMINATION, code); 18168 throw new FHIRException("Unknown Use code '"+codeString+"'"); 18169 } 18170 public String toCode(Use code) { 18171 if (code == Use.CLAIM) 18172 return "claim"; 18173 if (code == Use.PREAUTHORIZATION) 18174 return "preauthorization"; 18175 if (code == Use.PREDETERMINATION) 18176 return "predetermination"; 18177 return "?"; 18178 } 18179 public String toSystem(Use code) { 18180 return code.getSystem(); 18181 } 18182 } 18183 18184 public enum VersionIndependentResourceTypesAll { 18185 /** 18186 * 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. 18187 */ 18188 ACCOUNT, 18189 /** 18190 * This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context. 18191 */ 18192 ACTIVITYDEFINITION, 18193 /** 18194 * 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. 18195 */ 18196 ACTORDEFINITION, 18197 /** 18198 * 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). 18199 */ 18200 ADMINISTRABLEPRODUCTDEFINITION, 18201 /** 18202 * 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. 18203 */ 18204 ADVERSEEVENT, 18205 /** 18206 * Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance. 18207 */ 18208 ALLERGYINTOLERANCE, 18209 /** 18210 * 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). 18211 */ 18212 APPOINTMENT, 18213 /** 18214 * A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection. 18215 */ 18216 APPOINTMENTRESPONSE, 18217 /** 18218 * This Resource provides one or more comments, classifiers or ratings about a Resource and supports attribution and rights management metadata for the added content. 18219 */ 18220 ARTIFACTASSESSMENT, 18221 /** 18222 * A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis. 18223 */ 18224 AUDITEVENT, 18225 /** 18226 * 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. 18227 */ 18228 BASIC, 18229 /** 18230 * 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. 18231 */ 18232 BINARY, 18233 /** 18234 * A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity. 18235 */ 18236 BIOLOGICALLYDERIVEDPRODUCT, 18237 /** 18238 * A record of dispensation of a biologically derived product. 18239 */ 18240 BIOLOGICALLYDERIVEDPRODUCTDISPENSE, 18241 /** 18242 * 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. 18243 */ 18244 BODYSTRUCTURE, 18245 /** 18246 * A container for a collection of resources. 18247 */ 18248 BUNDLE, 18249 /** 18250 * Common Interface declaration for conformance and knowledge artifact resources. 18251 */ 18252 CANONICALRESOURCE, 18253 /** 18254 * 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. 18255 */ 18256 CAPABILITYSTATEMENT, 18257 /** 18258 * 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. 18259 */ 18260 CAREPLAN, 18261 /** 18262 * The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care. 18263 */ 18264 CARETEAM, 18265 /** 18266 * 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. 18267 */ 18268 CHARGEITEM, 18269 /** 18270 * 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. 18271 */ 18272 CHARGEITEMDEFINITION, 18273 /** 18274 * 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. 18275 */ 18276 CITATION, 18277 /** 18278 * 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. 18279 */ 18280 CLAIM, 18281 /** 18282 * This resource provides the adjudication details from the processing of a Claim resource. 18283 */ 18284 CLAIMRESPONSE, 18285 /** 18286 * 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. 18287 */ 18288 CLINICALIMPRESSION, 18289 /** 18290 * A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure. 18291 */ 18292 CLINICALUSEDEFINITION, 18293 /** 18294 * 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. 18295 */ 18296 CODESYSTEM, 18297 /** 18298 * 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. 18299 */ 18300 COMMUNICATION, 18301 /** 18302 * 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. 18303 */ 18304 COMMUNICATIONREQUEST, 18305 /** 18306 * A compartment definition that defines how resources are accessed on a server. 18307 */ 18308 COMPARTMENTDEFINITION, 18309 /** 18310 * 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.). 18311 */ 18312 COMPOSITION, 18313 /** 18314 * 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. 18315 */ 18316 CONCEPTMAP, 18317 /** 18318 * A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern. 18319 */ 18320 CONDITION, 18321 /** 18322 * A definition of a condition and information relevant to managing it. 18323 */ 18324 CONDITIONDEFINITION, 18325 /** 18326 * 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. 18327 */ 18328 CONSENT, 18329 /** 18330 * Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement. 18331 */ 18332 CONTRACT, 18333 /** 18334 * Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment. 18335 */ 18336 COVERAGE, 18337 /** 18338 * 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. 18339 */ 18340 COVERAGEELIGIBILITYREQUEST, 18341 /** 18342 * This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource. 18343 */ 18344 COVERAGEELIGIBILITYRESPONSE, 18345 /** 18346 * 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. 18347 */ 18348 DETECTEDISSUE, 18349 /** 18350 * 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. 18351 */ 18352 DEVICE, 18353 /** 18354 * A record of association of a device. 18355 */ 18356 DEVICEASSOCIATION, 18357 /** 18358 * This is a specialized resource that defines the characteristics and capabilities of a device. 18359 */ 18360 DEVICEDEFINITION, 18361 /** 18362 * 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. 18363 */ 18364 DEVICEDISPENSE, 18365 /** 18366 * 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. 18367 */ 18368 DEVICEMETRIC, 18369 /** 18370 * 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. 18371 */ 18372 DEVICEREQUEST, 18373 /** 18374 * 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. 18375 */ 18376 DEVICEUSAGE, 18377 /** 18378 * 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. 18379 */ 18380 DIAGNOSTICREPORT, 18381 /** 18382 * 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. 18383 */ 18384 DOCUMENTREFERENCE, 18385 /** 18386 * A resource that includes narrative, extensions, and contained resources. 18387 */ 18388 DOMAINRESOURCE, 18389 /** 18390 * 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). 18391 */ 18392 ENCOUNTER, 18393 /** 18394 * A record of significant events/milestones key data throughout the history of an Encounter 18395 */ 18396 ENCOUNTERHISTORY, 18397 /** 18398 * 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. 18399 */ 18400 ENDPOINT, 18401 /** 18402 * This resource provides the insurance enrollment details to the insurer regarding a specified coverage. 18403 */ 18404 ENROLLMENTREQUEST, 18405 /** 18406 * This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource. 18407 */ 18408 ENROLLMENTRESPONSE, 18409 /** 18410 * 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. 18411 */ 18412 EPISODEOFCARE, 18413 /** 18414 * The EventDefinition resource provides a reusable description of when a particular event can occur. 18415 */ 18416 EVENTDEFINITION, 18417 /** 18418 * 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. 18419 */ 18420 EVIDENCE, 18421 /** 18422 * 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. 18423 */ 18424 EVIDENCEREPORT, 18425 /** 18426 * The EvidenceVariable resource describes an element that knowledge (Evidence) is about. 18427 */ 18428 EVIDENCEVARIABLE, 18429 /** 18430 * A walkthrough of a workflow showing the interaction between systems and the instances shared, possibly including the evolution of instances over time. 18431 */ 18432 EXAMPLESCENARIO, 18433 /** 18434 * 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. 18435 */ 18436 EXPLANATIONOFBENEFIT, 18437 /** 18438 * Significant health conditions for a person related to the patient relevant in the context of care for the patient. 18439 */ 18440 FAMILYMEMBERHISTORY, 18441 /** 18442 * Prospective warnings of potential issues when providing care to the patient. 18443 */ 18444 FLAG, 18445 /** 18446 * 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. 18447 */ 18448 FORMULARYITEM, 18449 /** 18450 * A set of analyses performed to analyze and generate genomic data. 18451 */ 18452 GENOMICSTUDY, 18453 /** 18454 * 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. 18455 */ 18456 GOAL, 18457 /** 18458 * 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. 18459 */ 18460 GRAPHDEFINITION, 18461 /** 18462 * 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. 18463 */ 18464 GROUP, 18465 /** 18466 * 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. 18467 */ 18468 GUIDANCERESPONSE, 18469 /** 18470 * 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. 18471 */ 18472 HEALTHCARESERVICE, 18473 /** 18474 * 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. 18475 */ 18476 IMAGINGSELECTION, 18477 /** 18478 * 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. 18479 */ 18480 IMAGINGSTUDY, 18481 /** 18482 * 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. 18483 */ 18484 IMMUNIZATION, 18485 /** 18486 * Describes a comparison of an immunization event against published recommendations to determine if the administration is "valid" in relation to those recommendations. 18487 */ 18488 IMMUNIZATIONEVALUATION, 18489 /** 18490 * A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification. 18491 */ 18492 IMMUNIZATIONRECOMMENDATION, 18493 /** 18494 * 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. 18495 */ 18496 IMPLEMENTATIONGUIDE, 18497 /** 18498 * An ingredient of a manufactured item or pharmaceutical product. 18499 */ 18500 INGREDIENT, 18501 /** 18502 * Details of a Health Insurance product/plan provided by an organization. 18503 */ 18504 INSURANCEPLAN, 18505 /** 18506 * functional description of an inventory item used in inventory and supply-related workflows. 18507 */ 18508 INVENTORYITEM, 18509 /** 18510 * A report of inventory or stock items. 18511 */ 18512 INVENTORYREPORT, 18513 /** 18514 * Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose. 18515 */ 18516 INVOICE, 18517 /** 18518 * 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. 18519 */ 18520 LIBRARY, 18521 /** 18522 * Identifies two or more records (resource instances) that refer to the same real-world "occurrence". 18523 */ 18524 LINKAGE, 18525 /** 18526 * A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc. 18527 */ 18528 LIST, 18529 /** 18530 * Details and position information for a place where services are provided and resources and participants may be stored, found, contained, or accommodated. 18531 */ 18532 LOCATION, 18533 /** 18534 * The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product. 18535 */ 18536 MANUFACTUREDITEMDEFINITION, 18537 /** 18538 * The Measure resource provides the definition of a quality measure. 18539 */ 18540 MEASURE, 18541 /** 18542 * The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation. 18543 */ 18544 MEASUREREPORT, 18545 /** 18546 * 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. 18547 */ 18548 MEDICATION, 18549 /** 18550 * 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. 18551 */ 18552 MEDICATIONADMINISTRATION, 18553 /** 18554 * 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. 18555 */ 18556 MEDICATIONDISPENSE, 18557 /** 18558 * Information about a medication that is used to support knowledge. 18559 */ 18560 MEDICATIONKNOWLEDGE, 18561 /** 18562 * 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. 18563 */ 18564 MEDICATIONREQUEST, 18565 /** 18566 * 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. 18567 18568The 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. 18569 */ 18570 MEDICATIONSTATEMENT, 18571 /** 18572 * 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.). 18573 */ 18574 MEDICINALPRODUCTDEFINITION, 18575 /** 18576 * 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. 18577 */ 18578 MESSAGEDEFINITION, 18579 /** 18580 * 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. 18581 */ 18582 MESSAGEHEADER, 18583 /** 18584 * Common Interface declaration for conformance and knowledge artifact resources. 18585 */ 18586 METADATARESOURCE, 18587 /** 18588 * Representation of a molecular sequence. 18589 */ 18590 MOLECULARSEQUENCE, 18591 /** 18592 * 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. 18593 */ 18594 NAMINGSYSTEM, 18595 /** 18596 * 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. 18597 */ 18598 NUTRITIONINTAKE, 18599 /** 18600 * A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident. 18601 */ 18602 NUTRITIONORDER, 18603 /** 18604 * A food or supplement that is consumed by patients. 18605 */ 18606 NUTRITIONPRODUCT, 18607 /** 18608 * Measurements and simple assertions made about a patient, device or other subject. 18609 */ 18610 OBSERVATION, 18611 /** 18612 * Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service. 18613 */ 18614 OBSERVATIONDEFINITION, 18615 /** 18616 * A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction). 18617 */ 18618 OPERATIONDEFINITION, 18619 /** 18620 * A collection of error, warning, or information messages that result from a system action. 18621 */ 18622 OPERATIONOUTCOME, 18623 /** 18624 * 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. 18625 */ 18626 ORGANIZATION, 18627 /** 18628 * Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship. 18629 */ 18630 ORGANIZATIONAFFILIATION, 18631 /** 18632 * A medically related item or items, in a container or package. 18633 */ 18634 PACKAGEDPRODUCTDEFINITION, 18635 /** 18636 * 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. 18637 */ 18638 PARAMETERS, 18639 /** 18640 * Demographics and other administrative information about an individual or animal receiving care or other health-related services. 18641 */ 18642 PATIENT, 18643 /** 18644 * This resource provides the status of the payment for goods and services rendered, and the request and response resource references. 18645 */ 18646 PAYMENTNOTICE, 18647 /** 18648 * This resource provides the details including amount of a payment and allocates the payment items being paid. 18649 */ 18650 PAYMENTRECONCILIATION, 18651 /** 18652 * Permission resource holds access rules for a given data and context. 18653 */ 18654 PERMISSION, 18655 /** 18656 * Demographics and administrative information about a person independent of a specific health-related context. 18657 */ 18658 PERSON, 18659 /** 18660 * 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. 18661 */ 18662 PLANDEFINITION, 18663 /** 18664 * A person who is directly or indirectly involved in the provisioning of healthcare or related services. 18665 */ 18666 PRACTITIONER, 18667 /** 18668 * A specific set of Roles/Locations/specialties/services that a practitioner may perform, or has performed at an organization during a period of time. 18669 */ 18670 PRACTITIONERROLE, 18671 /** 18672 * 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. 18673 */ 18674 PROCEDURE, 18675 /** 18676 * 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. 18677 */ 18678 PROVENANCE, 18679 /** 18680 * 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. 18681 */ 18682 QUESTIONNAIRE, 18683 /** 18684 * 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. 18685 */ 18686 QUESTIONNAIRERESPONSE, 18687 /** 18688 * 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. 18689 */ 18690 REGULATEDAUTHORIZATION, 18691 /** 18692 * 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. 18693 */ 18694 RELATEDPERSON, 18695 /** 18696 * 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". 18697 */ 18698 REQUESTORCHESTRATION, 18699 /** 18700 * 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. 18701 */ 18702 REQUIREMENTS, 18703 /** 18704 * 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. 18705 */ 18706 RESEARCHSTUDY, 18707 /** 18708 * A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study. 18709 */ 18710 RESEARCHSUBJECT, 18711 /** 18712 * This is the base resource type for everything. 18713 */ 18714 RESOURCE, 18715 /** 18716 * An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome. 18717 */ 18718 RISKASSESSMENT, 18719 /** 18720 * A container for slots of time that may be available for booking appointments. 18721 */ 18722 SCHEDULE, 18723 /** 18724 * A search parameter that defines a named search item that can be used to search/filter on a resource. 18725 */ 18726 SEARCHPARAMETER, 18727 /** 18728 * A record of a request for service such as diagnostic investigations, treatments, or operations to be performed. 18729 */ 18730 SERVICEREQUEST, 18731 /** 18732 * A slot of time on a schedule that may be available for booking appointments. 18733 */ 18734 SLOT, 18735 /** 18736 * A sample to be used for analysis. 18737 */ 18738 SPECIMEN, 18739 /** 18740 * A kind of specimen with associated set of requirements. 18741 */ 18742 SPECIMENDEFINITION, 18743 /** 18744 * 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. 18745 */ 18746 STRUCTUREDEFINITION, 18747 /** 18748 * A Map of relationships between 2 structures that can be used to transform data. 18749 */ 18750 STRUCTUREMAP, 18751 /** 18752 * The subscription resource describes a particular client's request to be notified about a SubscriptionTopic. 18753 */ 18754 SUBSCRIPTION, 18755 /** 18756 * The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted. 18757 */ 18758 SUBSCRIPTIONSTATUS, 18759 /** 18760 * Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic. 18761 */ 18762 SUBSCRIPTIONTOPIC, 18763 /** 18764 * A homogeneous material with a definite composition. 18765 */ 18766 SUBSTANCE, 18767 /** 18768 * The detailed description of a substance, typically at a level beyond what is used for prescribing. 18769 */ 18770 SUBSTANCEDEFINITION, 18771 /** 18772 * 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. 18773 */ 18774 SUBSTANCENUCLEICACID, 18775 /** 18776 * Properties of a substance specific to it being a polymer. 18777 */ 18778 SUBSTANCEPOLYMER, 18779 /** 18780 * 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. 18781 */ 18782 SUBSTANCEPROTEIN, 18783 /** 18784 * Todo. 18785 */ 18786 SUBSTANCEREFERENCEINFORMATION, 18787 /** 18788 * 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. 18789 */ 18790 SUBSTANCESOURCEMATERIAL, 18791 /** 18792 * Record of delivery of what is supplied. 18793 */ 18794 SUPPLYDELIVERY, 18795 /** 18796 * 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. 18797 */ 18798 SUPPLYREQUEST, 18799 /** 18800 * A task to be performed. 18801 */ 18802 TASK, 18803 /** 18804 * 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. 18805 */ 18806 TERMINOLOGYCAPABILITIES, 18807 /** 18808 * A plan for executing testing on an artifact or specifications 18809 */ 18810 TESTPLAN, 18811 /** 18812 * A summary of information based on the results of executing a TestScript. 18813 */ 18814 TESTREPORT, 18815 /** 18816 * A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification. 18817 */ 18818 TESTSCRIPT, 18819 /** 18820 * Record of transport. 18821 */ 18822 TRANSPORT, 18823 /** 18824 * 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). 18825 */ 18826 VALUESET, 18827 /** 18828 * Describes validation requirements, source(s), status and dates for one or more elements. 18829 */ 18830 VERIFICATIONRESULT, 18831 /** 18832 * An authorization for the provision of glasses and/or contact lenses to a patient. 18833 */ 18834 VISIONPRESCRIPTION, 18835 /** 18836 * null 18837 */ 18838 BODYSITE, 18839 /** 18840 * null 18841 */ 18842 CATALOGENTRY, 18843 /** 18844 * null 18845 */ 18846 CONFORMANCE, 18847 /** 18848 * null 18849 */ 18850 DATAELEMENT, 18851 /** 18852 * null 18853 */ 18854 DEVICECOMPONENT, 18855 /** 18856 * null 18857 */ 18858 DEVICEUSEREQUEST, 18859 /** 18860 * null 18861 */ 18862 DEVICEUSESTATEMENT, 18863 /** 18864 * null 18865 */ 18866 DIAGNOSTICORDER, 18867 /** 18868 * null 18869 */ 18870 DOCUMENTMANIFEST, 18871 /** 18872 * null 18873 */ 18874 EFFECTEVIDENCESYNTHESIS, 18875 /** 18876 * null 18877 */ 18878 ELIGIBILITYREQUEST, 18879 /** 18880 * null 18881 */ 18882 ELIGIBILITYRESPONSE, 18883 /** 18884 * null 18885 */ 18886 EXPANSIONPROFILE, 18887 /** 18888 * null 18889 */ 18890 IMAGINGMANIFEST, 18891 /** 18892 * null 18893 */ 18894 IMAGINGOBJECTSELECTION, 18895 /** 18896 * null 18897 */ 18898 MEDIA, 18899 /** 18900 * null 18901 */ 18902 MEDICATIONORDER, 18903 /** 18904 * null 18905 */ 18906 MEDICATIONUSAGE, 18907 /** 18908 * null 18909 */ 18910 MEDICINALPRODUCT, 18911 /** 18912 * null 18913 */ 18914 MEDICINALPRODUCTAUTHORIZATION, 18915 /** 18916 * null 18917 */ 18918 MEDICINALPRODUCTCONTRAINDICATION, 18919 /** 18920 * null 18921 */ 18922 MEDICINALPRODUCTINDICATION, 18923 /** 18924 * null 18925 */ 18926 MEDICINALPRODUCTINGREDIENT, 18927 /** 18928 * null 18929 */ 18930 MEDICINALPRODUCTINTERACTION, 18931 /** 18932 * null 18933 */ 18934 MEDICINALPRODUCTMANUFACTURED, 18935 /** 18936 * null 18937 */ 18938 MEDICINALPRODUCTPACKAGED, 18939 /** 18940 * null 18941 */ 18942 MEDICINALPRODUCTPHARMACEUTICAL, 18943 /** 18944 * null 18945 */ 18946 MEDICINALPRODUCTUNDESIRABLEEFFECT, 18947 /** 18948 * null 18949 */ 18950 ORDER, 18951 /** 18952 * null 18953 */ 18954 ORDERRESPONSE, 18955 /** 18956 * null 18957 */ 18958 PROCEDUREREQUEST, 18959 /** 18960 * null 18961 */ 18962 PROCESSREQUEST, 18963 /** 18964 * null 18965 */ 18966 PROCESSRESPONSE, 18967 /** 18968 * null 18969 */ 18970 REFERRALREQUEST, 18971 /** 18972 * null 18973 */ 18974 REQUESTGROUP, 18975 /** 18976 * null 18977 */ 18978 RESEARCHDEFINITION, 18979 /** 18980 * null 18981 */ 18982 RESEARCHELEMENTDEFINITION, 18983 /** 18984 * null 18985 */ 18986 RISKEVIDENCESYNTHESIS, 18987 /** 18988 * null 18989 */ 18990 SEQUENCE, 18991 /** 18992 * null 18993 */ 18994 SERVICEDEFINITION, 18995 /** 18996 * null 18997 */ 18998 SUBSTANCESPECIFICATION, 18999 /** 19000 * added to help the parsers 19001 */ 19002 NULL; 19003 public static VersionIndependentResourceTypesAll fromCode(String codeString) throws FHIRException { 19004 if (codeString == null || "".equals(codeString)) 19005 return null; 19006 if ("Account".equals(codeString)) 19007 return ACCOUNT; 19008 if ("ActivityDefinition".equals(codeString)) 19009 return ACTIVITYDEFINITION; 19010 if ("ActorDefinition".equals(codeString)) 19011 return ACTORDEFINITION; 19012 if ("AdministrableProductDefinition".equals(codeString)) 19013 return ADMINISTRABLEPRODUCTDEFINITION; 19014 if ("AdverseEvent".equals(codeString)) 19015 return ADVERSEEVENT; 19016 if ("AllergyIntolerance".equals(codeString)) 19017 return ALLERGYINTOLERANCE; 19018 if ("Appointment".equals(codeString)) 19019 return APPOINTMENT; 19020 if ("AppointmentResponse".equals(codeString)) 19021 return APPOINTMENTRESPONSE; 19022 if ("ArtifactAssessment".equals(codeString)) 19023 return ARTIFACTASSESSMENT; 19024 if ("AuditEvent".equals(codeString)) 19025 return AUDITEVENT; 19026 if ("Basic".equals(codeString)) 19027 return BASIC; 19028 if ("Binary".equals(codeString)) 19029 return BINARY; 19030 if ("BiologicallyDerivedProduct".equals(codeString)) 19031 return BIOLOGICALLYDERIVEDPRODUCT; 19032 if ("BiologicallyDerivedProductDispense".equals(codeString)) 19033 return BIOLOGICALLYDERIVEDPRODUCTDISPENSE; 19034 if ("BodyStructure".equals(codeString)) 19035 return BODYSTRUCTURE; 19036 if ("Bundle".equals(codeString)) 19037 return BUNDLE; 19038 if ("CanonicalResource".equals(codeString)) 19039 return CANONICALRESOURCE; 19040 if ("CapabilityStatement".equals(codeString)) 19041 return CAPABILITYSTATEMENT; 19042 if ("CarePlan".equals(codeString)) 19043 return CAREPLAN; 19044 if ("CareTeam".equals(codeString)) 19045 return CARETEAM; 19046 if ("ChargeItem".equals(codeString)) 19047 return CHARGEITEM; 19048 if ("ChargeItemDefinition".equals(codeString)) 19049 return CHARGEITEMDEFINITION; 19050 if ("Citation".equals(codeString)) 19051 return CITATION; 19052 if ("Claim".equals(codeString)) 19053 return CLAIM; 19054 if ("ClaimResponse".equals(codeString)) 19055 return CLAIMRESPONSE; 19056 if ("ClinicalImpression".equals(codeString)) 19057 return CLINICALIMPRESSION; 19058 if ("ClinicalUseDefinition".equals(codeString)) 19059 return CLINICALUSEDEFINITION; 19060 if ("CodeSystem".equals(codeString)) 19061 return CODESYSTEM; 19062 if ("Communication".equals(codeString)) 19063 return COMMUNICATION; 19064 if ("CommunicationRequest".equals(codeString)) 19065 return COMMUNICATIONREQUEST; 19066 if ("CompartmentDefinition".equals(codeString)) 19067 return COMPARTMENTDEFINITION; 19068 if ("Composition".equals(codeString)) 19069 return COMPOSITION; 19070 if ("ConceptMap".equals(codeString)) 19071 return CONCEPTMAP; 19072 if ("Condition".equals(codeString)) 19073 return CONDITION; 19074 if ("ConditionDefinition".equals(codeString)) 19075 return CONDITIONDEFINITION; 19076 if ("Consent".equals(codeString)) 19077 return CONSENT; 19078 if ("Contract".equals(codeString)) 19079 return CONTRACT; 19080 if ("Coverage".equals(codeString)) 19081 return COVERAGE; 19082 if ("CoverageEligibilityRequest".equals(codeString)) 19083 return COVERAGEELIGIBILITYREQUEST; 19084 if ("CoverageEligibilityResponse".equals(codeString)) 19085 return COVERAGEELIGIBILITYRESPONSE; 19086 if ("DetectedIssue".equals(codeString)) 19087 return DETECTEDISSUE; 19088 if ("Device".equals(codeString)) 19089 return DEVICE; 19090 if ("DeviceAssociation".equals(codeString)) 19091 return DEVICEASSOCIATION; 19092 if ("DeviceDefinition".equals(codeString)) 19093 return DEVICEDEFINITION; 19094 if ("DeviceDispense".equals(codeString)) 19095 return DEVICEDISPENSE; 19096 if ("DeviceMetric".equals(codeString)) 19097 return DEVICEMETRIC; 19098 if ("DeviceRequest".equals(codeString)) 19099 return DEVICEREQUEST; 19100 if ("DeviceUsage".equals(codeString)) 19101 return DEVICEUSAGE; 19102 if ("DiagnosticReport".equals(codeString)) 19103 return DIAGNOSTICREPORT; 19104 if ("DocumentReference".equals(codeString)) 19105 return DOCUMENTREFERENCE; 19106 if ("DomainResource".equals(codeString)) 19107 return DOMAINRESOURCE; 19108 if ("Encounter".equals(codeString)) 19109 return ENCOUNTER; 19110 if ("EncounterHistory".equals(codeString)) 19111 return ENCOUNTERHISTORY; 19112 if ("Endpoint".equals(codeString)) 19113 return ENDPOINT; 19114 if ("EnrollmentRequest".equals(codeString)) 19115 return ENROLLMENTREQUEST; 19116 if ("EnrollmentResponse".equals(codeString)) 19117 return ENROLLMENTRESPONSE; 19118 if ("EpisodeOfCare".equals(codeString)) 19119 return EPISODEOFCARE; 19120 if ("EventDefinition".equals(codeString)) 19121 return EVENTDEFINITION; 19122 if ("Evidence".equals(codeString)) 19123 return EVIDENCE; 19124 if ("EvidenceReport".equals(codeString)) 19125 return EVIDENCEREPORT; 19126 if ("EvidenceVariable".equals(codeString)) 19127 return EVIDENCEVARIABLE; 19128 if ("ExampleScenario".equals(codeString)) 19129 return EXAMPLESCENARIO; 19130 if ("ExplanationOfBenefit".equals(codeString)) 19131 return EXPLANATIONOFBENEFIT; 19132 if ("FamilyMemberHistory".equals(codeString)) 19133 return FAMILYMEMBERHISTORY; 19134 if ("Flag".equals(codeString)) 19135 return FLAG; 19136 if ("FormularyItem".equals(codeString)) 19137 return FORMULARYITEM; 19138 if ("GenomicStudy".equals(codeString)) 19139 return GENOMICSTUDY; 19140 if ("Goal".equals(codeString)) 19141 return GOAL; 19142 if ("GraphDefinition".equals(codeString)) 19143 return GRAPHDEFINITION; 19144 if ("Group".equals(codeString)) 19145 return GROUP; 19146 if ("GuidanceResponse".equals(codeString)) 19147 return GUIDANCERESPONSE; 19148 if ("HealthcareService".equals(codeString)) 19149 return HEALTHCARESERVICE; 19150 if ("ImagingSelection".equals(codeString)) 19151 return IMAGINGSELECTION; 19152 if ("ImagingStudy".equals(codeString)) 19153 return IMAGINGSTUDY; 19154 if ("Immunization".equals(codeString)) 19155 return IMMUNIZATION; 19156 if ("ImmunizationEvaluation".equals(codeString)) 19157 return IMMUNIZATIONEVALUATION; 19158 if ("ImmunizationRecommendation".equals(codeString)) 19159 return IMMUNIZATIONRECOMMENDATION; 19160 if ("ImplementationGuide".equals(codeString)) 19161 return IMPLEMENTATIONGUIDE; 19162 if ("Ingredient".equals(codeString)) 19163 return INGREDIENT; 19164 if ("InsurancePlan".equals(codeString)) 19165 return INSURANCEPLAN; 19166 if ("InventoryItem".equals(codeString)) 19167 return INVENTORYITEM; 19168 if ("InventoryReport".equals(codeString)) 19169 return INVENTORYREPORT; 19170 if ("Invoice".equals(codeString)) 19171 return INVOICE; 19172 if ("Library".equals(codeString)) 19173 return LIBRARY; 19174 if ("Linkage".equals(codeString)) 19175 return LINKAGE; 19176 if ("List".equals(codeString)) 19177 return LIST; 19178 if ("Location".equals(codeString)) 19179 return LOCATION; 19180 if ("ManufacturedItemDefinition".equals(codeString)) 19181 return MANUFACTUREDITEMDEFINITION; 19182 if ("Measure".equals(codeString)) 19183 return MEASURE; 19184 if ("MeasureReport".equals(codeString)) 19185 return MEASUREREPORT; 19186 if ("Medication".equals(codeString)) 19187 return MEDICATION; 19188 if ("MedicationAdministration".equals(codeString)) 19189 return MEDICATIONADMINISTRATION; 19190 if ("MedicationDispense".equals(codeString)) 19191 return MEDICATIONDISPENSE; 19192 if ("MedicationKnowledge".equals(codeString)) 19193 return MEDICATIONKNOWLEDGE; 19194 if ("MedicationRequest".equals(codeString)) 19195 return MEDICATIONREQUEST; 19196 if ("MedicationStatement".equals(codeString)) 19197 return MEDICATIONSTATEMENT; 19198 if ("MedicinalProductDefinition".equals(codeString)) 19199 return MEDICINALPRODUCTDEFINITION; 19200 if ("MessageDefinition".equals(codeString)) 19201 return MESSAGEDEFINITION; 19202 if ("MessageHeader".equals(codeString)) 19203 return MESSAGEHEADER; 19204 if ("MetadataResource".equals(codeString)) 19205 return METADATARESOURCE; 19206 if ("MolecularSequence".equals(codeString)) 19207 return MOLECULARSEQUENCE; 19208 if ("NamingSystem".equals(codeString)) 19209 return NAMINGSYSTEM; 19210 if ("NutritionIntake".equals(codeString)) 19211 return NUTRITIONINTAKE; 19212 if ("NutritionOrder".equals(codeString)) 19213 return NUTRITIONORDER; 19214 if ("NutritionProduct".equals(codeString)) 19215 return NUTRITIONPRODUCT; 19216 if ("Observation".equals(codeString)) 19217 return OBSERVATION; 19218 if ("ObservationDefinition".equals(codeString)) 19219 return OBSERVATIONDEFINITION; 19220 if ("OperationDefinition".equals(codeString)) 19221 return OPERATIONDEFINITION; 19222 if ("OperationOutcome".equals(codeString)) 19223 return OPERATIONOUTCOME; 19224 if ("Organization".equals(codeString)) 19225 return ORGANIZATION; 19226 if ("OrganizationAffiliation".equals(codeString)) 19227 return ORGANIZATIONAFFILIATION; 19228 if ("PackagedProductDefinition".equals(codeString)) 19229 return PACKAGEDPRODUCTDEFINITION; 19230 if ("Parameters".equals(codeString)) 19231 return PARAMETERS; 19232 if ("Patient".equals(codeString)) 19233 return PATIENT; 19234 if ("PaymentNotice".equals(codeString)) 19235 return PAYMENTNOTICE; 19236 if ("PaymentReconciliation".equals(codeString)) 19237 return PAYMENTRECONCILIATION; 19238 if ("Permission".equals(codeString)) 19239 return PERMISSION; 19240 if ("Person".equals(codeString)) 19241 return PERSON; 19242 if ("PlanDefinition".equals(codeString)) 19243 return PLANDEFINITION; 19244 if ("Practitioner".equals(codeString)) 19245 return PRACTITIONER; 19246 if ("PractitionerRole".equals(codeString)) 19247 return PRACTITIONERROLE; 19248 if ("Procedure".equals(codeString)) 19249 return PROCEDURE; 19250 if ("Provenance".equals(codeString)) 19251 return PROVENANCE; 19252 if ("Questionnaire".equals(codeString)) 19253 return QUESTIONNAIRE; 19254 if ("QuestionnaireResponse".equals(codeString)) 19255 return QUESTIONNAIRERESPONSE; 19256 if ("RegulatedAuthorization".equals(codeString)) 19257 return REGULATEDAUTHORIZATION; 19258 if ("RelatedPerson".equals(codeString)) 19259 return RELATEDPERSON; 19260 if ("RequestOrchestration".equals(codeString)) 19261 return REQUESTORCHESTRATION; 19262 if ("Requirements".equals(codeString)) 19263 return REQUIREMENTS; 19264 if ("ResearchStudy".equals(codeString)) 19265 return RESEARCHSTUDY; 19266 if ("ResearchSubject".equals(codeString)) 19267 return RESEARCHSUBJECT; 19268 if ("Resource".equals(codeString)) 19269 return RESOURCE; 19270 if ("RiskAssessment".equals(codeString)) 19271 return RISKASSESSMENT; 19272 if ("Schedule".equals(codeString)) 19273 return SCHEDULE; 19274 if ("SearchParameter".equals(codeString)) 19275 return SEARCHPARAMETER; 19276 if ("ServiceRequest".equals(codeString)) 19277 return SERVICEREQUEST; 19278 if ("Slot".equals(codeString)) 19279 return SLOT; 19280 if ("Specimen".equals(codeString)) 19281 return SPECIMEN; 19282 if ("SpecimenDefinition".equals(codeString)) 19283 return SPECIMENDEFINITION; 19284 if ("StructureDefinition".equals(codeString)) 19285 return STRUCTUREDEFINITION; 19286 if ("StructureMap".equals(codeString)) 19287 return STRUCTUREMAP; 19288 if ("Subscription".equals(codeString)) 19289 return SUBSCRIPTION; 19290 if ("SubscriptionStatus".equals(codeString)) 19291 return SUBSCRIPTIONSTATUS; 19292 if ("SubscriptionTopic".equals(codeString)) 19293 return SUBSCRIPTIONTOPIC; 19294 if ("Substance".equals(codeString)) 19295 return SUBSTANCE; 19296 if ("SubstanceDefinition".equals(codeString)) 19297 return SUBSTANCEDEFINITION; 19298 if ("SubstanceNucleicAcid".equals(codeString)) 19299 return SUBSTANCENUCLEICACID; 19300 if ("SubstancePolymer".equals(codeString)) 19301 return SUBSTANCEPOLYMER; 19302 if ("SubstanceProtein".equals(codeString)) 19303 return SUBSTANCEPROTEIN; 19304 if ("SubstanceReferenceInformation".equals(codeString)) 19305 return SUBSTANCEREFERENCEINFORMATION; 19306 if ("SubstanceSourceMaterial".equals(codeString)) 19307 return SUBSTANCESOURCEMATERIAL; 19308 if ("SupplyDelivery".equals(codeString)) 19309 return SUPPLYDELIVERY; 19310 if ("SupplyRequest".equals(codeString)) 19311 return SUPPLYREQUEST; 19312 if ("Task".equals(codeString)) 19313 return TASK; 19314 if ("TerminologyCapabilities".equals(codeString)) 19315 return TERMINOLOGYCAPABILITIES; 19316 if ("TestPlan".equals(codeString)) 19317 return TESTPLAN; 19318 if ("TestReport".equals(codeString)) 19319 return TESTREPORT; 19320 if ("TestScript".equals(codeString)) 19321 return TESTSCRIPT; 19322 if ("Transport".equals(codeString)) 19323 return TRANSPORT; 19324 if ("ValueSet".equals(codeString)) 19325 return VALUESET; 19326 if ("VerificationResult".equals(codeString)) 19327 return VERIFICATIONRESULT; 19328 if ("VisionPrescription".equals(codeString)) 19329 return VISIONPRESCRIPTION; 19330 if ("BodySite".equals(codeString)) 19331 return BODYSITE; 19332 if ("CatalogEntry".equals(codeString)) 19333 return CATALOGENTRY; 19334 if ("Conformance".equals(codeString)) 19335 return CONFORMANCE; 19336 if ("DataElement".equals(codeString)) 19337 return DATAELEMENT; 19338 if ("DeviceComponent".equals(codeString)) 19339 return DEVICECOMPONENT; 19340 if ("DeviceUseRequest".equals(codeString)) 19341 return DEVICEUSEREQUEST; 19342 if ("DeviceUseStatement".equals(codeString)) 19343 return DEVICEUSESTATEMENT; 19344 if ("DiagnosticOrder".equals(codeString)) 19345 return DIAGNOSTICORDER; 19346 if ("DocumentManifest".equals(codeString)) 19347 return DOCUMENTMANIFEST; 19348 if ("EffectEvidenceSynthesis".equals(codeString)) 19349 return EFFECTEVIDENCESYNTHESIS; 19350 if ("EligibilityRequest".equals(codeString)) 19351 return ELIGIBILITYREQUEST; 19352 if ("EligibilityResponse".equals(codeString)) 19353 return ELIGIBILITYRESPONSE; 19354 if ("ExpansionProfile".equals(codeString)) 19355 return EXPANSIONPROFILE; 19356 if ("ImagingManifest".equals(codeString)) 19357 return IMAGINGMANIFEST; 19358 if ("ImagingObjectSelection".equals(codeString)) 19359 return IMAGINGOBJECTSELECTION; 19360 if ("Media".equals(codeString)) 19361 return MEDIA; 19362 if ("MedicationOrder".equals(codeString)) 19363 return MEDICATIONORDER; 19364 if ("MedicationUsage".equals(codeString)) 19365 return MEDICATIONUSAGE; 19366 if ("MedicinalProduct".equals(codeString)) 19367 return MEDICINALPRODUCT; 19368 if ("MedicinalProductAuthorization".equals(codeString)) 19369 return MEDICINALPRODUCTAUTHORIZATION; 19370 if ("MedicinalProductContraindication".equals(codeString)) 19371 return MEDICINALPRODUCTCONTRAINDICATION; 19372 if ("MedicinalProductIndication".equals(codeString)) 19373 return MEDICINALPRODUCTINDICATION; 19374 if ("MedicinalProductIngredient".equals(codeString)) 19375 return MEDICINALPRODUCTINGREDIENT; 19376 if ("MedicinalProductInteraction".equals(codeString)) 19377 return MEDICINALPRODUCTINTERACTION; 19378 if ("MedicinalProductManufactured".equals(codeString)) 19379 return MEDICINALPRODUCTMANUFACTURED; 19380 if ("MedicinalProductPackaged".equals(codeString)) 19381 return MEDICINALPRODUCTPACKAGED; 19382 if ("MedicinalProductPharmaceutical".equals(codeString)) 19383 return MEDICINALPRODUCTPHARMACEUTICAL; 19384 if ("MedicinalProductUndesirableEffect".equals(codeString)) 19385 return MEDICINALPRODUCTUNDESIRABLEEFFECT; 19386 if ("Order".equals(codeString)) 19387 return ORDER; 19388 if ("OrderResponse".equals(codeString)) 19389 return ORDERRESPONSE; 19390 if ("ProcedureRequest".equals(codeString)) 19391 return PROCEDUREREQUEST; 19392 if ("ProcessRequest".equals(codeString)) 19393 return PROCESSREQUEST; 19394 if ("ProcessResponse".equals(codeString)) 19395 return PROCESSRESPONSE; 19396 if ("ReferralRequest".equals(codeString)) 19397 return REFERRALREQUEST; 19398 if ("RequestGroup".equals(codeString)) 19399 return REQUESTGROUP; 19400 if ("ResearchDefinition".equals(codeString)) 19401 return RESEARCHDEFINITION; 19402 if ("ResearchElementDefinition".equals(codeString)) 19403 return RESEARCHELEMENTDEFINITION; 19404 if ("RiskEvidenceSynthesis".equals(codeString)) 19405 return RISKEVIDENCESYNTHESIS; 19406 if ("Sequence".equals(codeString)) 19407 return SEQUENCE; 19408 if ("ServiceDefinition".equals(codeString)) 19409 return SERVICEDEFINITION; 19410 if ("SubstanceSpecification".equals(codeString)) 19411 return SUBSTANCESPECIFICATION; 19412 throw new FHIRException("Unknown VersionIndependentResourceTypesAll code '"+codeString+"'"); 19413 } 19414 public static boolean isValidCode(String codeString) { 19415 if (codeString == null || "".equals(codeString)) 19416 return false; 19417 return Utilities.existsInList(codeString, "Account", "ActivityDefinition", "ActorDefinition", "AdministrableProductDefinition", "AdverseEvent", "AllergyIntolerance", "Appointment", "AppointmentResponse", "ArtifactAssessment", "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", "BodySite", "CatalogEntry", "Conformance", "DataElement", "DeviceComponent", "DeviceUseRequest", "DeviceUseStatement", "DiagnosticOrder", "DocumentManifest", "EffectEvidenceSynthesis", "EligibilityRequest", "EligibilityResponse", "ExpansionProfile", "ImagingManifest", "ImagingObjectSelection", "Media", "MedicationOrder", "MedicationUsage", "MedicinalProduct", "MedicinalProductAuthorization", "MedicinalProductContraindication", "MedicinalProductIndication", "MedicinalProductIngredient", "MedicinalProductInteraction", "MedicinalProductManufactured", "MedicinalProductPackaged", "MedicinalProductPharmaceutical", "MedicinalProductUndesirableEffect", "Order", "OrderResponse", "ProcedureRequest", "ProcessRequest", "ProcessResponse", "ReferralRequest", "RequestGroup", "ResearchDefinition", "ResearchElementDefinition", "RiskEvidenceSynthesis", "Sequence", "ServiceDefinition", "SubstanceSpecification"); 19418 } 19419 public String toCode() { 19420 switch (this) { 19421 case ACCOUNT: return "Account"; 19422 case ACTIVITYDEFINITION: return "ActivityDefinition"; 19423 case ACTORDEFINITION: return "ActorDefinition"; 19424 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 19425 case ADVERSEEVENT: return "AdverseEvent"; 19426 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 19427 case APPOINTMENT: return "Appointment"; 19428 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 19429 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 19430 case AUDITEVENT: return "AuditEvent"; 19431 case BASIC: return "Basic"; 19432 case BINARY: return "Binary"; 19433 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 19434 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "BiologicallyDerivedProductDispense"; 19435 case BODYSTRUCTURE: return "BodyStructure"; 19436 case BUNDLE: return "Bundle"; 19437 case CANONICALRESOURCE: return "CanonicalResource"; 19438 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 19439 case CAREPLAN: return "CarePlan"; 19440 case CARETEAM: return "CareTeam"; 19441 case CHARGEITEM: return "ChargeItem"; 19442 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 19443 case CITATION: return "Citation"; 19444 case CLAIM: return "Claim"; 19445 case CLAIMRESPONSE: return "ClaimResponse"; 19446 case CLINICALIMPRESSION: return "ClinicalImpression"; 19447 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 19448 case CODESYSTEM: return "CodeSystem"; 19449 case COMMUNICATION: return "Communication"; 19450 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 19451 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 19452 case COMPOSITION: return "Composition"; 19453 case CONCEPTMAP: return "ConceptMap"; 19454 case CONDITION: return "Condition"; 19455 case CONDITIONDEFINITION: return "ConditionDefinition"; 19456 case CONSENT: return "Consent"; 19457 case CONTRACT: return "Contract"; 19458 case COVERAGE: return "Coverage"; 19459 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 19460 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 19461 case DETECTEDISSUE: return "DetectedIssue"; 19462 case DEVICE: return "Device"; 19463 case DEVICEASSOCIATION: return "DeviceAssociation"; 19464 case DEVICEDEFINITION: return "DeviceDefinition"; 19465 case DEVICEDISPENSE: return "DeviceDispense"; 19466 case DEVICEMETRIC: return "DeviceMetric"; 19467 case DEVICEREQUEST: return "DeviceRequest"; 19468 case DEVICEUSAGE: return "DeviceUsage"; 19469 case DIAGNOSTICREPORT: return "DiagnosticReport"; 19470 case DOCUMENTREFERENCE: return "DocumentReference"; 19471 case DOMAINRESOURCE: return "DomainResource"; 19472 case ENCOUNTER: return "Encounter"; 19473 case ENCOUNTERHISTORY: return "EncounterHistory"; 19474 case ENDPOINT: return "Endpoint"; 19475 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 19476 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 19477 case EPISODEOFCARE: return "EpisodeOfCare"; 19478 case EVENTDEFINITION: return "EventDefinition"; 19479 case EVIDENCE: return "Evidence"; 19480 case EVIDENCEREPORT: return "EvidenceReport"; 19481 case EVIDENCEVARIABLE: return "EvidenceVariable"; 19482 case EXAMPLESCENARIO: return "ExampleScenario"; 19483 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 19484 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 19485 case FLAG: return "Flag"; 19486 case FORMULARYITEM: return "FormularyItem"; 19487 case GENOMICSTUDY: return "GenomicStudy"; 19488 case GOAL: return "Goal"; 19489 case GRAPHDEFINITION: return "GraphDefinition"; 19490 case GROUP: return "Group"; 19491 case GUIDANCERESPONSE: return "GuidanceResponse"; 19492 case HEALTHCARESERVICE: return "HealthcareService"; 19493 case IMAGINGSELECTION: return "ImagingSelection"; 19494 case IMAGINGSTUDY: return "ImagingStudy"; 19495 case IMMUNIZATION: return "Immunization"; 19496 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 19497 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 19498 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 19499 case INGREDIENT: return "Ingredient"; 19500 case INSURANCEPLAN: return "InsurancePlan"; 19501 case INVENTORYITEM: return "InventoryItem"; 19502 case INVENTORYREPORT: return "InventoryReport"; 19503 case INVOICE: return "Invoice"; 19504 case LIBRARY: return "Library"; 19505 case LINKAGE: return "Linkage"; 19506 case LIST: return "List"; 19507 case LOCATION: return "Location"; 19508 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 19509 case MEASURE: return "Measure"; 19510 case MEASUREREPORT: return "MeasureReport"; 19511 case MEDICATION: return "Medication"; 19512 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 19513 case MEDICATIONDISPENSE: return "MedicationDispense"; 19514 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 19515 case MEDICATIONREQUEST: return "MedicationRequest"; 19516 case MEDICATIONSTATEMENT: return "MedicationStatement"; 19517 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 19518 case MESSAGEDEFINITION: return "MessageDefinition"; 19519 case MESSAGEHEADER: return "MessageHeader"; 19520 case METADATARESOURCE: return "MetadataResource"; 19521 case MOLECULARSEQUENCE: return "MolecularSequence"; 19522 case NAMINGSYSTEM: return "NamingSystem"; 19523 case NUTRITIONINTAKE: return "NutritionIntake"; 19524 case NUTRITIONORDER: return "NutritionOrder"; 19525 case NUTRITIONPRODUCT: return "NutritionProduct"; 19526 case OBSERVATION: return "Observation"; 19527 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 19528 case OPERATIONDEFINITION: return "OperationDefinition"; 19529 case OPERATIONOUTCOME: return "OperationOutcome"; 19530 case ORGANIZATION: return "Organization"; 19531 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 19532 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 19533 case PARAMETERS: return "Parameters"; 19534 case PATIENT: return "Patient"; 19535 case PAYMENTNOTICE: return "PaymentNotice"; 19536 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 19537 case PERMISSION: return "Permission"; 19538 case PERSON: return "Person"; 19539 case PLANDEFINITION: return "PlanDefinition"; 19540 case PRACTITIONER: return "Practitioner"; 19541 case PRACTITIONERROLE: return "PractitionerRole"; 19542 case PROCEDURE: return "Procedure"; 19543 case PROVENANCE: return "Provenance"; 19544 case QUESTIONNAIRE: return "Questionnaire"; 19545 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 19546 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 19547 case RELATEDPERSON: return "RelatedPerson"; 19548 case REQUESTORCHESTRATION: return "RequestOrchestration"; 19549 case REQUIREMENTS: return "Requirements"; 19550 case RESEARCHSTUDY: return "ResearchStudy"; 19551 case RESEARCHSUBJECT: return "ResearchSubject"; 19552 case RESOURCE: return "Resource"; 19553 case RISKASSESSMENT: return "RiskAssessment"; 19554 case SCHEDULE: return "Schedule"; 19555 case SEARCHPARAMETER: return "SearchParameter"; 19556 case SERVICEREQUEST: return "ServiceRequest"; 19557 case SLOT: return "Slot"; 19558 case SPECIMEN: return "Specimen"; 19559 case SPECIMENDEFINITION: return "SpecimenDefinition"; 19560 case STRUCTUREDEFINITION: return "StructureDefinition"; 19561 case STRUCTUREMAP: return "StructureMap"; 19562 case SUBSCRIPTION: return "Subscription"; 19563 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 19564 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 19565 case SUBSTANCE: return "Substance"; 19566 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 19567 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 19568 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 19569 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 19570 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 19571 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 19572 case SUPPLYDELIVERY: return "SupplyDelivery"; 19573 case SUPPLYREQUEST: return "SupplyRequest"; 19574 case TASK: return "Task"; 19575 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 19576 case TESTPLAN: return "TestPlan"; 19577 case TESTREPORT: return "TestReport"; 19578 case TESTSCRIPT: return "TestScript"; 19579 case TRANSPORT: return "Transport"; 19580 case VALUESET: return "ValueSet"; 19581 case VERIFICATIONRESULT: return "VerificationResult"; 19582 case VISIONPRESCRIPTION: return "VisionPrescription"; 19583 case BODYSITE: return "BodySite"; 19584 case CATALOGENTRY: return "CatalogEntry"; 19585 case CONFORMANCE: return "Conformance"; 19586 case DATAELEMENT: return "DataElement"; 19587 case DEVICECOMPONENT: return "DeviceComponent"; 19588 case DEVICEUSEREQUEST: return "DeviceUseRequest"; 19589 case DEVICEUSESTATEMENT: return "DeviceUseStatement"; 19590 case DIAGNOSTICORDER: return "DiagnosticOrder"; 19591 case DOCUMENTMANIFEST: return "DocumentManifest"; 19592 case EFFECTEVIDENCESYNTHESIS: return "EffectEvidenceSynthesis"; 19593 case ELIGIBILITYREQUEST: return "EligibilityRequest"; 19594 case ELIGIBILITYRESPONSE: return "EligibilityResponse"; 19595 case EXPANSIONPROFILE: return "ExpansionProfile"; 19596 case IMAGINGMANIFEST: return "ImagingManifest"; 19597 case IMAGINGOBJECTSELECTION: return "ImagingObjectSelection"; 19598 case MEDIA: return "Media"; 19599 case MEDICATIONORDER: return "MedicationOrder"; 19600 case MEDICATIONUSAGE: return "MedicationUsage"; 19601 case MEDICINALPRODUCT: return "MedicinalProduct"; 19602 case MEDICINALPRODUCTAUTHORIZATION: return "MedicinalProductAuthorization"; 19603 case MEDICINALPRODUCTCONTRAINDICATION: return "MedicinalProductContraindication"; 19604 case MEDICINALPRODUCTINDICATION: return "MedicinalProductIndication"; 19605 case MEDICINALPRODUCTINGREDIENT: return "MedicinalProductIngredient"; 19606 case MEDICINALPRODUCTINTERACTION: return "MedicinalProductInteraction"; 19607 case MEDICINALPRODUCTMANUFACTURED: return "MedicinalProductManufactured"; 19608 case MEDICINALPRODUCTPACKAGED: return "MedicinalProductPackaged"; 19609 case MEDICINALPRODUCTPHARMACEUTICAL: return "MedicinalProductPharmaceutical"; 19610 case MEDICINALPRODUCTUNDESIRABLEEFFECT: return "MedicinalProductUndesirableEffect"; 19611 case ORDER: return "Order"; 19612 case ORDERRESPONSE: return "OrderResponse"; 19613 case PROCEDUREREQUEST: return "ProcedureRequest"; 19614 case PROCESSREQUEST: return "ProcessRequest"; 19615 case PROCESSRESPONSE: return "ProcessResponse"; 19616 case REFERRALREQUEST: return "ReferralRequest"; 19617 case REQUESTGROUP: return "RequestGroup"; 19618 case RESEARCHDEFINITION: return "ResearchDefinition"; 19619 case RESEARCHELEMENTDEFINITION: return "ResearchElementDefinition"; 19620 case RISKEVIDENCESYNTHESIS: return "RiskEvidenceSynthesis"; 19621 case SEQUENCE: return "Sequence"; 19622 case SERVICEDEFINITION: return "ServiceDefinition"; 19623 case SUBSTANCESPECIFICATION: return "SubstanceSpecification"; 19624 case NULL: return null; 19625 default: return "?"; 19626 } 19627 } 19628 public String getSystem() { 19629 switch (this) { 19630 case ACCOUNT: return "http://hl7.org/fhir/fhir-types"; 19631 case ACTIVITYDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19632 case ACTORDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19633 case ADMINISTRABLEPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19634 case ADVERSEEVENT: return "http://hl7.org/fhir/fhir-types"; 19635 case ALLERGYINTOLERANCE: return "http://hl7.org/fhir/fhir-types"; 19636 case APPOINTMENT: return "http://hl7.org/fhir/fhir-types"; 19637 case APPOINTMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 19638 case ARTIFACTASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 19639 case AUDITEVENT: return "http://hl7.org/fhir/fhir-types"; 19640 case BASIC: return "http://hl7.org/fhir/fhir-types"; 19641 case BINARY: return "http://hl7.org/fhir/fhir-types"; 19642 case BIOLOGICALLYDERIVEDPRODUCT: return "http://hl7.org/fhir/fhir-types"; 19643 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "http://hl7.org/fhir/fhir-types"; 19644 case BODYSTRUCTURE: return "http://hl7.org/fhir/fhir-types"; 19645 case BUNDLE: return "http://hl7.org/fhir/fhir-types"; 19646 case CANONICALRESOURCE: return "http://hl7.org/fhir/fhir-types"; 19647 case CAPABILITYSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 19648 case CAREPLAN: return "http://hl7.org/fhir/fhir-types"; 19649 case CARETEAM: return "http://hl7.org/fhir/fhir-types"; 19650 case CHARGEITEM: return "http://hl7.org/fhir/fhir-types"; 19651 case CHARGEITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19652 case CITATION: return "http://hl7.org/fhir/fhir-types"; 19653 case CLAIM: return "http://hl7.org/fhir/fhir-types"; 19654 case CLAIMRESPONSE: return "http://hl7.org/fhir/fhir-types"; 19655 case CLINICALIMPRESSION: return "http://hl7.org/fhir/fhir-types"; 19656 case CLINICALUSEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19657 case CODESYSTEM: return "http://hl7.org/fhir/fhir-types"; 19658 case COMMUNICATION: return "http://hl7.org/fhir/fhir-types"; 19659 case COMMUNICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 19660 case COMPARTMENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19661 case COMPOSITION: return "http://hl7.org/fhir/fhir-types"; 19662 case CONCEPTMAP: return "http://hl7.org/fhir/fhir-types"; 19663 case CONDITION: return "http://hl7.org/fhir/fhir-types"; 19664 case CONDITIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19665 case CONSENT: return "http://hl7.org/fhir/fhir-types"; 19666 case CONTRACT: return "http://hl7.org/fhir/fhir-types"; 19667 case COVERAGE: return "http://hl7.org/fhir/fhir-types"; 19668 case COVERAGEELIGIBILITYREQUEST: return "http://hl7.org/fhir/fhir-types"; 19669 case COVERAGEELIGIBILITYRESPONSE: return "http://hl7.org/fhir/fhir-types"; 19670 case DETECTEDISSUE: return "http://hl7.org/fhir/fhir-types"; 19671 case DEVICE: return "http://hl7.org/fhir/fhir-types"; 19672 case DEVICEASSOCIATION: return "http://hl7.org/fhir/fhir-types"; 19673 case DEVICEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19674 case DEVICEDISPENSE: return "http://hl7.org/fhir/fhir-types"; 19675 case DEVICEMETRIC: return "http://hl7.org/fhir/fhir-types"; 19676 case DEVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 19677 case DEVICEUSAGE: return "http://hl7.org/fhir/fhir-types"; 19678 case DIAGNOSTICREPORT: return "http://hl7.org/fhir/fhir-types"; 19679 case DOCUMENTREFERENCE: return "http://hl7.org/fhir/fhir-types"; 19680 case DOMAINRESOURCE: return "http://hl7.org/fhir/fhir-types"; 19681 case ENCOUNTER: return "http://hl7.org/fhir/fhir-types"; 19682 case ENCOUNTERHISTORY: return "http://hl7.org/fhir/fhir-types"; 19683 case ENDPOINT: return "http://hl7.org/fhir/fhir-types"; 19684 case ENROLLMENTREQUEST: return "http://hl7.org/fhir/fhir-types"; 19685 case ENROLLMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 19686 case EPISODEOFCARE: return "http://hl7.org/fhir/fhir-types"; 19687 case EVENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19688 case EVIDENCE: return "http://hl7.org/fhir/fhir-types"; 19689 case EVIDENCEREPORT: return "http://hl7.org/fhir/fhir-types"; 19690 case EVIDENCEVARIABLE: return "http://hl7.org/fhir/fhir-types"; 19691 case EXAMPLESCENARIO: return "http://hl7.org/fhir/fhir-types"; 19692 case EXPLANATIONOFBENEFIT: return "http://hl7.org/fhir/fhir-types"; 19693 case FAMILYMEMBERHISTORY: return "http://hl7.org/fhir/fhir-types"; 19694 case FLAG: return "http://hl7.org/fhir/fhir-types"; 19695 case FORMULARYITEM: return "http://hl7.org/fhir/fhir-types"; 19696 case GENOMICSTUDY: return "http://hl7.org/fhir/fhir-types"; 19697 case GOAL: return "http://hl7.org/fhir/fhir-types"; 19698 case GRAPHDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19699 case GROUP: return "http://hl7.org/fhir/fhir-types"; 19700 case GUIDANCERESPONSE: return "http://hl7.org/fhir/fhir-types"; 19701 case HEALTHCARESERVICE: return "http://hl7.org/fhir/fhir-types"; 19702 case IMAGINGSELECTION: return "http://hl7.org/fhir/fhir-types"; 19703 case IMAGINGSTUDY: return "http://hl7.org/fhir/fhir-types"; 19704 case IMMUNIZATION: return "http://hl7.org/fhir/fhir-types"; 19705 case IMMUNIZATIONEVALUATION: return "http://hl7.org/fhir/fhir-types"; 19706 case IMMUNIZATIONRECOMMENDATION: return "http://hl7.org/fhir/fhir-types"; 19707 case IMPLEMENTATIONGUIDE: return "http://hl7.org/fhir/fhir-types"; 19708 case INGREDIENT: return "http://hl7.org/fhir/fhir-types"; 19709 case INSURANCEPLAN: return "http://hl7.org/fhir/fhir-types"; 19710 case INVENTORYITEM: return "http://hl7.org/fhir/fhir-types"; 19711 case INVENTORYREPORT: return "http://hl7.org/fhir/fhir-types"; 19712 case INVOICE: return "http://hl7.org/fhir/fhir-types"; 19713 case LIBRARY: return "http://hl7.org/fhir/fhir-types"; 19714 case LINKAGE: return "http://hl7.org/fhir/fhir-types"; 19715 case LIST: return "http://hl7.org/fhir/fhir-types"; 19716 case LOCATION: return "http://hl7.org/fhir/fhir-types"; 19717 case MANUFACTUREDITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19718 case MEASURE: return "http://hl7.org/fhir/fhir-types"; 19719 case MEASUREREPORT: return "http://hl7.org/fhir/fhir-types"; 19720 case MEDICATION: return "http://hl7.org/fhir/fhir-types"; 19721 case MEDICATIONADMINISTRATION: return "http://hl7.org/fhir/fhir-types"; 19722 case MEDICATIONDISPENSE: return "http://hl7.org/fhir/fhir-types"; 19723 case MEDICATIONKNOWLEDGE: return "http://hl7.org/fhir/fhir-types"; 19724 case MEDICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 19725 case MEDICATIONSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 19726 case MEDICINALPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19727 case MESSAGEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19728 case MESSAGEHEADER: return "http://hl7.org/fhir/fhir-types"; 19729 case METADATARESOURCE: return "http://hl7.org/fhir/fhir-types"; 19730 case MOLECULARSEQUENCE: return "http://hl7.org/fhir/fhir-types"; 19731 case NAMINGSYSTEM: return "http://hl7.org/fhir/fhir-types"; 19732 case NUTRITIONINTAKE: return "http://hl7.org/fhir/fhir-types"; 19733 case NUTRITIONORDER: return "http://hl7.org/fhir/fhir-types"; 19734 case NUTRITIONPRODUCT: return "http://hl7.org/fhir/fhir-types"; 19735 case OBSERVATION: return "http://hl7.org/fhir/fhir-types"; 19736 case OBSERVATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19737 case OPERATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19738 case OPERATIONOUTCOME: return "http://hl7.org/fhir/fhir-types"; 19739 case ORGANIZATION: return "http://hl7.org/fhir/fhir-types"; 19740 case ORGANIZATIONAFFILIATION: return "http://hl7.org/fhir/fhir-types"; 19741 case PACKAGEDPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19742 case PARAMETERS: return "http://hl7.org/fhir/fhir-types"; 19743 case PATIENT: return "http://hl7.org/fhir/fhir-types"; 19744 case PAYMENTNOTICE: return "http://hl7.org/fhir/fhir-types"; 19745 case PAYMENTRECONCILIATION: return "http://hl7.org/fhir/fhir-types"; 19746 case PERMISSION: return "http://hl7.org/fhir/fhir-types"; 19747 case PERSON: return "http://hl7.org/fhir/fhir-types"; 19748 case PLANDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19749 case PRACTITIONER: return "http://hl7.org/fhir/fhir-types"; 19750 case PRACTITIONERROLE: return "http://hl7.org/fhir/fhir-types"; 19751 case PROCEDURE: return "http://hl7.org/fhir/fhir-types"; 19752 case PROVENANCE: return "http://hl7.org/fhir/fhir-types"; 19753 case QUESTIONNAIRE: return "http://hl7.org/fhir/fhir-types"; 19754 case QUESTIONNAIRERESPONSE: return "http://hl7.org/fhir/fhir-types"; 19755 case REGULATEDAUTHORIZATION: return "http://hl7.org/fhir/fhir-types"; 19756 case RELATEDPERSON: return "http://hl7.org/fhir/fhir-types"; 19757 case REQUESTORCHESTRATION: return "http://hl7.org/fhir/fhir-types"; 19758 case REQUIREMENTS: return "http://hl7.org/fhir/fhir-types"; 19759 case RESEARCHSTUDY: return "http://hl7.org/fhir/fhir-types"; 19760 case RESEARCHSUBJECT: return "http://hl7.org/fhir/fhir-types"; 19761 case RESOURCE: return "http://hl7.org/fhir/fhir-types"; 19762 case RISKASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 19763 case SCHEDULE: return "http://hl7.org/fhir/fhir-types"; 19764 case SEARCHPARAMETER: return "http://hl7.org/fhir/fhir-types"; 19765 case SERVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 19766 case SLOT: return "http://hl7.org/fhir/fhir-types"; 19767 case SPECIMEN: return "http://hl7.org/fhir/fhir-types"; 19768 case SPECIMENDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19769 case STRUCTUREDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19770 case STRUCTUREMAP: return "http://hl7.org/fhir/fhir-types"; 19771 case SUBSCRIPTION: return "http://hl7.org/fhir/fhir-types"; 19772 case SUBSCRIPTIONSTATUS: return "http://hl7.org/fhir/fhir-types"; 19773 case SUBSCRIPTIONTOPIC: return "http://hl7.org/fhir/fhir-types"; 19774 case SUBSTANCE: return "http://hl7.org/fhir/fhir-types"; 19775 case SUBSTANCEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19776 case SUBSTANCENUCLEICACID: return "http://hl7.org/fhir/fhir-types"; 19777 case SUBSTANCEPOLYMER: return "http://hl7.org/fhir/fhir-types"; 19778 case SUBSTANCEPROTEIN: return "http://hl7.org/fhir/fhir-types"; 19779 case SUBSTANCEREFERENCEINFORMATION: return "http://hl7.org/fhir/fhir-types"; 19780 case SUBSTANCESOURCEMATERIAL: return "http://hl7.org/fhir/fhir-types"; 19781 case SUPPLYDELIVERY: return "http://hl7.org/fhir/fhir-types"; 19782 case SUPPLYREQUEST: return "http://hl7.org/fhir/fhir-types"; 19783 case TASK: return "http://hl7.org/fhir/fhir-types"; 19784 case TERMINOLOGYCAPABILITIES: return "http://hl7.org/fhir/fhir-types"; 19785 case TESTPLAN: return "http://hl7.org/fhir/fhir-types"; 19786 case TESTREPORT: return "http://hl7.org/fhir/fhir-types"; 19787 case TESTSCRIPT: return "http://hl7.org/fhir/fhir-types"; 19788 case TRANSPORT: return "http://hl7.org/fhir/fhir-types"; 19789 case VALUESET: return "http://hl7.org/fhir/fhir-types"; 19790 case VERIFICATIONRESULT: return "http://hl7.org/fhir/fhir-types"; 19791 case VISIONPRESCRIPTION: return "http://hl7.org/fhir/fhir-types"; 19792 case BODYSITE: return "http://hl7.org/fhir/fhir-old-types"; 19793 case CATALOGENTRY: return "http://hl7.org/fhir/fhir-old-types"; 19794 case CONFORMANCE: return "http://hl7.org/fhir/fhir-old-types"; 19795 case DATAELEMENT: return "http://hl7.org/fhir/fhir-old-types"; 19796 case DEVICECOMPONENT: return "http://hl7.org/fhir/fhir-old-types"; 19797 case DEVICEUSEREQUEST: return "http://hl7.org/fhir/fhir-old-types"; 19798 case DEVICEUSESTATEMENT: return "http://hl7.org/fhir/fhir-old-types"; 19799 case DIAGNOSTICORDER: return "http://hl7.org/fhir/fhir-old-types"; 19800 case DOCUMENTMANIFEST: return "http://hl7.org/fhir/fhir-old-types"; 19801 case EFFECTEVIDENCESYNTHESIS: return "http://hl7.org/fhir/fhir-old-types"; 19802 case ELIGIBILITYREQUEST: return "http://hl7.org/fhir/fhir-old-types"; 19803 case ELIGIBILITYRESPONSE: return "http://hl7.org/fhir/fhir-old-types"; 19804 case EXPANSIONPROFILE: return "http://hl7.org/fhir/fhir-old-types"; 19805 case IMAGINGMANIFEST: return "http://hl7.org/fhir/fhir-old-types"; 19806 case IMAGINGOBJECTSELECTION: return "http://hl7.org/fhir/fhir-old-types"; 19807 case MEDIA: return "http://hl7.org/fhir/fhir-old-types"; 19808 case MEDICATIONORDER: return "http://hl7.org/fhir/fhir-old-types"; 19809 case MEDICATIONUSAGE: return "http://hl7.org/fhir/fhir-old-types"; 19810 case MEDICINALPRODUCT: return "http://hl7.org/fhir/fhir-old-types"; 19811 case MEDICINALPRODUCTAUTHORIZATION: return "http://hl7.org/fhir/fhir-old-types"; 19812 case MEDICINALPRODUCTCONTRAINDICATION: return "http://hl7.org/fhir/fhir-old-types"; 19813 case MEDICINALPRODUCTINDICATION: return "http://hl7.org/fhir/fhir-old-types"; 19814 case MEDICINALPRODUCTINGREDIENT: return "http://hl7.org/fhir/fhir-old-types"; 19815 case MEDICINALPRODUCTINTERACTION: return "http://hl7.org/fhir/fhir-old-types"; 19816 case MEDICINALPRODUCTMANUFACTURED: return "http://hl7.org/fhir/fhir-old-types"; 19817 case MEDICINALPRODUCTPACKAGED: return "http://hl7.org/fhir/fhir-old-types"; 19818 case MEDICINALPRODUCTPHARMACEUTICAL: return "http://hl7.org/fhir/fhir-old-types"; 19819 case MEDICINALPRODUCTUNDESIRABLEEFFECT: return "http://hl7.org/fhir/fhir-old-types"; 19820 case ORDER: return "http://hl7.org/fhir/fhir-old-types"; 19821 case ORDERRESPONSE: return "http://hl7.org/fhir/fhir-old-types"; 19822 case PROCEDUREREQUEST: return "http://hl7.org/fhir/fhir-old-types"; 19823 case PROCESSREQUEST: return "http://hl7.org/fhir/fhir-old-types"; 19824 case PROCESSRESPONSE: return "http://hl7.org/fhir/fhir-old-types"; 19825 case REFERRALREQUEST: return "http://hl7.org/fhir/fhir-old-types"; 19826 case REQUESTGROUP: return "http://hl7.org/fhir/fhir-old-types"; 19827 case RESEARCHDEFINITION: return "http://hl7.org/fhir/fhir-old-types"; 19828 case RESEARCHELEMENTDEFINITION: return "http://hl7.org/fhir/fhir-old-types"; 19829 case RISKEVIDENCESYNTHESIS: return "http://hl7.org/fhir/fhir-old-types"; 19830 case SEQUENCE: return "http://hl7.org/fhir/fhir-old-types"; 19831 case SERVICEDEFINITION: return "http://hl7.org/fhir/fhir-old-types"; 19832 case SUBSTANCESPECIFICATION: return "http://hl7.org/fhir/fhir-old-types"; 19833 case NULL: return null; 19834 default: return "?"; 19835 } 19836 } 19837 public String getDefinition() { 19838 switch (this) { 19839 case ACCOUNT: return "A financial tool for tracking value accrued for a particular purpose. In the healthcare field, used to track charges for a patient, cost centers, etc."; 19840 case ACTIVITYDEFINITION: return "This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context."; 19841 case ACTORDEFINITION: return "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."; 19842 case ADMINISTRABLEPRODUCTDEFINITION: return "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)."; 19843 case ADVERSEEVENT: return "An event (i.e. any change to current patient status) that may be related to unintended effects on a patient or research 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."; 19844 case ALLERGYINTOLERANCE: return "Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance."; 19845 case APPOINTMENT: return "A booking of a healthcare event among patient(s), practitioner(s), related person(s) and/or device(s) for a specific date/time. This may result in one or more Encounter(s)."; 19846 case APPOINTMENTRESPONSE: return "A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection."; 19847 case ARTIFACTASSESSMENT: return "This Resource provides one or more comments, classifiers or ratings about a Resource and supports attribution and rights management metadata for the added content."; 19848 case AUDITEVENT: return "A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis."; 19849 case BASIC: return "Basic is used for handling concepts not yet defined in FHIR, narrative-only resources that don't map to an existing resource, and custom resources not appropriate for inclusion in the FHIR specification."; 19850 case BINARY: return "A resource that represents the data of a single raw artifact as digital content accessible in its native format. A Binary resource can contain any content, whether text, image, pdf, zip archive, etc."; 19851 case BIOLOGICALLYDERIVEDPRODUCT: return "A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity."; 19852 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "A record of dispensation of a biologically derived product."; 19853 case BODYSTRUCTURE: return "Record details about an anatomical structure. This resource may be used when a coded concept does not provide the necessary detail needed for the use case."; 19854 case BUNDLE: return "A container for a collection of resources."; 19855 case CANONICALRESOURCE: return "Common Interface declaration for conformance and knowledge artifact resources."; 19856 case CAPABILITYSTATEMENT: return "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."; 19857 case CAREPLAN: return "Describes the intention of how one or more practitioners intend to deliver care for a particular patient, group or community for a period of time, possibly limited to care for a specific condition or set of conditions."; 19858 case CARETEAM: return "The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care."; 19859 case CHARGEITEM: return "The resource ChargeItem describes the provision of healthcare provider products for a certain patient, therefore referring not only to the product, but containing in addition details of the provision, like date, time, amounts and participating organizations and persons. Main Usage of the ChargeItem is to enable the billing process and internal cost allocation."; 19860 case CHARGEITEMDEFINITION: return "The ChargeItemDefinition resource provides the properties that apply to the (billing) codes necessary to calculate costs and prices. The properties may differ largely depending on type and realm, therefore this resource gives only a rough structure and requires profiling for each type of billing code system."; 19861 case CITATION: return "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."; 19862 case CLAIM: return "A provider issued list of professional services and products which have been provided, or are to be provided, to a patient which is sent to an insurer for reimbursement."; 19863 case CLAIMRESPONSE: return "This resource provides the adjudication details from the processing of a Claim resource."; 19864 case CLINICALIMPRESSION: return "A record of a clinical assessment performed to determine what problem(s) may affect the patient and before planning the treatments or management strategies that are best to manage a patient's condition. Assessments are often 1:1 with a clinical consultation / encounter, but this varies greatly depending on the clinical workflow. This resource is called \"ClinicalImpression\" rather than \"ClinicalAssessment\" to avoid confusion with the recording of assessment tools such as Apgar score."; 19865 case CLINICALUSEDEFINITION: return "A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure."; 19866 case CODESYSTEM: return "The CodeSystem resource is used to declare the existence of and describe a code system or code system supplement and its key properties, and optionally define a part or all of its content."; 19867 case COMMUNICATION: return "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."; 19868 case COMMUNICATIONREQUEST: return "A request to convey information; e.g. the CDS system proposes that an alert be sent to a responsible provider, the CDS system proposes that the public health agency be notified about a reportable condition."; 19869 case COMPARTMENTDEFINITION: return "A compartment definition that defines how resources are accessed on a server."; 19870 case COMPOSITION: return "A set of healthcare-related information that is assembled together into a single logical package that provides a single coherent statement of meaning, establishes its own context and that has clinical attestation with regard to who is making the statement. A Composition defines the structure and narrative content necessary for a document. However, a Composition alone does not constitute a document. Rather, the Composition must be the first entry in a Bundle where Bundle.type=document, and any other resources referenced from Composition must be included as subsequent entries in the Bundle (for example Patient, Practitioner, Encounter, etc.)."; 19871 case CONCEPTMAP: return "A statement of relationships from one set of concepts to one or more other concepts - either concepts in code systems, or data element/data element concepts, or classes in class models."; 19872 case CONDITION: return "A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern."; 19873 case CONDITIONDEFINITION: return "A definition of a condition and information relevant to managing it."; 19874 case CONSENT: return "A record of a healthcare consumer?s choices or choices made on their behalf by a third party, which permits or denies identified recipient(s) or recipient role(s) to perform one or more actions within a given policy context, for specific purposes and periods of time."; 19875 case CONTRACT: return "Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement."; 19876 case COVERAGE: return "Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment."; 19877 case COVERAGEELIGIBILITYREQUEST: return "The CoverageEligibilityRequest provides patient and insurance coverage information to an insurer for them to respond, in the form of an CoverageEligibilityResponse, with information regarding whether the stated coverage is valid and in-force and optionally to provide the insurance details of the policy."; 19878 case COVERAGEELIGIBILITYRESPONSE: return "This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource."; 19879 case DETECTEDISSUE: return "Indicates an actual or potential clinical issue with or between one or more active or proposed clinical actions for a patient; e.g. Drug-drug interaction, Ineffective treatment frequency, Procedure-condition conflict, gaps in care, etc."; 19880 case DEVICE: return "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."; 19881 case DEVICEASSOCIATION: return "A record of association of a device."; 19882 case DEVICEDEFINITION: return "This is a specialized resource that defines the characteristics and capabilities of a device."; 19883 case DEVICEDISPENSE: return "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."; 19884 case DEVICEMETRIC: return "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. "; 19885 case DEVICEREQUEST: return "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."; 19886 case DEVICEUSAGE: return "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."; 19887 case DIAGNOSTICREPORT: return "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."; 19888 case DOCUMENTREFERENCE: return "A reference to a document of any kind for any purpose. While the term ?document? implies a more narrow focus, for this resource this ?document? encompasses *any* serialized object with a mime-type, it includes formal patient-centric documents (CDA), clinical notes, scanned paper, non-patient specific documents like policy text, as well as a photo, video, or audio recording acquired or used in healthcare. The DocumentReference resource provides metadata about the document so that the document can be discovered and managed. The actual content may be inline base64 encoded data or provided by direct reference."; 19889 case DOMAINRESOURCE: return "A resource that includes narrative, extensions, and contained resources."; 19890 case ENCOUNTER: return "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)."; 19891 case ENCOUNTERHISTORY: return "A record of significant events/milestones key data throughout the history of an Encounter"; 19892 case ENDPOINT: return "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."; 19893 case ENROLLMENTREQUEST: return "This resource provides the insurance enrollment details to the insurer regarding a specified coverage."; 19894 case ENROLLMENTRESPONSE: return "This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource."; 19895 case EPISODEOFCARE: return "An association between a patient and an organization / healthcare provider(s) during which time encounters may occur. The managing organization assumes a level of responsibility for the patient during this time."; 19896 case EVENTDEFINITION: return "The EventDefinition resource provides a reusable description of when a particular event can occur."; 19897 case EVIDENCE: return "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."; 19898 case EVIDENCEREPORT: return "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."; 19899 case EVIDENCEVARIABLE: return "The EvidenceVariable resource describes an element that knowledge (Evidence) is about."; 19900 case EXAMPLESCENARIO: return "A walkthrough of a workflow showing the interaction between systems and the instances shared, possibly including the evolution of instances over time."; 19901 case EXPLANATIONOFBENEFIT: return "This resource provides: the claim details; adjudication details from the processing of a Claim; and optionally account balance information, for informing the subscriber of the benefits provided."; 19902 case FAMILYMEMBERHISTORY: return "Significant health conditions for a person related to the patient relevant in the context of care for the patient."; 19903 case FLAG: return "Prospective warnings of potential issues when providing care to the patient."; 19904 case FORMULARYITEM: return "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."; 19905 case GENOMICSTUDY: return "A set of analyses performed to analyze and generate genomic data."; 19906 case GOAL: return "Describes the intended objective(s) for a patient, group or organization care, for example, weight loss, restoring an activity of daily living, obtaining herd immunity via immunization, meeting a process improvement objective, etc."; 19907 case GRAPHDEFINITION: return "A formal computable definition of a graph of resources - that is, a coherent set of resources that form a graph by following references. The Graph Definition resource defines a set and makes rules about the set."; 19908 case GROUP: return "Represents a defined collection of entities that may be discussed or acted upon collectively but which are not expected to act collectively, and are not formally or legally recognized; i.e. a collection of entities that isn't an Organization."; 19909 case GUIDANCERESPONSE: return "A guidance response is the formal response to a guidance request, including any output parameters returned by the evaluation, as well as the description of any proposed actions to be taken."; 19910 case HEALTHCARESERVICE: return "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."; 19911 case IMAGINGSELECTION: return "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."; 19912 case IMAGINGSTUDY: return "Representation of the content produced in a DICOM imaging study. A study comprises a set of series, each of which includes a set of Service-Object Pair Instances (SOP Instances - images or other data) acquired or produced in a common context. A series is of only one modality (e.g. X-ray, CT, MR, ultrasound), but a study may have multiple series of different modalities."; 19913 case IMMUNIZATION: return "Describes the event of a patient being administered a vaccine or a record of an immunization as reported by a patient, a clinician or another party."; 19914 case IMMUNIZATIONEVALUATION: return "Describes a comparison of an immunization event against published recommendations to determine if the administration is \"valid\" in relation to those recommendations."; 19915 case IMMUNIZATIONRECOMMENDATION: return "A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification."; 19916 case IMPLEMENTATIONGUIDE: return "A set of rules of how a particular interoperability or standards problem is solved - typically through the use of FHIR resources. This resource is used to gather all the parts of an implementation guide into a logical whole and to publish a computable definition of all the parts."; 19917 case INGREDIENT: return "An ingredient of a manufactured item or pharmaceutical product."; 19918 case INSURANCEPLAN: return "Details of a Health Insurance product/plan provided by an organization."; 19919 case INVENTORYITEM: return "functional description of an inventory item used in inventory and supply-related workflows."; 19920 case INVENTORYREPORT: return "A report of inventory or stock items."; 19921 case INVOICE: return "Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose."; 19922 case LIBRARY: return "The Library resource is a general-purpose container for knowledge asset definitions. It can be used to describe and expose existing knowledge assets such as logic libraries and information model descriptions, as well as to describe a collection of knowledge assets."; 19923 case LINKAGE: return "Identifies two or more records (resource instances) that refer to the same real-world \"occurrence\"."; 19924 case LIST: return "A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc."; 19925 case LOCATION: return "Details and position information for a place where services are provided and resources and participants may be stored, found, contained, or accommodated."; 19926 case MANUFACTUREDITEMDEFINITION: return "The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product."; 19927 case MEASURE: return "The Measure resource provides the definition of a quality measure."; 19928 case MEASUREREPORT: return "The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation."; 19929 case MEDICATION: return "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."; 19930 case MEDICATIONADMINISTRATION: return "Describes the event of a patient consuming or otherwise being administered a medication. This may be as simple as swallowing a tablet or it may be a long running infusion. Related resources tie this event to the authorizing prescription, and the specific encounter between patient and health care practitioner. This event can also be used to record waste using a status of not-done and the appropriate statusReason."; 19931 case MEDICATIONDISPENSE: return "Indicates that a medication product is to be or has been dispensed for a named person/patient. This includes a description of the medication product (supply) provided and the instructions for administering the medication. The medication dispense is the result of a pharmacy system responding to a medication order."; 19932 case MEDICATIONKNOWLEDGE: return "Information about a medication that is used to support knowledge."; 19933 case MEDICATIONREQUEST: return "An order or request for both supply of the medication and the instructions for administration of the medication to a patient. The resource is called \"MedicationRequest\" rather than \"MedicationPrescription\" or \"MedicationOrder\" to generalize the use across inpatient and outpatient settings, including care plans, etc., and to harmonize with workflow patterns."; 19934 case MEDICATIONSTATEMENT: return "A record of a medication that is being consumed by a patient. A MedicationStatement may indicate that the patient may be taking the medication now or has taken the medication in the past or will be taking the medication in the future. The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician. A common scenario where this information is captured is during the history taking process during a patient visit or stay. The medication information may come from sources such as the patient's memory, from a prescription bottle, or from a list of medications the patient, clinician or other party maintains. \n\nThe primary difference between a 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."; 19935 case MEDICINALPRODUCTDEFINITION: return "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.)."; 19936 case MESSAGEDEFINITION: return "Defines the characteristics of a message that can be shared between systems, including the type of event that initiates the message, the content to be transmitted and what response(s), if any, are permitted."; 19937 case MESSAGEHEADER: return "The header for a message exchange that is either requesting or responding to an action. The reference(s) that are the subject of the action as well as other information related to the action are typically transmitted in a bundle in which the MessageHeader resource instance is the first resource in the bundle."; 19938 case METADATARESOURCE: return "Common Interface declaration for conformance and knowledge artifact resources."; 19939 case MOLECULARSEQUENCE: return "Representation of a molecular sequence."; 19940 case NAMINGSYSTEM: return "A curated namespace that issues unique symbols within that namespace for the identification of concepts, people, devices, etc. Represents a \"System\" used within the Identifier and Coding data types."; 19941 case NUTRITIONINTAKE: return "A record of food or fluid that is being consumed by a patient. A NutritionIntake may indicate that the patient may be consuming the food or fluid now or has consumed the food or fluid in the past. The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician. A common scenario where this information is captured is during the history taking process during a patient visit or stay or through an app that tracks food or fluids consumed. The consumption information may come from sources such as the patient's memory, from a nutrition label, or from a clinician documenting observed intake."; 19942 case NUTRITIONORDER: return "A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident."; 19943 case NUTRITIONPRODUCT: return "A food or supplement that is consumed by patients."; 19944 case OBSERVATION: return "Measurements and simple assertions made about a patient, device or other subject."; 19945 case OBSERVATIONDEFINITION: return "Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service."; 19946 case OPERATIONDEFINITION: return "A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction)."; 19947 case OPERATIONOUTCOME: return "A collection of error, warning, or information messages that result from a system action."; 19948 case ORGANIZATION: return "A formally or informally recognized grouping of people or organizations formed for the purpose of achieving some form of collective action. Includes companies, institutions, corporations, departments, community groups, healthcare practice groups, payer/insurer, etc."; 19949 case ORGANIZATIONAFFILIATION: return "Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship."; 19950 case PACKAGEDPRODUCTDEFINITION: return "A medically related item or items, in a container or package."; 19951 case PARAMETERS: return "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."; 19952 case PATIENT: return "Demographics and other administrative information about an individual or animal receiving care or other health-related services."; 19953 case PAYMENTNOTICE: return "This resource provides the status of the payment for goods and services rendered, and the request and response resource references."; 19954 case PAYMENTRECONCILIATION: return "This resource provides the details including amount of a payment and allocates the payment items being paid."; 19955 case PERMISSION: return "Permission resource holds access rules for a given data and context."; 19956 case PERSON: return "Demographics and administrative information about a person independent of a specific health-related context."; 19957 case PLANDEFINITION: return "This resource allows for the definition of various types of plans as a sharable, consumable, and executable artifact. The resource is general enough to support the description of a broad range of clinical and non-clinical artifacts such as clinical decision support rules, order sets, protocols, and drug quality specifications."; 19958 case PRACTITIONER: return "A person who is directly or indirectly involved in the provisioning of healthcare or related services."; 19959 case PRACTITIONERROLE: return "A specific set of Roles/Locations/specialties/services that a practitioner may perform, or has performed at an organization during a period of time."; 19960 case PROCEDURE: return "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."; 19961 case PROVENANCE: return "Provenance of a resource is a record that describes entities and processes involved in producing and delivering or otherwise influencing that resource. Provenance provides a critical foundation for assessing authenticity, enabling trust, and allowing reproducibility. Provenance assertions are a form of contextual metadata and can themselves become important records with their own provenance. Provenance statement indicates clinical significance in terms of confidence in authenticity, reliability, and trustworthiness, integrity, and stage in lifecycle (e.g. Document Completion - has the artifact been legally authenticated), all of which may impact security, privacy, and trust policies."; 19962 case QUESTIONNAIRE: return "A structured set of questions intended to guide the collection of answers from end-users. Questionnaires provide detailed control over order, presentation, phraseology and grouping to allow coherent, consistent data collection."; 19963 case QUESTIONNAIRERESPONSE: return "A structured set of questions and their answers. The questions are ordered and grouped into coherent subsets, corresponding to the structure of the grouping of the questionnaire being responded to."; 19964 case REGULATEDAUTHORIZATION: return "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."; 19965 case RELATEDPERSON: return "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."; 19966 case REQUESTORCHESTRATION: return "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\"."; 19967 case REQUIREMENTS: return "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."; 19968 case RESEARCHSTUDY: return "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."; 19969 case RESEARCHSUBJECT: return "A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study."; 19970 case RESOURCE: return "This is the base resource type for everything."; 19971 case RISKASSESSMENT: return "An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome."; 19972 case SCHEDULE: return "A container for slots of time that may be available for booking appointments."; 19973 case SEARCHPARAMETER: return "A search parameter that defines a named search item that can be used to search/filter on a resource."; 19974 case SERVICEREQUEST: return "A record of a request for service such as diagnostic investigations, treatments, or operations to be performed."; 19975 case SLOT: return "A slot of time on a schedule that may be available for booking appointments."; 19976 case SPECIMEN: return "A sample to be used for analysis."; 19977 case SPECIMENDEFINITION: return "A kind of specimen with associated set of requirements."; 19978 case STRUCTUREDEFINITION: return "A definition of a FHIR structure. This resource is used to describe the underlying resources, data types defined in FHIR, and also for describing extensions and constraints on resources and data types."; 19979 case STRUCTUREMAP: return "A Map of relationships between 2 structures that can be used to transform data."; 19980 case SUBSCRIPTION: return "The subscription resource describes a particular client's request to be notified about a SubscriptionTopic."; 19981 case SUBSCRIPTIONSTATUS: return "The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted."; 19982 case SUBSCRIPTIONTOPIC: return "Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic."; 19983 case SUBSTANCE: return "A homogeneous material with a definite composition."; 19984 case SUBSTANCEDEFINITION: return "The detailed description of a substance, typically at a level beyond what is used for prescribing."; 19985 case SUBSTANCENUCLEICACID: return "Nucleic acids are defined by three distinct elements: the base, sugar and linkage. Individual substance/moiety IDs will be created for each of these elements. The nucleotide sequence will be always entered in the 5?-3? direction."; 19986 case SUBSTANCEPOLYMER: return "Properties of a substance specific to it being a polymer."; 19987 case SUBSTANCEPROTEIN: return "A SubstanceProtein is defined as a single unit of a linear amino acid sequence, or a combination of subunits that are either covalently linked or have a defined invariant stoichiometric relationship. This includes all synthetic, recombinant and purified SubstanceProteins of defined sequence, whether the use is therapeutic or prophylactic. This set of elements will be used to describe albumins, coagulation factors, cytokines, growth factors, peptide/SubstanceProtein hormones, enzymes, toxins, toxoids, recombinant vaccines, and immunomodulators."; 19988 case SUBSTANCEREFERENCEINFORMATION: return "Todo."; 19989 case SUBSTANCESOURCEMATERIAL: return "Source material shall capture information on the taxonomic and anatomical origins as well as the fraction of a material that can result in or can be modified to form a substance. This set of data elements shall be used to define polymer substances isolated from biological matrices. Taxonomic and anatomical origins shall be described using a controlled vocabulary as required. This information is captured for naturally derived polymers ( . starch) and structurally diverse substances. For Organisms belonging to the Kingdom Plantae the Substance level defines the fresh material of a single species or infraspecies, the Herbal Drug and the Herbal preparation. For Herbal preparations, the fraction information will be captured at the Substance information level and additional information for herbal extracts will be captured at the Specified Substance Group 1 information level. See for further explanation the Substance Class: Structurally Diverse and the herbal annex."; 19990 case SUPPLYDELIVERY: return "Record of delivery of what is supplied."; 19991 case SUPPLYREQUEST: return "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."; 19992 case TASK: return "A task to be performed."; 19993 case TERMINOLOGYCAPABILITIES: return "A TerminologyCapabilities resource documents a set of capabilities (behaviors) of a FHIR Terminology Server that may be used as a statement of actual server functionality or a statement of required or desired server implementation."; 19994 case TESTPLAN: return "A plan for executing testing on an artifact or specifications"; 19995 case TESTREPORT: return "A summary of information based on the results of executing a TestScript."; 19996 case TESTSCRIPT: return "A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification."; 19997 case TRANSPORT: return "Record of transport."; 19998 case VALUESET: return "A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html)."; 19999 case VERIFICATIONRESULT: return "Describes validation requirements, source(s), status and dates for one or more elements."; 20000 case VISIONPRESCRIPTION: return "An authorization for the provision of glasses and/or contact lenses to a patient."; 20001 case BODYSITE: return ""; 20002 case CATALOGENTRY: return ""; 20003 case CONFORMANCE: return ""; 20004 case DATAELEMENT: return ""; 20005 case DEVICECOMPONENT: return ""; 20006 case DEVICEUSEREQUEST: return ""; 20007 case DEVICEUSESTATEMENT: return ""; 20008 case DIAGNOSTICORDER: return ""; 20009 case DOCUMENTMANIFEST: return ""; 20010 case EFFECTEVIDENCESYNTHESIS: return ""; 20011 case ELIGIBILITYREQUEST: return ""; 20012 case ELIGIBILITYRESPONSE: return ""; 20013 case EXPANSIONPROFILE: return ""; 20014 case IMAGINGMANIFEST: return ""; 20015 case IMAGINGOBJECTSELECTION: return ""; 20016 case MEDIA: return ""; 20017 case MEDICATIONORDER: return ""; 20018 case MEDICATIONUSAGE: return ""; 20019 case MEDICINALPRODUCT: return ""; 20020 case MEDICINALPRODUCTAUTHORIZATION: return ""; 20021 case MEDICINALPRODUCTCONTRAINDICATION: return ""; 20022 case MEDICINALPRODUCTINDICATION: return ""; 20023 case MEDICINALPRODUCTINGREDIENT: return ""; 20024 case MEDICINALPRODUCTINTERACTION: return ""; 20025 case MEDICINALPRODUCTMANUFACTURED: return ""; 20026 case MEDICINALPRODUCTPACKAGED: return ""; 20027 case MEDICINALPRODUCTPHARMACEUTICAL: return ""; 20028 case MEDICINALPRODUCTUNDESIRABLEEFFECT: return ""; 20029 case ORDER: return ""; 20030 case ORDERRESPONSE: return ""; 20031 case PROCEDUREREQUEST: return ""; 20032 case PROCESSREQUEST: return ""; 20033 case PROCESSRESPONSE: return ""; 20034 case REFERRALREQUEST: return ""; 20035 case REQUESTGROUP: return ""; 20036 case RESEARCHDEFINITION: return ""; 20037 case RESEARCHELEMENTDEFINITION: return ""; 20038 case RISKEVIDENCESYNTHESIS: return ""; 20039 case SEQUENCE: return ""; 20040 case SERVICEDEFINITION: return ""; 20041 case SUBSTANCESPECIFICATION: return ""; 20042 case NULL: return null; 20043 default: return "?"; 20044 } 20045 } 20046 public String getDisplay() { 20047 switch (this) { 20048 case ACCOUNT: return "Account"; 20049 case ACTIVITYDEFINITION: return "ActivityDefinition"; 20050 case ACTORDEFINITION: return "ActorDefinition"; 20051 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 20052 case ADVERSEEVENT: return "AdverseEvent"; 20053 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 20054 case APPOINTMENT: return "Appointment"; 20055 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 20056 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 20057 case AUDITEVENT: return "AuditEvent"; 20058 case BASIC: return "Basic"; 20059 case BINARY: return "Binary"; 20060 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 20061 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "BiologicallyDerivedProductDispense"; 20062 case BODYSTRUCTURE: return "BodyStructure"; 20063 case BUNDLE: return "Bundle"; 20064 case CANONICALRESOURCE: return "CanonicalResource"; 20065 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 20066 case CAREPLAN: return "CarePlan"; 20067 case CARETEAM: return "CareTeam"; 20068 case CHARGEITEM: return "ChargeItem"; 20069 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 20070 case CITATION: return "Citation"; 20071 case CLAIM: return "Claim"; 20072 case CLAIMRESPONSE: return "ClaimResponse"; 20073 case CLINICALIMPRESSION: return "ClinicalImpression"; 20074 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 20075 case CODESYSTEM: return "CodeSystem"; 20076 case COMMUNICATION: return "Communication"; 20077 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 20078 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 20079 case COMPOSITION: return "Composition"; 20080 case CONCEPTMAP: return "ConceptMap"; 20081 case CONDITION: return "Condition"; 20082 case CONDITIONDEFINITION: return "ConditionDefinition"; 20083 case CONSENT: return "Consent"; 20084 case CONTRACT: return "Contract"; 20085 case COVERAGE: return "Coverage"; 20086 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 20087 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 20088 case DETECTEDISSUE: return "DetectedIssue"; 20089 case DEVICE: return "Device"; 20090 case DEVICEASSOCIATION: return "DeviceAssociation"; 20091 case DEVICEDEFINITION: return "DeviceDefinition"; 20092 case DEVICEDISPENSE: return "DeviceDispense"; 20093 case DEVICEMETRIC: return "DeviceMetric"; 20094 case DEVICEREQUEST: return "DeviceRequest"; 20095 case DEVICEUSAGE: return "DeviceUsage"; 20096 case DIAGNOSTICREPORT: return "DiagnosticReport"; 20097 case DOCUMENTREFERENCE: return "DocumentReference"; 20098 case DOMAINRESOURCE: return "DomainResource"; 20099 case ENCOUNTER: return "Encounter"; 20100 case ENCOUNTERHISTORY: return "EncounterHistory"; 20101 case ENDPOINT: return "Endpoint"; 20102 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 20103 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 20104 case EPISODEOFCARE: return "EpisodeOfCare"; 20105 case EVENTDEFINITION: return "EventDefinition"; 20106 case EVIDENCE: return "Evidence"; 20107 case EVIDENCEREPORT: return "EvidenceReport"; 20108 case EVIDENCEVARIABLE: return "EvidenceVariable"; 20109 case EXAMPLESCENARIO: return "ExampleScenario"; 20110 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 20111 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 20112 case FLAG: return "Flag"; 20113 case FORMULARYITEM: return "FormularyItem"; 20114 case GENOMICSTUDY: return "GenomicStudy"; 20115 case GOAL: return "Goal"; 20116 case GRAPHDEFINITION: return "GraphDefinition"; 20117 case GROUP: return "Group"; 20118 case GUIDANCERESPONSE: return "GuidanceResponse"; 20119 case HEALTHCARESERVICE: return "HealthcareService"; 20120 case IMAGINGSELECTION: return "ImagingSelection"; 20121 case IMAGINGSTUDY: return "ImagingStudy"; 20122 case IMMUNIZATION: return "Immunization"; 20123 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 20124 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 20125 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 20126 case INGREDIENT: return "Ingredient"; 20127 case INSURANCEPLAN: return "InsurancePlan"; 20128 case INVENTORYITEM: return "InventoryItem"; 20129 case INVENTORYREPORT: return "InventoryReport"; 20130 case INVOICE: return "Invoice"; 20131 case LIBRARY: return "Library"; 20132 case LINKAGE: return "Linkage"; 20133 case LIST: return "List"; 20134 case LOCATION: return "Location"; 20135 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 20136 case MEASURE: return "Measure"; 20137 case MEASUREREPORT: return "MeasureReport"; 20138 case MEDICATION: return "Medication"; 20139 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 20140 case MEDICATIONDISPENSE: return "MedicationDispense"; 20141 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 20142 case MEDICATIONREQUEST: return "MedicationRequest"; 20143 case MEDICATIONSTATEMENT: return "MedicationStatement"; 20144 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 20145 case MESSAGEDEFINITION: return "MessageDefinition"; 20146 case MESSAGEHEADER: return "MessageHeader"; 20147 case METADATARESOURCE: return "MetadataResource"; 20148 case MOLECULARSEQUENCE: return "MolecularSequence"; 20149 case NAMINGSYSTEM: return "NamingSystem"; 20150 case NUTRITIONINTAKE: return "NutritionIntake"; 20151 case NUTRITIONORDER: return "NutritionOrder"; 20152 case NUTRITIONPRODUCT: return "NutritionProduct"; 20153 case OBSERVATION: return "Observation"; 20154 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 20155 case OPERATIONDEFINITION: return "OperationDefinition"; 20156 case OPERATIONOUTCOME: return "OperationOutcome"; 20157 case ORGANIZATION: return "Organization"; 20158 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 20159 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 20160 case PARAMETERS: return "Parameters"; 20161 case PATIENT: return "Patient"; 20162 case PAYMENTNOTICE: return "PaymentNotice"; 20163 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 20164 case PERMISSION: return "Permission"; 20165 case PERSON: return "Person"; 20166 case PLANDEFINITION: return "PlanDefinition"; 20167 case PRACTITIONER: return "Practitioner"; 20168 case PRACTITIONERROLE: return "PractitionerRole"; 20169 case PROCEDURE: return "Procedure"; 20170 case PROVENANCE: return "Provenance"; 20171 case QUESTIONNAIRE: return "Questionnaire"; 20172 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 20173 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 20174 case RELATEDPERSON: return "RelatedPerson"; 20175 case REQUESTORCHESTRATION: return "RequestOrchestration"; 20176 case REQUIREMENTS: return "Requirements"; 20177 case RESEARCHSTUDY: return "ResearchStudy"; 20178 case RESEARCHSUBJECT: return "ResearchSubject"; 20179 case RESOURCE: return "Resource"; 20180 case RISKASSESSMENT: return "RiskAssessment"; 20181 case SCHEDULE: return "Schedule"; 20182 case SEARCHPARAMETER: return "SearchParameter"; 20183 case SERVICEREQUEST: return "ServiceRequest"; 20184 case SLOT: return "Slot"; 20185 case SPECIMEN: return "Specimen"; 20186 case SPECIMENDEFINITION: return "SpecimenDefinition"; 20187 case STRUCTUREDEFINITION: return "StructureDefinition"; 20188 case STRUCTUREMAP: return "StructureMap"; 20189 case SUBSCRIPTION: return "Subscription"; 20190 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 20191 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 20192 case SUBSTANCE: return "Substance"; 20193 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 20194 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 20195 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 20196 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 20197 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 20198 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 20199 case SUPPLYDELIVERY: return "SupplyDelivery"; 20200 case SUPPLYREQUEST: return "SupplyRequest"; 20201 case TASK: return "Task"; 20202 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 20203 case TESTPLAN: return "TestPlan"; 20204 case TESTREPORT: return "TestReport"; 20205 case TESTSCRIPT: return "TestScript"; 20206 case TRANSPORT: return "Transport"; 20207 case VALUESET: return "ValueSet"; 20208 case VERIFICATIONRESULT: return "VerificationResult"; 20209 case VISIONPRESCRIPTION: return "VisionPrescription"; 20210 case BODYSITE: return "BodySite"; 20211 case CATALOGENTRY: return "CatalogEntry"; 20212 case CONFORMANCE: return "Conformance"; 20213 case DATAELEMENT: return "DataElement"; 20214 case DEVICECOMPONENT: return "DeviceComponent"; 20215 case DEVICEUSEREQUEST: return "DeviceUseRequest"; 20216 case DEVICEUSESTATEMENT: return "DeviceUseStatement"; 20217 case DIAGNOSTICORDER: return "DiagnosticOrder"; 20218 case DOCUMENTMANIFEST: return "DocumentManifest"; 20219 case EFFECTEVIDENCESYNTHESIS: return "EffectEvidenceSynthesis"; 20220 case ELIGIBILITYREQUEST: return "EligibilityRequest"; 20221 case ELIGIBILITYRESPONSE: return "EligibilityResponse"; 20222 case EXPANSIONPROFILE: return "ExpansionProfile"; 20223 case IMAGINGMANIFEST: return "ImagingManifest"; 20224 case IMAGINGOBJECTSELECTION: return "ImagingObjectSelection"; 20225 case MEDIA: return "Media"; 20226 case MEDICATIONORDER: return "MedicationOrder"; 20227 case MEDICATIONUSAGE: return "MedicationUsage"; 20228 case MEDICINALPRODUCT: return "MedicinalProduct"; 20229 case MEDICINALPRODUCTAUTHORIZATION: return "MedicinalProductAuthorization"; 20230 case MEDICINALPRODUCTCONTRAINDICATION: return "MedicinalProductContraindication"; 20231 case MEDICINALPRODUCTINDICATION: return "MedicinalProductIndication"; 20232 case MEDICINALPRODUCTINGREDIENT: return "MedicinalProductIngredient"; 20233 case MEDICINALPRODUCTINTERACTION: return "MedicinalProductInteraction"; 20234 case MEDICINALPRODUCTMANUFACTURED: return "MedicinalProductManufactured"; 20235 case MEDICINALPRODUCTPACKAGED: return "MedicinalProductPackaged"; 20236 case MEDICINALPRODUCTPHARMACEUTICAL: return "MedicinalProductPharmaceutical"; 20237 case MEDICINALPRODUCTUNDESIRABLEEFFECT: return "MedicinalProductUndesirableEffect"; 20238 case ORDER: return "Order"; 20239 case ORDERRESPONSE: return "OrderResponse"; 20240 case PROCEDUREREQUEST: return "ProcedureRequest"; 20241 case PROCESSREQUEST: return "ProcessRequest"; 20242 case PROCESSRESPONSE: return "ProcessResponse"; 20243 case REFERRALREQUEST: return "ReferralRequest"; 20244 case REQUESTGROUP: return "RequestGroup"; 20245 case RESEARCHDEFINITION: return "ResearchDefinition"; 20246 case RESEARCHELEMENTDEFINITION: return "ResearchElementDefinition"; 20247 case RISKEVIDENCESYNTHESIS: return "RiskEvidenceSynthesis"; 20248 case SEQUENCE: return "Sequence"; 20249 case SERVICEDEFINITION: return "ServiceDefinition"; 20250 case SUBSTANCESPECIFICATION: return "SubstanceSpecification"; 20251 case NULL: return null; 20252 default: return "?"; 20253 } 20254 } 20255 } 20256 20257 public static class VersionIndependentResourceTypesAllEnumFactory implements EnumFactory<VersionIndependentResourceTypesAll> { 20258 public VersionIndependentResourceTypesAll fromCode(String codeString) throws IllegalArgumentException { 20259 if (codeString == null || "".equals(codeString)) 20260 if (codeString == null || "".equals(codeString)) 20261 return null; 20262 if ("Account".equals(codeString)) 20263 return VersionIndependentResourceTypesAll.ACCOUNT; 20264 if ("ActivityDefinition".equals(codeString)) 20265 return VersionIndependentResourceTypesAll.ACTIVITYDEFINITION; 20266 if ("ActorDefinition".equals(codeString)) 20267 return VersionIndependentResourceTypesAll.ACTORDEFINITION; 20268 if ("AdministrableProductDefinition".equals(codeString)) 20269 return VersionIndependentResourceTypesAll.ADMINISTRABLEPRODUCTDEFINITION; 20270 if ("AdverseEvent".equals(codeString)) 20271 return VersionIndependentResourceTypesAll.ADVERSEEVENT; 20272 if ("AllergyIntolerance".equals(codeString)) 20273 return VersionIndependentResourceTypesAll.ALLERGYINTOLERANCE; 20274 if ("Appointment".equals(codeString)) 20275 return VersionIndependentResourceTypesAll.APPOINTMENT; 20276 if ("AppointmentResponse".equals(codeString)) 20277 return VersionIndependentResourceTypesAll.APPOINTMENTRESPONSE; 20278 if ("ArtifactAssessment".equals(codeString)) 20279 return VersionIndependentResourceTypesAll.ARTIFACTASSESSMENT; 20280 if ("AuditEvent".equals(codeString)) 20281 return VersionIndependentResourceTypesAll.AUDITEVENT; 20282 if ("Basic".equals(codeString)) 20283 return VersionIndependentResourceTypesAll.BASIC; 20284 if ("Binary".equals(codeString)) 20285 return VersionIndependentResourceTypesAll.BINARY; 20286 if ("BiologicallyDerivedProduct".equals(codeString)) 20287 return VersionIndependentResourceTypesAll.BIOLOGICALLYDERIVEDPRODUCT; 20288 if ("BiologicallyDerivedProductDispense".equals(codeString)) 20289 return VersionIndependentResourceTypesAll.BIOLOGICALLYDERIVEDPRODUCTDISPENSE; 20290 if ("BodyStructure".equals(codeString)) 20291 return VersionIndependentResourceTypesAll.BODYSTRUCTURE; 20292 if ("Bundle".equals(codeString)) 20293 return VersionIndependentResourceTypesAll.BUNDLE; 20294 if ("CanonicalResource".equals(codeString)) 20295 return VersionIndependentResourceTypesAll.CANONICALRESOURCE; 20296 if ("CapabilityStatement".equals(codeString)) 20297 return VersionIndependentResourceTypesAll.CAPABILITYSTATEMENT; 20298 if ("CarePlan".equals(codeString)) 20299 return VersionIndependentResourceTypesAll.CAREPLAN; 20300 if ("CareTeam".equals(codeString)) 20301 return VersionIndependentResourceTypesAll.CARETEAM; 20302 if ("ChargeItem".equals(codeString)) 20303 return VersionIndependentResourceTypesAll.CHARGEITEM; 20304 if ("ChargeItemDefinition".equals(codeString)) 20305 return VersionIndependentResourceTypesAll.CHARGEITEMDEFINITION; 20306 if ("Citation".equals(codeString)) 20307 return VersionIndependentResourceTypesAll.CITATION; 20308 if ("Claim".equals(codeString)) 20309 return VersionIndependentResourceTypesAll.CLAIM; 20310 if ("ClaimResponse".equals(codeString)) 20311 return VersionIndependentResourceTypesAll.CLAIMRESPONSE; 20312 if ("ClinicalImpression".equals(codeString)) 20313 return VersionIndependentResourceTypesAll.CLINICALIMPRESSION; 20314 if ("ClinicalUseDefinition".equals(codeString)) 20315 return VersionIndependentResourceTypesAll.CLINICALUSEDEFINITION; 20316 if ("CodeSystem".equals(codeString)) 20317 return VersionIndependentResourceTypesAll.CODESYSTEM; 20318 if ("Communication".equals(codeString)) 20319 return VersionIndependentResourceTypesAll.COMMUNICATION; 20320 if ("CommunicationRequest".equals(codeString)) 20321 return VersionIndependentResourceTypesAll.COMMUNICATIONREQUEST; 20322 if ("CompartmentDefinition".equals(codeString)) 20323 return VersionIndependentResourceTypesAll.COMPARTMENTDEFINITION; 20324 if ("Composition".equals(codeString)) 20325 return VersionIndependentResourceTypesAll.COMPOSITION; 20326 if ("ConceptMap".equals(codeString)) 20327 return VersionIndependentResourceTypesAll.CONCEPTMAP; 20328 if ("Condition".equals(codeString)) 20329 return VersionIndependentResourceTypesAll.CONDITION; 20330 if ("ConditionDefinition".equals(codeString)) 20331 return VersionIndependentResourceTypesAll.CONDITIONDEFINITION; 20332 if ("Consent".equals(codeString)) 20333 return VersionIndependentResourceTypesAll.CONSENT; 20334 if ("Contract".equals(codeString)) 20335 return VersionIndependentResourceTypesAll.CONTRACT; 20336 if ("Coverage".equals(codeString)) 20337 return VersionIndependentResourceTypesAll.COVERAGE; 20338 if ("CoverageEligibilityRequest".equals(codeString)) 20339 return VersionIndependentResourceTypesAll.COVERAGEELIGIBILITYREQUEST; 20340 if ("CoverageEligibilityResponse".equals(codeString)) 20341 return VersionIndependentResourceTypesAll.COVERAGEELIGIBILITYRESPONSE; 20342 if ("DetectedIssue".equals(codeString)) 20343 return VersionIndependentResourceTypesAll.DETECTEDISSUE; 20344 if ("Device".equals(codeString)) 20345 return VersionIndependentResourceTypesAll.DEVICE; 20346 if ("DeviceAssociation".equals(codeString)) 20347 return VersionIndependentResourceTypesAll.DEVICEASSOCIATION; 20348 if ("DeviceDefinition".equals(codeString)) 20349 return VersionIndependentResourceTypesAll.DEVICEDEFINITION; 20350 if ("DeviceDispense".equals(codeString)) 20351 return VersionIndependentResourceTypesAll.DEVICEDISPENSE; 20352 if ("DeviceMetric".equals(codeString)) 20353 return VersionIndependentResourceTypesAll.DEVICEMETRIC; 20354 if ("DeviceRequest".equals(codeString)) 20355 return VersionIndependentResourceTypesAll.DEVICEREQUEST; 20356 if ("DeviceUsage".equals(codeString)) 20357 return VersionIndependentResourceTypesAll.DEVICEUSAGE; 20358 if ("DiagnosticReport".equals(codeString)) 20359 return VersionIndependentResourceTypesAll.DIAGNOSTICREPORT; 20360 if ("DocumentReference".equals(codeString)) 20361 return VersionIndependentResourceTypesAll.DOCUMENTREFERENCE; 20362 if ("DomainResource".equals(codeString)) 20363 return VersionIndependentResourceTypesAll.DOMAINRESOURCE; 20364 if ("Encounter".equals(codeString)) 20365 return VersionIndependentResourceTypesAll.ENCOUNTER; 20366 if ("EncounterHistory".equals(codeString)) 20367 return VersionIndependentResourceTypesAll.ENCOUNTERHISTORY; 20368 if ("Endpoint".equals(codeString)) 20369 return VersionIndependentResourceTypesAll.ENDPOINT; 20370 if ("EnrollmentRequest".equals(codeString)) 20371 return VersionIndependentResourceTypesAll.ENROLLMENTREQUEST; 20372 if ("EnrollmentResponse".equals(codeString)) 20373 return VersionIndependentResourceTypesAll.ENROLLMENTRESPONSE; 20374 if ("EpisodeOfCare".equals(codeString)) 20375 return VersionIndependentResourceTypesAll.EPISODEOFCARE; 20376 if ("EventDefinition".equals(codeString)) 20377 return VersionIndependentResourceTypesAll.EVENTDEFINITION; 20378 if ("Evidence".equals(codeString)) 20379 return VersionIndependentResourceTypesAll.EVIDENCE; 20380 if ("EvidenceReport".equals(codeString)) 20381 return VersionIndependentResourceTypesAll.EVIDENCEREPORT; 20382 if ("EvidenceVariable".equals(codeString)) 20383 return VersionIndependentResourceTypesAll.EVIDENCEVARIABLE; 20384 if ("ExampleScenario".equals(codeString)) 20385 return VersionIndependentResourceTypesAll.EXAMPLESCENARIO; 20386 if ("ExplanationOfBenefit".equals(codeString)) 20387 return VersionIndependentResourceTypesAll.EXPLANATIONOFBENEFIT; 20388 if ("FamilyMemberHistory".equals(codeString)) 20389 return VersionIndependentResourceTypesAll.FAMILYMEMBERHISTORY; 20390 if ("Flag".equals(codeString)) 20391 return VersionIndependentResourceTypesAll.FLAG; 20392 if ("FormularyItem".equals(codeString)) 20393 return VersionIndependentResourceTypesAll.FORMULARYITEM; 20394 if ("GenomicStudy".equals(codeString)) 20395 return VersionIndependentResourceTypesAll.GENOMICSTUDY; 20396 if ("Goal".equals(codeString)) 20397 return VersionIndependentResourceTypesAll.GOAL; 20398 if ("GraphDefinition".equals(codeString)) 20399 return VersionIndependentResourceTypesAll.GRAPHDEFINITION; 20400 if ("Group".equals(codeString)) 20401 return VersionIndependentResourceTypesAll.GROUP; 20402 if ("GuidanceResponse".equals(codeString)) 20403 return VersionIndependentResourceTypesAll.GUIDANCERESPONSE; 20404 if ("HealthcareService".equals(codeString)) 20405 return VersionIndependentResourceTypesAll.HEALTHCARESERVICE; 20406 if ("ImagingSelection".equals(codeString)) 20407 return VersionIndependentResourceTypesAll.IMAGINGSELECTION; 20408 if ("ImagingStudy".equals(codeString)) 20409 return VersionIndependentResourceTypesAll.IMAGINGSTUDY; 20410 if ("Immunization".equals(codeString)) 20411 return VersionIndependentResourceTypesAll.IMMUNIZATION; 20412 if ("ImmunizationEvaluation".equals(codeString)) 20413 return VersionIndependentResourceTypesAll.IMMUNIZATIONEVALUATION; 20414 if ("ImmunizationRecommendation".equals(codeString)) 20415 return VersionIndependentResourceTypesAll.IMMUNIZATIONRECOMMENDATION; 20416 if ("ImplementationGuide".equals(codeString)) 20417 return VersionIndependentResourceTypesAll.IMPLEMENTATIONGUIDE; 20418 if ("Ingredient".equals(codeString)) 20419 return VersionIndependentResourceTypesAll.INGREDIENT; 20420 if ("InsurancePlan".equals(codeString)) 20421 return VersionIndependentResourceTypesAll.INSURANCEPLAN; 20422 if ("InventoryItem".equals(codeString)) 20423 return VersionIndependentResourceTypesAll.INVENTORYITEM; 20424 if ("InventoryReport".equals(codeString)) 20425 return VersionIndependentResourceTypesAll.INVENTORYREPORT; 20426 if ("Invoice".equals(codeString)) 20427 return VersionIndependentResourceTypesAll.INVOICE; 20428 if ("Library".equals(codeString)) 20429 return VersionIndependentResourceTypesAll.LIBRARY; 20430 if ("Linkage".equals(codeString)) 20431 return VersionIndependentResourceTypesAll.LINKAGE; 20432 if ("List".equals(codeString)) 20433 return VersionIndependentResourceTypesAll.LIST; 20434 if ("Location".equals(codeString)) 20435 return VersionIndependentResourceTypesAll.LOCATION; 20436 if ("ManufacturedItemDefinition".equals(codeString)) 20437 return VersionIndependentResourceTypesAll.MANUFACTUREDITEMDEFINITION; 20438 if ("Measure".equals(codeString)) 20439 return VersionIndependentResourceTypesAll.MEASURE; 20440 if ("MeasureReport".equals(codeString)) 20441 return VersionIndependentResourceTypesAll.MEASUREREPORT; 20442 if ("Medication".equals(codeString)) 20443 return VersionIndependentResourceTypesAll.MEDICATION; 20444 if ("MedicationAdministration".equals(codeString)) 20445 return VersionIndependentResourceTypesAll.MEDICATIONADMINISTRATION; 20446 if ("MedicationDispense".equals(codeString)) 20447 return VersionIndependentResourceTypesAll.MEDICATIONDISPENSE; 20448 if ("MedicationKnowledge".equals(codeString)) 20449 return VersionIndependentResourceTypesAll.MEDICATIONKNOWLEDGE; 20450 if ("MedicationRequest".equals(codeString)) 20451 return VersionIndependentResourceTypesAll.MEDICATIONREQUEST; 20452 if ("MedicationStatement".equals(codeString)) 20453 return VersionIndependentResourceTypesAll.MEDICATIONSTATEMENT; 20454 if ("MedicinalProductDefinition".equals(codeString)) 20455 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTDEFINITION; 20456 if ("MessageDefinition".equals(codeString)) 20457 return VersionIndependentResourceTypesAll.MESSAGEDEFINITION; 20458 if ("MessageHeader".equals(codeString)) 20459 return VersionIndependentResourceTypesAll.MESSAGEHEADER; 20460 if ("MetadataResource".equals(codeString)) 20461 return VersionIndependentResourceTypesAll.METADATARESOURCE; 20462 if ("MolecularSequence".equals(codeString)) 20463 return VersionIndependentResourceTypesAll.MOLECULARSEQUENCE; 20464 if ("NamingSystem".equals(codeString)) 20465 return VersionIndependentResourceTypesAll.NAMINGSYSTEM; 20466 if ("NutritionIntake".equals(codeString)) 20467 return VersionIndependentResourceTypesAll.NUTRITIONINTAKE; 20468 if ("NutritionOrder".equals(codeString)) 20469 return VersionIndependentResourceTypesAll.NUTRITIONORDER; 20470 if ("NutritionProduct".equals(codeString)) 20471 return VersionIndependentResourceTypesAll.NUTRITIONPRODUCT; 20472 if ("Observation".equals(codeString)) 20473 return VersionIndependentResourceTypesAll.OBSERVATION; 20474 if ("ObservationDefinition".equals(codeString)) 20475 return VersionIndependentResourceTypesAll.OBSERVATIONDEFINITION; 20476 if ("OperationDefinition".equals(codeString)) 20477 return VersionIndependentResourceTypesAll.OPERATIONDEFINITION; 20478 if ("OperationOutcome".equals(codeString)) 20479 return VersionIndependentResourceTypesAll.OPERATIONOUTCOME; 20480 if ("Organization".equals(codeString)) 20481 return VersionIndependentResourceTypesAll.ORGANIZATION; 20482 if ("OrganizationAffiliation".equals(codeString)) 20483 return VersionIndependentResourceTypesAll.ORGANIZATIONAFFILIATION; 20484 if ("PackagedProductDefinition".equals(codeString)) 20485 return VersionIndependentResourceTypesAll.PACKAGEDPRODUCTDEFINITION; 20486 if ("Parameters".equals(codeString)) 20487 return VersionIndependentResourceTypesAll.PARAMETERS; 20488 if ("Patient".equals(codeString)) 20489 return VersionIndependentResourceTypesAll.PATIENT; 20490 if ("PaymentNotice".equals(codeString)) 20491 return VersionIndependentResourceTypesAll.PAYMENTNOTICE; 20492 if ("PaymentReconciliation".equals(codeString)) 20493 return VersionIndependentResourceTypesAll.PAYMENTRECONCILIATION; 20494 if ("Permission".equals(codeString)) 20495 return VersionIndependentResourceTypesAll.PERMISSION; 20496 if ("Person".equals(codeString)) 20497 return VersionIndependentResourceTypesAll.PERSON; 20498 if ("PlanDefinition".equals(codeString)) 20499 return VersionIndependentResourceTypesAll.PLANDEFINITION; 20500 if ("Practitioner".equals(codeString)) 20501 return VersionIndependentResourceTypesAll.PRACTITIONER; 20502 if ("PractitionerRole".equals(codeString)) 20503 return VersionIndependentResourceTypesAll.PRACTITIONERROLE; 20504 if ("Procedure".equals(codeString)) 20505 return VersionIndependentResourceTypesAll.PROCEDURE; 20506 if ("Provenance".equals(codeString)) 20507 return VersionIndependentResourceTypesAll.PROVENANCE; 20508 if ("Questionnaire".equals(codeString)) 20509 return VersionIndependentResourceTypesAll.QUESTIONNAIRE; 20510 if ("QuestionnaireResponse".equals(codeString)) 20511 return VersionIndependentResourceTypesAll.QUESTIONNAIRERESPONSE; 20512 if ("RegulatedAuthorization".equals(codeString)) 20513 return VersionIndependentResourceTypesAll.REGULATEDAUTHORIZATION; 20514 if ("RelatedPerson".equals(codeString)) 20515 return VersionIndependentResourceTypesAll.RELATEDPERSON; 20516 if ("RequestOrchestration".equals(codeString)) 20517 return VersionIndependentResourceTypesAll.REQUESTORCHESTRATION; 20518 if ("Requirements".equals(codeString)) 20519 return VersionIndependentResourceTypesAll.REQUIREMENTS; 20520 if ("ResearchStudy".equals(codeString)) 20521 return VersionIndependentResourceTypesAll.RESEARCHSTUDY; 20522 if ("ResearchSubject".equals(codeString)) 20523 return VersionIndependentResourceTypesAll.RESEARCHSUBJECT; 20524 if ("Resource".equals(codeString)) 20525 return VersionIndependentResourceTypesAll.RESOURCE; 20526 if ("RiskAssessment".equals(codeString)) 20527 return VersionIndependentResourceTypesAll.RISKASSESSMENT; 20528 if ("Schedule".equals(codeString)) 20529 return VersionIndependentResourceTypesAll.SCHEDULE; 20530 if ("SearchParameter".equals(codeString)) 20531 return VersionIndependentResourceTypesAll.SEARCHPARAMETER; 20532 if ("ServiceRequest".equals(codeString)) 20533 return VersionIndependentResourceTypesAll.SERVICEREQUEST; 20534 if ("Slot".equals(codeString)) 20535 return VersionIndependentResourceTypesAll.SLOT; 20536 if ("Specimen".equals(codeString)) 20537 return VersionIndependentResourceTypesAll.SPECIMEN; 20538 if ("SpecimenDefinition".equals(codeString)) 20539 return VersionIndependentResourceTypesAll.SPECIMENDEFINITION; 20540 if ("StructureDefinition".equals(codeString)) 20541 return VersionIndependentResourceTypesAll.STRUCTUREDEFINITION; 20542 if ("StructureMap".equals(codeString)) 20543 return VersionIndependentResourceTypesAll.STRUCTUREMAP; 20544 if ("Subscription".equals(codeString)) 20545 return VersionIndependentResourceTypesAll.SUBSCRIPTION; 20546 if ("SubscriptionStatus".equals(codeString)) 20547 return VersionIndependentResourceTypesAll.SUBSCRIPTIONSTATUS; 20548 if ("SubscriptionTopic".equals(codeString)) 20549 return VersionIndependentResourceTypesAll.SUBSCRIPTIONTOPIC; 20550 if ("Substance".equals(codeString)) 20551 return VersionIndependentResourceTypesAll.SUBSTANCE; 20552 if ("SubstanceDefinition".equals(codeString)) 20553 return VersionIndependentResourceTypesAll.SUBSTANCEDEFINITION; 20554 if ("SubstanceNucleicAcid".equals(codeString)) 20555 return VersionIndependentResourceTypesAll.SUBSTANCENUCLEICACID; 20556 if ("SubstancePolymer".equals(codeString)) 20557 return VersionIndependentResourceTypesAll.SUBSTANCEPOLYMER; 20558 if ("SubstanceProtein".equals(codeString)) 20559 return VersionIndependentResourceTypesAll.SUBSTANCEPROTEIN; 20560 if ("SubstanceReferenceInformation".equals(codeString)) 20561 return VersionIndependentResourceTypesAll.SUBSTANCEREFERENCEINFORMATION; 20562 if ("SubstanceSourceMaterial".equals(codeString)) 20563 return VersionIndependentResourceTypesAll.SUBSTANCESOURCEMATERIAL; 20564 if ("SupplyDelivery".equals(codeString)) 20565 return VersionIndependentResourceTypesAll.SUPPLYDELIVERY; 20566 if ("SupplyRequest".equals(codeString)) 20567 return VersionIndependentResourceTypesAll.SUPPLYREQUEST; 20568 if ("Task".equals(codeString)) 20569 return VersionIndependentResourceTypesAll.TASK; 20570 if ("TerminologyCapabilities".equals(codeString)) 20571 return VersionIndependentResourceTypesAll.TERMINOLOGYCAPABILITIES; 20572 if ("TestPlan".equals(codeString)) 20573 return VersionIndependentResourceTypesAll.TESTPLAN; 20574 if ("TestReport".equals(codeString)) 20575 return VersionIndependentResourceTypesAll.TESTREPORT; 20576 if ("TestScript".equals(codeString)) 20577 return VersionIndependentResourceTypesAll.TESTSCRIPT; 20578 if ("Transport".equals(codeString)) 20579 return VersionIndependentResourceTypesAll.TRANSPORT; 20580 if ("ValueSet".equals(codeString)) 20581 return VersionIndependentResourceTypesAll.VALUESET; 20582 if ("VerificationResult".equals(codeString)) 20583 return VersionIndependentResourceTypesAll.VERIFICATIONRESULT; 20584 if ("VisionPrescription".equals(codeString)) 20585 return VersionIndependentResourceTypesAll.VISIONPRESCRIPTION; 20586 if ("BodySite".equals(codeString)) 20587 return VersionIndependentResourceTypesAll.BODYSITE; 20588 if ("CatalogEntry".equals(codeString)) 20589 return VersionIndependentResourceTypesAll.CATALOGENTRY; 20590 if ("Conformance".equals(codeString)) 20591 return VersionIndependentResourceTypesAll.CONFORMANCE; 20592 if ("DataElement".equals(codeString)) 20593 return VersionIndependentResourceTypesAll.DATAELEMENT; 20594 if ("DeviceComponent".equals(codeString)) 20595 return VersionIndependentResourceTypesAll.DEVICECOMPONENT; 20596 if ("DeviceUseRequest".equals(codeString)) 20597 return VersionIndependentResourceTypesAll.DEVICEUSEREQUEST; 20598 if ("DeviceUseStatement".equals(codeString)) 20599 return VersionIndependentResourceTypesAll.DEVICEUSESTATEMENT; 20600 if ("DiagnosticOrder".equals(codeString)) 20601 return VersionIndependentResourceTypesAll.DIAGNOSTICORDER; 20602 if ("DocumentManifest".equals(codeString)) 20603 return VersionIndependentResourceTypesAll.DOCUMENTMANIFEST; 20604 if ("EffectEvidenceSynthesis".equals(codeString)) 20605 return VersionIndependentResourceTypesAll.EFFECTEVIDENCESYNTHESIS; 20606 if ("EligibilityRequest".equals(codeString)) 20607 return VersionIndependentResourceTypesAll.ELIGIBILITYREQUEST; 20608 if ("EligibilityResponse".equals(codeString)) 20609 return VersionIndependentResourceTypesAll.ELIGIBILITYRESPONSE; 20610 if ("ExpansionProfile".equals(codeString)) 20611 return VersionIndependentResourceTypesAll.EXPANSIONPROFILE; 20612 if ("ImagingManifest".equals(codeString)) 20613 return VersionIndependentResourceTypesAll.IMAGINGMANIFEST; 20614 if ("ImagingObjectSelection".equals(codeString)) 20615 return VersionIndependentResourceTypesAll.IMAGINGOBJECTSELECTION; 20616 if ("Media".equals(codeString)) 20617 return VersionIndependentResourceTypesAll.MEDIA; 20618 if ("MedicationOrder".equals(codeString)) 20619 return VersionIndependentResourceTypesAll.MEDICATIONORDER; 20620 if ("MedicationUsage".equals(codeString)) 20621 return VersionIndependentResourceTypesAll.MEDICATIONUSAGE; 20622 if ("MedicinalProduct".equals(codeString)) 20623 return VersionIndependentResourceTypesAll.MEDICINALPRODUCT; 20624 if ("MedicinalProductAuthorization".equals(codeString)) 20625 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTAUTHORIZATION; 20626 if ("MedicinalProductContraindication".equals(codeString)) 20627 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTCONTRAINDICATION; 20628 if ("MedicinalProductIndication".equals(codeString)) 20629 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTINDICATION; 20630 if ("MedicinalProductIngredient".equals(codeString)) 20631 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTINGREDIENT; 20632 if ("MedicinalProductInteraction".equals(codeString)) 20633 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTINTERACTION; 20634 if ("MedicinalProductManufactured".equals(codeString)) 20635 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTMANUFACTURED; 20636 if ("MedicinalProductPackaged".equals(codeString)) 20637 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTPACKAGED; 20638 if ("MedicinalProductPharmaceutical".equals(codeString)) 20639 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTPHARMACEUTICAL; 20640 if ("MedicinalProductUndesirableEffect".equals(codeString)) 20641 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTUNDESIRABLEEFFECT; 20642 if ("Order".equals(codeString)) 20643 return VersionIndependentResourceTypesAll.ORDER; 20644 if ("OrderResponse".equals(codeString)) 20645 return VersionIndependentResourceTypesAll.ORDERRESPONSE; 20646 if ("ProcedureRequest".equals(codeString)) 20647 return VersionIndependentResourceTypesAll.PROCEDUREREQUEST; 20648 if ("ProcessRequest".equals(codeString)) 20649 return VersionIndependentResourceTypesAll.PROCESSREQUEST; 20650 if ("ProcessResponse".equals(codeString)) 20651 return VersionIndependentResourceTypesAll.PROCESSRESPONSE; 20652 if ("ReferralRequest".equals(codeString)) 20653 return VersionIndependentResourceTypesAll.REFERRALREQUEST; 20654 if ("RequestGroup".equals(codeString)) 20655 return VersionIndependentResourceTypesAll.REQUESTGROUP; 20656 if ("ResearchDefinition".equals(codeString)) 20657 return VersionIndependentResourceTypesAll.RESEARCHDEFINITION; 20658 if ("ResearchElementDefinition".equals(codeString)) 20659 return VersionIndependentResourceTypesAll.RESEARCHELEMENTDEFINITION; 20660 if ("RiskEvidenceSynthesis".equals(codeString)) 20661 return VersionIndependentResourceTypesAll.RISKEVIDENCESYNTHESIS; 20662 if ("Sequence".equals(codeString)) 20663 return VersionIndependentResourceTypesAll.SEQUENCE; 20664 if ("ServiceDefinition".equals(codeString)) 20665 return VersionIndependentResourceTypesAll.SERVICEDEFINITION; 20666 if ("SubstanceSpecification".equals(codeString)) 20667 return VersionIndependentResourceTypesAll.SUBSTANCESPECIFICATION; 20668 throw new IllegalArgumentException("Unknown VersionIndependentResourceTypesAll code '"+codeString+"'"); 20669 } 20670 20671 public Enumeration<VersionIndependentResourceTypesAll> fromType(PrimitiveType<?> code) throws FHIRException { 20672 if (code == null) 20673 return null; 20674 if (code.isEmpty()) 20675 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.NULL, code); 20676 String codeString = ((PrimitiveType) code).asStringValue(); 20677 if (codeString == null || "".equals(codeString)) 20678 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.NULL, code); 20679 if ("Account".equals(codeString)) 20680 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ACCOUNT, code); 20681 if ("ActivityDefinition".equals(codeString)) 20682 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ACTIVITYDEFINITION, code); 20683 if ("ActorDefinition".equals(codeString)) 20684 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ACTORDEFINITION, code); 20685 if ("AdministrableProductDefinition".equals(codeString)) 20686 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ADMINISTRABLEPRODUCTDEFINITION, code); 20687 if ("AdverseEvent".equals(codeString)) 20688 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ADVERSEEVENT, code); 20689 if ("AllergyIntolerance".equals(codeString)) 20690 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ALLERGYINTOLERANCE, code); 20691 if ("Appointment".equals(codeString)) 20692 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.APPOINTMENT, code); 20693 if ("AppointmentResponse".equals(codeString)) 20694 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.APPOINTMENTRESPONSE, code); 20695 if ("ArtifactAssessment".equals(codeString)) 20696 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ARTIFACTASSESSMENT, code); 20697 if ("AuditEvent".equals(codeString)) 20698 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.AUDITEVENT, code); 20699 if ("Basic".equals(codeString)) 20700 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BASIC, code); 20701 if ("Binary".equals(codeString)) 20702 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BINARY, code); 20703 if ("BiologicallyDerivedProduct".equals(codeString)) 20704 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BIOLOGICALLYDERIVEDPRODUCT, code); 20705 if ("BiologicallyDerivedProductDispense".equals(codeString)) 20706 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BIOLOGICALLYDERIVEDPRODUCTDISPENSE, code); 20707 if ("BodyStructure".equals(codeString)) 20708 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BODYSTRUCTURE, code); 20709 if ("Bundle".equals(codeString)) 20710 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BUNDLE, code); 20711 if ("CanonicalResource".equals(codeString)) 20712 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CANONICALRESOURCE, code); 20713 if ("CapabilityStatement".equals(codeString)) 20714 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CAPABILITYSTATEMENT, code); 20715 if ("CarePlan".equals(codeString)) 20716 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CAREPLAN, code); 20717 if ("CareTeam".equals(codeString)) 20718 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CARETEAM, code); 20719 if ("ChargeItem".equals(codeString)) 20720 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CHARGEITEM, code); 20721 if ("ChargeItemDefinition".equals(codeString)) 20722 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CHARGEITEMDEFINITION, code); 20723 if ("Citation".equals(codeString)) 20724 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CITATION, code); 20725 if ("Claim".equals(codeString)) 20726 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CLAIM, code); 20727 if ("ClaimResponse".equals(codeString)) 20728 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CLAIMRESPONSE, code); 20729 if ("ClinicalImpression".equals(codeString)) 20730 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CLINICALIMPRESSION, code); 20731 if ("ClinicalUseDefinition".equals(codeString)) 20732 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CLINICALUSEDEFINITION, code); 20733 if ("CodeSystem".equals(codeString)) 20734 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CODESYSTEM, code); 20735 if ("Communication".equals(codeString)) 20736 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COMMUNICATION, code); 20737 if ("CommunicationRequest".equals(codeString)) 20738 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COMMUNICATIONREQUEST, code); 20739 if ("CompartmentDefinition".equals(codeString)) 20740 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COMPARTMENTDEFINITION, code); 20741 if ("Composition".equals(codeString)) 20742 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COMPOSITION, code); 20743 if ("ConceptMap".equals(codeString)) 20744 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CONCEPTMAP, code); 20745 if ("Condition".equals(codeString)) 20746 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CONDITION, code); 20747 if ("ConditionDefinition".equals(codeString)) 20748 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CONDITIONDEFINITION, code); 20749 if ("Consent".equals(codeString)) 20750 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CONSENT, code); 20751 if ("Contract".equals(codeString)) 20752 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CONTRACT, code); 20753 if ("Coverage".equals(codeString)) 20754 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COVERAGE, code); 20755 if ("CoverageEligibilityRequest".equals(codeString)) 20756 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COVERAGEELIGIBILITYREQUEST, code); 20757 if ("CoverageEligibilityResponse".equals(codeString)) 20758 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COVERAGEELIGIBILITYRESPONSE, code); 20759 if ("DetectedIssue".equals(codeString)) 20760 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DETECTEDISSUE, code); 20761 if ("Device".equals(codeString)) 20762 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICE, code); 20763 if ("DeviceAssociation".equals(codeString)) 20764 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEASSOCIATION, code); 20765 if ("DeviceDefinition".equals(codeString)) 20766 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEDEFINITION, code); 20767 if ("DeviceDispense".equals(codeString)) 20768 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEDISPENSE, code); 20769 if ("DeviceMetric".equals(codeString)) 20770 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEMETRIC, code); 20771 if ("DeviceRequest".equals(codeString)) 20772 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEREQUEST, code); 20773 if ("DeviceUsage".equals(codeString)) 20774 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEUSAGE, code); 20775 if ("DiagnosticReport".equals(codeString)) 20776 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DIAGNOSTICREPORT, code); 20777 if ("DocumentReference".equals(codeString)) 20778 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DOCUMENTREFERENCE, code); 20779 if ("DomainResource".equals(codeString)) 20780 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DOMAINRESOURCE, code); 20781 if ("Encounter".equals(codeString)) 20782 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ENCOUNTER, code); 20783 if ("EncounterHistory".equals(codeString)) 20784 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ENCOUNTERHISTORY, code); 20785 if ("Endpoint".equals(codeString)) 20786 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ENDPOINT, code); 20787 if ("EnrollmentRequest".equals(codeString)) 20788 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ENROLLMENTREQUEST, code); 20789 if ("EnrollmentResponse".equals(codeString)) 20790 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ENROLLMENTRESPONSE, code); 20791 if ("EpisodeOfCare".equals(codeString)) 20792 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EPISODEOFCARE, code); 20793 if ("EventDefinition".equals(codeString)) 20794 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EVENTDEFINITION, code); 20795 if ("Evidence".equals(codeString)) 20796 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EVIDENCE, code); 20797 if ("EvidenceReport".equals(codeString)) 20798 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EVIDENCEREPORT, code); 20799 if ("EvidenceVariable".equals(codeString)) 20800 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EVIDENCEVARIABLE, code); 20801 if ("ExampleScenario".equals(codeString)) 20802 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EXAMPLESCENARIO, code); 20803 if ("ExplanationOfBenefit".equals(codeString)) 20804 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EXPLANATIONOFBENEFIT, code); 20805 if ("FamilyMemberHistory".equals(codeString)) 20806 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.FAMILYMEMBERHISTORY, code); 20807 if ("Flag".equals(codeString)) 20808 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.FLAG, code); 20809 if ("FormularyItem".equals(codeString)) 20810 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.FORMULARYITEM, code); 20811 if ("GenomicStudy".equals(codeString)) 20812 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.GENOMICSTUDY, code); 20813 if ("Goal".equals(codeString)) 20814 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.GOAL, code); 20815 if ("GraphDefinition".equals(codeString)) 20816 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.GRAPHDEFINITION, code); 20817 if ("Group".equals(codeString)) 20818 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.GROUP, code); 20819 if ("GuidanceResponse".equals(codeString)) 20820 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.GUIDANCERESPONSE, code); 20821 if ("HealthcareService".equals(codeString)) 20822 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.HEALTHCARESERVICE, code); 20823 if ("ImagingSelection".equals(codeString)) 20824 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMAGINGSELECTION, code); 20825 if ("ImagingStudy".equals(codeString)) 20826 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMAGINGSTUDY, code); 20827 if ("Immunization".equals(codeString)) 20828 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMMUNIZATION, code); 20829 if ("ImmunizationEvaluation".equals(codeString)) 20830 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMMUNIZATIONEVALUATION, code); 20831 if ("ImmunizationRecommendation".equals(codeString)) 20832 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMMUNIZATIONRECOMMENDATION, code); 20833 if ("ImplementationGuide".equals(codeString)) 20834 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMPLEMENTATIONGUIDE, code); 20835 if ("Ingredient".equals(codeString)) 20836 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.INGREDIENT, code); 20837 if ("InsurancePlan".equals(codeString)) 20838 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.INSURANCEPLAN, code); 20839 if ("InventoryItem".equals(codeString)) 20840 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.INVENTORYITEM, code); 20841 if ("InventoryReport".equals(codeString)) 20842 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.INVENTORYREPORT, code); 20843 if ("Invoice".equals(codeString)) 20844 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.INVOICE, code); 20845 if ("Library".equals(codeString)) 20846 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.LIBRARY, code); 20847 if ("Linkage".equals(codeString)) 20848 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.LINKAGE, code); 20849 if ("List".equals(codeString)) 20850 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.LIST, code); 20851 if ("Location".equals(codeString)) 20852 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.LOCATION, code); 20853 if ("ManufacturedItemDefinition".equals(codeString)) 20854 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MANUFACTUREDITEMDEFINITION, code); 20855 if ("Measure".equals(codeString)) 20856 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEASURE, code); 20857 if ("MeasureReport".equals(codeString)) 20858 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEASUREREPORT, code); 20859 if ("Medication".equals(codeString)) 20860 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATION, code); 20861 if ("MedicationAdministration".equals(codeString)) 20862 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONADMINISTRATION, code); 20863 if ("MedicationDispense".equals(codeString)) 20864 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONDISPENSE, code); 20865 if ("MedicationKnowledge".equals(codeString)) 20866 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONKNOWLEDGE, code); 20867 if ("MedicationRequest".equals(codeString)) 20868 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONREQUEST, code); 20869 if ("MedicationStatement".equals(codeString)) 20870 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONSTATEMENT, code); 20871 if ("MedicinalProductDefinition".equals(codeString)) 20872 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTDEFINITION, code); 20873 if ("MessageDefinition".equals(codeString)) 20874 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MESSAGEDEFINITION, code); 20875 if ("MessageHeader".equals(codeString)) 20876 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MESSAGEHEADER, code); 20877 if ("MetadataResource".equals(codeString)) 20878 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.METADATARESOURCE, code); 20879 if ("MolecularSequence".equals(codeString)) 20880 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MOLECULARSEQUENCE, code); 20881 if ("NamingSystem".equals(codeString)) 20882 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.NAMINGSYSTEM, code); 20883 if ("NutritionIntake".equals(codeString)) 20884 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.NUTRITIONINTAKE, code); 20885 if ("NutritionOrder".equals(codeString)) 20886 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.NUTRITIONORDER, code); 20887 if ("NutritionProduct".equals(codeString)) 20888 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.NUTRITIONPRODUCT, code); 20889 if ("Observation".equals(codeString)) 20890 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.OBSERVATION, code); 20891 if ("ObservationDefinition".equals(codeString)) 20892 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.OBSERVATIONDEFINITION, code); 20893 if ("OperationDefinition".equals(codeString)) 20894 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.OPERATIONDEFINITION, code); 20895 if ("OperationOutcome".equals(codeString)) 20896 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.OPERATIONOUTCOME, code); 20897 if ("Organization".equals(codeString)) 20898 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ORGANIZATION, code); 20899 if ("OrganizationAffiliation".equals(codeString)) 20900 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ORGANIZATIONAFFILIATION, code); 20901 if ("PackagedProductDefinition".equals(codeString)) 20902 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PACKAGEDPRODUCTDEFINITION, code); 20903 if ("Parameters".equals(codeString)) 20904 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PARAMETERS, code); 20905 if ("Patient".equals(codeString)) 20906 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PATIENT, code); 20907 if ("PaymentNotice".equals(codeString)) 20908 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PAYMENTNOTICE, code); 20909 if ("PaymentReconciliation".equals(codeString)) 20910 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PAYMENTRECONCILIATION, code); 20911 if ("Permission".equals(codeString)) 20912 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PERMISSION, code); 20913 if ("Person".equals(codeString)) 20914 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PERSON, code); 20915 if ("PlanDefinition".equals(codeString)) 20916 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PLANDEFINITION, code); 20917 if ("Practitioner".equals(codeString)) 20918 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PRACTITIONER, code); 20919 if ("PractitionerRole".equals(codeString)) 20920 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PRACTITIONERROLE, code); 20921 if ("Procedure".equals(codeString)) 20922 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PROCEDURE, code); 20923 if ("Provenance".equals(codeString)) 20924 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PROVENANCE, code); 20925 if ("Questionnaire".equals(codeString)) 20926 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.QUESTIONNAIRE, code); 20927 if ("QuestionnaireResponse".equals(codeString)) 20928 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.QUESTIONNAIRERESPONSE, code); 20929 if ("RegulatedAuthorization".equals(codeString)) 20930 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.REGULATEDAUTHORIZATION, code); 20931 if ("RelatedPerson".equals(codeString)) 20932 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RELATEDPERSON, code); 20933 if ("RequestOrchestration".equals(codeString)) 20934 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.REQUESTORCHESTRATION, code); 20935 if ("Requirements".equals(codeString)) 20936 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.REQUIREMENTS, code); 20937 if ("ResearchStudy".equals(codeString)) 20938 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RESEARCHSTUDY, code); 20939 if ("ResearchSubject".equals(codeString)) 20940 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RESEARCHSUBJECT, code); 20941 if ("Resource".equals(codeString)) 20942 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RESOURCE, code); 20943 if ("RiskAssessment".equals(codeString)) 20944 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RISKASSESSMENT, code); 20945 if ("Schedule".equals(codeString)) 20946 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SCHEDULE, code); 20947 if ("SearchParameter".equals(codeString)) 20948 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SEARCHPARAMETER, code); 20949 if ("ServiceRequest".equals(codeString)) 20950 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SERVICEREQUEST, code); 20951 if ("Slot".equals(codeString)) 20952 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SLOT, code); 20953 if ("Specimen".equals(codeString)) 20954 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SPECIMEN, code); 20955 if ("SpecimenDefinition".equals(codeString)) 20956 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SPECIMENDEFINITION, code); 20957 if ("StructureDefinition".equals(codeString)) 20958 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.STRUCTUREDEFINITION, code); 20959 if ("StructureMap".equals(codeString)) 20960 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.STRUCTUREMAP, code); 20961 if ("Subscription".equals(codeString)) 20962 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSCRIPTION, code); 20963 if ("SubscriptionStatus".equals(codeString)) 20964 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSCRIPTIONSTATUS, code); 20965 if ("SubscriptionTopic".equals(codeString)) 20966 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSCRIPTIONTOPIC, code); 20967 if ("Substance".equals(codeString)) 20968 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCE, code); 20969 if ("SubstanceDefinition".equals(codeString)) 20970 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCEDEFINITION, code); 20971 if ("SubstanceNucleicAcid".equals(codeString)) 20972 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCENUCLEICACID, code); 20973 if ("SubstancePolymer".equals(codeString)) 20974 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCEPOLYMER, code); 20975 if ("SubstanceProtein".equals(codeString)) 20976 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCEPROTEIN, code); 20977 if ("SubstanceReferenceInformation".equals(codeString)) 20978 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCEREFERENCEINFORMATION, code); 20979 if ("SubstanceSourceMaterial".equals(codeString)) 20980 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCESOURCEMATERIAL, code); 20981 if ("SupplyDelivery".equals(codeString)) 20982 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUPPLYDELIVERY, code); 20983 if ("SupplyRequest".equals(codeString)) 20984 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUPPLYREQUEST, code); 20985 if ("Task".equals(codeString)) 20986 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.TASK, code); 20987 if ("TerminologyCapabilities".equals(codeString)) 20988 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.TERMINOLOGYCAPABILITIES, code); 20989 if ("TestPlan".equals(codeString)) 20990 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.TESTPLAN, code); 20991 if ("TestReport".equals(codeString)) 20992 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.TESTREPORT, code); 20993 if ("TestScript".equals(codeString)) 20994 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.TESTSCRIPT, code); 20995 if ("Transport".equals(codeString)) 20996 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.TRANSPORT, code); 20997 if ("ValueSet".equals(codeString)) 20998 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.VALUESET, code); 20999 if ("VerificationResult".equals(codeString)) 21000 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.VERIFICATIONRESULT, code); 21001 if ("VisionPrescription".equals(codeString)) 21002 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.VISIONPRESCRIPTION, code); 21003 if ("BodySite".equals(codeString)) 21004 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BODYSITE, code); 21005 if ("CatalogEntry".equals(codeString)) 21006 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CATALOGENTRY, code); 21007 if ("Conformance".equals(codeString)) 21008 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CONFORMANCE, code); 21009 if ("DataElement".equals(codeString)) 21010 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DATAELEMENT, code); 21011 if ("DeviceComponent".equals(codeString)) 21012 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICECOMPONENT, code); 21013 if ("DeviceUseRequest".equals(codeString)) 21014 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEUSEREQUEST, code); 21015 if ("DeviceUseStatement".equals(codeString)) 21016 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEUSESTATEMENT, code); 21017 if ("DiagnosticOrder".equals(codeString)) 21018 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DIAGNOSTICORDER, code); 21019 if ("DocumentManifest".equals(codeString)) 21020 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DOCUMENTMANIFEST, code); 21021 if ("EffectEvidenceSynthesis".equals(codeString)) 21022 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EFFECTEVIDENCESYNTHESIS, code); 21023 if ("EligibilityRequest".equals(codeString)) 21024 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ELIGIBILITYREQUEST, code); 21025 if ("EligibilityResponse".equals(codeString)) 21026 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ELIGIBILITYRESPONSE, code); 21027 if ("ExpansionProfile".equals(codeString)) 21028 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EXPANSIONPROFILE, code); 21029 if ("ImagingManifest".equals(codeString)) 21030 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMAGINGMANIFEST, code); 21031 if ("ImagingObjectSelection".equals(codeString)) 21032 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMAGINGOBJECTSELECTION, code); 21033 if ("Media".equals(codeString)) 21034 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDIA, code); 21035 if ("MedicationOrder".equals(codeString)) 21036 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONORDER, code); 21037 if ("MedicationUsage".equals(codeString)) 21038 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONUSAGE, code); 21039 if ("MedicinalProduct".equals(codeString)) 21040 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCT, code); 21041 if ("MedicinalProductAuthorization".equals(codeString)) 21042 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTAUTHORIZATION, code); 21043 if ("MedicinalProductContraindication".equals(codeString)) 21044 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTCONTRAINDICATION, code); 21045 if ("MedicinalProductIndication".equals(codeString)) 21046 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTINDICATION, code); 21047 if ("MedicinalProductIngredient".equals(codeString)) 21048 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTINGREDIENT, code); 21049 if ("MedicinalProductInteraction".equals(codeString)) 21050 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTINTERACTION, code); 21051 if ("MedicinalProductManufactured".equals(codeString)) 21052 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTMANUFACTURED, code); 21053 if ("MedicinalProductPackaged".equals(codeString)) 21054 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTPACKAGED, code); 21055 if ("MedicinalProductPharmaceutical".equals(codeString)) 21056 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTPHARMACEUTICAL, code); 21057 if ("MedicinalProductUndesirableEffect".equals(codeString)) 21058 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTUNDESIRABLEEFFECT, code); 21059 if ("Order".equals(codeString)) 21060 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ORDER, code); 21061 if ("OrderResponse".equals(codeString)) 21062 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ORDERRESPONSE, code); 21063 if ("ProcedureRequest".equals(codeString)) 21064 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PROCEDUREREQUEST, code); 21065 if ("ProcessRequest".equals(codeString)) 21066 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PROCESSREQUEST, code); 21067 if ("ProcessResponse".equals(codeString)) 21068 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PROCESSRESPONSE, code); 21069 if ("ReferralRequest".equals(codeString)) 21070 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.REFERRALREQUEST, code); 21071 if ("RequestGroup".equals(codeString)) 21072 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.REQUESTGROUP, code); 21073 if ("ResearchDefinition".equals(codeString)) 21074 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RESEARCHDEFINITION, code); 21075 if ("ResearchElementDefinition".equals(codeString)) 21076 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RESEARCHELEMENTDEFINITION, code); 21077 if ("RiskEvidenceSynthesis".equals(codeString)) 21078 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RISKEVIDENCESYNTHESIS, code); 21079 if ("Sequence".equals(codeString)) 21080 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SEQUENCE, code); 21081 if ("ServiceDefinition".equals(codeString)) 21082 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SERVICEDEFINITION, code); 21083 if ("SubstanceSpecification".equals(codeString)) 21084 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCESPECIFICATION, code); 21085 throw new FHIRException("Unknown VersionIndependentResourceTypesAll code '"+codeString+"'"); 21086 } 21087 public String toCode(VersionIndependentResourceTypesAll code) { 21088 if (code == VersionIndependentResourceTypesAll.ACCOUNT) 21089 return "Account"; 21090 if (code == VersionIndependentResourceTypesAll.ACTIVITYDEFINITION) 21091 return "ActivityDefinition"; 21092 if (code == VersionIndependentResourceTypesAll.ACTORDEFINITION) 21093 return "ActorDefinition"; 21094 if (code == VersionIndependentResourceTypesAll.ADMINISTRABLEPRODUCTDEFINITION) 21095 return "AdministrableProductDefinition"; 21096 if (code == VersionIndependentResourceTypesAll.ADVERSEEVENT) 21097 return "AdverseEvent"; 21098 if (code == VersionIndependentResourceTypesAll.ALLERGYINTOLERANCE) 21099 return "AllergyIntolerance"; 21100 if (code == VersionIndependentResourceTypesAll.APPOINTMENT) 21101 return "Appointment"; 21102 if (code == VersionIndependentResourceTypesAll.APPOINTMENTRESPONSE) 21103 return "AppointmentResponse"; 21104 if (code == VersionIndependentResourceTypesAll.ARTIFACTASSESSMENT) 21105 return "ArtifactAssessment"; 21106 if (code == VersionIndependentResourceTypesAll.AUDITEVENT) 21107 return "AuditEvent"; 21108 if (code == VersionIndependentResourceTypesAll.BASIC) 21109 return "Basic"; 21110 if (code == VersionIndependentResourceTypesAll.BINARY) 21111 return "Binary"; 21112 if (code == VersionIndependentResourceTypesAll.BIOLOGICALLYDERIVEDPRODUCT) 21113 return "BiologicallyDerivedProduct"; 21114 if (code == VersionIndependentResourceTypesAll.BIOLOGICALLYDERIVEDPRODUCTDISPENSE) 21115 return "BiologicallyDerivedProductDispense"; 21116 if (code == VersionIndependentResourceTypesAll.BODYSTRUCTURE) 21117 return "BodyStructure"; 21118 if (code == VersionIndependentResourceTypesAll.BUNDLE) 21119 return "Bundle"; 21120 if (code == VersionIndependentResourceTypesAll.CANONICALRESOURCE) 21121 return "CanonicalResource"; 21122 if (code == VersionIndependentResourceTypesAll.CAPABILITYSTATEMENT) 21123 return "CapabilityStatement"; 21124 if (code == VersionIndependentResourceTypesAll.CAREPLAN) 21125 return "CarePlan"; 21126 if (code == VersionIndependentResourceTypesAll.CARETEAM) 21127 return "CareTeam"; 21128 if (code == VersionIndependentResourceTypesAll.CHARGEITEM) 21129 return "ChargeItem"; 21130 if (code == VersionIndependentResourceTypesAll.CHARGEITEMDEFINITION) 21131 return "ChargeItemDefinition"; 21132 if (code == VersionIndependentResourceTypesAll.CITATION) 21133 return "Citation"; 21134 if (code == VersionIndependentResourceTypesAll.CLAIM) 21135 return "Claim"; 21136 if (code == VersionIndependentResourceTypesAll.CLAIMRESPONSE) 21137 return "ClaimResponse"; 21138 if (code == VersionIndependentResourceTypesAll.CLINICALIMPRESSION) 21139 return "ClinicalImpression"; 21140 if (code == VersionIndependentResourceTypesAll.CLINICALUSEDEFINITION) 21141 return "ClinicalUseDefinition"; 21142 if (code == VersionIndependentResourceTypesAll.CODESYSTEM) 21143 return "CodeSystem"; 21144 if (code == VersionIndependentResourceTypesAll.COMMUNICATION) 21145 return "Communication"; 21146 if (code == VersionIndependentResourceTypesAll.COMMUNICATIONREQUEST) 21147 return "CommunicationRequest"; 21148 if (code == VersionIndependentResourceTypesAll.COMPARTMENTDEFINITION) 21149 return "CompartmentDefinition"; 21150 if (code == VersionIndependentResourceTypesAll.COMPOSITION) 21151 return "Composition"; 21152 if (code == VersionIndependentResourceTypesAll.CONCEPTMAP) 21153 return "ConceptMap"; 21154 if (code == VersionIndependentResourceTypesAll.CONDITION) 21155 return "Condition"; 21156 if (code == VersionIndependentResourceTypesAll.CONDITIONDEFINITION) 21157 return "ConditionDefinition"; 21158 if (code == VersionIndependentResourceTypesAll.CONSENT) 21159 return "Consent"; 21160 if (code == VersionIndependentResourceTypesAll.CONTRACT) 21161 return "Contract"; 21162 if (code == VersionIndependentResourceTypesAll.COVERAGE) 21163 return "Coverage"; 21164 if (code == VersionIndependentResourceTypesAll.COVERAGEELIGIBILITYREQUEST) 21165 return "CoverageEligibilityRequest"; 21166 if (code == VersionIndependentResourceTypesAll.COVERAGEELIGIBILITYRESPONSE) 21167 return "CoverageEligibilityResponse"; 21168 if (code == VersionIndependentResourceTypesAll.DETECTEDISSUE) 21169 return "DetectedIssue"; 21170 if (code == VersionIndependentResourceTypesAll.DEVICE) 21171 return "Device"; 21172 if (code == VersionIndependentResourceTypesAll.DEVICEASSOCIATION) 21173 return "DeviceAssociation"; 21174 if (code == VersionIndependentResourceTypesAll.DEVICEDEFINITION) 21175 return "DeviceDefinition"; 21176 if (code == VersionIndependentResourceTypesAll.DEVICEDISPENSE) 21177 return "DeviceDispense"; 21178 if (code == VersionIndependentResourceTypesAll.DEVICEMETRIC) 21179 return "DeviceMetric"; 21180 if (code == VersionIndependentResourceTypesAll.DEVICEREQUEST) 21181 return "DeviceRequest"; 21182 if (code == VersionIndependentResourceTypesAll.DEVICEUSAGE) 21183 return "DeviceUsage"; 21184 if (code == VersionIndependentResourceTypesAll.DIAGNOSTICREPORT) 21185 return "DiagnosticReport"; 21186 if (code == VersionIndependentResourceTypesAll.DOCUMENTREFERENCE) 21187 return "DocumentReference"; 21188 if (code == VersionIndependentResourceTypesAll.DOMAINRESOURCE) 21189 return "DomainResource"; 21190 if (code == VersionIndependentResourceTypesAll.ENCOUNTER) 21191 return "Encounter"; 21192 if (code == VersionIndependentResourceTypesAll.ENCOUNTERHISTORY) 21193 return "EncounterHistory"; 21194 if (code == VersionIndependentResourceTypesAll.ENDPOINT) 21195 return "Endpoint"; 21196 if (code == VersionIndependentResourceTypesAll.ENROLLMENTREQUEST) 21197 return "EnrollmentRequest"; 21198 if (code == VersionIndependentResourceTypesAll.ENROLLMENTRESPONSE) 21199 return "EnrollmentResponse"; 21200 if (code == VersionIndependentResourceTypesAll.EPISODEOFCARE) 21201 return "EpisodeOfCare"; 21202 if (code == VersionIndependentResourceTypesAll.EVENTDEFINITION) 21203 return "EventDefinition"; 21204 if (code == VersionIndependentResourceTypesAll.EVIDENCE) 21205 return "Evidence"; 21206 if (code == VersionIndependentResourceTypesAll.EVIDENCEREPORT) 21207 return "EvidenceReport"; 21208 if (code == VersionIndependentResourceTypesAll.EVIDENCEVARIABLE) 21209 return "EvidenceVariable"; 21210 if (code == VersionIndependentResourceTypesAll.EXAMPLESCENARIO) 21211 return "ExampleScenario"; 21212 if (code == VersionIndependentResourceTypesAll.EXPLANATIONOFBENEFIT) 21213 return "ExplanationOfBenefit"; 21214 if (code == VersionIndependentResourceTypesAll.FAMILYMEMBERHISTORY) 21215 return "FamilyMemberHistory"; 21216 if (code == VersionIndependentResourceTypesAll.FLAG) 21217 return "Flag"; 21218 if (code == VersionIndependentResourceTypesAll.FORMULARYITEM) 21219 return "FormularyItem"; 21220 if (code == VersionIndependentResourceTypesAll.GENOMICSTUDY) 21221 return "GenomicStudy"; 21222 if (code == VersionIndependentResourceTypesAll.GOAL) 21223 return "Goal"; 21224 if (code == VersionIndependentResourceTypesAll.GRAPHDEFINITION) 21225 return "GraphDefinition"; 21226 if (code == VersionIndependentResourceTypesAll.GROUP) 21227 return "Group"; 21228 if (code == VersionIndependentResourceTypesAll.GUIDANCERESPONSE) 21229 return "GuidanceResponse"; 21230 if (code == VersionIndependentResourceTypesAll.HEALTHCARESERVICE) 21231 return "HealthcareService"; 21232 if (code == VersionIndependentResourceTypesAll.IMAGINGSELECTION) 21233 return "ImagingSelection"; 21234 if (code == VersionIndependentResourceTypesAll.IMAGINGSTUDY) 21235 return "ImagingStudy"; 21236 if (code == VersionIndependentResourceTypesAll.IMMUNIZATION) 21237 return "Immunization"; 21238 if (code == VersionIndependentResourceTypesAll.IMMUNIZATIONEVALUATION) 21239 return "ImmunizationEvaluation"; 21240 if (code == VersionIndependentResourceTypesAll.IMMUNIZATIONRECOMMENDATION) 21241 return "ImmunizationRecommendation"; 21242 if (code == VersionIndependentResourceTypesAll.IMPLEMENTATIONGUIDE) 21243 return "ImplementationGuide"; 21244 if (code == VersionIndependentResourceTypesAll.INGREDIENT) 21245 return "Ingredient"; 21246 if (code == VersionIndependentResourceTypesAll.INSURANCEPLAN) 21247 return "InsurancePlan"; 21248 if (code == VersionIndependentResourceTypesAll.INVENTORYITEM) 21249 return "InventoryItem"; 21250 if (code == VersionIndependentResourceTypesAll.INVENTORYREPORT) 21251 return "InventoryReport"; 21252 if (code == VersionIndependentResourceTypesAll.INVOICE) 21253 return "Invoice"; 21254 if (code == VersionIndependentResourceTypesAll.LIBRARY) 21255 return "Library"; 21256 if (code == VersionIndependentResourceTypesAll.LINKAGE) 21257 return "Linkage"; 21258 if (code == VersionIndependentResourceTypesAll.LIST) 21259 return "List"; 21260 if (code == VersionIndependentResourceTypesAll.LOCATION) 21261 return "Location"; 21262 if (code == VersionIndependentResourceTypesAll.MANUFACTUREDITEMDEFINITION) 21263 return "ManufacturedItemDefinition"; 21264 if (code == VersionIndependentResourceTypesAll.MEASURE) 21265 return "Measure"; 21266 if (code == VersionIndependentResourceTypesAll.MEASUREREPORT) 21267 return "MeasureReport"; 21268 if (code == VersionIndependentResourceTypesAll.MEDICATION) 21269 return "Medication"; 21270 if (code == VersionIndependentResourceTypesAll.MEDICATIONADMINISTRATION) 21271 return "MedicationAdministration"; 21272 if (code == VersionIndependentResourceTypesAll.MEDICATIONDISPENSE) 21273 return "MedicationDispense"; 21274 if (code == VersionIndependentResourceTypesAll.MEDICATIONKNOWLEDGE) 21275 return "MedicationKnowledge"; 21276 if (code == VersionIndependentResourceTypesAll.MEDICATIONREQUEST) 21277 return "MedicationRequest"; 21278 if (code == VersionIndependentResourceTypesAll.MEDICATIONSTATEMENT) 21279 return "MedicationStatement"; 21280 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTDEFINITION) 21281 return "MedicinalProductDefinition"; 21282 if (code == VersionIndependentResourceTypesAll.MESSAGEDEFINITION) 21283 return "MessageDefinition"; 21284 if (code == VersionIndependentResourceTypesAll.MESSAGEHEADER) 21285 return "MessageHeader"; 21286 if (code == VersionIndependentResourceTypesAll.METADATARESOURCE) 21287 return "MetadataResource"; 21288 if (code == VersionIndependentResourceTypesAll.MOLECULARSEQUENCE) 21289 return "MolecularSequence"; 21290 if (code == VersionIndependentResourceTypesAll.NAMINGSYSTEM) 21291 return "NamingSystem"; 21292 if (code == VersionIndependentResourceTypesAll.NUTRITIONINTAKE) 21293 return "NutritionIntake"; 21294 if (code == VersionIndependentResourceTypesAll.NUTRITIONORDER) 21295 return "NutritionOrder"; 21296 if (code == VersionIndependentResourceTypesAll.NUTRITIONPRODUCT) 21297 return "NutritionProduct"; 21298 if (code == VersionIndependentResourceTypesAll.OBSERVATION) 21299 return "Observation"; 21300 if (code == VersionIndependentResourceTypesAll.OBSERVATIONDEFINITION) 21301 return "ObservationDefinition"; 21302 if (code == VersionIndependentResourceTypesAll.OPERATIONDEFINITION) 21303 return "OperationDefinition"; 21304 if (code == VersionIndependentResourceTypesAll.OPERATIONOUTCOME) 21305 return "OperationOutcome"; 21306 if (code == VersionIndependentResourceTypesAll.ORGANIZATION) 21307 return "Organization"; 21308 if (code == VersionIndependentResourceTypesAll.ORGANIZATIONAFFILIATION) 21309 return "OrganizationAffiliation"; 21310 if (code == VersionIndependentResourceTypesAll.PACKAGEDPRODUCTDEFINITION) 21311 return "PackagedProductDefinition"; 21312 if (code == VersionIndependentResourceTypesAll.PARAMETERS) 21313 return "Parameters"; 21314 if (code == VersionIndependentResourceTypesAll.PATIENT) 21315 return "Patient"; 21316 if (code == VersionIndependentResourceTypesAll.PAYMENTNOTICE) 21317 return "PaymentNotice"; 21318 if (code == VersionIndependentResourceTypesAll.PAYMENTRECONCILIATION) 21319 return "PaymentReconciliation"; 21320 if (code == VersionIndependentResourceTypesAll.PERMISSION) 21321 return "Permission"; 21322 if (code == VersionIndependentResourceTypesAll.PERSON) 21323 return "Person"; 21324 if (code == VersionIndependentResourceTypesAll.PLANDEFINITION) 21325 return "PlanDefinition"; 21326 if (code == VersionIndependentResourceTypesAll.PRACTITIONER) 21327 return "Practitioner"; 21328 if (code == VersionIndependentResourceTypesAll.PRACTITIONERROLE) 21329 return "PractitionerRole"; 21330 if (code == VersionIndependentResourceTypesAll.PROCEDURE) 21331 return "Procedure"; 21332 if (code == VersionIndependentResourceTypesAll.PROVENANCE) 21333 return "Provenance"; 21334 if (code == VersionIndependentResourceTypesAll.QUESTIONNAIRE) 21335 return "Questionnaire"; 21336 if (code == VersionIndependentResourceTypesAll.QUESTIONNAIRERESPONSE) 21337 return "QuestionnaireResponse"; 21338 if (code == VersionIndependentResourceTypesAll.REGULATEDAUTHORIZATION) 21339 return "RegulatedAuthorization"; 21340 if (code == VersionIndependentResourceTypesAll.RELATEDPERSON) 21341 return "RelatedPerson"; 21342 if (code == VersionIndependentResourceTypesAll.REQUESTORCHESTRATION) 21343 return "RequestOrchestration"; 21344 if (code == VersionIndependentResourceTypesAll.REQUIREMENTS) 21345 return "Requirements"; 21346 if (code == VersionIndependentResourceTypesAll.RESEARCHSTUDY) 21347 return "ResearchStudy"; 21348 if (code == VersionIndependentResourceTypesAll.RESEARCHSUBJECT) 21349 return "ResearchSubject"; 21350 if (code == VersionIndependentResourceTypesAll.RESOURCE) 21351 return "Resource"; 21352 if (code == VersionIndependentResourceTypesAll.RISKASSESSMENT) 21353 return "RiskAssessment"; 21354 if (code == VersionIndependentResourceTypesAll.SCHEDULE) 21355 return "Schedule"; 21356 if (code == VersionIndependentResourceTypesAll.SEARCHPARAMETER) 21357 return "SearchParameter"; 21358 if (code == VersionIndependentResourceTypesAll.SERVICEREQUEST) 21359 return "ServiceRequest"; 21360 if (code == VersionIndependentResourceTypesAll.SLOT) 21361 return "Slot"; 21362 if (code == VersionIndependentResourceTypesAll.SPECIMEN) 21363 return "Specimen"; 21364 if (code == VersionIndependentResourceTypesAll.SPECIMENDEFINITION) 21365 return "SpecimenDefinition"; 21366 if (code == VersionIndependentResourceTypesAll.STRUCTUREDEFINITION) 21367 return "StructureDefinition"; 21368 if (code == VersionIndependentResourceTypesAll.STRUCTUREMAP) 21369 return "StructureMap"; 21370 if (code == VersionIndependentResourceTypesAll.SUBSCRIPTION) 21371 return "Subscription"; 21372 if (code == VersionIndependentResourceTypesAll.SUBSCRIPTIONSTATUS) 21373 return "SubscriptionStatus"; 21374 if (code == VersionIndependentResourceTypesAll.SUBSCRIPTIONTOPIC) 21375 return "SubscriptionTopic"; 21376 if (code == VersionIndependentResourceTypesAll.SUBSTANCE) 21377 return "Substance"; 21378 if (code == VersionIndependentResourceTypesAll.SUBSTANCEDEFINITION) 21379 return "SubstanceDefinition"; 21380 if (code == VersionIndependentResourceTypesAll.SUBSTANCENUCLEICACID) 21381 return "SubstanceNucleicAcid"; 21382 if (code == VersionIndependentResourceTypesAll.SUBSTANCEPOLYMER) 21383 return "SubstancePolymer"; 21384 if (code == VersionIndependentResourceTypesAll.SUBSTANCEPROTEIN) 21385 return "SubstanceProtein"; 21386 if (code == VersionIndependentResourceTypesAll.SUBSTANCEREFERENCEINFORMATION) 21387 return "SubstanceReferenceInformation"; 21388 if (code == VersionIndependentResourceTypesAll.SUBSTANCESOURCEMATERIAL) 21389 return "SubstanceSourceMaterial"; 21390 if (code == VersionIndependentResourceTypesAll.SUPPLYDELIVERY) 21391 return "SupplyDelivery"; 21392 if (code == VersionIndependentResourceTypesAll.SUPPLYREQUEST) 21393 return "SupplyRequest"; 21394 if (code == VersionIndependentResourceTypesAll.TASK) 21395 return "Task"; 21396 if (code == VersionIndependentResourceTypesAll.TERMINOLOGYCAPABILITIES) 21397 return "TerminologyCapabilities"; 21398 if (code == VersionIndependentResourceTypesAll.TESTPLAN) 21399 return "TestPlan"; 21400 if (code == VersionIndependentResourceTypesAll.TESTREPORT) 21401 return "TestReport"; 21402 if (code == VersionIndependentResourceTypesAll.TESTSCRIPT) 21403 return "TestScript"; 21404 if (code == VersionIndependentResourceTypesAll.TRANSPORT) 21405 return "Transport"; 21406 if (code == VersionIndependentResourceTypesAll.VALUESET) 21407 return "ValueSet"; 21408 if (code == VersionIndependentResourceTypesAll.VERIFICATIONRESULT) 21409 return "VerificationResult"; 21410 if (code == VersionIndependentResourceTypesAll.VISIONPRESCRIPTION) 21411 return "VisionPrescription"; 21412 if (code == VersionIndependentResourceTypesAll.BODYSITE) 21413 return "BodySite"; 21414 if (code == VersionIndependentResourceTypesAll.CATALOGENTRY) 21415 return "CatalogEntry"; 21416 if (code == VersionIndependentResourceTypesAll.CONFORMANCE) 21417 return "Conformance"; 21418 if (code == VersionIndependentResourceTypesAll.DATAELEMENT) 21419 return "DataElement"; 21420 if (code == VersionIndependentResourceTypesAll.DEVICECOMPONENT) 21421 return "DeviceComponent"; 21422 if (code == VersionIndependentResourceTypesAll.DEVICEUSEREQUEST) 21423 return "DeviceUseRequest"; 21424 if (code == VersionIndependentResourceTypesAll.DEVICEUSESTATEMENT) 21425 return "DeviceUseStatement"; 21426 if (code == VersionIndependentResourceTypesAll.DIAGNOSTICORDER) 21427 return "DiagnosticOrder"; 21428 if (code == VersionIndependentResourceTypesAll.DOCUMENTMANIFEST) 21429 return "DocumentManifest"; 21430 if (code == VersionIndependentResourceTypesAll.EFFECTEVIDENCESYNTHESIS) 21431 return "EffectEvidenceSynthesis"; 21432 if (code == VersionIndependentResourceTypesAll.ELIGIBILITYREQUEST) 21433 return "EligibilityRequest"; 21434 if (code == VersionIndependentResourceTypesAll.ELIGIBILITYRESPONSE) 21435 return "EligibilityResponse"; 21436 if (code == VersionIndependentResourceTypesAll.EXPANSIONPROFILE) 21437 return "ExpansionProfile"; 21438 if (code == VersionIndependentResourceTypesAll.IMAGINGMANIFEST) 21439 return "ImagingManifest"; 21440 if (code == VersionIndependentResourceTypesAll.IMAGINGOBJECTSELECTION) 21441 return "ImagingObjectSelection"; 21442 if (code == VersionIndependentResourceTypesAll.MEDIA) 21443 return "Media"; 21444 if (code == VersionIndependentResourceTypesAll.MEDICATIONORDER) 21445 return "MedicationOrder"; 21446 if (code == VersionIndependentResourceTypesAll.MEDICATIONUSAGE) 21447 return "MedicationUsage"; 21448 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCT) 21449 return "MedicinalProduct"; 21450 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTAUTHORIZATION) 21451 return "MedicinalProductAuthorization"; 21452 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTCONTRAINDICATION) 21453 return "MedicinalProductContraindication"; 21454 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTINDICATION) 21455 return "MedicinalProductIndication"; 21456 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTINGREDIENT) 21457 return "MedicinalProductIngredient"; 21458 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTINTERACTION) 21459 return "MedicinalProductInteraction"; 21460 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTMANUFACTURED) 21461 return "MedicinalProductManufactured"; 21462 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTPACKAGED) 21463 return "MedicinalProductPackaged"; 21464 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTPHARMACEUTICAL) 21465 return "MedicinalProductPharmaceutical"; 21466 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTUNDESIRABLEEFFECT) 21467 return "MedicinalProductUndesirableEffect"; 21468 if (code == VersionIndependentResourceTypesAll.ORDER) 21469 return "Order"; 21470 if (code == VersionIndependentResourceTypesAll.ORDERRESPONSE) 21471 return "OrderResponse"; 21472 if (code == VersionIndependentResourceTypesAll.PROCEDUREREQUEST) 21473 return "ProcedureRequest"; 21474 if (code == VersionIndependentResourceTypesAll.PROCESSREQUEST) 21475 return "ProcessRequest"; 21476 if (code == VersionIndependentResourceTypesAll.PROCESSRESPONSE) 21477 return "ProcessResponse"; 21478 if (code == VersionIndependentResourceTypesAll.REFERRALREQUEST) 21479 return "ReferralRequest"; 21480 if (code == VersionIndependentResourceTypesAll.REQUESTGROUP) 21481 return "RequestGroup"; 21482 if (code == VersionIndependentResourceTypesAll.RESEARCHDEFINITION) 21483 return "ResearchDefinition"; 21484 if (code == VersionIndependentResourceTypesAll.RESEARCHELEMENTDEFINITION) 21485 return "ResearchElementDefinition"; 21486 if (code == VersionIndependentResourceTypesAll.RISKEVIDENCESYNTHESIS) 21487 return "RiskEvidenceSynthesis"; 21488 if (code == VersionIndependentResourceTypesAll.SEQUENCE) 21489 return "Sequence"; 21490 if (code == VersionIndependentResourceTypesAll.SERVICEDEFINITION) 21491 return "ServiceDefinition"; 21492 if (code == VersionIndependentResourceTypesAll.SUBSTANCESPECIFICATION) 21493 return "SubstanceSpecification"; 21494 return "?"; 21495 } 21496 public String toSystem(VersionIndependentResourceTypesAll code) { 21497 return code.getSystem(); 21498 } 21499 } 21500 21501 21502} 21503