
001package org.hl7.fhir.r5.model; 002 003 004/* 005 Copyright (c) 2011+, HL7, Inc. 006 All rights reserved. 007 008 Redistribution and use in source and binary forms, with or without modification, \ 009 are permitted provided that the following conditions are met: 010 011 * Redistributions of source code must retain the above copyright notice, this \ 012 list of conditions and the following disclaimer. 013 * Redistributions in binary form must reproduce the above copyright notice, \ 014 this list of conditions and the following disclaimer in the documentation \ 015 and/or other materials provided with the distribution. 016 * Neither the name of HL7 nor the names of its contributors may be used to 017 endorse or promote products derived from this software without specific 018 prior written permission. 019 020 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \ 021 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \ 022 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \ 023 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \ 024 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \ 025 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \ 026 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \ 027 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \ 028 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \ 029 POSSIBILITY OF SUCH DAMAGE. 030 */ 031 032// Generated on Thu, Mar 23, 2023 19:59+1100 for FHIR v5.0.0 033 034 035import org.hl7.fhir.instance.model.api.*; 036import org.hl7.fhir.utilities.Utilities; 037import org.hl7.fhir.exceptions.FHIRException; 038 039public class Enumerations { 040 041// In here: 042// ActionCardinalityBehavior: Defines behavior for an action or a group for how many times that item may be repeated.[PlanDefinition, RequestOrchestration] 043// ActionConditionKind: Defines the kinds of conditions that can appear on actions.[PlanDefinition, RequestOrchestration] 044// ActionGroupingBehavior: Defines organization behavior of a group.[PlanDefinition, RequestOrchestration] 045// ActionParticipantType: The type of participant for the action.[ActivityDefinition, PlanDefinition, RequestOrchestration] 046// ActionPrecheckBehavior: Defines selection frequency behavior for an action or group.[PlanDefinition, RequestOrchestration] 047// ActionRelationshipType: Defines the types of relationships between actions.[PlanDefinition, RequestOrchestration] 048// ActionRequiredBehavior: Defines expectations around whether an action or action group is required.[PlanDefinition, RequestOrchestration] 049// ActionSelectionBehavior: Defines selection behavior of a group.[PlanDefinition, RequestOrchestration] 050// AdministrativeGender: The gender of a person used for administrative purposes.[ObservationDefinition, Patient, Person, Practitioner, RelatedPerson] 051// AllLanguages: This value set includes all possible codes from BCP-47 (see http://tools.ietf.org/html/bcp47)[Account, ActivityDefinition, ActorDefinition, AdministrableProductDefinition, AdverseEvent, AllergyIntolerance, Appointment, AppointmentResponse, ArtifactAssessment, Attachment, AuditEvent, Basic, Binary, BiologicallyDerivedProduct, BiologicallyDerivedProductDispense, BodyStructure, Bundle, CanonicalResource, CapabilityStatement, CarePlan, CareTeam, ChargeItem, ChargeItemDefinition, Citation, Claim, ClaimResponse, ClinicalImpression, ClinicalUseDefinition, CodeSystem, Communication, CommunicationRequest, CompartmentDefinition, Composition, ConceptMap, Condition, ConditionDefinition, Consent, Contract, Coverage, CoverageEligibilityRequest, CoverageEligibilityResponse, DetectedIssue, Device, DeviceAssociation, DeviceDefinition, DeviceDispense, DeviceMetric, DeviceRequest, DeviceUsage, DiagnosticReport, DocumentReference, DomainResource, Encounter, EncounterHistory, Endpoint, EnrollmentRequest, EnrollmentResponse, EpisodeOfCare, EventDefinition, Evidence, EvidenceReport, EvidenceVariable, ExampleScenario, ExplanationOfBenefit, FamilyMemberHistory, Flag, FormularyItem, GenomicStudy, Goal, GraphDefinition, Group, GuidanceResponse, HealthcareService, ImagingSelection, ImagingStudy, Immunization, ImmunizationEvaluation, ImmunizationRecommendation, ImplementationGuide, Ingredient, InsurancePlan, InventoryItem, InventoryReport, Invoice, Library, Linkage, List, Location, ManufacturedItemDefinition, Measure, MeasureReport, Medication, MedicationAdministration, MedicationDispense, MedicationKnowledge, MedicationRequest, MedicationStatement, MedicinalProductDefinition, MessageDefinition, MessageHeader, MetadataResource, MolecularSequence, NamingSystem, NutritionIntake, NutritionOrder, NutritionProduct, Observation, ObservationDefinition, OperationDefinition, OperationOutcome, Organization, OrganizationAffiliation, PackagedProductDefinition, Parameters, Patient, PaymentNotice, PaymentReconciliation, Permission, Person, PlanDefinition, Practitioner, PractitionerRole, Procedure, Provenance, Questionnaire, QuestionnaireResponse, RegulatedAuthorization, RelatedPerson, RequestOrchestration, Requirements, ResearchStudy, ResearchSubject, Resource, RiskAssessment, Schedule, SearchParameter, ServiceRequest, Slot, Specimen, SpecimenDefinition, StructureDefinition, StructureMap, Subscription, SubscriptionStatus, SubscriptionTopic, Substance, SubstanceDefinition, SubstanceNucleicAcid, SubstancePolymer, SubstanceProtein, SubstanceReferenceInformation, SubstanceSourceMaterial, SupplyDelivery, SupplyRequest, Task, TerminologyCapabilities, TestPlan, TestReport, TestScript, Transport, ValueSet, VerificationResult, VisionPrescription] 052// BindingStrength: Indication of the degree of conformance expectations associated with a binding.[ElementDefinition, OperationDefinition] 053// CapabilityStatementKind: How a capability statement is intended to be used.[CapabilityStatement, TerminologyCapabilities] 054// ClaimProcessingCodes: This value set includes Claim Processing Outcome codes.[ClaimResponse, ExplanationOfBenefit] 055// CodeSystemContentMode: The extent of the content of the code system (the concepts and codes it defines) are represented in a code system resource.[CodeSystem, TerminologyCapabilities] 056// CommonLanguages: This value set includes common codes from BCP-47 (see http://tools.ietf.org/html/bcp47)[InventoryItem, TerminologyCapabilities] 057// CompartmentType: Which type a compartment definition describes.[CompartmentDefinition, GraphDefinition] 058// CompositionStatus: The workflow/clinical status of the composition.[Composition, DocumentReference] 059// ConceptMapRelationship: The relationship between concepts.[ConceptMap] 060// ConsentDataMeaning: How a resource reference is interpreted when testing consent restrictions.[Consent, Permission] 061// ConsentProvisionType: How a rule statement is applied, such as adding additional consent or removing consent.[Consent, Permission] 062// Currencies: Currency codes from ISO 4217 (see https://www.iso.org/iso-4217-currency-codes.html)[Account, Money] 063// DaysOfWeek: The days of the week.[Appointment, Availability, Timing] 064// DeviceNameType: The type of name the device is referred by.[Device, DeviceDefinition] 065// EncounterStatus: Current state of the encounter.[Encounter, EncounterHistory] 066// EventStatus: Codes identifying the lifecycle stage of an event.[ClinicalImpression, Communication, NutritionIntake, Procedure] 067// EvidenceVariableHandling: The handling of the variable in statistical analysis for exposures or outcomes (E.g. Dichotomous, Continuous, Descriptive).[Evidence, EvidenceVariable] 068// ExampleScenarioActorType: The type of actor - system or human.[ActorDefinition, ExampleScenario] 069// FHIRTypes: All FHIR types[DataRequirement, Measure, OperationDefinition, ParameterDefinition] 070// FHIRVersion: All published FHIR Versions.[CapabilityStatement, ImplementationGuide, StructureDefinition] 071// FilterOperator: The kind of operation to perform as a part of a property based filter.[CodeSystem, ValueSet] 072// FinancialResourceStatusCodes: This value set includes Status codes.[Claim, ClaimResponse, Coverage, CoverageEligibilityRequest, CoverageEligibilityResponse, EnrollmentRequest, EnrollmentResponse, PaymentNotice, PaymentReconciliation, VisionPrescription] 073// ListMode: The processing mode that applies to this list.[EvidenceReport, List] 074// MeasureImprovementNotation: Observation values that indicate what change in a measurement value or score is indicative of an improvement in the measured item or scored issue.[Measure, MeasureReport] 075// MimeTypes: This value set includes all possible codes from BCP-13 (see http://tools.ietf.org/html/bcp13)[Attachment, Binary, CapabilityStatement, ElementDefinition, Endpoint, Signature, Subscription, TestScript] 076// ObservationStatus: Codes providing the status of an observation.[Observation, RiskAssessment] 077// OperationParameterUse: Whether an operation parameter is an input or an output parameter.[OperationDefinition, ParameterDefinition] 078// PublicationStatus: The lifecycle status of an artifact.[ActivityDefinition, ActorDefinition, AdministrableProductDefinition, CanonicalResource, CapabilityStatement, ChargeItemDefinition, Citation, CodeSystem, CompartmentDefinition, ConceptMap, ConditionDefinition, EventDefinition, Evidence, EvidenceReport, EvidenceVariable, ExampleScenario, GraphDefinition, ImplementationGuide, Ingredient, InsurancePlan, Library, ManufacturedItemDefinition, Measure, MessageDefinition, MetadataResource, NamingSystem, ObservationDefinition, OperationDefinition, PlanDefinition, Questionnaire, RelatedArtifact, Requirements, ResearchStudy, ResearchSubject, SearchParameter, SpecimenDefinition, StructureDefinition, StructureMap, SubscriptionTopic, TerminologyCapabilities, TestPlan, TestScript, ValueSet] 079// QuantityComparator: How the Quantity should be understood and represented.[Age, Count, Distance, Duration, Quantity] 080// RequestIntent: Codes indicating the degree of authority/intentionality associated with a request.[ActivityDefinition, CommunicationRequest, DeviceRequest, NutritionOrder, RequestOrchestration, ServiceRequest] 081// RequestPriority: Identifies the level of importance to be assigned to actioning the request.[ActivityDefinition, Communication, CommunicationRequest, DeviceRequest, MedicationRequest, NutritionOrder, PlanDefinition, RequestOrchestration, ServiceRequest, SupplyRequest, Task, Transport] 082// RequestStatus: Codes identifying the lifecycle stage of a request.[CarePlan, CommunicationRequest, DeviceRequest, NutritionOrder, RequestOrchestration, ServiceRequest] 083// ResourceTypeEnum: Concrete FHIR Resource Types[CapabilityStatement, CompartmentDefinition, ImplementationGuide, MessageDefinition, Questionnaire] 084// SearchComparator: What Search Comparator Codes are supported in search.[SearchParameter, Subscription, SubscriptionTopic] 085// SearchModifierCode: A supported modifier for a search parameter.[SearchParameter, Subscription, SubscriptionTopic] 086// SearchParamType: Data types allowed to be used for search parameters.[CapabilityStatement, OperationDefinition, SearchParameter] 087// SubscriptionStatusCodes: State values for FHIR Subscriptions.[Subscription, SubscriptionStatus] 088// Use: The purpose of the Claim: predetermination, preauthorization, claim.[Claim, ClaimResponse, ExplanationOfBenefit] 089// VersionIndependentResourceTypesAll: Current and past FHIR resource types (deleted or renamed), including abstract types[GraphDefinition, OperationDefinition, SearchParameter] 090 091 092 public enum ActionCardinalityBehavior { 093 /** 094 * The action may only be selected one time. 095 */ 096 SINGLE, 097 /** 098 * The action may be selected multiple times. 099 */ 100 MULTIPLE, 101 /** 102 * added to help the parsers 103 */ 104 NULL; 105 public static ActionCardinalityBehavior fromCode(String codeString) throws FHIRException { 106 if (codeString == null || "".equals(codeString)) 107 return null; 108 if ("single".equals(codeString)) 109 return SINGLE; 110 if ("multiple".equals(codeString)) 111 return MULTIPLE; 112 throw new FHIRException("Unknown ActionCardinalityBehavior code '"+codeString+"'"); 113 } 114 public static boolean isValidCode(String codeString) { 115 if (codeString == null || "".equals(codeString)) 116 return false; 117 return Utilities.existsInList(codeString, "single", "multiple"); 118 } 119 public String toCode() { 120 switch (this) { 121 case SINGLE: return "single"; 122 case MULTIPLE: return "multiple"; 123 case NULL: return null; 124 default: return "?"; 125 } 126 } 127 public String getSystem() { 128 switch (this) { 129 case SINGLE: return "http://hl7.org/fhir/action-cardinality-behavior"; 130 case MULTIPLE: return "http://hl7.org/fhir/action-cardinality-behavior"; 131 case NULL: return null; 132 default: return "?"; 133 } 134 } 135 public String getDefinition() { 136 switch (this) { 137 case SINGLE: return "The action may only be selected one time."; 138 case MULTIPLE: return "The action may be selected multiple times."; 139 case NULL: return null; 140 default: return "?"; 141 } 142 } 143 public String getDisplay() { 144 switch (this) { 145 case SINGLE: return "Single"; 146 case MULTIPLE: return "Multiple"; 147 case NULL: return null; 148 default: return "?"; 149 } 150 } 151 } 152 153 public static class ActionCardinalityBehaviorEnumFactory implements EnumFactory<ActionCardinalityBehavior> { 154 public ActionCardinalityBehavior fromCode(String codeString) throws IllegalArgumentException { 155 if (codeString == null || "".equals(codeString)) 156 if (codeString == null || "".equals(codeString)) 157 return null; 158 if ("single".equals(codeString)) 159 return ActionCardinalityBehavior.SINGLE; 160 if ("multiple".equals(codeString)) 161 return ActionCardinalityBehavior.MULTIPLE; 162 throw new IllegalArgumentException("Unknown ActionCardinalityBehavior code '"+codeString+"'"); 163 } 164 165 public Enumeration<ActionCardinalityBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 166 if (code == null) 167 return null; 168 if (code.isEmpty()) 169 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.NULL, code); 170 String codeString = ((PrimitiveType) code).asStringValue(); 171 if (codeString == null || "".equals(codeString)) 172 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.NULL, code); 173 if ("single".equals(codeString)) 174 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.SINGLE, code); 175 if ("multiple".equals(codeString)) 176 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.MULTIPLE, code); 177 throw new FHIRException("Unknown ActionCardinalityBehavior code '"+codeString+"'"); 178 } 179 public String toCode(ActionCardinalityBehavior code) { 180 if (code == ActionCardinalityBehavior.NULL) 181 return null; 182 if (code == ActionCardinalityBehavior.SINGLE) 183 return "single"; 184 if (code == ActionCardinalityBehavior.MULTIPLE) 185 return "multiple"; 186 return "?"; 187 } 188 public String toSystem(ActionCardinalityBehavior code) { 189 return code.getSystem(); 190 } 191 } 192 193 public enum ActionConditionKind { 194 /** 195 * The condition describes whether or not a given action is applicable. 196 */ 197 APPLICABILITY, 198 /** 199 * The condition is a starting condition for the action. 200 */ 201 START, 202 /** 203 * The condition is a stop, or exit condition for the action. 204 */ 205 STOP, 206 /** 207 * added to help the parsers 208 */ 209 NULL; 210 public static ActionConditionKind fromCode(String codeString) throws FHIRException { 211 if (codeString == null || "".equals(codeString)) 212 return null; 213 if ("applicability".equals(codeString)) 214 return APPLICABILITY; 215 if ("start".equals(codeString)) 216 return START; 217 if ("stop".equals(codeString)) 218 return STOP; 219 throw new FHIRException("Unknown ActionConditionKind code '"+codeString+"'"); 220 } 221 public static boolean isValidCode(String codeString) { 222 if (codeString == null || "".equals(codeString)) 223 return false; 224 return Utilities.existsInList(codeString, "applicability", "start", "stop"); 225 } 226 public String toCode() { 227 switch (this) { 228 case APPLICABILITY: return "applicability"; 229 case START: return "start"; 230 case STOP: return "stop"; 231 case NULL: return null; 232 default: return "?"; 233 } 234 } 235 public String getSystem() { 236 switch (this) { 237 case APPLICABILITY: return "http://hl7.org/fhir/action-condition-kind"; 238 case START: return "http://hl7.org/fhir/action-condition-kind"; 239 case STOP: return "http://hl7.org/fhir/action-condition-kind"; 240 case NULL: return null; 241 default: return "?"; 242 } 243 } 244 public String getDefinition() { 245 switch (this) { 246 case APPLICABILITY: return "The condition describes whether or not a given action is applicable."; 247 case START: return "The condition is a starting condition for the action."; 248 case STOP: return "The condition is a stop, or exit condition for the action."; 249 case NULL: return null; 250 default: return "?"; 251 } 252 } 253 public String getDisplay() { 254 switch (this) { 255 case APPLICABILITY: return "Applicability"; 256 case START: return "Start"; 257 case STOP: return "Stop"; 258 case NULL: return null; 259 default: return "?"; 260 } 261 } 262 } 263 264 public static class ActionConditionKindEnumFactory implements EnumFactory<ActionConditionKind> { 265 public ActionConditionKind fromCode(String codeString) throws IllegalArgumentException { 266 if (codeString == null || "".equals(codeString)) 267 if (codeString == null || "".equals(codeString)) 268 return null; 269 if ("applicability".equals(codeString)) 270 return ActionConditionKind.APPLICABILITY; 271 if ("start".equals(codeString)) 272 return ActionConditionKind.START; 273 if ("stop".equals(codeString)) 274 return ActionConditionKind.STOP; 275 throw new IllegalArgumentException("Unknown ActionConditionKind code '"+codeString+"'"); 276 } 277 278 public Enumeration<ActionConditionKind> fromType(PrimitiveType<?> code) throws FHIRException { 279 if (code == null) 280 return null; 281 if (code.isEmpty()) 282 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.NULL, code); 283 String codeString = ((PrimitiveType) code).asStringValue(); 284 if (codeString == null || "".equals(codeString)) 285 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.NULL, code); 286 if ("applicability".equals(codeString)) 287 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.APPLICABILITY, code); 288 if ("start".equals(codeString)) 289 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.START, code); 290 if ("stop".equals(codeString)) 291 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.STOP, code); 292 throw new FHIRException("Unknown ActionConditionKind code '"+codeString+"'"); 293 } 294 public String toCode(ActionConditionKind code) { 295 if (code == ActionConditionKind.NULL) 296 return null; 297 if (code == ActionConditionKind.APPLICABILITY) 298 return "applicability"; 299 if (code == ActionConditionKind.START) 300 return "start"; 301 if (code == ActionConditionKind.STOP) 302 return "stop"; 303 return "?"; 304 } 305 public String toSystem(ActionConditionKind code) { 306 return code.getSystem(); 307 } 308 } 309 310 public enum ActionGroupingBehavior { 311 /** 312 * Any group marked with this behavior should be displayed as a visual group to the end user. 313 */ 314 VISUALGROUP, 315 /** 316 * A group with this behavior logically groups its sub-elements, and may be shown as a visual group to the end user, but it is not required to do so. 317 */ 318 LOGICALGROUP, 319 /** 320 * A group of related alternative actions is a sentence group if the target referenced by the action is the same in all the actions and each action simply constitutes a different variation on how to specify the details for the target. For example, two actions that could be in a SentenceGroup are "aspirin, 500 mg, 2 times per day" and "aspirin, 300 mg, 3 times per day". In both cases, aspirin is the target referenced by the action, and the two actions represent different options for how aspirin might be ordered for the patient. Note that a SentenceGroup would almost always have an associated selection behavior of "AtMostOne", unless it's a required action, in which case, it would be "ExactlyOne". 321 */ 322 SENTENCEGROUP, 323 /** 324 * added to help the parsers 325 */ 326 NULL; 327 public static ActionGroupingBehavior fromCode(String codeString) throws FHIRException { 328 if (codeString == null || "".equals(codeString)) 329 return null; 330 if ("visual-group".equals(codeString)) 331 return VISUALGROUP; 332 if ("logical-group".equals(codeString)) 333 return LOGICALGROUP; 334 if ("sentence-group".equals(codeString)) 335 return SENTENCEGROUP; 336 throw new FHIRException("Unknown ActionGroupingBehavior code '"+codeString+"'"); 337 } 338 public static boolean isValidCode(String codeString) { 339 if (codeString == null || "".equals(codeString)) 340 return false; 341 return Utilities.existsInList(codeString, "visual-group", "logical-group", "sentence-group"); 342 } 343 public String toCode() { 344 switch (this) { 345 case VISUALGROUP: return "visual-group"; 346 case LOGICALGROUP: return "logical-group"; 347 case SENTENCEGROUP: return "sentence-group"; 348 case NULL: return null; 349 default: return "?"; 350 } 351 } 352 public String getSystem() { 353 switch (this) { 354 case VISUALGROUP: return "http://hl7.org/fhir/action-grouping-behavior"; 355 case LOGICALGROUP: return "http://hl7.org/fhir/action-grouping-behavior"; 356 case SENTENCEGROUP: return "http://hl7.org/fhir/action-grouping-behavior"; 357 case NULL: return null; 358 default: return "?"; 359 } 360 } 361 public String getDefinition() { 362 switch (this) { 363 case VISUALGROUP: return "Any group marked with this behavior should be displayed as a visual group to the end user."; 364 case LOGICALGROUP: return "A group with this behavior logically groups its sub-elements, and may be shown as a visual group to the end user, but it is not required to do so."; 365 case SENTENCEGROUP: return "A group of related alternative actions is a sentence group if the target referenced by the action is the same in all the actions and each action simply constitutes a different variation on how to specify the details for the target. For example, two actions that could be in a SentenceGroup are \"aspirin, 500 mg, 2 times per day\" and \"aspirin, 300 mg, 3 times per day\". In both cases, aspirin is the target referenced by the action, and the two actions represent different options for how aspirin might be ordered for the patient. Note that a SentenceGroup would almost always have an associated selection behavior of \"AtMostOne\", unless it's a required action, in which case, it would be \"ExactlyOne\"."; 366 case NULL: return null; 367 default: return "?"; 368 } 369 } 370 public String getDisplay() { 371 switch (this) { 372 case VISUALGROUP: return "Visual Group"; 373 case LOGICALGROUP: return "Logical Group"; 374 case SENTENCEGROUP: return "Sentence Group"; 375 case NULL: return null; 376 default: return "?"; 377 } 378 } 379 } 380 381 public static class ActionGroupingBehaviorEnumFactory implements EnumFactory<ActionGroupingBehavior> { 382 public ActionGroupingBehavior fromCode(String codeString) throws IllegalArgumentException { 383 if (codeString == null || "".equals(codeString)) 384 if (codeString == null || "".equals(codeString)) 385 return null; 386 if ("visual-group".equals(codeString)) 387 return ActionGroupingBehavior.VISUALGROUP; 388 if ("logical-group".equals(codeString)) 389 return ActionGroupingBehavior.LOGICALGROUP; 390 if ("sentence-group".equals(codeString)) 391 return ActionGroupingBehavior.SENTENCEGROUP; 392 throw new IllegalArgumentException("Unknown ActionGroupingBehavior code '"+codeString+"'"); 393 } 394 395 public Enumeration<ActionGroupingBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 396 if (code == null) 397 return null; 398 if (code.isEmpty()) 399 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.NULL, code); 400 String codeString = ((PrimitiveType) code).asStringValue(); 401 if (codeString == null || "".equals(codeString)) 402 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.NULL, code); 403 if ("visual-group".equals(codeString)) 404 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.VISUALGROUP, code); 405 if ("logical-group".equals(codeString)) 406 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.LOGICALGROUP, code); 407 if ("sentence-group".equals(codeString)) 408 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.SENTENCEGROUP, code); 409 throw new FHIRException("Unknown ActionGroupingBehavior code '"+codeString+"'"); 410 } 411 public String toCode(ActionGroupingBehavior code) { 412 if (code == ActionGroupingBehavior.NULL) 413 return null; 414 if (code == ActionGroupingBehavior.VISUALGROUP) 415 return "visual-group"; 416 if (code == ActionGroupingBehavior.LOGICALGROUP) 417 return "logical-group"; 418 if (code == ActionGroupingBehavior.SENTENCEGROUP) 419 return "sentence-group"; 420 return "?"; 421 } 422 public String toSystem(ActionGroupingBehavior code) { 423 return code.getSystem(); 424 } 425 } 426 427 public enum ActionParticipantType { 428 /** 429 * The participant is a care team caring for the patient under evaluation. 430 */ 431 CARETEAM, 432 /** 433 * The participant is a system or device used in the care of the patient. 434 */ 435 DEVICE, 436 /** 437 * The participant is a group of participants involved in the care of the patient. 438 */ 439 GROUP, 440 /** 441 * The participant is an institution that can provide the given healthcare service used in the care of the patient. 442 */ 443 HEALTHCARESERVICE, 444 /** 445 * The participant is a location involved in the care of the patient. 446 */ 447 LOCATION, 448 /** 449 * The participant is an organization involved in the care of the patient. 450 */ 451 ORGANIZATION, 452 /** 453 * The participant is the patient under evaluation. 454 */ 455 PATIENT, 456 /** 457 * The participant is a practitioner involved in the patient's care. 458 */ 459 PRACTITIONER, 460 /** 461 * The participant is a particular practitioner role involved in the patient's care. 462 */ 463 PRACTITIONERROLE, 464 /** 465 * The participant is a person related to the patient. 466 */ 467 RELATEDPERSON, 468 /** 469 * added to help the parsers 470 */ 471 NULL; 472 public static ActionParticipantType fromCode(String codeString) throws FHIRException { 473 if (codeString == null || "".equals(codeString)) 474 return null; 475 if ("careteam".equals(codeString)) 476 return CARETEAM; 477 if ("device".equals(codeString)) 478 return DEVICE; 479 if ("group".equals(codeString)) 480 return GROUP; 481 if ("healthcareservice".equals(codeString)) 482 return HEALTHCARESERVICE; 483 if ("location".equals(codeString)) 484 return LOCATION; 485 if ("organization".equals(codeString)) 486 return ORGANIZATION; 487 if ("patient".equals(codeString)) 488 return PATIENT; 489 if ("practitioner".equals(codeString)) 490 return PRACTITIONER; 491 if ("practitionerrole".equals(codeString)) 492 return PRACTITIONERROLE; 493 if ("relatedperson".equals(codeString)) 494 return RELATEDPERSON; 495 throw new FHIRException("Unknown ActionParticipantType code '"+codeString+"'"); 496 } 497 public static boolean isValidCode(String codeString) { 498 if (codeString == null || "".equals(codeString)) 499 return false; 500 return Utilities.existsInList(codeString, "careteam", "device", "group", "healthcareservice", "location", "organization", "patient", "practitioner", "practitionerrole", "relatedperson"); 501 } 502 public String toCode() { 503 switch (this) { 504 case CARETEAM: return "careteam"; 505 case DEVICE: return "device"; 506 case GROUP: return "group"; 507 case HEALTHCARESERVICE: return "healthcareservice"; 508 case LOCATION: return "location"; 509 case ORGANIZATION: return "organization"; 510 case PATIENT: return "patient"; 511 case PRACTITIONER: return "practitioner"; 512 case PRACTITIONERROLE: return "practitionerrole"; 513 case RELATEDPERSON: return "relatedperson"; 514 case NULL: return null; 515 default: return "?"; 516 } 517 } 518 public String getSystem() { 519 switch (this) { 520 case CARETEAM: return "http://hl7.org/fhir/action-participant-type"; 521 case DEVICE: return "http://hl7.org/fhir/action-participant-type"; 522 case GROUP: return "http://hl7.org/fhir/action-participant-type"; 523 case HEALTHCARESERVICE: return "http://hl7.org/fhir/action-participant-type"; 524 case LOCATION: return "http://hl7.org/fhir/action-participant-type"; 525 case ORGANIZATION: return "http://hl7.org/fhir/action-participant-type"; 526 case PATIENT: return "http://hl7.org/fhir/action-participant-type"; 527 case PRACTITIONER: return "http://hl7.org/fhir/action-participant-type"; 528 case PRACTITIONERROLE: return "http://hl7.org/fhir/action-participant-type"; 529 case RELATEDPERSON: return "http://hl7.org/fhir/action-participant-type"; 530 case NULL: return null; 531 default: return "?"; 532 } 533 } 534 public String getDefinition() { 535 switch (this) { 536 case CARETEAM: return "The participant is a care team caring for the patient under evaluation."; 537 case DEVICE: return "The participant is a system or device used in the care of the patient."; 538 case GROUP: return "The participant is a group of participants involved in the care of the patient."; 539 case HEALTHCARESERVICE: return "The participant is an institution that can provide the given healthcare service used in the care of the patient."; 540 case LOCATION: return "The participant is a location involved in the care of the patient."; 541 case ORGANIZATION: return "The participant is an organization involved in the care of the patient."; 542 case PATIENT: return "The participant is the patient under evaluation."; 543 case PRACTITIONER: return "The participant is a practitioner involved in the patient's care."; 544 case PRACTITIONERROLE: return "The participant is a particular practitioner role involved in the patient's care."; 545 case RELATEDPERSON: return "The participant is a person related to the patient."; 546 case NULL: return null; 547 default: return "?"; 548 } 549 } 550 public String getDisplay() { 551 switch (this) { 552 case CARETEAM: return "CareTeam"; 553 case DEVICE: return "Device"; 554 case GROUP: return "Group"; 555 case HEALTHCARESERVICE: return "HealthcareService"; 556 case LOCATION: return "Location"; 557 case ORGANIZATION: return "Organization"; 558 case PATIENT: return "Patient"; 559 case PRACTITIONER: return "Practitioner"; 560 case PRACTITIONERROLE: return "PractitionerRole"; 561 case RELATEDPERSON: return "RelatedPerson"; 562 case NULL: return null; 563 default: return "?"; 564 } 565 } 566 } 567 568 public static class ActionParticipantTypeEnumFactory implements EnumFactory<ActionParticipantType> { 569 public ActionParticipantType fromCode(String codeString) throws IllegalArgumentException { 570 if (codeString == null || "".equals(codeString)) 571 if (codeString == null || "".equals(codeString)) 572 return null; 573 if ("careteam".equals(codeString)) 574 return ActionParticipantType.CARETEAM; 575 if ("device".equals(codeString)) 576 return ActionParticipantType.DEVICE; 577 if ("group".equals(codeString)) 578 return ActionParticipantType.GROUP; 579 if ("healthcareservice".equals(codeString)) 580 return ActionParticipantType.HEALTHCARESERVICE; 581 if ("location".equals(codeString)) 582 return ActionParticipantType.LOCATION; 583 if ("organization".equals(codeString)) 584 return ActionParticipantType.ORGANIZATION; 585 if ("patient".equals(codeString)) 586 return ActionParticipantType.PATIENT; 587 if ("practitioner".equals(codeString)) 588 return ActionParticipantType.PRACTITIONER; 589 if ("practitionerrole".equals(codeString)) 590 return ActionParticipantType.PRACTITIONERROLE; 591 if ("relatedperson".equals(codeString)) 592 return ActionParticipantType.RELATEDPERSON; 593 throw new IllegalArgumentException("Unknown ActionParticipantType code '"+codeString+"'"); 594 } 595 596 public Enumeration<ActionParticipantType> fromType(PrimitiveType<?> code) throws FHIRException { 597 if (code == null) 598 return null; 599 if (code.isEmpty()) 600 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.NULL, code); 601 String codeString = ((PrimitiveType) code).asStringValue(); 602 if (codeString == null || "".equals(codeString)) 603 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.NULL, code); 604 if ("careteam".equals(codeString)) 605 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.CARETEAM, code); 606 if ("device".equals(codeString)) 607 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.DEVICE, code); 608 if ("group".equals(codeString)) 609 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.GROUP, code); 610 if ("healthcareservice".equals(codeString)) 611 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.HEALTHCARESERVICE, code); 612 if ("location".equals(codeString)) 613 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.LOCATION, code); 614 if ("organization".equals(codeString)) 615 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.ORGANIZATION, code); 616 if ("patient".equals(codeString)) 617 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PATIENT, code); 618 if ("practitioner".equals(codeString)) 619 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PRACTITIONER, code); 620 if ("practitionerrole".equals(codeString)) 621 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PRACTITIONERROLE, code); 622 if ("relatedperson".equals(codeString)) 623 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.RELATEDPERSON, code); 624 throw new FHIRException("Unknown ActionParticipantType code '"+codeString+"'"); 625 } 626 public String toCode(ActionParticipantType code) { 627 if (code == ActionParticipantType.NULL) 628 return null; 629 if (code == ActionParticipantType.CARETEAM) 630 return "careteam"; 631 if (code == ActionParticipantType.DEVICE) 632 return "device"; 633 if (code == ActionParticipantType.GROUP) 634 return "group"; 635 if (code == ActionParticipantType.HEALTHCARESERVICE) 636 return "healthcareservice"; 637 if (code == ActionParticipantType.LOCATION) 638 return "location"; 639 if (code == ActionParticipantType.ORGANIZATION) 640 return "organization"; 641 if (code == ActionParticipantType.PATIENT) 642 return "patient"; 643 if (code == ActionParticipantType.PRACTITIONER) 644 return "practitioner"; 645 if (code == ActionParticipantType.PRACTITIONERROLE) 646 return "practitionerrole"; 647 if (code == ActionParticipantType.RELATEDPERSON) 648 return "relatedperson"; 649 return "?"; 650 } 651 public String toSystem(ActionParticipantType code) { 652 return code.getSystem(); 653 } 654 } 655 656 public enum ActionPrecheckBehavior { 657 /** 658 * An action with this behavior is one of the most frequent action that is, or should be, included by an end user, for the particular context in which the action occurs. The system displaying the action to the end user should consider "pre-checking" such an action as a convenience for the user. 659 */ 660 YES, 661 /** 662 * An action with this behavior is one of the less frequent actions included by the end user, for the particular context in which the action occurs. The system displaying the actions to the end user would typically not "pre-check" such an action. 663 */ 664 NO, 665 /** 666 * added to help the parsers 667 */ 668 NULL; 669 public static ActionPrecheckBehavior fromCode(String codeString) throws FHIRException { 670 if (codeString == null || "".equals(codeString)) 671 return null; 672 if ("yes".equals(codeString)) 673 return YES; 674 if ("no".equals(codeString)) 675 return NO; 676 throw new FHIRException("Unknown ActionPrecheckBehavior code '"+codeString+"'"); 677 } 678 public static boolean isValidCode(String codeString) { 679 if (codeString == null || "".equals(codeString)) 680 return false; 681 return Utilities.existsInList(codeString, "yes", "no"); 682 } 683 public String toCode() { 684 switch (this) { 685 case YES: return "yes"; 686 case NO: return "no"; 687 case NULL: return null; 688 default: return "?"; 689 } 690 } 691 public String getSystem() { 692 switch (this) { 693 case YES: return "http://hl7.org/fhir/action-precheck-behavior"; 694 case NO: return "http://hl7.org/fhir/action-precheck-behavior"; 695 case NULL: return null; 696 default: return "?"; 697 } 698 } 699 public String getDefinition() { 700 switch (this) { 701 case YES: return "An action with this behavior is one of the most frequent action that is, or should be, included by an end user, for the particular context in which the action occurs. The system displaying the action to the end user should consider \"pre-checking\" such an action as a convenience for the user."; 702 case NO: return "An action with this behavior is one of the less frequent actions included by the end user, for the particular context in which the action occurs. The system displaying the actions to the end user would typically not \"pre-check\" such an action."; 703 case NULL: return null; 704 default: return "?"; 705 } 706 } 707 public String getDisplay() { 708 switch (this) { 709 case YES: return "Yes"; 710 case NO: return "No"; 711 case NULL: return null; 712 default: return "?"; 713 } 714 } 715 } 716 717 public static class ActionPrecheckBehaviorEnumFactory implements EnumFactory<ActionPrecheckBehavior> { 718 public ActionPrecheckBehavior fromCode(String codeString) throws IllegalArgumentException { 719 if (codeString == null || "".equals(codeString)) 720 if (codeString == null || "".equals(codeString)) 721 return null; 722 if ("yes".equals(codeString)) 723 return ActionPrecheckBehavior.YES; 724 if ("no".equals(codeString)) 725 return ActionPrecheckBehavior.NO; 726 throw new IllegalArgumentException("Unknown ActionPrecheckBehavior code '"+codeString+"'"); 727 } 728 729 public Enumeration<ActionPrecheckBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 730 if (code == null) 731 return null; 732 if (code.isEmpty()) 733 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NULL, code); 734 String codeString = ((PrimitiveType) code).asStringValue(); 735 if (codeString == null || "".equals(codeString)) 736 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NULL, code); 737 if ("yes".equals(codeString)) 738 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.YES, code); 739 if ("no".equals(codeString)) 740 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NO, code); 741 throw new FHIRException("Unknown ActionPrecheckBehavior code '"+codeString+"'"); 742 } 743 public String toCode(ActionPrecheckBehavior code) { 744 if (code == ActionPrecheckBehavior.NULL) 745 return null; 746 if (code == ActionPrecheckBehavior.YES) 747 return "yes"; 748 if (code == ActionPrecheckBehavior.NO) 749 return "no"; 750 return "?"; 751 } 752 public String toSystem(ActionPrecheckBehavior code) { 753 return code.getSystem(); 754 } 755 } 756 757 public enum ActionRelationshipType { 758 /** 759 * The action must be performed before the related action. 760 */ 761 BEFORE, 762 /** 763 * The action must be performed before the start of the related action. 764 */ 765 BEFORESTART, 766 /** 767 * The action must be performed before the end of the related action. 768 */ 769 BEFOREEND, 770 /** 771 * The action must be performed concurrent with the related action. 772 */ 773 CONCURRENT, 774 /** 775 * The action must be performed concurrent with the start of the related action. 776 */ 777 CONCURRENTWITHSTART, 778 /** 779 * The action must be performed concurrent with the end of the related action. 780 */ 781 CONCURRENTWITHEND, 782 /** 783 * The action must be performed after the related action. 784 */ 785 AFTER, 786 /** 787 * The action must be performed after the start of the related action. 788 */ 789 AFTERSTART, 790 /** 791 * The action must be performed after the end of the related action. 792 */ 793 AFTEREND, 794 /** 795 * added to help the parsers 796 */ 797 NULL; 798 public static ActionRelationshipType fromCode(String codeString) throws FHIRException { 799 if (codeString == null || "".equals(codeString)) 800 return null; 801 if ("before".equals(codeString)) 802 return BEFORE; 803 if ("before-start".equals(codeString)) 804 return BEFORESTART; 805 if ("before-end".equals(codeString)) 806 return BEFOREEND; 807 if ("concurrent".equals(codeString)) 808 return CONCURRENT; 809 if ("concurrent-with-start".equals(codeString)) 810 return CONCURRENTWITHSTART; 811 if ("concurrent-with-end".equals(codeString)) 812 return CONCURRENTWITHEND; 813 if ("after".equals(codeString)) 814 return AFTER; 815 if ("after-start".equals(codeString)) 816 return AFTERSTART; 817 if ("after-end".equals(codeString)) 818 return AFTEREND; 819 throw new FHIRException("Unknown ActionRelationshipType code '"+codeString+"'"); 820 } 821 public static boolean isValidCode(String codeString) { 822 if (codeString == null || "".equals(codeString)) 823 return false; 824 return Utilities.existsInList(codeString, "before", "before-start", "before-end", "concurrent", "concurrent-with-start", "concurrent-with-end", "after", "after-start", "after-end"); 825 } 826 public String toCode() { 827 switch (this) { 828 case BEFORE: return "before"; 829 case BEFORESTART: return "before-start"; 830 case BEFOREEND: return "before-end"; 831 case CONCURRENT: return "concurrent"; 832 case CONCURRENTWITHSTART: return "concurrent-with-start"; 833 case CONCURRENTWITHEND: return "concurrent-with-end"; 834 case AFTER: return "after"; 835 case AFTERSTART: return "after-start"; 836 case AFTEREND: return "after-end"; 837 case NULL: return null; 838 default: return "?"; 839 } 840 } 841 public String getSystem() { 842 switch (this) { 843 case BEFORE: return "http://hl7.org/fhir/action-relationship-type"; 844 case BEFORESTART: return "http://hl7.org/fhir/action-relationship-type"; 845 case BEFOREEND: return "http://hl7.org/fhir/action-relationship-type"; 846 case CONCURRENT: return "http://hl7.org/fhir/action-relationship-type"; 847 case CONCURRENTWITHSTART: return "http://hl7.org/fhir/action-relationship-type"; 848 case CONCURRENTWITHEND: return "http://hl7.org/fhir/action-relationship-type"; 849 case AFTER: return "http://hl7.org/fhir/action-relationship-type"; 850 case AFTERSTART: return "http://hl7.org/fhir/action-relationship-type"; 851 case AFTEREND: return "http://hl7.org/fhir/action-relationship-type"; 852 case NULL: return null; 853 default: return "?"; 854 } 855 } 856 public String getDefinition() { 857 switch (this) { 858 case BEFORE: return "The action must be performed before the related action."; 859 case BEFORESTART: return "The action must be performed before the start of the related action."; 860 case BEFOREEND: return "The action must be performed before the end of the related action."; 861 case CONCURRENT: return "The action must be performed concurrent with the related action."; 862 case CONCURRENTWITHSTART: return "The action must be performed concurrent with the start of the related action."; 863 case CONCURRENTWITHEND: return "The action must be performed concurrent with the end of the related action."; 864 case AFTER: return "The action must be performed after the related action."; 865 case AFTERSTART: return "The action must be performed after the start of the related action."; 866 case AFTEREND: return "The action must be performed after the end of the related action."; 867 case NULL: return null; 868 default: return "?"; 869 } 870 } 871 public String getDisplay() { 872 switch (this) { 873 case BEFORE: return "Before"; 874 case BEFORESTART: return "Before Start"; 875 case BEFOREEND: return "Before End"; 876 case CONCURRENT: return "Concurrent"; 877 case CONCURRENTWITHSTART: return "Concurrent With Start"; 878 case CONCURRENTWITHEND: return "Concurrent With End"; 879 case AFTER: return "After"; 880 case AFTERSTART: return "After Start"; 881 case AFTEREND: return "After End"; 882 case NULL: return null; 883 default: return "?"; 884 } 885 } 886 } 887 888 public static class ActionRelationshipTypeEnumFactory implements EnumFactory<ActionRelationshipType> { 889 public ActionRelationshipType fromCode(String codeString) throws IllegalArgumentException { 890 if (codeString == null || "".equals(codeString)) 891 if (codeString == null || "".equals(codeString)) 892 return null; 893 if ("before".equals(codeString)) 894 return ActionRelationshipType.BEFORE; 895 if ("before-start".equals(codeString)) 896 return ActionRelationshipType.BEFORESTART; 897 if ("before-end".equals(codeString)) 898 return ActionRelationshipType.BEFOREEND; 899 if ("concurrent".equals(codeString)) 900 return ActionRelationshipType.CONCURRENT; 901 if ("concurrent-with-start".equals(codeString)) 902 return ActionRelationshipType.CONCURRENTWITHSTART; 903 if ("concurrent-with-end".equals(codeString)) 904 return ActionRelationshipType.CONCURRENTWITHEND; 905 if ("after".equals(codeString)) 906 return ActionRelationshipType.AFTER; 907 if ("after-start".equals(codeString)) 908 return ActionRelationshipType.AFTERSTART; 909 if ("after-end".equals(codeString)) 910 return ActionRelationshipType.AFTEREND; 911 throw new IllegalArgumentException("Unknown ActionRelationshipType code '"+codeString+"'"); 912 } 913 914 public Enumeration<ActionRelationshipType> fromType(PrimitiveType<?> code) throws FHIRException { 915 if (code == null) 916 return null; 917 if (code.isEmpty()) 918 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.NULL, code); 919 String codeString = ((PrimitiveType) code).asStringValue(); 920 if (codeString == null || "".equals(codeString)) 921 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.NULL, code); 922 if ("before".equals(codeString)) 923 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORE, code); 924 if ("before-start".equals(codeString)) 925 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORESTART, code); 926 if ("before-end".equals(codeString)) 927 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFOREEND, code); 928 if ("concurrent".equals(codeString)) 929 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENT, code); 930 if ("concurrent-with-start".equals(codeString)) 931 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHSTART, code); 932 if ("concurrent-with-end".equals(codeString)) 933 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHEND, code); 934 if ("after".equals(codeString)) 935 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTER, code); 936 if ("after-start".equals(codeString)) 937 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTERSTART, code); 938 if ("after-end".equals(codeString)) 939 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTEREND, code); 940 throw new FHIRException("Unknown ActionRelationshipType code '"+codeString+"'"); 941 } 942 public String toCode(ActionRelationshipType code) { 943 if (code == ActionRelationshipType.NULL) 944 return null; 945 if (code == ActionRelationshipType.BEFORE) 946 return "before"; 947 if (code == ActionRelationshipType.BEFORESTART) 948 return "before-start"; 949 if (code == ActionRelationshipType.BEFOREEND) 950 return "before-end"; 951 if (code == ActionRelationshipType.CONCURRENT) 952 return "concurrent"; 953 if (code == ActionRelationshipType.CONCURRENTWITHSTART) 954 return "concurrent-with-start"; 955 if (code == ActionRelationshipType.CONCURRENTWITHEND) 956 return "concurrent-with-end"; 957 if (code == ActionRelationshipType.AFTER) 958 return "after"; 959 if (code == ActionRelationshipType.AFTERSTART) 960 return "after-start"; 961 if (code == ActionRelationshipType.AFTEREND) 962 return "after-end"; 963 return "?"; 964 } 965 public String toSystem(ActionRelationshipType code) { 966 return code.getSystem(); 967 } 968 } 969 970 public enum ActionRequiredBehavior { 971 /** 972 * An action with this behavior must be included in the actions processed by the end user; the end user SHALL NOT choose not to include this action. 973 */ 974 MUST, 975 /** 976 * An action with this behavior may be included in the set of actions processed by the end user. 977 */ 978 COULD, 979 /** 980 * An action with this behavior must be included in the set of actions processed by the end user, unless the end user provides documentation as to why the action was not included. 981 */ 982 MUSTUNLESSDOCUMENTED, 983 /** 984 * added to help the parsers 985 */ 986 NULL; 987 public static ActionRequiredBehavior fromCode(String codeString) throws FHIRException { 988 if (codeString == null || "".equals(codeString)) 989 return null; 990 if ("must".equals(codeString)) 991 return MUST; 992 if ("could".equals(codeString)) 993 return COULD; 994 if ("must-unless-documented".equals(codeString)) 995 return MUSTUNLESSDOCUMENTED; 996 throw new FHIRException("Unknown ActionRequiredBehavior code '"+codeString+"'"); 997 } 998 public static boolean isValidCode(String codeString) { 999 if (codeString == null || "".equals(codeString)) 1000 return false; 1001 return Utilities.existsInList(codeString, "must", "could", "must-unless-documented"); 1002 } 1003 public String toCode() { 1004 switch (this) { 1005 case MUST: return "must"; 1006 case COULD: return "could"; 1007 case MUSTUNLESSDOCUMENTED: return "must-unless-documented"; 1008 case NULL: return null; 1009 default: return "?"; 1010 } 1011 } 1012 public String getSystem() { 1013 switch (this) { 1014 case MUST: return "http://hl7.org/fhir/action-required-behavior"; 1015 case COULD: return "http://hl7.org/fhir/action-required-behavior"; 1016 case MUSTUNLESSDOCUMENTED: return "http://hl7.org/fhir/action-required-behavior"; 1017 case NULL: return null; 1018 default: return "?"; 1019 } 1020 } 1021 public String getDefinition() { 1022 switch (this) { 1023 case MUST: return "An action with this behavior must be included in the actions processed by the end user; the end user SHALL NOT choose not to include this action."; 1024 case COULD: return "An action with this behavior may be included in the set of actions processed by the end user."; 1025 case MUSTUNLESSDOCUMENTED: return "An action with this behavior must be included in the set of actions processed by the end user, unless the end user provides documentation as to why the action was not included."; 1026 case NULL: return null; 1027 default: return "?"; 1028 } 1029 } 1030 public String getDisplay() { 1031 switch (this) { 1032 case MUST: return "Must"; 1033 case COULD: return "Could"; 1034 case MUSTUNLESSDOCUMENTED: return "Must Unless Documented"; 1035 case NULL: return null; 1036 default: return "?"; 1037 } 1038 } 1039 } 1040 1041 public static class ActionRequiredBehaviorEnumFactory implements EnumFactory<ActionRequiredBehavior> { 1042 public ActionRequiredBehavior fromCode(String codeString) throws IllegalArgumentException { 1043 if (codeString == null || "".equals(codeString)) 1044 if (codeString == null || "".equals(codeString)) 1045 return null; 1046 if ("must".equals(codeString)) 1047 return ActionRequiredBehavior.MUST; 1048 if ("could".equals(codeString)) 1049 return ActionRequiredBehavior.COULD; 1050 if ("must-unless-documented".equals(codeString)) 1051 return ActionRequiredBehavior.MUSTUNLESSDOCUMENTED; 1052 throw new IllegalArgumentException("Unknown ActionRequiredBehavior code '"+codeString+"'"); 1053 } 1054 1055 public Enumeration<ActionRequiredBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1056 if (code == null) 1057 return null; 1058 if (code.isEmpty()) 1059 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.NULL, code); 1060 String codeString = ((PrimitiveType) code).asStringValue(); 1061 if (codeString == null || "".equals(codeString)) 1062 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.NULL, code); 1063 if ("must".equals(codeString)) 1064 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUST, code); 1065 if ("could".equals(codeString)) 1066 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.COULD, code); 1067 if ("must-unless-documented".equals(codeString)) 1068 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUSTUNLESSDOCUMENTED, code); 1069 throw new FHIRException("Unknown ActionRequiredBehavior code '"+codeString+"'"); 1070 } 1071 public String toCode(ActionRequiredBehavior code) { 1072 if (code == ActionRequiredBehavior.NULL) 1073 return null; 1074 if (code == ActionRequiredBehavior.MUST) 1075 return "must"; 1076 if (code == ActionRequiredBehavior.COULD) 1077 return "could"; 1078 if (code == ActionRequiredBehavior.MUSTUNLESSDOCUMENTED) 1079 return "must-unless-documented"; 1080 return "?"; 1081 } 1082 public String toSystem(ActionRequiredBehavior code) { 1083 return code.getSystem(); 1084 } 1085 } 1086 1087 public enum ActionSelectionBehavior { 1088 /** 1089 * Any number of the actions in the group may be chosen, from zero to all. 1090 */ 1091 ANY, 1092 /** 1093 * All the actions in the group must be selected as a single unit. 1094 */ 1095 ALL, 1096 /** 1097 * All the actions in the group are meant to be chosen as a single unit: either all must be selected by the end user, or none may be selected. 1098 */ 1099 ALLORNONE, 1100 /** 1101 * The end user must choose one and only one of the selectable actions in the group. The user SHALL NOT choose none of the actions in the group. 1102 */ 1103 EXACTLYONE, 1104 /** 1105 * The end user may choose zero or at most one of the actions in the group. 1106 */ 1107 ATMOSTONE, 1108 /** 1109 * The end user must choose a minimum of one, and as many additional as desired. 1110 */ 1111 ONEORMORE, 1112 /** 1113 * added to help the parsers 1114 */ 1115 NULL; 1116 public static ActionSelectionBehavior fromCode(String codeString) throws FHIRException { 1117 if (codeString == null || "".equals(codeString)) 1118 return null; 1119 if ("any".equals(codeString)) 1120 return ANY; 1121 if ("all".equals(codeString)) 1122 return ALL; 1123 if ("all-or-none".equals(codeString)) 1124 return ALLORNONE; 1125 if ("exactly-one".equals(codeString)) 1126 return EXACTLYONE; 1127 if ("at-most-one".equals(codeString)) 1128 return ATMOSTONE; 1129 if ("one-or-more".equals(codeString)) 1130 return ONEORMORE; 1131 throw new FHIRException("Unknown ActionSelectionBehavior code '"+codeString+"'"); 1132 } 1133 public static boolean isValidCode(String codeString) { 1134 if (codeString == null || "".equals(codeString)) 1135 return false; 1136 return Utilities.existsInList(codeString, "any", "all", "all-or-none", "exactly-one", "at-most-one", "one-or-more"); 1137 } 1138 public String toCode() { 1139 switch (this) { 1140 case ANY: return "any"; 1141 case ALL: return "all"; 1142 case ALLORNONE: return "all-or-none"; 1143 case EXACTLYONE: return "exactly-one"; 1144 case ATMOSTONE: return "at-most-one"; 1145 case ONEORMORE: return "one-or-more"; 1146 case NULL: return null; 1147 default: return "?"; 1148 } 1149 } 1150 public String getSystem() { 1151 switch (this) { 1152 case ANY: return "http://hl7.org/fhir/action-selection-behavior"; 1153 case ALL: return "http://hl7.org/fhir/action-selection-behavior"; 1154 case ALLORNONE: return "http://hl7.org/fhir/action-selection-behavior"; 1155 case EXACTLYONE: return "http://hl7.org/fhir/action-selection-behavior"; 1156 case ATMOSTONE: return "http://hl7.org/fhir/action-selection-behavior"; 1157 case ONEORMORE: return "http://hl7.org/fhir/action-selection-behavior"; 1158 case NULL: return null; 1159 default: return "?"; 1160 } 1161 } 1162 public String getDefinition() { 1163 switch (this) { 1164 case ANY: return "Any number of the actions in the group may be chosen, from zero to all."; 1165 case ALL: return "All the actions in the group must be selected as a single unit."; 1166 case ALLORNONE: return "All the actions in the group are meant to be chosen as a single unit: either all must be selected by the end user, or none may be selected."; 1167 case EXACTLYONE: return "The end user must choose one and only one of the selectable actions in the group. The user SHALL NOT choose none of the actions in the group."; 1168 case ATMOSTONE: return "The end user may choose zero or at most one of the actions in the group."; 1169 case ONEORMORE: return "The end user must choose a minimum of one, and as many additional as desired."; 1170 case NULL: return null; 1171 default: return "?"; 1172 } 1173 } 1174 public String getDisplay() { 1175 switch (this) { 1176 case ANY: return "Any"; 1177 case ALL: return "All"; 1178 case ALLORNONE: return "All Or None"; 1179 case EXACTLYONE: return "Exactly One"; 1180 case ATMOSTONE: return "At Most One"; 1181 case ONEORMORE: return "One Or More"; 1182 case NULL: return null; 1183 default: return "?"; 1184 } 1185 } 1186 } 1187 1188 public static class ActionSelectionBehaviorEnumFactory implements EnumFactory<ActionSelectionBehavior> { 1189 public ActionSelectionBehavior fromCode(String codeString) throws IllegalArgumentException { 1190 if (codeString == null || "".equals(codeString)) 1191 if (codeString == null || "".equals(codeString)) 1192 return null; 1193 if ("any".equals(codeString)) 1194 return ActionSelectionBehavior.ANY; 1195 if ("all".equals(codeString)) 1196 return ActionSelectionBehavior.ALL; 1197 if ("all-or-none".equals(codeString)) 1198 return ActionSelectionBehavior.ALLORNONE; 1199 if ("exactly-one".equals(codeString)) 1200 return ActionSelectionBehavior.EXACTLYONE; 1201 if ("at-most-one".equals(codeString)) 1202 return ActionSelectionBehavior.ATMOSTONE; 1203 if ("one-or-more".equals(codeString)) 1204 return ActionSelectionBehavior.ONEORMORE; 1205 throw new IllegalArgumentException("Unknown ActionSelectionBehavior code '"+codeString+"'"); 1206 } 1207 1208 public Enumeration<ActionSelectionBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1209 if (code == null) 1210 return null; 1211 if (code.isEmpty()) 1212 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.NULL, code); 1213 String codeString = ((PrimitiveType) code).asStringValue(); 1214 if (codeString == null || "".equals(codeString)) 1215 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.NULL, code); 1216 if ("any".equals(codeString)) 1217 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ANY, code); 1218 if ("all".equals(codeString)) 1219 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALL, code); 1220 if ("all-or-none".equals(codeString)) 1221 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALLORNONE, code); 1222 if ("exactly-one".equals(codeString)) 1223 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.EXACTLYONE, code); 1224 if ("at-most-one".equals(codeString)) 1225 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ATMOSTONE, code); 1226 if ("one-or-more".equals(codeString)) 1227 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ONEORMORE, code); 1228 throw new FHIRException("Unknown ActionSelectionBehavior code '"+codeString+"'"); 1229 } 1230 public String toCode(ActionSelectionBehavior code) { 1231 if (code == ActionSelectionBehavior.NULL) 1232 return null; 1233 if (code == ActionSelectionBehavior.ANY) 1234 return "any"; 1235 if (code == ActionSelectionBehavior.ALL) 1236 return "all"; 1237 if (code == ActionSelectionBehavior.ALLORNONE) 1238 return "all-or-none"; 1239 if (code == ActionSelectionBehavior.EXACTLYONE) 1240 return "exactly-one"; 1241 if (code == ActionSelectionBehavior.ATMOSTONE) 1242 return "at-most-one"; 1243 if (code == ActionSelectionBehavior.ONEORMORE) 1244 return "one-or-more"; 1245 return "?"; 1246 } 1247 public String toSystem(ActionSelectionBehavior code) { 1248 return code.getSystem(); 1249 } 1250 } 1251 1252 public enum AdministrativeGender { 1253 /** 1254 * Male. 1255 */ 1256 MALE, 1257 /** 1258 * Female. 1259 */ 1260 FEMALE, 1261 /** 1262 * Other. 1263 */ 1264 OTHER, 1265 /** 1266 * Unknown. 1267 */ 1268 UNKNOWN, 1269 /** 1270 * added to help the parsers 1271 */ 1272 NULL; 1273 public static AdministrativeGender fromCode(String codeString) throws FHIRException { 1274 if (codeString == null || "".equals(codeString)) 1275 return null; 1276 if ("male".equals(codeString)) 1277 return MALE; 1278 if ("female".equals(codeString)) 1279 return FEMALE; 1280 if ("other".equals(codeString)) 1281 return OTHER; 1282 if ("unknown".equals(codeString)) 1283 return UNKNOWN; 1284 throw new FHIRException("Unknown AdministrativeGender code '"+codeString+"'"); 1285 } 1286 public static boolean isValidCode(String codeString) { 1287 if (codeString == null || "".equals(codeString)) 1288 return false; 1289 return Utilities.existsInList(codeString, "male", "female", "other", "unknown"); 1290 } 1291 public String toCode() { 1292 switch (this) { 1293 case MALE: return "male"; 1294 case FEMALE: return "female"; 1295 case OTHER: return "other"; 1296 case UNKNOWN: return "unknown"; 1297 case NULL: return null; 1298 default: return "?"; 1299 } 1300 } 1301 public String getSystem() { 1302 switch (this) { 1303 case MALE: return "http://hl7.org/fhir/administrative-gender"; 1304 case FEMALE: return "http://hl7.org/fhir/administrative-gender"; 1305 case OTHER: return "http://hl7.org/fhir/administrative-gender"; 1306 case UNKNOWN: return "http://hl7.org/fhir/administrative-gender"; 1307 case NULL: return null; 1308 default: return "?"; 1309 } 1310 } 1311 public String getDefinition() { 1312 switch (this) { 1313 case MALE: return "Male."; 1314 case FEMALE: return "Female."; 1315 case OTHER: return "Other."; 1316 case UNKNOWN: return "Unknown."; 1317 case NULL: return null; 1318 default: return "?"; 1319 } 1320 } 1321 public String getDisplay() { 1322 switch (this) { 1323 case MALE: return "Male"; 1324 case FEMALE: return "Female"; 1325 case OTHER: return "Other"; 1326 case UNKNOWN: return "Unknown"; 1327 case NULL: return null; 1328 default: return "?"; 1329 } 1330 } 1331 } 1332 1333 public static class AdministrativeGenderEnumFactory implements EnumFactory<AdministrativeGender> { 1334 public AdministrativeGender fromCode(String codeString) throws IllegalArgumentException { 1335 if (codeString == null || "".equals(codeString)) 1336 if (codeString == null || "".equals(codeString)) 1337 return null; 1338 if ("male".equals(codeString)) 1339 return AdministrativeGender.MALE; 1340 if ("female".equals(codeString)) 1341 return AdministrativeGender.FEMALE; 1342 if ("other".equals(codeString)) 1343 return AdministrativeGender.OTHER; 1344 if ("unknown".equals(codeString)) 1345 return AdministrativeGender.UNKNOWN; 1346 throw new IllegalArgumentException("Unknown AdministrativeGender code '"+codeString+"'"); 1347 } 1348 1349 public Enumeration<AdministrativeGender> fromType(PrimitiveType<?> code) throws FHIRException { 1350 if (code == null) 1351 return null; 1352 if (code.isEmpty()) 1353 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.NULL, code); 1354 String codeString = ((PrimitiveType) code).asStringValue(); 1355 if (codeString == null || "".equals(codeString)) 1356 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.NULL, code); 1357 if ("male".equals(codeString)) 1358 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.MALE, code); 1359 if ("female".equals(codeString)) 1360 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.FEMALE, code); 1361 if ("other".equals(codeString)) 1362 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.OTHER, code); 1363 if ("unknown".equals(codeString)) 1364 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.UNKNOWN, code); 1365 throw new FHIRException("Unknown AdministrativeGender code '"+codeString+"'"); 1366 } 1367 public String toCode(AdministrativeGender code) { 1368 if (code == AdministrativeGender.NULL) 1369 return null; 1370 if (code == AdministrativeGender.MALE) 1371 return "male"; 1372 if (code == AdministrativeGender.FEMALE) 1373 return "female"; 1374 if (code == AdministrativeGender.OTHER) 1375 return "other"; 1376 if (code == AdministrativeGender.UNKNOWN) 1377 return "unknown"; 1378 return "?"; 1379 } 1380 public String toSystem(AdministrativeGender code) { 1381 return code.getSystem(); 1382 } 1383 } 1384 1385 public enum AllLanguages { 1386 /** 1387 * added to help the parsers 1388 */ 1389 NULL; 1390 public static AllLanguages fromCode(String codeString) throws FHIRException { 1391 if (codeString == null || "".equals(codeString)) 1392 return null; 1393 throw new FHIRException("Unknown AllLanguages code '"+codeString+"'"); 1394 } 1395 public static boolean isValidCode(String codeString) { 1396 if (codeString == null || "".equals(codeString)) 1397 return false; 1398 return Utilities.existsInList(codeString); 1399 } 1400 public String toCode() { 1401 switch (this) { 1402 case NULL: return null; 1403 default: return "?"; 1404 } 1405 } 1406 public String getSystem() { 1407 switch (this) { 1408 case NULL: return null; 1409 default: return "?"; 1410 } 1411 } 1412 public String getDefinition() { 1413 switch (this) { 1414 case NULL: return null; 1415 default: return "?"; 1416 } 1417 } 1418 public String getDisplay() { 1419 switch (this) { 1420 case NULL: return null; 1421 default: return "?"; 1422 } 1423 } 1424 } 1425 1426 public static class AllLanguagesEnumFactory implements EnumFactory<AllLanguages> { 1427 public AllLanguages fromCode(String codeString) throws IllegalArgumentException { 1428 if (codeString == null || "".equals(codeString)) 1429 if (codeString == null || "".equals(codeString)) 1430 return null; 1431 throw new IllegalArgumentException("Unknown AllLanguages code '"+codeString+"'"); 1432 } 1433 1434 public Enumeration<AllLanguages> fromType(PrimitiveType<?> code) throws FHIRException { 1435 if (code == null) 1436 return null; 1437 if (code.isEmpty()) 1438 return new Enumeration<AllLanguages>(this, AllLanguages.NULL, code); 1439 String codeString = ((PrimitiveType) code).asStringValue(); 1440 if (codeString == null || "".equals(codeString)) 1441 return new Enumeration<AllLanguages>(this, AllLanguages.NULL, code); 1442 throw new FHIRException("Unknown AllLanguages code '"+codeString+"'"); 1443 } 1444 public String toCode(AllLanguages code) { 1445 if (code == AllLanguages.NULL) 1446 return null; 1447 return "?"; 1448 } 1449 public String toSystem(AllLanguages code) { 1450 return code.getSystem(); 1451 } 1452 } 1453 1454 public enum BindingStrength { 1455 /** 1456 * To be conformant, the concept in this element SHALL be from the specified value set. 1457 */ 1458 REQUIRED, 1459 /** 1460 * To be conformant, the concept in this element SHALL be from the specified value set if any of the codes within the value set can apply to the concept being communicated. If the value set does not cover the concept (based on human review), alternate codings (or, data type allowing, text) may be included instead. 1461 */ 1462 EXTENSIBLE, 1463 /** 1464 * Instances are encouraged to draw from the specified codes for interoperability purposes but are not required to do so to be considered conformant. 1465 */ 1466 PREFERRED, 1467 /** 1468 * Instances are not expected or even encouraged to draw from the specified value set. The value set merely provides examples of the types of concepts intended to be included. 1469 */ 1470 EXAMPLE, 1471 /** 1472 * added to help the parsers 1473 */ 1474 NULL; 1475 public static BindingStrength fromCode(String codeString) throws FHIRException { 1476 if (codeString == null || "".equals(codeString)) 1477 return null; 1478 if ("required".equals(codeString)) 1479 return REQUIRED; 1480 if ("extensible".equals(codeString)) 1481 return EXTENSIBLE; 1482 if ("preferred".equals(codeString)) 1483 return PREFERRED; 1484 if ("example".equals(codeString)) 1485 return EXAMPLE; 1486 throw new FHIRException("Unknown BindingStrength code '"+codeString+"'"); 1487 } 1488 public static boolean isValidCode(String codeString) { 1489 if (codeString == null || "".equals(codeString)) 1490 return false; 1491 return Utilities.existsInList(codeString, "required", "extensible", "preferred", "example"); 1492 } 1493 public String toCode() { 1494 switch (this) { 1495 case REQUIRED: return "required"; 1496 case EXTENSIBLE: return "extensible"; 1497 case PREFERRED: return "preferred"; 1498 case EXAMPLE: return "example"; 1499 case NULL: return null; 1500 default: return "?"; 1501 } 1502 } 1503 public String getSystem() { 1504 switch (this) { 1505 case REQUIRED: return "http://hl7.org/fhir/binding-strength"; 1506 case EXTENSIBLE: return "http://hl7.org/fhir/binding-strength"; 1507 case PREFERRED: return "http://hl7.org/fhir/binding-strength"; 1508 case EXAMPLE: return "http://hl7.org/fhir/binding-strength"; 1509 case NULL: return null; 1510 default: return "?"; 1511 } 1512 } 1513 public String getDefinition() { 1514 switch (this) { 1515 case REQUIRED: return "To be conformant, the concept in this element SHALL be from the specified value set."; 1516 case EXTENSIBLE: return "To be conformant, the concept in this element SHALL be from the specified value set if any of the codes within the value set can apply to the concept being communicated. If the value set does not cover the concept (based on human review), alternate codings (or, data type allowing, text) may be included instead."; 1517 case PREFERRED: return "Instances are encouraged to draw from the specified codes for interoperability purposes but are not required to do so to be considered conformant."; 1518 case EXAMPLE: return "Instances are not expected or even encouraged to draw from the specified value set. The value set merely provides examples of the types of concepts intended to be included."; 1519 case NULL: return null; 1520 default: return "?"; 1521 } 1522 } 1523 public String getDisplay() { 1524 switch (this) { 1525 case REQUIRED: return "Required"; 1526 case EXTENSIBLE: return "Extensible"; 1527 case PREFERRED: return "Preferred"; 1528 case EXAMPLE: return "Example"; 1529 case NULL: return null; 1530 default: return "?"; 1531 } 1532 } 1533 } 1534 1535 public static class BindingStrengthEnumFactory implements EnumFactory<BindingStrength> { 1536 public BindingStrength fromCode(String codeString) throws IllegalArgumentException { 1537 if (codeString == null || "".equals(codeString)) 1538 if (codeString == null || "".equals(codeString)) 1539 return null; 1540 if ("required".equals(codeString)) 1541 return BindingStrength.REQUIRED; 1542 if ("extensible".equals(codeString)) 1543 return BindingStrength.EXTENSIBLE; 1544 if ("preferred".equals(codeString)) 1545 return BindingStrength.PREFERRED; 1546 if ("example".equals(codeString)) 1547 return BindingStrength.EXAMPLE; 1548 throw new IllegalArgumentException("Unknown BindingStrength code '"+codeString+"'"); 1549 } 1550 1551 public Enumeration<BindingStrength> fromType(PrimitiveType<?> code) throws FHIRException { 1552 if (code == null) 1553 return null; 1554 if (code.isEmpty()) 1555 return new Enumeration<BindingStrength>(this, BindingStrength.NULL, code); 1556 String codeString = ((PrimitiveType) code).asStringValue(); 1557 if (codeString == null || "".equals(codeString)) 1558 return new Enumeration<BindingStrength>(this, BindingStrength.NULL, code); 1559 if ("required".equals(codeString)) 1560 return new Enumeration<BindingStrength>(this, BindingStrength.REQUIRED, code); 1561 if ("extensible".equals(codeString)) 1562 return new Enumeration<BindingStrength>(this, BindingStrength.EXTENSIBLE, code); 1563 if ("preferred".equals(codeString)) 1564 return new Enumeration<BindingStrength>(this, BindingStrength.PREFERRED, code); 1565 if ("example".equals(codeString)) 1566 return new Enumeration<BindingStrength>(this, BindingStrength.EXAMPLE, code); 1567 throw new FHIRException("Unknown BindingStrength code '"+codeString+"'"); 1568 } 1569 public String toCode(BindingStrength code) { 1570 if (code == BindingStrength.NULL) 1571 return null; 1572 if (code == BindingStrength.REQUIRED) 1573 return "required"; 1574 if (code == BindingStrength.EXTENSIBLE) 1575 return "extensible"; 1576 if (code == BindingStrength.PREFERRED) 1577 return "preferred"; 1578 if (code == BindingStrength.EXAMPLE) 1579 return "example"; 1580 return "?"; 1581 } 1582 public String toSystem(BindingStrength code) { 1583 return code.getSystem(); 1584 } 1585 } 1586 1587 public enum CapabilityStatementKind { 1588 /** 1589 * The CapabilityStatement instance represents the present capabilities of a specific system instance. This is the kind returned by /metadata for a FHIR server end-point. 1590 */ 1591 INSTANCE, 1592 /** 1593 * The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation. 1594 */ 1595 CAPABILITY, 1596 /** 1597 * The CapabilityStatement instance represents a set of requirements for other systems to meet; e.g. as part of an implementation guide or 'request for proposal'. 1598 */ 1599 REQUIREMENTS, 1600 /** 1601 * added to help the parsers 1602 */ 1603 NULL; 1604 public static CapabilityStatementKind fromCode(String codeString) throws FHIRException { 1605 if (codeString == null || "".equals(codeString)) 1606 return null; 1607 if ("instance".equals(codeString)) 1608 return INSTANCE; 1609 if ("capability".equals(codeString)) 1610 return CAPABILITY; 1611 if ("requirements".equals(codeString)) 1612 return REQUIREMENTS; 1613 throw new FHIRException("Unknown CapabilityStatementKind code '"+codeString+"'"); 1614 } 1615 public static boolean isValidCode(String codeString) { 1616 if (codeString == null || "".equals(codeString)) 1617 return false; 1618 return Utilities.existsInList(codeString, "instance", "capability", "requirements"); 1619 } 1620 public String toCode() { 1621 switch (this) { 1622 case INSTANCE: return "instance"; 1623 case CAPABILITY: return "capability"; 1624 case REQUIREMENTS: return "requirements"; 1625 case NULL: return null; 1626 default: return "?"; 1627 } 1628 } 1629 public String getSystem() { 1630 switch (this) { 1631 case INSTANCE: return "http://hl7.org/fhir/capability-statement-kind"; 1632 case CAPABILITY: return "http://hl7.org/fhir/capability-statement-kind"; 1633 case REQUIREMENTS: return "http://hl7.org/fhir/capability-statement-kind"; 1634 case NULL: return null; 1635 default: return "?"; 1636 } 1637 } 1638 public String getDefinition() { 1639 switch (this) { 1640 case INSTANCE: return "The CapabilityStatement instance represents the present capabilities of a specific system instance. This is the kind returned by /metadata for a FHIR server end-point."; 1641 case CAPABILITY: return "The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation."; 1642 case REQUIREMENTS: return "The CapabilityStatement instance represents a set of requirements for other systems to meet; e.g. as part of an implementation guide or 'request for proposal'."; 1643 case NULL: return null; 1644 default: return "?"; 1645 } 1646 } 1647 public String getDisplay() { 1648 switch (this) { 1649 case INSTANCE: return "Instance"; 1650 case CAPABILITY: return "Capability"; 1651 case REQUIREMENTS: return "Requirements"; 1652 case NULL: return null; 1653 default: return "?"; 1654 } 1655 } 1656 } 1657 1658 public static class CapabilityStatementKindEnumFactory implements EnumFactory<CapabilityStatementKind> { 1659 public CapabilityStatementKind fromCode(String codeString) throws IllegalArgumentException { 1660 if (codeString == null || "".equals(codeString)) 1661 if (codeString == null || "".equals(codeString)) 1662 return null; 1663 if ("instance".equals(codeString)) 1664 return CapabilityStatementKind.INSTANCE; 1665 if ("capability".equals(codeString)) 1666 return CapabilityStatementKind.CAPABILITY; 1667 if ("requirements".equals(codeString)) 1668 return CapabilityStatementKind.REQUIREMENTS; 1669 throw new IllegalArgumentException("Unknown CapabilityStatementKind code '"+codeString+"'"); 1670 } 1671 1672 public Enumeration<CapabilityStatementKind> fromType(PrimitiveType<?> code) throws FHIRException { 1673 if (code == null) 1674 return null; 1675 if (code.isEmpty()) 1676 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.NULL, code); 1677 String codeString = ((PrimitiveType) code).asStringValue(); 1678 if (codeString == null || "".equals(codeString)) 1679 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.NULL, code); 1680 if ("instance".equals(codeString)) 1681 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.INSTANCE, code); 1682 if ("capability".equals(codeString)) 1683 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.CAPABILITY, code); 1684 if ("requirements".equals(codeString)) 1685 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.REQUIREMENTS, code); 1686 throw new FHIRException("Unknown CapabilityStatementKind code '"+codeString+"'"); 1687 } 1688 public String toCode(CapabilityStatementKind code) { 1689 if (code == CapabilityStatementKind.NULL) 1690 return null; 1691 if (code == CapabilityStatementKind.INSTANCE) 1692 return "instance"; 1693 if (code == CapabilityStatementKind.CAPABILITY) 1694 return "capability"; 1695 if (code == CapabilityStatementKind.REQUIREMENTS) 1696 return "requirements"; 1697 return "?"; 1698 } 1699 public String toSystem(CapabilityStatementKind code) { 1700 return code.getSystem(); 1701 } 1702 } 1703 1704 public enum ClaimProcessingCodes { 1705 /** 1706 * The Claim/Pre-authorization/Pre-determination has been received but processing has not begun. 1707 */ 1708 QUEUED, 1709 /** 1710 * The processing has completed without errors 1711 */ 1712 COMPLETE, 1713 /** 1714 * One or more errors have been detected in the Claim 1715 */ 1716 ERROR, 1717 /** 1718 * No errors have been detected in the Claim and some of the adjudication has been performed. 1719 */ 1720 PARTIAL, 1721 /** 1722 * added to help the parsers 1723 */ 1724 NULL; 1725 public static ClaimProcessingCodes fromCode(String codeString) throws FHIRException { 1726 if (codeString == null || "".equals(codeString)) 1727 return null; 1728 if ("queued".equals(codeString)) 1729 return QUEUED; 1730 if ("complete".equals(codeString)) 1731 return COMPLETE; 1732 if ("error".equals(codeString)) 1733 return ERROR; 1734 if ("partial".equals(codeString)) 1735 return PARTIAL; 1736 throw new FHIRException("Unknown ClaimProcessingCodes code '"+codeString+"'"); 1737 } 1738 public static boolean isValidCode(String codeString) { 1739 if (codeString == null || "".equals(codeString)) 1740 return false; 1741 return Utilities.existsInList(codeString, "queued", "complete", "error", "partial"); 1742 } 1743 public String toCode() { 1744 switch (this) { 1745 case QUEUED: return "queued"; 1746 case COMPLETE: return "complete"; 1747 case ERROR: return "error"; 1748 case PARTIAL: return "partial"; 1749 case NULL: return null; 1750 default: return "?"; 1751 } 1752 } 1753 public String getSystem() { 1754 switch (this) { 1755 case QUEUED: return "http://hl7.org/fhir/claim-outcome"; 1756 case COMPLETE: return "http://hl7.org/fhir/claim-outcome"; 1757 case ERROR: return "http://hl7.org/fhir/claim-outcome"; 1758 case PARTIAL: return "http://hl7.org/fhir/claim-outcome"; 1759 case NULL: return null; 1760 default: return "?"; 1761 } 1762 } 1763 public String getDefinition() { 1764 switch (this) { 1765 case QUEUED: return "The Claim/Pre-authorization/Pre-determination has been received but processing has not begun."; 1766 case COMPLETE: return "The processing has completed without errors"; 1767 case ERROR: return "One or more errors have been detected in the Claim"; 1768 case PARTIAL: return "No errors have been detected in the Claim and some of the adjudication has been performed."; 1769 case NULL: return null; 1770 default: return "?"; 1771 } 1772 } 1773 public String getDisplay() { 1774 switch (this) { 1775 case QUEUED: return "Queued"; 1776 case COMPLETE: return "Processing Complete"; 1777 case ERROR: return "Error"; 1778 case PARTIAL: return "Partial Processing"; 1779 case NULL: return null; 1780 default: return "?"; 1781 } 1782 } 1783 } 1784 1785 public static class ClaimProcessingCodesEnumFactory implements EnumFactory<ClaimProcessingCodes> { 1786 public ClaimProcessingCodes fromCode(String codeString) throws IllegalArgumentException { 1787 if (codeString == null || "".equals(codeString)) 1788 if (codeString == null || "".equals(codeString)) 1789 return null; 1790 if ("queued".equals(codeString)) 1791 return ClaimProcessingCodes.QUEUED; 1792 if ("complete".equals(codeString)) 1793 return ClaimProcessingCodes.COMPLETE; 1794 if ("error".equals(codeString)) 1795 return ClaimProcessingCodes.ERROR; 1796 if ("partial".equals(codeString)) 1797 return ClaimProcessingCodes.PARTIAL; 1798 throw new IllegalArgumentException("Unknown ClaimProcessingCodes code '"+codeString+"'"); 1799 } 1800 1801 public Enumeration<ClaimProcessingCodes> fromType(PrimitiveType<?> code) throws FHIRException { 1802 if (code == null) 1803 return null; 1804 if (code.isEmpty()) 1805 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.NULL, code); 1806 String codeString = ((PrimitiveType) code).asStringValue(); 1807 if (codeString == null || "".equals(codeString)) 1808 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.NULL, code); 1809 if ("queued".equals(codeString)) 1810 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.QUEUED, code); 1811 if ("complete".equals(codeString)) 1812 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.COMPLETE, code); 1813 if ("error".equals(codeString)) 1814 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.ERROR, code); 1815 if ("partial".equals(codeString)) 1816 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.PARTIAL, code); 1817 throw new FHIRException("Unknown ClaimProcessingCodes code '"+codeString+"'"); 1818 } 1819 public String toCode(ClaimProcessingCodes code) { 1820 if (code == ClaimProcessingCodes.NULL) 1821 return null; 1822 if (code == ClaimProcessingCodes.QUEUED) 1823 return "queued"; 1824 if (code == ClaimProcessingCodes.COMPLETE) 1825 return "complete"; 1826 if (code == ClaimProcessingCodes.ERROR) 1827 return "error"; 1828 if (code == ClaimProcessingCodes.PARTIAL) 1829 return "partial"; 1830 return "?"; 1831 } 1832 public String toSystem(ClaimProcessingCodes code) { 1833 return code.getSystem(); 1834 } 1835 } 1836 1837 public enum CodeSystemContentMode { 1838 /** 1839 * None of the concepts defined by the code system are included in the code system resource. 1840 */ 1841 NOTPRESENT, 1842 /** 1843 * A subset of the valid externally defined concepts are included in the code system resource. There is no specific purpose or documented intent other than for illustrative purposes. 1844 */ 1845 EXAMPLE, 1846 /** 1847 * A subset of the code system concepts are included in the code system resource. This is a curated subset released for a specific purpose under the governance of the code system steward, and that the intent, bounds and consequences of the fragmentation are clearly defined in the fragment or the code system documentation. Fragments are also known as partitions. 1848 */ 1849 FRAGMENT, 1850 /** 1851 * All the concepts defined by the code system are included in the code system resource. 1852 */ 1853 COMPLETE, 1854 /** 1855 * The resource doesn't define any new concepts; it just provides additional designations and properties to another code system. 1856 */ 1857 SUPPLEMENT, 1858 /** 1859 * added to help the parsers 1860 */ 1861 NULL; 1862 public static CodeSystemContentMode fromCode(String codeString) throws FHIRException { 1863 if (codeString == null || "".equals(codeString)) 1864 return null; 1865 if ("not-present".equals(codeString)) 1866 return NOTPRESENT; 1867 if ("example".equals(codeString)) 1868 return EXAMPLE; 1869 if ("fragment".equals(codeString)) 1870 return FRAGMENT; 1871 if ("complete".equals(codeString)) 1872 return COMPLETE; 1873 if ("supplement".equals(codeString)) 1874 return SUPPLEMENT; 1875 throw new FHIRException("Unknown CodeSystemContentMode code '"+codeString+"'"); 1876 } 1877 public static boolean isValidCode(String codeString) { 1878 if (codeString == null || "".equals(codeString)) 1879 return false; 1880 return Utilities.existsInList(codeString, "not-present", "example", "fragment", "complete", "supplement"); 1881 } 1882 public String toCode() { 1883 switch (this) { 1884 case NOTPRESENT: return "not-present"; 1885 case EXAMPLE: return "example"; 1886 case FRAGMENT: return "fragment"; 1887 case COMPLETE: return "complete"; 1888 case SUPPLEMENT: return "supplement"; 1889 case NULL: return null; 1890 default: return "?"; 1891 } 1892 } 1893 public String getSystem() { 1894 switch (this) { 1895 case NOTPRESENT: return "http://hl7.org/fhir/codesystem-content-mode"; 1896 case EXAMPLE: return "http://hl7.org/fhir/codesystem-content-mode"; 1897 case FRAGMENT: return "http://hl7.org/fhir/codesystem-content-mode"; 1898 case COMPLETE: return "http://hl7.org/fhir/codesystem-content-mode"; 1899 case SUPPLEMENT: return "http://hl7.org/fhir/codesystem-content-mode"; 1900 case NULL: return null; 1901 default: return "?"; 1902 } 1903 } 1904 public String getDefinition() { 1905 switch (this) { 1906 case NOTPRESENT: return "None of the concepts defined by the code system are included in the code system resource."; 1907 case EXAMPLE: return "A subset of the valid externally defined concepts are included in the code system resource. There is no specific purpose or documented intent other than for illustrative purposes."; 1908 case FRAGMENT: return "A subset of the code system concepts are included in the code system resource. This is a curated subset released for a specific purpose under the governance of the code system steward, and that the intent, bounds and consequences of the fragmentation are clearly defined in the fragment or the code system documentation. Fragments are also known as partitions."; 1909 case COMPLETE: return "All the concepts defined by the code system are included in the code system resource."; 1910 case SUPPLEMENT: return "The resource doesn't define any new concepts; it just provides additional designations and properties to another code system."; 1911 case NULL: return null; 1912 default: return "?"; 1913 } 1914 } 1915 public String getDisplay() { 1916 switch (this) { 1917 case NOTPRESENT: return "Not Present"; 1918 case EXAMPLE: return "Example"; 1919 case FRAGMENT: return "Fragment"; 1920 case COMPLETE: return "Complete"; 1921 case SUPPLEMENT: return "Supplement"; 1922 case NULL: return null; 1923 default: return "?"; 1924 } 1925 } 1926 } 1927 1928 public static class CodeSystemContentModeEnumFactory implements EnumFactory<CodeSystemContentMode> { 1929 public CodeSystemContentMode fromCode(String codeString) throws IllegalArgumentException { 1930 if (codeString == null || "".equals(codeString)) 1931 if (codeString == null || "".equals(codeString)) 1932 return null; 1933 if ("not-present".equals(codeString)) 1934 return CodeSystemContentMode.NOTPRESENT; 1935 if ("example".equals(codeString)) 1936 return CodeSystemContentMode.EXAMPLE; 1937 if ("fragment".equals(codeString)) 1938 return CodeSystemContentMode.FRAGMENT; 1939 if ("complete".equals(codeString)) 1940 return CodeSystemContentMode.COMPLETE; 1941 if ("supplement".equals(codeString)) 1942 return CodeSystemContentMode.SUPPLEMENT; 1943 throw new IllegalArgumentException("Unknown CodeSystemContentMode code '"+codeString+"'"); 1944 } 1945 1946 public Enumeration<CodeSystemContentMode> fromType(PrimitiveType<?> code) throws FHIRException { 1947 if (code == null) 1948 return null; 1949 if (code.isEmpty()) 1950 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.NULL, code); 1951 String codeString = ((PrimitiveType) code).asStringValue(); 1952 if (codeString == null || "".equals(codeString)) 1953 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.NULL, code); 1954 if ("not-present".equals(codeString)) 1955 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.NOTPRESENT, code); 1956 if ("example".equals(codeString)) 1957 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.EXAMPLE, code); 1958 if ("fragment".equals(codeString)) 1959 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.FRAGMENT, code); 1960 if ("complete".equals(codeString)) 1961 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.COMPLETE, code); 1962 if ("supplement".equals(codeString)) 1963 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.SUPPLEMENT, code); 1964 throw new FHIRException("Unknown CodeSystemContentMode code '"+codeString+"'"); 1965 } 1966 public String toCode(CodeSystemContentMode code) { 1967 if (code == CodeSystemContentMode.NULL) 1968 return null; 1969 if (code == CodeSystemContentMode.NOTPRESENT) 1970 return "not-present"; 1971 if (code == CodeSystemContentMode.EXAMPLE) 1972 return "example"; 1973 if (code == CodeSystemContentMode.FRAGMENT) 1974 return "fragment"; 1975 if (code == CodeSystemContentMode.COMPLETE) 1976 return "complete"; 1977 if (code == CodeSystemContentMode.SUPPLEMENT) 1978 return "supplement"; 1979 return "?"; 1980 } 1981 public String toSystem(CodeSystemContentMode code) { 1982 return code.getSystem(); 1983 } 1984 } 1985 1986 public enum CommonLanguages { 1987 /** 1988 * null 1989 */ 1990 AR, 1991 /** 1992 * null 1993 */ 1994 BG, 1995 /** 1996 * null 1997 */ 1998 BGBG, 1999 /** 2000 * null 2001 */ 2002 BN, 2003 /** 2004 * null 2005 */ 2006 CS, 2007 /** 2008 * null 2009 */ 2010 CSCZ, 2011 /** 2012 * null 2013 */ 2014 BS, 2015 /** 2016 * null 2017 */ 2018 BSBA, 2019 /** 2020 * null 2021 */ 2022 DA, 2023 /** 2024 * null 2025 */ 2026 DADK, 2027 /** 2028 * null 2029 */ 2030 DE, 2031 /** 2032 * null 2033 */ 2034 DEAT, 2035 /** 2036 * null 2037 */ 2038 DECH, 2039 /** 2040 * null 2041 */ 2042 DEDE, 2043 /** 2044 * null 2045 */ 2046 EL, 2047 /** 2048 * null 2049 */ 2050 ELGR, 2051 /** 2052 * null 2053 */ 2054 EN, 2055 /** 2056 * null 2057 */ 2058 ENAU, 2059 /** 2060 * null 2061 */ 2062 ENCA, 2063 /** 2064 * null 2065 */ 2066 ENGB, 2067 /** 2068 * null 2069 */ 2070 ENIN, 2071 /** 2072 * null 2073 */ 2074 ENNZ, 2075 /** 2076 * null 2077 */ 2078 ENSG, 2079 /** 2080 * null 2081 */ 2082 ENUS, 2083 /** 2084 * null 2085 */ 2086 ES, 2087 /** 2088 * null 2089 */ 2090 ESAR, 2091 /** 2092 * null 2093 */ 2094 ESES, 2095 /** 2096 * null 2097 */ 2098 ESUY, 2099 /** 2100 * null 2101 */ 2102 ET, 2103 /** 2104 * null 2105 */ 2106 ETEE, 2107 /** 2108 * null 2109 */ 2110 FI, 2111 /** 2112 * null 2113 */ 2114 FR, 2115 /** 2116 * null 2117 */ 2118 FRBE, 2119 /** 2120 * null 2121 */ 2122 FRCH, 2123 /** 2124 * null 2125 */ 2126 FRFR, 2127 /** 2128 * null 2129 */ 2130 FIFI, 2131 /** 2132 * null 2133 */ 2134 FRCA, 2135 /** 2136 * null 2137 */ 2138 FY, 2139 /** 2140 * null 2141 */ 2142 FYNL, 2143 /** 2144 * null 2145 */ 2146 HI, 2147 /** 2148 * null 2149 */ 2150 HR, 2151 /** 2152 * null 2153 */ 2154 HRHR, 2155 /** 2156 * null 2157 */ 2158 IS, 2159 /** 2160 * null 2161 */ 2162 ISIS, 2163 /** 2164 * null 2165 */ 2166 IT, 2167 /** 2168 * null 2169 */ 2170 ITCH, 2171 /** 2172 * null 2173 */ 2174 ITIT, 2175 /** 2176 * null 2177 */ 2178 JA, 2179 /** 2180 * null 2181 */ 2182 KO, 2183 /** 2184 * null 2185 */ 2186 LT, 2187 /** 2188 * null 2189 */ 2190 LTLT, 2191 /** 2192 * null 2193 */ 2194 LV, 2195 /** 2196 * null 2197 */ 2198 LVLV, 2199 /** 2200 * null 2201 */ 2202 NL, 2203 /** 2204 * null 2205 */ 2206 NLBE, 2207 /** 2208 * null 2209 */ 2210 NLNL, 2211 /** 2212 * null 2213 */ 2214 NO, 2215 /** 2216 * null 2217 */ 2218 NONO, 2219 /** 2220 * null 2221 */ 2222 PA, 2223 /** 2224 * null 2225 */ 2226 PL, 2227 /** 2228 * null 2229 */ 2230 PLPL, 2231 /** 2232 * null 2233 */ 2234 PT, 2235 /** 2236 * null 2237 */ 2238 PTPT, 2239 /** 2240 * null 2241 */ 2242 PTBR, 2243 /** 2244 * null 2245 */ 2246 RO, 2247 /** 2248 * null 2249 */ 2250 RORO, 2251 /** 2252 * null 2253 */ 2254 RU, 2255 /** 2256 * null 2257 */ 2258 RURU, 2259 /** 2260 * null 2261 */ 2262 SK, 2263 /** 2264 * null 2265 */ 2266 SKSK, 2267 /** 2268 * null 2269 */ 2270 SL, 2271 /** 2272 * null 2273 */ 2274 SLSI, 2275 /** 2276 * null 2277 */ 2278 SR, 2279 /** 2280 * null 2281 */ 2282 SRRS, 2283 /** 2284 * null 2285 */ 2286 SV, 2287 /** 2288 * null 2289 */ 2290 SVSE, 2291 /** 2292 * null 2293 */ 2294 TE, 2295 /** 2296 * null 2297 */ 2298 ZH, 2299 /** 2300 * null 2301 */ 2302 ZHCN, 2303 /** 2304 * null 2305 */ 2306 ZHHK, 2307 /** 2308 * null 2309 */ 2310 ZHSG, 2311 /** 2312 * null 2313 */ 2314 ZHTW, 2315 /** 2316 * added to help the parsers 2317 */ 2318 NULL; 2319 public static CommonLanguages fromCode(String codeString) throws FHIRException { 2320 if (codeString == null || "".equals(codeString)) 2321 return null; 2322 if ("ar".equals(codeString)) 2323 return AR; 2324 if ("bg".equals(codeString)) 2325 return BG; 2326 if ("bg-BG".equals(codeString)) 2327 return BGBG; 2328 if ("bn".equals(codeString)) 2329 return BN; 2330 if ("cs".equals(codeString)) 2331 return CS; 2332 if ("cs-CZ".equals(codeString)) 2333 return CSCZ; 2334 if ("bs".equals(codeString)) 2335 return BS; 2336 if ("bs-BA".equals(codeString)) 2337 return BSBA; 2338 if ("da".equals(codeString)) 2339 return DA; 2340 if ("da-DK".equals(codeString)) 2341 return DADK; 2342 if ("de".equals(codeString)) 2343 return DE; 2344 if ("de-AT".equals(codeString)) 2345 return DEAT; 2346 if ("de-CH".equals(codeString)) 2347 return DECH; 2348 if ("de-DE".equals(codeString)) 2349 return DEDE; 2350 if ("el".equals(codeString)) 2351 return EL; 2352 if ("el-GR".equals(codeString)) 2353 return ELGR; 2354 if ("en".equals(codeString)) 2355 return EN; 2356 if ("en-AU".equals(codeString)) 2357 return ENAU; 2358 if ("en-CA".equals(codeString)) 2359 return ENCA; 2360 if ("en-GB".equals(codeString)) 2361 return ENGB; 2362 if ("en-IN".equals(codeString)) 2363 return ENIN; 2364 if ("en-NZ".equals(codeString)) 2365 return ENNZ; 2366 if ("en-SG".equals(codeString)) 2367 return ENSG; 2368 if ("en-US".equals(codeString)) 2369 return ENUS; 2370 if ("es".equals(codeString)) 2371 return ES; 2372 if ("es-AR".equals(codeString)) 2373 return ESAR; 2374 if ("es-ES".equals(codeString)) 2375 return ESES; 2376 if ("es-UY".equals(codeString)) 2377 return ESUY; 2378 if ("et".equals(codeString)) 2379 return ET; 2380 if ("et-EE".equals(codeString)) 2381 return ETEE; 2382 if ("fi".equals(codeString)) 2383 return FI; 2384 if ("fr".equals(codeString)) 2385 return FR; 2386 if ("fr-BE".equals(codeString)) 2387 return FRBE; 2388 if ("fr-CH".equals(codeString)) 2389 return FRCH; 2390 if ("fr-FR".equals(codeString)) 2391 return FRFR; 2392 if ("fi-FI".equals(codeString)) 2393 return FIFI; 2394 if ("fr-CA".equals(codeString)) 2395 return FRCA; 2396 if ("fy".equals(codeString)) 2397 return FY; 2398 if ("fy-NL".equals(codeString)) 2399 return FYNL; 2400 if ("hi".equals(codeString)) 2401 return HI; 2402 if ("hr".equals(codeString)) 2403 return HR; 2404 if ("hr-HR".equals(codeString)) 2405 return HRHR; 2406 if ("is".equals(codeString)) 2407 return IS; 2408 if ("is-IS".equals(codeString)) 2409 return ISIS; 2410 if ("it".equals(codeString)) 2411 return IT; 2412 if ("it-CH".equals(codeString)) 2413 return ITCH; 2414 if ("it-IT".equals(codeString)) 2415 return ITIT; 2416 if ("ja".equals(codeString)) 2417 return JA; 2418 if ("ko".equals(codeString)) 2419 return KO; 2420 if ("lt".equals(codeString)) 2421 return LT; 2422 if ("lt-LT".equals(codeString)) 2423 return LTLT; 2424 if ("lv".equals(codeString)) 2425 return LV; 2426 if ("lv-LV".equals(codeString)) 2427 return LVLV; 2428 if ("nl".equals(codeString)) 2429 return NL; 2430 if ("nl-BE".equals(codeString)) 2431 return NLBE; 2432 if ("nl-NL".equals(codeString)) 2433 return NLNL; 2434 if ("no".equals(codeString)) 2435 return NO; 2436 if ("no-NO".equals(codeString)) 2437 return NONO; 2438 if ("pa".equals(codeString)) 2439 return PA; 2440 if ("pl".equals(codeString)) 2441 return PL; 2442 if ("pl-PL".equals(codeString)) 2443 return PLPL; 2444 if ("pt".equals(codeString)) 2445 return PT; 2446 if ("pt-PT".equals(codeString)) 2447 return PTPT; 2448 if ("pt-BR".equals(codeString)) 2449 return PTBR; 2450 if ("ro".equals(codeString)) 2451 return RO; 2452 if ("ro-RO".equals(codeString)) 2453 return RORO; 2454 if ("ru".equals(codeString)) 2455 return RU; 2456 if ("ru-RU".equals(codeString)) 2457 return RURU; 2458 if ("sk".equals(codeString)) 2459 return SK; 2460 if ("sk-SK".equals(codeString)) 2461 return SKSK; 2462 if ("sl".equals(codeString)) 2463 return SL; 2464 if ("sl-SI".equals(codeString)) 2465 return SLSI; 2466 if ("sr".equals(codeString)) 2467 return SR; 2468 if ("sr-RS".equals(codeString)) 2469 return SRRS; 2470 if ("sv".equals(codeString)) 2471 return SV; 2472 if ("sv-SE".equals(codeString)) 2473 return SVSE; 2474 if ("te".equals(codeString)) 2475 return TE; 2476 if ("zh".equals(codeString)) 2477 return ZH; 2478 if ("zh-CN".equals(codeString)) 2479 return ZHCN; 2480 if ("zh-HK".equals(codeString)) 2481 return ZHHK; 2482 if ("zh-SG".equals(codeString)) 2483 return ZHSG; 2484 if ("zh-TW".equals(codeString)) 2485 return ZHTW; 2486 throw new FHIRException("Unknown CommonLanguages code '"+codeString+"'"); 2487 } 2488 public static boolean isValidCode(String codeString) { 2489 if (codeString == null || "".equals(codeString)) 2490 return false; 2491 return Utilities.existsInList(codeString, "ar", "bg", "bg-BG", "bn", "cs", "cs-CZ", "bs", "bs-BA", "da", "da-DK", "de", "de-AT", "de-CH", "de-DE", "el", "el-GR", "en", "en-AU", "en-CA", "en-GB", "en-IN", "en-NZ", "en-SG", "en-US", "es", "es-AR", "es-ES", "es-UY", "et", "et-EE", "fi", "fr", "fr-BE", "fr-CH", "fr-FR", "fi-FI", "fr-CA", "fy", "fy-NL", "hi", "hr", "hr-HR", "is", "is-IS", "it", "it-CH", "it-IT", "ja", "ko", "lt", "lt-LT", "lv", "lv-LV", "nl", "nl-BE", "nl-NL", "no", "no-NO", "pa", "pl", "pl-PL", "pt", "pt-PT", "pt-BR", "ro", "ro-RO", "ru", "ru-RU", "sk", "sk-SK", "sl", "sl-SI", "sr", "sr-RS", "sv", "sv-SE", "te", "zh", "zh-CN", "zh-HK", "zh-SG", "zh-TW"); 2492 } 2493 public String toCode() { 2494 switch (this) { 2495 case AR: return "ar"; 2496 case BG: return "bg"; 2497 case BGBG: return "bg-BG"; 2498 case BN: return "bn"; 2499 case CS: return "cs"; 2500 case CSCZ: return "cs-CZ"; 2501 case BS: return "bs"; 2502 case BSBA: return "bs-BA"; 2503 case DA: return "da"; 2504 case DADK: return "da-DK"; 2505 case DE: return "de"; 2506 case DEAT: return "de-AT"; 2507 case DECH: return "de-CH"; 2508 case DEDE: return "de-DE"; 2509 case EL: return "el"; 2510 case ELGR: return "el-GR"; 2511 case EN: return "en"; 2512 case ENAU: return "en-AU"; 2513 case ENCA: return "en-CA"; 2514 case ENGB: return "en-GB"; 2515 case ENIN: return "en-IN"; 2516 case ENNZ: return "en-NZ"; 2517 case ENSG: return "en-SG"; 2518 case ENUS: return "en-US"; 2519 case ES: return "es"; 2520 case ESAR: return "es-AR"; 2521 case ESES: return "es-ES"; 2522 case ESUY: return "es-UY"; 2523 case ET: return "et"; 2524 case ETEE: return "et-EE"; 2525 case FI: return "fi"; 2526 case FR: return "fr"; 2527 case FRBE: return "fr-BE"; 2528 case FRCH: return "fr-CH"; 2529 case FRFR: return "fr-FR"; 2530 case FIFI: return "fi-FI"; 2531 case FRCA: return "fr-CA"; 2532 case FY: return "fy"; 2533 case FYNL: return "fy-NL"; 2534 case HI: return "hi"; 2535 case HR: return "hr"; 2536 case HRHR: return "hr-HR"; 2537 case IS: return "is"; 2538 case ISIS: return "is-IS"; 2539 case IT: return "it"; 2540 case ITCH: return "it-CH"; 2541 case ITIT: return "it-IT"; 2542 case JA: return "ja"; 2543 case KO: return "ko"; 2544 case LT: return "lt"; 2545 case LTLT: return "lt-LT"; 2546 case LV: return "lv"; 2547 case LVLV: return "lv-LV"; 2548 case NL: return "nl"; 2549 case NLBE: return "nl-BE"; 2550 case NLNL: return "nl-NL"; 2551 case NO: return "no"; 2552 case NONO: return "no-NO"; 2553 case PA: return "pa"; 2554 case PL: return "pl"; 2555 case PLPL: return "pl-PL"; 2556 case PT: return "pt"; 2557 case PTPT: return "pt-PT"; 2558 case PTBR: return "pt-BR"; 2559 case RO: return "ro"; 2560 case RORO: return "ro-RO"; 2561 case RU: return "ru"; 2562 case RURU: return "ru-RU"; 2563 case SK: return "sk"; 2564 case SKSK: return "sk-SK"; 2565 case SL: return "sl"; 2566 case SLSI: return "sl-SI"; 2567 case SR: return "sr"; 2568 case SRRS: return "sr-RS"; 2569 case SV: return "sv"; 2570 case SVSE: return "sv-SE"; 2571 case TE: return "te"; 2572 case ZH: return "zh"; 2573 case ZHCN: return "zh-CN"; 2574 case ZHHK: return "zh-HK"; 2575 case ZHSG: return "zh-SG"; 2576 case ZHTW: return "zh-TW"; 2577 case NULL: return null; 2578 default: return "?"; 2579 } 2580 } 2581 public String getSystem() { 2582 switch (this) { 2583 case AR: return "urn:ietf:bcp:47"; 2584 case BG: return "urn:ietf:bcp:47"; 2585 case BGBG: return "urn:ietf:bcp:47"; 2586 case BN: return "urn:ietf:bcp:47"; 2587 case CS: return "urn:ietf:bcp:47"; 2588 case CSCZ: return "urn:ietf:bcp:47"; 2589 case BS: return "urn:ietf:bcp:47"; 2590 case BSBA: return "urn:ietf:bcp:47"; 2591 case DA: return "urn:ietf:bcp:47"; 2592 case DADK: return "urn:ietf:bcp:47"; 2593 case DE: return "urn:ietf:bcp:47"; 2594 case DEAT: return "urn:ietf:bcp:47"; 2595 case DECH: return "urn:ietf:bcp:47"; 2596 case DEDE: return "urn:ietf:bcp:47"; 2597 case EL: return "urn:ietf:bcp:47"; 2598 case ELGR: return "urn:ietf:bcp:47"; 2599 case EN: return "urn:ietf:bcp:47"; 2600 case ENAU: return "urn:ietf:bcp:47"; 2601 case ENCA: return "urn:ietf:bcp:47"; 2602 case ENGB: return "urn:ietf:bcp:47"; 2603 case ENIN: return "urn:ietf:bcp:47"; 2604 case ENNZ: return "urn:ietf:bcp:47"; 2605 case ENSG: return "urn:ietf:bcp:47"; 2606 case ENUS: return "urn:ietf:bcp:47"; 2607 case ES: return "urn:ietf:bcp:47"; 2608 case ESAR: return "urn:ietf:bcp:47"; 2609 case ESES: return "urn:ietf:bcp:47"; 2610 case ESUY: return "urn:ietf:bcp:47"; 2611 case ET: return "urn:ietf:bcp:47"; 2612 case ETEE: return "urn:ietf:bcp:47"; 2613 case FI: return "urn:ietf:bcp:47"; 2614 case FR: return "urn:ietf:bcp:47"; 2615 case FRBE: return "urn:ietf:bcp:47"; 2616 case FRCH: return "urn:ietf:bcp:47"; 2617 case FRFR: return "urn:ietf:bcp:47"; 2618 case FIFI: return "urn:ietf:bcp:47"; 2619 case FRCA: return "urn:ietf:bcp:47"; 2620 case FY: return "urn:ietf:bcp:47"; 2621 case FYNL: return "urn:ietf:bcp:47"; 2622 case HI: return "urn:ietf:bcp:47"; 2623 case HR: return "urn:ietf:bcp:47"; 2624 case HRHR: return "urn:ietf:bcp:47"; 2625 case IS: return "urn:ietf:bcp:47"; 2626 case ISIS: return "urn:ietf:bcp:47"; 2627 case IT: return "urn:ietf:bcp:47"; 2628 case ITCH: return "urn:ietf:bcp:47"; 2629 case ITIT: return "urn:ietf:bcp:47"; 2630 case JA: return "urn:ietf:bcp:47"; 2631 case KO: return "urn:ietf:bcp:47"; 2632 case LT: return "urn:ietf:bcp:47"; 2633 case LTLT: return "urn:ietf:bcp:47"; 2634 case LV: return "urn:ietf:bcp:47"; 2635 case LVLV: return "urn:ietf:bcp:47"; 2636 case NL: return "urn:ietf:bcp:47"; 2637 case NLBE: return "urn:ietf:bcp:47"; 2638 case NLNL: return "urn:ietf:bcp:47"; 2639 case NO: return "urn:ietf:bcp:47"; 2640 case NONO: return "urn:ietf:bcp:47"; 2641 case PA: return "urn:ietf:bcp:47"; 2642 case PL: return "urn:ietf:bcp:47"; 2643 case PLPL: return "urn:ietf:bcp:47"; 2644 case PT: return "urn:ietf:bcp:47"; 2645 case PTPT: return "urn:ietf:bcp:47"; 2646 case PTBR: return "urn:ietf:bcp:47"; 2647 case RO: return "urn:ietf:bcp:47"; 2648 case RORO: return "urn:ietf:bcp:47"; 2649 case RU: return "urn:ietf:bcp:47"; 2650 case RURU: return "urn:ietf:bcp:47"; 2651 case SK: return "urn:ietf:bcp:47"; 2652 case SKSK: return "urn:ietf:bcp:47"; 2653 case SL: return "urn:ietf:bcp:47"; 2654 case SLSI: return "urn:ietf:bcp:47"; 2655 case SR: return "urn:ietf:bcp:47"; 2656 case SRRS: return "urn:ietf:bcp:47"; 2657 case SV: return "urn:ietf:bcp:47"; 2658 case SVSE: return "urn:ietf:bcp:47"; 2659 case TE: return "urn:ietf:bcp:47"; 2660 case ZH: return "urn:ietf:bcp:47"; 2661 case ZHCN: return "urn:ietf:bcp:47"; 2662 case ZHHK: return "urn:ietf:bcp:47"; 2663 case ZHSG: return "urn:ietf:bcp:47"; 2664 case ZHTW: return "urn:ietf:bcp:47"; 2665 case NULL: return null; 2666 default: return "?"; 2667 } 2668 } 2669 public String getDefinition() { 2670 switch (this) { 2671 case AR: return ""; 2672 case BG: return ""; 2673 case BGBG: return ""; 2674 case BN: return ""; 2675 case CS: return ""; 2676 case CSCZ: return ""; 2677 case BS: return ""; 2678 case BSBA: return ""; 2679 case DA: return ""; 2680 case DADK: return ""; 2681 case DE: return ""; 2682 case DEAT: return ""; 2683 case DECH: return ""; 2684 case DEDE: return ""; 2685 case EL: return ""; 2686 case ELGR: return ""; 2687 case EN: return ""; 2688 case ENAU: return ""; 2689 case ENCA: return ""; 2690 case ENGB: return ""; 2691 case ENIN: return ""; 2692 case ENNZ: return ""; 2693 case ENSG: return ""; 2694 case ENUS: return ""; 2695 case ES: return ""; 2696 case ESAR: return ""; 2697 case ESES: return ""; 2698 case ESUY: return ""; 2699 case ET: return ""; 2700 case ETEE: return ""; 2701 case FI: return ""; 2702 case FR: return ""; 2703 case FRBE: return ""; 2704 case FRCH: return ""; 2705 case FRFR: return ""; 2706 case FIFI: return ""; 2707 case FRCA: return ""; 2708 case FY: return ""; 2709 case FYNL: return ""; 2710 case HI: return ""; 2711 case HR: return ""; 2712 case HRHR: return ""; 2713 case IS: return ""; 2714 case ISIS: return ""; 2715 case IT: return ""; 2716 case ITCH: return ""; 2717 case ITIT: return ""; 2718 case JA: return ""; 2719 case KO: return ""; 2720 case LT: return ""; 2721 case LTLT: return ""; 2722 case LV: return ""; 2723 case LVLV: return ""; 2724 case NL: return ""; 2725 case NLBE: return ""; 2726 case NLNL: return ""; 2727 case NO: return ""; 2728 case NONO: return ""; 2729 case PA: return ""; 2730 case PL: return ""; 2731 case PLPL: return ""; 2732 case PT: return ""; 2733 case PTPT: return ""; 2734 case PTBR: return ""; 2735 case RO: return ""; 2736 case RORO: return ""; 2737 case RU: return ""; 2738 case RURU: return ""; 2739 case SK: return ""; 2740 case SKSK: return ""; 2741 case SL: return ""; 2742 case SLSI: return ""; 2743 case SR: return ""; 2744 case SRRS: return ""; 2745 case SV: return ""; 2746 case SVSE: return ""; 2747 case TE: return ""; 2748 case ZH: return ""; 2749 case ZHCN: return ""; 2750 case ZHHK: return ""; 2751 case ZHSG: return ""; 2752 case ZHTW: return ""; 2753 case NULL: return null; 2754 default: return "?"; 2755 } 2756 } 2757 public String getDisplay() { 2758 switch (this) { 2759 case AR: return "Arabisk"; 2760 case BG: return "Bulgarian"; 2761 case BGBG: return "Bulgarian (Bulgaria)"; 2762 case BN: return "Bengali"; 2763 case CS: return "Czech"; 2764 case CSCZ: return "Czech (Czechia)"; 2765 case BS: return "Bosnian"; 2766 case BSBA: return "Bosnian (Bosnia and Herzegovina))"; 2767 case DA: return "Danish"; 2768 case DADK: return "Danish (Denmark)"; 2769 case DE: return "German"; 2770 case DEAT: return "German (Austria)"; 2771 case DECH: return "German (Switzerland)"; 2772 case DEDE: return "German (Germany)"; 2773 case EL: return "Greek"; 2774 case ELGR: return "Greek (Greece)"; 2775 case EN: return "English"; 2776 case ENAU: return "English (Australia)"; 2777 case ENCA: return "English (Canada)"; 2778 case ENGB: return "English (Great Britain)"; 2779 case ENIN: return "English (India)"; 2780 case ENNZ: return "English (New Zealand)"; 2781 case ENSG: return "English (Singapore)"; 2782 case ENUS: return "English (United States)"; 2783 case ES: return "Spanish"; 2784 case ESAR: return "Spanish (Argentina)"; 2785 case ESES: return "Spanish (Spain)"; 2786 case ESUY: return "Spanish (Uruguay)"; 2787 case ET: return "Estonian"; 2788 case ETEE: return "Estonian (Estonia)"; 2789 case FI: return "Finnish"; 2790 case FR: return "French"; 2791 case FRBE: return "French (Belgium)"; 2792 case FRCH: return "French (Switzerland)"; 2793 case FRFR: return "French (France)"; 2794 case FIFI: return "Finnish (Finland)"; 2795 case FRCA: return "French (Canada)"; 2796 case FY: return "Frisian"; 2797 case FYNL: return "Frisian (Netherlands)"; 2798 case HI: return "Hindi"; 2799 case HR: return "Croatian"; 2800 case HRHR: return "Croatian (Croatia)"; 2801 case IS: return "Icelandic"; 2802 case ISIS: return "Icelandic (Iceland)"; 2803 case IT: return "Italian"; 2804 case ITCH: return "Italian (Switzerland)"; 2805 case ITIT: return "Italian (Italy)"; 2806 case JA: return "Japanese"; 2807 case KO: return "Korean"; 2808 case LT: return "Lithuanian"; 2809 case LTLT: return "Lithuanian (Lithuania)"; 2810 case LV: return "Latvian"; 2811 case LVLV: return "Latvian (Latvia)"; 2812 case NL: return "Dutch"; 2813 case NLBE: return "Dutch (Belgium)"; 2814 case NLNL: return "Dutch (Netherlands)"; 2815 case NO: return "Norwegian"; 2816 case NONO: return "Norwegian (Norway)"; 2817 case PA: return "Punjabi"; 2818 case PL: return "Polskie"; 2819 case PLPL: return "Polish (Poland)"; 2820 case PT: return "Portuguese"; 2821 case PTPT: return "Portuguese (Portugal)"; 2822 case PTBR: return "Portuguese (Brazil)"; 2823 case RO: return "Romanian"; 2824 case RORO: return "Romanian (Romania)"; 2825 case RU: return "Russian"; 2826 case RURU: return "Russian (Russia)"; 2827 case SK: return "Slovakian"; 2828 case SKSK: return "Slovakian (Slovakia)"; 2829 case SL: return "Slovenian"; 2830 case SLSI: return "Slovenian (Slovenia)"; 2831 case SR: return "Serbian"; 2832 case SRRS: return "Serbian (Serbia)"; 2833 case SV: return "Swedish"; 2834 case SVSE: return "Swedish (Sweden)"; 2835 case TE: return "Telugu"; 2836 case ZH: return "Chinese"; 2837 case ZHCN: return "Chinese (China)"; 2838 case ZHHK: return "Chinese (Hong Kong)"; 2839 case ZHSG: return "Chinese (Singapore)"; 2840 case ZHTW: return "Chinese (Taiwan)"; 2841 case NULL: return null; 2842 default: return "?"; 2843 } 2844 } 2845 } 2846 2847 public static class CommonLanguagesEnumFactory implements EnumFactory<CommonLanguages> { 2848 public CommonLanguages fromCode(String codeString) throws IllegalArgumentException { 2849 if (codeString == null || "".equals(codeString)) 2850 if (codeString == null || "".equals(codeString)) 2851 return null; 2852 if ("ar".equals(codeString)) 2853 return CommonLanguages.AR; 2854 if ("bg".equals(codeString)) 2855 return CommonLanguages.BG; 2856 if ("bg-BG".equals(codeString)) 2857 return CommonLanguages.BGBG; 2858 if ("bn".equals(codeString)) 2859 return CommonLanguages.BN; 2860 if ("cs".equals(codeString)) 2861 return CommonLanguages.CS; 2862 if ("cs-CZ".equals(codeString)) 2863 return CommonLanguages.CSCZ; 2864 if ("bs".equals(codeString)) 2865 return CommonLanguages.BS; 2866 if ("bs-BA".equals(codeString)) 2867 return CommonLanguages.BSBA; 2868 if ("da".equals(codeString)) 2869 return CommonLanguages.DA; 2870 if ("da-DK".equals(codeString)) 2871 return CommonLanguages.DADK; 2872 if ("de".equals(codeString)) 2873 return CommonLanguages.DE; 2874 if ("de-AT".equals(codeString)) 2875 return CommonLanguages.DEAT; 2876 if ("de-CH".equals(codeString)) 2877 return CommonLanguages.DECH; 2878 if ("de-DE".equals(codeString)) 2879 return CommonLanguages.DEDE; 2880 if ("el".equals(codeString)) 2881 return CommonLanguages.EL; 2882 if ("el-GR".equals(codeString)) 2883 return CommonLanguages.ELGR; 2884 if ("en".equals(codeString)) 2885 return CommonLanguages.EN; 2886 if ("en-AU".equals(codeString)) 2887 return CommonLanguages.ENAU; 2888 if ("en-CA".equals(codeString)) 2889 return CommonLanguages.ENCA; 2890 if ("en-GB".equals(codeString)) 2891 return CommonLanguages.ENGB; 2892 if ("en-IN".equals(codeString)) 2893 return CommonLanguages.ENIN; 2894 if ("en-NZ".equals(codeString)) 2895 return CommonLanguages.ENNZ; 2896 if ("en-SG".equals(codeString)) 2897 return CommonLanguages.ENSG; 2898 if ("en-US".equals(codeString)) 2899 return CommonLanguages.ENUS; 2900 if ("es".equals(codeString)) 2901 return CommonLanguages.ES; 2902 if ("es-AR".equals(codeString)) 2903 return CommonLanguages.ESAR; 2904 if ("es-ES".equals(codeString)) 2905 return CommonLanguages.ESES; 2906 if ("es-UY".equals(codeString)) 2907 return CommonLanguages.ESUY; 2908 if ("et".equals(codeString)) 2909 return CommonLanguages.ET; 2910 if ("et-EE".equals(codeString)) 2911 return CommonLanguages.ETEE; 2912 if ("fi".equals(codeString)) 2913 return CommonLanguages.FI; 2914 if ("fr".equals(codeString)) 2915 return CommonLanguages.FR; 2916 if ("fr-BE".equals(codeString)) 2917 return CommonLanguages.FRBE; 2918 if ("fr-CH".equals(codeString)) 2919 return CommonLanguages.FRCH; 2920 if ("fr-FR".equals(codeString)) 2921 return CommonLanguages.FRFR; 2922 if ("fi-FI".equals(codeString)) 2923 return CommonLanguages.FIFI; 2924 if ("fr-CA".equals(codeString)) 2925 return CommonLanguages.FRCA; 2926 if ("fy".equals(codeString)) 2927 return CommonLanguages.FY; 2928 if ("fy-NL".equals(codeString)) 2929 return CommonLanguages.FYNL; 2930 if ("hi".equals(codeString)) 2931 return CommonLanguages.HI; 2932 if ("hr".equals(codeString)) 2933 return CommonLanguages.HR; 2934 if ("hr-HR".equals(codeString)) 2935 return CommonLanguages.HRHR; 2936 if ("is".equals(codeString)) 2937 return CommonLanguages.IS; 2938 if ("is-IS".equals(codeString)) 2939 return CommonLanguages.ISIS; 2940 if ("it".equals(codeString)) 2941 return CommonLanguages.IT; 2942 if ("it-CH".equals(codeString)) 2943 return CommonLanguages.ITCH; 2944 if ("it-IT".equals(codeString)) 2945 return CommonLanguages.ITIT; 2946 if ("ja".equals(codeString)) 2947 return CommonLanguages.JA; 2948 if ("ko".equals(codeString)) 2949 return CommonLanguages.KO; 2950 if ("lt".equals(codeString)) 2951 return CommonLanguages.LT; 2952 if ("lt-LT".equals(codeString)) 2953 return CommonLanguages.LTLT; 2954 if ("lv".equals(codeString)) 2955 return CommonLanguages.LV; 2956 if ("lv-LV".equals(codeString)) 2957 return CommonLanguages.LVLV; 2958 if ("nl".equals(codeString)) 2959 return CommonLanguages.NL; 2960 if ("nl-BE".equals(codeString)) 2961 return CommonLanguages.NLBE; 2962 if ("nl-NL".equals(codeString)) 2963 return CommonLanguages.NLNL; 2964 if ("no".equals(codeString)) 2965 return CommonLanguages.NO; 2966 if ("no-NO".equals(codeString)) 2967 return CommonLanguages.NONO; 2968 if ("pa".equals(codeString)) 2969 return CommonLanguages.PA; 2970 if ("pl".equals(codeString)) 2971 return CommonLanguages.PL; 2972 if ("pl-PL".equals(codeString)) 2973 return CommonLanguages.PLPL; 2974 if ("pt".equals(codeString)) 2975 return CommonLanguages.PT; 2976 if ("pt-PT".equals(codeString)) 2977 return CommonLanguages.PTPT; 2978 if ("pt-BR".equals(codeString)) 2979 return CommonLanguages.PTBR; 2980 if ("ro".equals(codeString)) 2981 return CommonLanguages.RO; 2982 if ("ro-RO".equals(codeString)) 2983 return CommonLanguages.RORO; 2984 if ("ru".equals(codeString)) 2985 return CommonLanguages.RU; 2986 if ("ru-RU".equals(codeString)) 2987 return CommonLanguages.RURU; 2988 if ("sk".equals(codeString)) 2989 return CommonLanguages.SK; 2990 if ("sk-SK".equals(codeString)) 2991 return CommonLanguages.SKSK; 2992 if ("sl".equals(codeString)) 2993 return CommonLanguages.SL; 2994 if ("sl-SI".equals(codeString)) 2995 return CommonLanguages.SLSI; 2996 if ("sr".equals(codeString)) 2997 return CommonLanguages.SR; 2998 if ("sr-RS".equals(codeString)) 2999 return CommonLanguages.SRRS; 3000 if ("sv".equals(codeString)) 3001 return CommonLanguages.SV; 3002 if ("sv-SE".equals(codeString)) 3003 return CommonLanguages.SVSE; 3004 if ("te".equals(codeString)) 3005 return CommonLanguages.TE; 3006 if ("zh".equals(codeString)) 3007 return CommonLanguages.ZH; 3008 if ("zh-CN".equals(codeString)) 3009 return CommonLanguages.ZHCN; 3010 if ("zh-HK".equals(codeString)) 3011 return CommonLanguages.ZHHK; 3012 if ("zh-SG".equals(codeString)) 3013 return CommonLanguages.ZHSG; 3014 if ("zh-TW".equals(codeString)) 3015 return CommonLanguages.ZHTW; 3016 throw new IllegalArgumentException("Unknown CommonLanguages code '"+codeString+"'"); 3017 } 3018 3019 public Enumeration<CommonLanguages> fromType(PrimitiveType<?> code) throws FHIRException { 3020 if (code == null) 3021 return null; 3022 if (code.isEmpty()) 3023 return new Enumeration<CommonLanguages>(this, CommonLanguages.NULL, code); 3024 String codeString = ((PrimitiveType) code).asStringValue(); 3025 if (codeString == null || "".equals(codeString)) 3026 return new Enumeration<CommonLanguages>(this, CommonLanguages.NULL, code); 3027 if ("ar".equals(codeString)) 3028 return new Enumeration<CommonLanguages>(this, CommonLanguages.AR, code); 3029 if ("bg".equals(codeString)) 3030 return new Enumeration<CommonLanguages>(this, CommonLanguages.BG, code); 3031 if ("bg-BG".equals(codeString)) 3032 return new Enumeration<CommonLanguages>(this, CommonLanguages.BGBG, code); 3033 if ("bn".equals(codeString)) 3034 return new Enumeration<CommonLanguages>(this, CommonLanguages.BN, code); 3035 if ("cs".equals(codeString)) 3036 return new Enumeration<CommonLanguages>(this, CommonLanguages.CS, code); 3037 if ("cs-CZ".equals(codeString)) 3038 return new Enumeration<CommonLanguages>(this, CommonLanguages.CSCZ, code); 3039 if ("bs".equals(codeString)) 3040 return new Enumeration<CommonLanguages>(this, CommonLanguages.BS, code); 3041 if ("bs-BA".equals(codeString)) 3042 return new Enumeration<CommonLanguages>(this, CommonLanguages.BSBA, code); 3043 if ("da".equals(codeString)) 3044 return new Enumeration<CommonLanguages>(this, CommonLanguages.DA, code); 3045 if ("da-DK".equals(codeString)) 3046 return new Enumeration<CommonLanguages>(this, CommonLanguages.DADK, code); 3047 if ("de".equals(codeString)) 3048 return new Enumeration<CommonLanguages>(this, CommonLanguages.DE, code); 3049 if ("de-AT".equals(codeString)) 3050 return new Enumeration<CommonLanguages>(this, CommonLanguages.DEAT, code); 3051 if ("de-CH".equals(codeString)) 3052 return new Enumeration<CommonLanguages>(this, CommonLanguages.DECH, code); 3053 if ("de-DE".equals(codeString)) 3054 return new Enumeration<CommonLanguages>(this, CommonLanguages.DEDE, code); 3055 if ("el".equals(codeString)) 3056 return new Enumeration<CommonLanguages>(this, CommonLanguages.EL, code); 3057 if ("el-GR".equals(codeString)) 3058 return new Enumeration<CommonLanguages>(this, CommonLanguages.ELGR, code); 3059 if ("en".equals(codeString)) 3060 return new Enumeration<CommonLanguages>(this, CommonLanguages.EN, code); 3061 if ("en-AU".equals(codeString)) 3062 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENAU, code); 3063 if ("en-CA".equals(codeString)) 3064 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENCA, code); 3065 if ("en-GB".equals(codeString)) 3066 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENGB, code); 3067 if ("en-IN".equals(codeString)) 3068 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENIN, code); 3069 if ("en-NZ".equals(codeString)) 3070 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENNZ, code); 3071 if ("en-SG".equals(codeString)) 3072 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENSG, code); 3073 if ("en-US".equals(codeString)) 3074 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENUS, code); 3075 if ("es".equals(codeString)) 3076 return new Enumeration<CommonLanguages>(this, CommonLanguages.ES, code); 3077 if ("es-AR".equals(codeString)) 3078 return new Enumeration<CommonLanguages>(this, CommonLanguages.ESAR, code); 3079 if ("es-ES".equals(codeString)) 3080 return new Enumeration<CommonLanguages>(this, CommonLanguages.ESES, code); 3081 if ("es-UY".equals(codeString)) 3082 return new Enumeration<CommonLanguages>(this, CommonLanguages.ESUY, code); 3083 if ("et".equals(codeString)) 3084 return new Enumeration<CommonLanguages>(this, CommonLanguages.ET, code); 3085 if ("et-EE".equals(codeString)) 3086 return new Enumeration<CommonLanguages>(this, CommonLanguages.ETEE, code); 3087 if ("fi".equals(codeString)) 3088 return new Enumeration<CommonLanguages>(this, CommonLanguages.FI, code); 3089 if ("fr".equals(codeString)) 3090 return new Enumeration<CommonLanguages>(this, CommonLanguages.FR, code); 3091 if ("fr-BE".equals(codeString)) 3092 return new Enumeration<CommonLanguages>(this, CommonLanguages.FRBE, code); 3093 if ("fr-CH".equals(codeString)) 3094 return new Enumeration<CommonLanguages>(this, CommonLanguages.FRCH, code); 3095 if ("fr-FR".equals(codeString)) 3096 return new Enumeration<CommonLanguages>(this, CommonLanguages.FRFR, code); 3097 if ("fi-FI".equals(codeString)) 3098 return new Enumeration<CommonLanguages>(this, CommonLanguages.FIFI, code); 3099 if ("fr-CA".equals(codeString)) 3100 return new Enumeration<CommonLanguages>(this, CommonLanguages.FRCA, code); 3101 if ("fy".equals(codeString)) 3102 return new Enumeration<CommonLanguages>(this, CommonLanguages.FY, code); 3103 if ("fy-NL".equals(codeString)) 3104 return new Enumeration<CommonLanguages>(this, CommonLanguages.FYNL, code); 3105 if ("hi".equals(codeString)) 3106 return new Enumeration<CommonLanguages>(this, CommonLanguages.HI, code); 3107 if ("hr".equals(codeString)) 3108 return new Enumeration<CommonLanguages>(this, CommonLanguages.HR, code); 3109 if ("hr-HR".equals(codeString)) 3110 return new Enumeration<CommonLanguages>(this, CommonLanguages.HRHR, code); 3111 if ("is".equals(codeString)) 3112 return new Enumeration<CommonLanguages>(this, CommonLanguages.IS, code); 3113 if ("is-IS".equals(codeString)) 3114 return new Enumeration<CommonLanguages>(this, CommonLanguages.ISIS, code); 3115 if ("it".equals(codeString)) 3116 return new Enumeration<CommonLanguages>(this, CommonLanguages.IT, code); 3117 if ("it-CH".equals(codeString)) 3118 return new Enumeration<CommonLanguages>(this, CommonLanguages.ITCH, code); 3119 if ("it-IT".equals(codeString)) 3120 return new Enumeration<CommonLanguages>(this, CommonLanguages.ITIT, code); 3121 if ("ja".equals(codeString)) 3122 return new Enumeration<CommonLanguages>(this, CommonLanguages.JA, code); 3123 if ("ko".equals(codeString)) 3124 return new Enumeration<CommonLanguages>(this, CommonLanguages.KO, code); 3125 if ("lt".equals(codeString)) 3126 return new Enumeration<CommonLanguages>(this, CommonLanguages.LT, code); 3127 if ("lt-LT".equals(codeString)) 3128 return new Enumeration<CommonLanguages>(this, CommonLanguages.LTLT, code); 3129 if ("lv".equals(codeString)) 3130 return new Enumeration<CommonLanguages>(this, CommonLanguages.LV, code); 3131 if ("lv-LV".equals(codeString)) 3132 return new Enumeration<CommonLanguages>(this, CommonLanguages.LVLV, code); 3133 if ("nl".equals(codeString)) 3134 return new Enumeration<CommonLanguages>(this, CommonLanguages.NL, code); 3135 if ("nl-BE".equals(codeString)) 3136 return new Enumeration<CommonLanguages>(this, CommonLanguages.NLBE, code); 3137 if ("nl-NL".equals(codeString)) 3138 return new Enumeration<CommonLanguages>(this, CommonLanguages.NLNL, code); 3139 if ("no".equals(codeString)) 3140 return new Enumeration<CommonLanguages>(this, CommonLanguages.NO, code); 3141 if ("no-NO".equals(codeString)) 3142 return new Enumeration<CommonLanguages>(this, CommonLanguages.NONO, code); 3143 if ("pa".equals(codeString)) 3144 return new Enumeration<CommonLanguages>(this, CommonLanguages.PA, code); 3145 if ("pl".equals(codeString)) 3146 return new Enumeration<CommonLanguages>(this, CommonLanguages.PL, code); 3147 if ("pl-PL".equals(codeString)) 3148 return new Enumeration<CommonLanguages>(this, CommonLanguages.PLPL, code); 3149 if ("pt".equals(codeString)) 3150 return new Enumeration<CommonLanguages>(this, CommonLanguages.PT, code); 3151 if ("pt-PT".equals(codeString)) 3152 return new Enumeration<CommonLanguages>(this, CommonLanguages.PTPT, code); 3153 if ("pt-BR".equals(codeString)) 3154 return new Enumeration<CommonLanguages>(this, CommonLanguages.PTBR, code); 3155 if ("ro".equals(codeString)) 3156 return new Enumeration<CommonLanguages>(this, CommonLanguages.RO, code); 3157 if ("ro-RO".equals(codeString)) 3158 return new Enumeration<CommonLanguages>(this, CommonLanguages.RORO, code); 3159 if ("ru".equals(codeString)) 3160 return new Enumeration<CommonLanguages>(this, CommonLanguages.RU, code); 3161 if ("ru-RU".equals(codeString)) 3162 return new Enumeration<CommonLanguages>(this, CommonLanguages.RURU, code); 3163 if ("sk".equals(codeString)) 3164 return new Enumeration<CommonLanguages>(this, CommonLanguages.SK, code); 3165 if ("sk-SK".equals(codeString)) 3166 return new Enumeration<CommonLanguages>(this, CommonLanguages.SKSK, code); 3167 if ("sl".equals(codeString)) 3168 return new Enumeration<CommonLanguages>(this, CommonLanguages.SL, code); 3169 if ("sl-SI".equals(codeString)) 3170 return new Enumeration<CommonLanguages>(this, CommonLanguages.SLSI, code); 3171 if ("sr".equals(codeString)) 3172 return new Enumeration<CommonLanguages>(this, CommonLanguages.SR, code); 3173 if ("sr-RS".equals(codeString)) 3174 return new Enumeration<CommonLanguages>(this, CommonLanguages.SRRS, code); 3175 if ("sv".equals(codeString)) 3176 return new Enumeration<CommonLanguages>(this, CommonLanguages.SV, code); 3177 if ("sv-SE".equals(codeString)) 3178 return new Enumeration<CommonLanguages>(this, CommonLanguages.SVSE, code); 3179 if ("te".equals(codeString)) 3180 return new Enumeration<CommonLanguages>(this, CommonLanguages.TE, code); 3181 if ("zh".equals(codeString)) 3182 return new Enumeration<CommonLanguages>(this, CommonLanguages.ZH, code); 3183 if ("zh-CN".equals(codeString)) 3184 return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHCN, code); 3185 if ("zh-HK".equals(codeString)) 3186 return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHHK, code); 3187 if ("zh-SG".equals(codeString)) 3188 return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHSG, code); 3189 if ("zh-TW".equals(codeString)) 3190 return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHTW, code); 3191 throw new FHIRException("Unknown CommonLanguages code '"+codeString+"'"); 3192 } 3193 public String toCode(CommonLanguages code) { 3194 if (code == CommonLanguages.NULL) 3195 return null; 3196 if (code == CommonLanguages.AR) 3197 return "ar"; 3198 if (code == CommonLanguages.BG) 3199 return "bg"; 3200 if (code == CommonLanguages.BGBG) 3201 return "bg-BG"; 3202 if (code == CommonLanguages.BN) 3203 return "bn"; 3204 if (code == CommonLanguages.CS) 3205 return "cs"; 3206 if (code == CommonLanguages.CSCZ) 3207 return "cs-CZ"; 3208 if (code == CommonLanguages.BS) 3209 return "bs"; 3210 if (code == CommonLanguages.BSBA) 3211 return "bs-BA"; 3212 if (code == CommonLanguages.DA) 3213 return "da"; 3214 if (code == CommonLanguages.DADK) 3215 return "da-DK"; 3216 if (code == CommonLanguages.DE) 3217 return "de"; 3218 if (code == CommonLanguages.DEAT) 3219 return "de-AT"; 3220 if (code == CommonLanguages.DECH) 3221 return "de-CH"; 3222 if (code == CommonLanguages.DEDE) 3223 return "de-DE"; 3224 if (code == CommonLanguages.EL) 3225 return "el"; 3226 if (code == CommonLanguages.ELGR) 3227 return "el-GR"; 3228 if (code == CommonLanguages.EN) 3229 return "en"; 3230 if (code == CommonLanguages.ENAU) 3231 return "en-AU"; 3232 if (code == CommonLanguages.ENCA) 3233 return "en-CA"; 3234 if (code == CommonLanguages.ENGB) 3235 return "en-GB"; 3236 if (code == CommonLanguages.ENIN) 3237 return "en-IN"; 3238 if (code == CommonLanguages.ENNZ) 3239 return "en-NZ"; 3240 if (code == CommonLanguages.ENSG) 3241 return "en-SG"; 3242 if (code == CommonLanguages.ENUS) 3243 return "en-US"; 3244 if (code == CommonLanguages.ES) 3245 return "es"; 3246 if (code == CommonLanguages.ESAR) 3247 return "es-AR"; 3248 if (code == CommonLanguages.ESES) 3249 return "es-ES"; 3250 if (code == CommonLanguages.ESUY) 3251 return "es-UY"; 3252 if (code == CommonLanguages.ET) 3253 return "et"; 3254 if (code == CommonLanguages.ETEE) 3255 return "et-EE"; 3256 if (code == CommonLanguages.FI) 3257 return "fi"; 3258 if (code == CommonLanguages.FR) 3259 return "fr"; 3260 if (code == CommonLanguages.FRBE) 3261 return "fr-BE"; 3262 if (code == CommonLanguages.FRCH) 3263 return "fr-CH"; 3264 if (code == CommonLanguages.FRFR) 3265 return "fr-FR"; 3266 if (code == CommonLanguages.FIFI) 3267 return "fi-FI"; 3268 if (code == CommonLanguages.FRCA) 3269 return "fr-CA"; 3270 if (code == CommonLanguages.FY) 3271 return "fy"; 3272 if (code == CommonLanguages.FYNL) 3273 return "fy-NL"; 3274 if (code == CommonLanguages.HI) 3275 return "hi"; 3276 if (code == CommonLanguages.HR) 3277 return "hr"; 3278 if (code == CommonLanguages.HRHR) 3279 return "hr-HR"; 3280 if (code == CommonLanguages.IS) 3281 return "is"; 3282 if (code == CommonLanguages.ISIS) 3283 return "is-IS"; 3284 if (code == CommonLanguages.IT) 3285 return "it"; 3286 if (code == CommonLanguages.ITCH) 3287 return "it-CH"; 3288 if (code == CommonLanguages.ITIT) 3289 return "it-IT"; 3290 if (code == CommonLanguages.JA) 3291 return "ja"; 3292 if (code == CommonLanguages.KO) 3293 return "ko"; 3294 if (code == CommonLanguages.LT) 3295 return "lt"; 3296 if (code == CommonLanguages.LTLT) 3297 return "lt-LT"; 3298 if (code == CommonLanguages.LV) 3299 return "lv"; 3300 if (code == CommonLanguages.LVLV) 3301 return "lv-LV"; 3302 if (code == CommonLanguages.NL) 3303 return "nl"; 3304 if (code == CommonLanguages.NLBE) 3305 return "nl-BE"; 3306 if (code == CommonLanguages.NLNL) 3307 return "nl-NL"; 3308 if (code == CommonLanguages.NO) 3309 return "no"; 3310 if (code == CommonLanguages.NONO) 3311 return "no-NO"; 3312 if (code == CommonLanguages.PA) 3313 return "pa"; 3314 if (code == CommonLanguages.PL) 3315 return "pl"; 3316 if (code == CommonLanguages.PLPL) 3317 return "pl-PL"; 3318 if (code == CommonLanguages.PT) 3319 return "pt"; 3320 if (code == CommonLanguages.PTPT) 3321 return "pt-PT"; 3322 if (code == CommonLanguages.PTBR) 3323 return "pt-BR"; 3324 if (code == CommonLanguages.RO) 3325 return "ro"; 3326 if (code == CommonLanguages.RORO) 3327 return "ro-RO"; 3328 if (code == CommonLanguages.RU) 3329 return "ru"; 3330 if (code == CommonLanguages.RURU) 3331 return "ru-RU"; 3332 if (code == CommonLanguages.SK) 3333 return "sk"; 3334 if (code == CommonLanguages.SKSK) 3335 return "sk-SK"; 3336 if (code == CommonLanguages.SL) 3337 return "sl"; 3338 if (code == CommonLanguages.SLSI) 3339 return "sl-SI"; 3340 if (code == CommonLanguages.SR) 3341 return "sr"; 3342 if (code == CommonLanguages.SRRS) 3343 return "sr-RS"; 3344 if (code == CommonLanguages.SV) 3345 return "sv"; 3346 if (code == CommonLanguages.SVSE) 3347 return "sv-SE"; 3348 if (code == CommonLanguages.TE) 3349 return "te"; 3350 if (code == CommonLanguages.ZH) 3351 return "zh"; 3352 if (code == CommonLanguages.ZHCN) 3353 return "zh-CN"; 3354 if (code == CommonLanguages.ZHHK) 3355 return "zh-HK"; 3356 if (code == CommonLanguages.ZHSG) 3357 return "zh-SG"; 3358 if (code == CommonLanguages.ZHTW) 3359 return "zh-TW"; 3360 return "?"; 3361 } 3362 public String toSystem(CommonLanguages code) { 3363 return code.getSystem(); 3364 } 3365 } 3366 3367 public enum CompartmentType { 3368 /** 3369 * The compartment definition is for the patient compartment. 3370 */ 3371 PATIENT, 3372 /** 3373 * The compartment definition is for the encounter compartment. 3374 */ 3375 ENCOUNTER, 3376 /** 3377 * The compartment definition is for the related-person compartment. 3378 */ 3379 RELATEDPERSON, 3380 /** 3381 * The compartment definition is for the practitioner compartment. 3382 */ 3383 PRACTITIONER, 3384 /** 3385 * The compartment definition is for the device compartment. 3386 */ 3387 DEVICE, 3388 /** 3389 * The compartment definition is for the episodeofcare compartment. 3390 */ 3391 EPISODEOFCARE, 3392 /** 3393 * added to help the parsers 3394 */ 3395 GROUP, 3396 /** 3397 * added to help the parsers 3398 */ 3399 NULL; 3400 public static CompartmentType fromCode(String codeString) throws FHIRException { 3401 if (codeString == null || "".equals(codeString)) 3402 return null; 3403 if ("Patient".equals(codeString)) 3404 return PATIENT; 3405 if ("Encounter".equals(codeString)) 3406 return ENCOUNTER; 3407 if ("RelatedPerson".equals(codeString)) 3408 return RELATEDPERSON; 3409 if ("Practitioner".equals(codeString)) 3410 return PRACTITIONER; 3411 if ("Device".equals(codeString)) 3412 return DEVICE; 3413 if ("EpisodeOfCare".equals(codeString)) 3414 return EPISODEOFCARE; 3415 if ("Group".equals(codeString)) 3416 return GROUP; 3417 throw new FHIRException("Unknown CompartmentType code '"+codeString+"'"); 3418 } 3419 public static boolean isValidCode(String codeString) { 3420 if (codeString == null || "".equals(codeString)) 3421 return false; 3422 return Utilities.existsInList(codeString, "Patient", "Encounter", "RelatedPerson", "Practitioner", "Device", "EpisodeOfCare"); 3423 } 3424 public String toCode() { 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 GROUP: return "Group"; 3433 case NULL: return null; 3434 default: return "?"; 3435 } 3436 } 3437 public String getSystem() { 3438 switch (this) { 3439 case PATIENT: return "http://hl7.org/fhir/compartment-type"; 3440 case ENCOUNTER: return "http://hl7.org/fhir/compartment-type"; 3441 case RELATEDPERSON: return "http://hl7.org/fhir/compartment-type"; 3442 case PRACTITIONER: return "http://hl7.org/fhir/compartment-type"; 3443 case DEVICE: return "http://hl7.org/fhir/compartment-type"; 3444 case EPISODEOFCARE: return "http://hl7.org/fhir/compartment-type"; 3445 case GROUP: return "http://hl7.org/fhir/compartment-type"; 3446 case NULL: return null; 3447 default: return "?"; 3448 } 3449 } 3450 public String getDefinition() { 3451 switch (this) { 3452 case PATIENT: return "The compartment definition is for the patient compartment."; 3453 case ENCOUNTER: return "The compartment definition is for the encounter compartment."; 3454 case RELATEDPERSON: return "The compartment definition is for the related-person compartment."; 3455 case PRACTITIONER: return "The compartment definition is for the practitioner compartment."; 3456 case DEVICE: return "The compartment definition is for the device compartment."; 3457 case EPISODEOFCARE: return "The compartment definition is for the episodeofcare compartment."; 3458 case GROUP: return "The compartment definition is for the Group compartment."; 3459 case NULL: return null; 3460 default: return "?"; 3461 } 3462 } 3463 public String getDisplay() { 3464 switch (this) { 3465 case PATIENT: return "Patient"; 3466 case ENCOUNTER: return "Encounter"; 3467 case RELATEDPERSON: return "RelatedPerson"; 3468 case PRACTITIONER: return "Practitioner"; 3469 case DEVICE: return "Device"; 3470 case EPISODEOFCARE: return "EpisodeOfCare"; 3471 case GROUP: return "Group"; 3472 case NULL: return null; 3473 default: return "?"; 3474 } 3475 } 3476 } 3477 3478 public static class CompartmentTypeEnumFactory implements EnumFactory<CompartmentType> { 3479 public CompartmentType fromCode(String codeString) throws IllegalArgumentException { 3480 if (codeString == null || "".equals(codeString)) 3481 if (codeString == null || "".equals(codeString)) 3482 return null; 3483 if ("Patient".equals(codeString)) 3484 return CompartmentType.PATIENT; 3485 if ("Encounter".equals(codeString)) 3486 return CompartmentType.ENCOUNTER; 3487 if ("RelatedPerson".equals(codeString)) 3488 return CompartmentType.RELATEDPERSON; 3489 if ("Practitioner".equals(codeString)) 3490 return CompartmentType.PRACTITIONER; 3491 if ("Device".equals(codeString)) 3492 return CompartmentType.DEVICE; 3493 if ("EpisodeOfCare".equals(codeString)) 3494 return CompartmentType.EPISODEOFCARE; 3495 if ("Group".equals(codeString)) 3496 return CompartmentType.GROUP; 3497 throw new IllegalArgumentException("Unknown CompartmentType code '"+codeString+"'"); 3498 } 3499 3500 public Enumeration<CompartmentType> fromType(PrimitiveType<?> code) throws FHIRException { 3501 if (code == null) 3502 return null; 3503 if (code.isEmpty()) 3504 return new Enumeration<CompartmentType>(this, CompartmentType.NULL, code); 3505 String codeString = ((PrimitiveType) code).asStringValue(); 3506 if (codeString == null || "".equals(codeString)) 3507 return new Enumeration<CompartmentType>(this, CompartmentType.NULL, code); 3508 if ("Patient".equals(codeString)) 3509 return new Enumeration<CompartmentType>(this, CompartmentType.PATIENT, code); 3510 if ("Encounter".equals(codeString)) 3511 return new Enumeration<CompartmentType>(this, CompartmentType.ENCOUNTER, code); 3512 if ("RelatedPerson".equals(codeString)) 3513 return new Enumeration<CompartmentType>(this, CompartmentType.RELATEDPERSON, code); 3514 if ("Practitioner".equals(codeString)) 3515 return new Enumeration<CompartmentType>(this, CompartmentType.PRACTITIONER, code); 3516 if ("Device".equals(codeString)) 3517 return new Enumeration<CompartmentType>(this, CompartmentType.DEVICE, code); 3518 if ("EpisodeOfCare".equals(codeString)) 3519 return new Enumeration<CompartmentType>(this, CompartmentType.EPISODEOFCARE, code); 3520 if ("Group".equals(codeString)) 3521 return new Enumeration<CompartmentType>(this, CompartmentType.GROUP, code); 3522 throw new FHIRException("Unknown CompartmentType code '"+codeString+"'"); 3523 } 3524 public String toCode(CompartmentType code) { 3525 if (code == CompartmentType.NULL) 3526 return null; 3527 if (code == CompartmentType.PATIENT) 3528 return "Patient"; 3529 if (code == CompartmentType.ENCOUNTER) 3530 return "Encounter"; 3531 if (code == CompartmentType.RELATEDPERSON) 3532 return "RelatedPerson"; 3533 if (code == CompartmentType.PRACTITIONER) 3534 return "Practitioner"; 3535 if (code == CompartmentType.DEVICE) 3536 return "Device"; 3537 if (code == CompartmentType.EPISODEOFCARE) 3538 return "EpisodeOfCare"; 3539 if (code == CompartmentType.GROUP) 3540 return "Group"; 3541 return "?"; 3542 } 3543 public String toSystem(CompartmentType code) { 3544 return code.getSystem(); 3545 } 3546 } 3547 3548 public enum CompositionStatus { 3549 /** 3550 * The existence of the composition is registered, but there is nothing yet available. 3551 */ 3552 REGISTERED, 3553 /** 3554 * This is a partial (e.g. initial, interim or preliminary) composition: data in the composition may be incomplete or unverified. 3555 */ 3556 PARTIAL, 3557 /** 3558 * Verified early results are available, but not all results are final. 3559 */ 3560 PRELIMINARY, 3561 /** 3562 * 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. 3563 */ 3564 FINAL, 3565 /** 3566 * 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. 3567 */ 3568 AMENDED, 3569 /** 3570 * Subsequent to being final, the composition content has been modified to correct an error in the composition or referenced results. 3571 */ 3572 CORRECTED, 3573 /** 3574 * Subsequent to being final, the composition content has been modified by adding new content. The existing content is unchanged. 3575 */ 3576 APPENDED, 3577 /** 3578 * The composition is unavailable because the measurement was not started or not completed (also sometimes called "aborted"). 3579 */ 3580 CANCELLED, 3581 /** 3582 * 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. 3583 */ 3584 ENTEREDINERROR, 3585 /** 3586 * This composition has been withdrawn or superseded and should no longer be used. 3587 */ 3588 DEPRECATED, 3589 /** 3590 * 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. 3591 */ 3592 UNKNOWN, 3593 /** 3594 * added to help the parsers 3595 */ 3596 NULL; 3597 public static CompositionStatus fromCode(String codeString) throws FHIRException { 3598 if (codeString == null || "".equals(codeString)) 3599 return null; 3600 if ("registered".equals(codeString)) 3601 return REGISTERED; 3602 if ("partial".equals(codeString)) 3603 return PARTIAL; 3604 if ("preliminary".equals(codeString)) 3605 return PRELIMINARY; 3606 if ("final".equals(codeString)) 3607 return FINAL; 3608 if ("amended".equals(codeString)) 3609 return AMENDED; 3610 if ("corrected".equals(codeString)) 3611 return CORRECTED; 3612 if ("appended".equals(codeString)) 3613 return APPENDED; 3614 if ("cancelled".equals(codeString)) 3615 return CANCELLED; 3616 if ("entered-in-error".equals(codeString)) 3617 return ENTEREDINERROR; 3618 if ("deprecated".equals(codeString)) 3619 return DEPRECATED; 3620 if ("unknown".equals(codeString)) 3621 return UNKNOWN; 3622 throw new FHIRException("Unknown CompositionStatus code '"+codeString+"'"); 3623 } 3624 public static boolean isValidCode(String codeString) { 3625 if (codeString == null || "".equals(codeString)) 3626 return false; 3627 return Utilities.existsInList(codeString, "registered", "partial", "preliminary", "final", "amended", "corrected", "appended", "cancelled", "entered-in-error", "deprecated", "unknown"); 3628 } 3629 public String toCode() { 3630 switch (this) { 3631 case REGISTERED: return "registered"; 3632 case PARTIAL: return "partial"; 3633 case PRELIMINARY: return "preliminary"; 3634 case FINAL: return "final"; 3635 case AMENDED: return "amended"; 3636 case CORRECTED: return "corrected"; 3637 case APPENDED: return "appended"; 3638 case CANCELLED: return "cancelled"; 3639 case ENTEREDINERROR: return "entered-in-error"; 3640 case DEPRECATED: return "deprecated"; 3641 case UNKNOWN: return "unknown"; 3642 case NULL: return null; 3643 default: return "?"; 3644 } 3645 } 3646 public String getSystem() { 3647 switch (this) { 3648 case REGISTERED: return "http://hl7.org/fhir/composition-status"; 3649 case PARTIAL: return "http://hl7.org/fhir/composition-status"; 3650 case PRELIMINARY: return "http://hl7.org/fhir/composition-status"; 3651 case FINAL: return "http://hl7.org/fhir/composition-status"; 3652 case AMENDED: return "http://hl7.org/fhir/composition-status"; 3653 case CORRECTED: return "http://hl7.org/fhir/composition-status"; 3654 case APPENDED: return "http://hl7.org/fhir/composition-status"; 3655 case CANCELLED: return "http://hl7.org/fhir/composition-status"; 3656 case ENTEREDINERROR: return "http://hl7.org/fhir/composition-status"; 3657 case DEPRECATED: return "http://hl7.org/fhir/composition-status"; 3658 case UNKNOWN: return "http://hl7.org/fhir/composition-status"; 3659 case NULL: return null; 3660 default: return "?"; 3661 } 3662 } 3663 public String getDefinition() { 3664 switch (this) { 3665 case REGISTERED: return "The existence of the composition is registered, but there is nothing yet available."; 3666 case PARTIAL: return "This is a partial (e.g. initial, interim or preliminary) composition: data in the composition may be incomplete or unverified."; 3667 case PRELIMINARY: return "Verified early results are available, but not all results are final."; 3668 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."; 3669 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."; 3670 case CORRECTED: return "Subsequent to being final, the composition content has been modified to correct an error in the composition or referenced results."; 3671 case APPENDED: return "Subsequent to being final, the composition content has been modified by adding new content. The existing content is unchanged."; 3672 case CANCELLED: return "The composition is unavailable because the measurement was not started or not completed (also sometimes called \"aborted\")."; 3673 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."; 3674 case DEPRECATED: return "This composition has been withdrawn or superseded and should no longer be used."; 3675 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."; 3676 case NULL: return null; 3677 default: return "?"; 3678 } 3679 } 3680 public String getDisplay() { 3681 switch (this) { 3682 case REGISTERED: return "Registered"; 3683 case PARTIAL: return "Partial"; 3684 case PRELIMINARY: return "Preliminary"; 3685 case FINAL: return "Final"; 3686 case AMENDED: return "Amended"; 3687 case CORRECTED: return "Corrected"; 3688 case APPENDED: return "Appended"; 3689 case CANCELLED: return "Cancelled"; 3690 case ENTEREDINERROR: return "Entered in Error"; 3691 case DEPRECATED: return "Deprecated"; 3692 case UNKNOWN: return "Unknown"; 3693 case NULL: return null; 3694 default: return "?"; 3695 } 3696 } 3697 } 3698 3699 public static class CompositionStatusEnumFactory implements EnumFactory<CompositionStatus> { 3700 public CompositionStatus fromCode(String codeString) throws IllegalArgumentException { 3701 if (codeString == null || "".equals(codeString)) 3702 if (codeString == null || "".equals(codeString)) 3703 return null; 3704 if ("registered".equals(codeString)) 3705 return CompositionStatus.REGISTERED; 3706 if ("partial".equals(codeString)) 3707 return CompositionStatus.PARTIAL; 3708 if ("preliminary".equals(codeString)) 3709 return CompositionStatus.PRELIMINARY; 3710 if ("final".equals(codeString)) 3711 return CompositionStatus.FINAL; 3712 if ("amended".equals(codeString)) 3713 return CompositionStatus.AMENDED; 3714 if ("corrected".equals(codeString)) 3715 return CompositionStatus.CORRECTED; 3716 if ("appended".equals(codeString)) 3717 return CompositionStatus.APPENDED; 3718 if ("cancelled".equals(codeString)) 3719 return CompositionStatus.CANCELLED; 3720 if ("entered-in-error".equals(codeString)) 3721 return CompositionStatus.ENTEREDINERROR; 3722 if ("deprecated".equals(codeString)) 3723 return CompositionStatus.DEPRECATED; 3724 if ("unknown".equals(codeString)) 3725 return CompositionStatus.UNKNOWN; 3726 throw new IllegalArgumentException("Unknown CompositionStatus code '"+codeString+"'"); 3727 } 3728 3729 public Enumeration<CompositionStatus> fromType(PrimitiveType<?> code) throws FHIRException { 3730 if (code == null) 3731 return null; 3732 if (code.isEmpty()) 3733 return new Enumeration<CompositionStatus>(this, CompositionStatus.NULL, code); 3734 String codeString = ((PrimitiveType) code).asStringValue(); 3735 if (codeString == null || "".equals(codeString)) 3736 return new Enumeration<CompositionStatus>(this, CompositionStatus.NULL, code); 3737 if ("registered".equals(codeString)) 3738 return new Enumeration<CompositionStatus>(this, CompositionStatus.REGISTERED, code); 3739 if ("partial".equals(codeString)) 3740 return new Enumeration<CompositionStatus>(this, CompositionStatus.PARTIAL, code); 3741 if ("preliminary".equals(codeString)) 3742 return new Enumeration<CompositionStatus>(this, CompositionStatus.PRELIMINARY, code); 3743 if ("final".equals(codeString)) 3744 return new Enumeration<CompositionStatus>(this, CompositionStatus.FINAL, code); 3745 if ("amended".equals(codeString)) 3746 return new Enumeration<CompositionStatus>(this, CompositionStatus.AMENDED, code); 3747 if ("corrected".equals(codeString)) 3748 return new Enumeration<CompositionStatus>(this, CompositionStatus.CORRECTED, code); 3749 if ("appended".equals(codeString)) 3750 return new Enumeration<CompositionStatus>(this, CompositionStatus.APPENDED, code); 3751 if ("cancelled".equals(codeString)) 3752 return new Enumeration<CompositionStatus>(this, CompositionStatus.CANCELLED, code); 3753 if ("entered-in-error".equals(codeString)) 3754 return new Enumeration<CompositionStatus>(this, CompositionStatus.ENTEREDINERROR, code); 3755 if ("deprecated".equals(codeString)) 3756 return new Enumeration<CompositionStatus>(this, CompositionStatus.DEPRECATED, code); 3757 if ("unknown".equals(codeString)) 3758 return new Enumeration<CompositionStatus>(this, CompositionStatus.UNKNOWN, code); 3759 throw new FHIRException("Unknown CompositionStatus code '"+codeString+"'"); 3760 } 3761 public String toCode(CompositionStatus code) { 3762 if (code == CompositionStatus.NULL) 3763 return null; 3764 if (code == CompositionStatus.REGISTERED) 3765 return "registered"; 3766 if (code == CompositionStatus.PARTIAL) 3767 return "partial"; 3768 if (code == CompositionStatus.PRELIMINARY) 3769 return "preliminary"; 3770 if (code == CompositionStatus.FINAL) 3771 return "final"; 3772 if (code == CompositionStatus.AMENDED) 3773 return "amended"; 3774 if (code == CompositionStatus.CORRECTED) 3775 return "corrected"; 3776 if (code == CompositionStatus.APPENDED) 3777 return "appended"; 3778 if (code == CompositionStatus.CANCELLED) 3779 return "cancelled"; 3780 if (code == CompositionStatus.ENTEREDINERROR) 3781 return "entered-in-error"; 3782 if (code == CompositionStatus.DEPRECATED) 3783 return "deprecated"; 3784 if (code == CompositionStatus.UNKNOWN) 3785 return "unknown"; 3786 return "?"; 3787 } 3788 public String toSystem(CompositionStatus code) { 3789 return code.getSystem(); 3790 } 3791 } 3792 3793 public enum ConceptMapRelationship { 3794 /** 3795 * The concepts are related to each other, but the exact relationship is not known. 3796 */ 3797 RELATEDTO, 3798 /** 3799 * The definitions of the concepts mean the same thing. 3800 */ 3801 EQUIVALENT, 3802 /** 3803 * The source concept is narrower in meaning than the target concept. 3804 */ 3805 SOURCEISNARROWERTHANTARGET, 3806 /** 3807 * The source concept is broader in meaning than the target concept. 3808 */ 3809 SOURCEISBROADERTHANTARGET, 3810 /** 3811 * This is an explicit assertion that the target concept is not related to the source concept. 3812 */ 3813 NOTRELATEDTO, 3814 /** 3815 * added to help the parsers 3816 */ 3817 NULL; 3818 public static ConceptMapRelationship fromCode(String codeString) throws FHIRException { 3819 if (codeString == null || "".equals(codeString)) 3820 return null; 3821 if ("related-to".equals(codeString)) 3822 return RELATEDTO; 3823 if ("equivalent".equals(codeString)) 3824 return EQUIVALENT; 3825 if ("source-is-narrower-than-target".equals(codeString)) 3826 return SOURCEISNARROWERTHANTARGET; 3827 if ("source-is-broader-than-target".equals(codeString)) 3828 return SOURCEISBROADERTHANTARGET; 3829 if ("not-related-to".equals(codeString)) 3830 return NOTRELATEDTO; 3831 throw new FHIRException("Unknown ConceptMapRelationship code '"+codeString+"'"); 3832 } 3833 public static boolean isValidCode(String codeString) { 3834 if (codeString == null || "".equals(codeString)) 3835 return false; 3836 return Utilities.existsInList(codeString, "related-to", "equivalent", "source-is-narrower-than-target", "source-is-broader-than-target", "not-related-to"); 3837 } 3838 public String toCode() { 3839 switch (this) { 3840 case RELATEDTO: return "related-to"; 3841 case EQUIVALENT: return "equivalent"; 3842 case SOURCEISNARROWERTHANTARGET: return "source-is-narrower-than-target"; 3843 case SOURCEISBROADERTHANTARGET: return "source-is-broader-than-target"; 3844 case NOTRELATEDTO: return "not-related-to"; 3845 case NULL: return null; 3846 default: return "?"; 3847 } 3848 } 3849 public String getSystem() { 3850 switch (this) { 3851 case RELATEDTO: return "http://hl7.org/fhir/concept-map-relationship"; 3852 case EQUIVALENT: return "http://hl7.org/fhir/concept-map-relationship"; 3853 case SOURCEISNARROWERTHANTARGET: return "http://hl7.org/fhir/concept-map-relationship"; 3854 case SOURCEISBROADERTHANTARGET: return "http://hl7.org/fhir/concept-map-relationship"; 3855 case NOTRELATEDTO: return "http://hl7.org/fhir/concept-map-relationship"; 3856 case NULL: return null; 3857 default: return "?"; 3858 } 3859 } 3860 public String getDefinition() { 3861 switch (this) { 3862 case RELATEDTO: return "The concepts are related to each other, but the exact relationship is not known."; 3863 case EQUIVALENT: return "The definitions of the concepts mean the same thing."; 3864 case SOURCEISNARROWERTHANTARGET: return "The source concept is narrower in meaning than the target concept."; 3865 case SOURCEISBROADERTHANTARGET: return "The source concept is broader in meaning than the target concept."; 3866 case NOTRELATEDTO: return "This is an explicit assertion that the target concept is not related to the source concept."; 3867 case NULL: return null; 3868 default: return "?"; 3869 } 3870 } 3871 public String getDisplay() { 3872 switch (this) { 3873 case RELATEDTO: return "Related To"; 3874 case EQUIVALENT: return "Equivalent"; 3875 case SOURCEISNARROWERTHANTARGET: return "Source Is Narrower Than Target"; 3876 case SOURCEISBROADERTHANTARGET: return "Source Is Broader Than Target"; 3877 case NOTRELATEDTO: return "Not Related To"; 3878 case NULL: return null; 3879 default: return "?"; 3880 } 3881 } 3882 public String getSymbol() { 3883 switch (this) { 3884 case RELATEDTO: return "-"; 3885 case EQUIVALENT: return "="; 3886 case SOURCEISNARROWERTHANTARGET: return "<"; 3887 case SOURCEISBROADERTHANTARGET: return ">"; 3888 case NOTRELATEDTO: return "!="; 3889 case NULL: return null; 3890 default: return "?"; 3891 } 3892 } 3893 } 3894 3895 public static class ConceptMapRelationshipEnumFactory implements EnumFactory<ConceptMapRelationship> { 3896 public ConceptMapRelationship fromCode(String codeString) throws IllegalArgumentException { 3897 if (codeString == null || "".equals(codeString)) 3898 if (codeString == null || "".equals(codeString)) 3899 return null; 3900 if ("related-to".equals(codeString)) 3901 return ConceptMapRelationship.RELATEDTO; 3902 if ("equivalent".equals(codeString)) 3903 return ConceptMapRelationship.EQUIVALENT; 3904 if ("source-is-narrower-than-target".equals(codeString)) 3905 return ConceptMapRelationship.SOURCEISNARROWERTHANTARGET; 3906 if ("source-is-broader-than-target".equals(codeString)) 3907 return ConceptMapRelationship.SOURCEISBROADERTHANTARGET; 3908 if ("not-related-to".equals(codeString)) 3909 return ConceptMapRelationship.NOTRELATEDTO; 3910 throw new IllegalArgumentException("Unknown ConceptMapRelationship code '"+codeString+"'"); 3911 } 3912 3913 public Enumeration<ConceptMapRelationship> fromType(PrimitiveType<?> code) throws FHIRException { 3914 if (code == null) 3915 return null; 3916 if (code.isEmpty()) 3917 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NULL, code); 3918 String codeString = ((PrimitiveType) code).asStringValue(); 3919 if (codeString == null || "".equals(codeString)) 3920 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NULL, code); 3921 if ("related-to".equals(codeString)) 3922 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.RELATEDTO, code); 3923 if ("equivalent".equals(codeString)) 3924 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.EQUIVALENT, code); 3925 if ("source-is-narrower-than-target".equals(codeString)) 3926 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.SOURCEISNARROWERTHANTARGET, code); 3927 if ("source-is-broader-than-target".equals(codeString)) 3928 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.SOURCEISBROADERTHANTARGET, code); 3929 if ("not-related-to".equals(codeString)) 3930 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NOTRELATEDTO, code); 3931 throw new FHIRException("Unknown ConceptMapRelationship code '"+codeString+"'"); 3932 } 3933 public String toCode(ConceptMapRelationship code) { 3934 if (code == ConceptMapRelationship.NULL) 3935 return null; 3936 if (code == ConceptMapRelationship.RELATEDTO) 3937 return "related-to"; 3938 if (code == ConceptMapRelationship.EQUIVALENT) 3939 return "equivalent"; 3940 if (code == ConceptMapRelationship.SOURCEISNARROWERTHANTARGET) 3941 return "source-is-narrower-than-target"; 3942 if (code == ConceptMapRelationship.SOURCEISBROADERTHANTARGET) 3943 return "source-is-broader-than-target"; 3944 if (code == ConceptMapRelationship.NOTRELATEDTO) 3945 return "not-related-to"; 3946 return "?"; 3947 } 3948 public String toSystem(ConceptMapRelationship code) { 3949 return code.getSystem(); 3950 } 3951 } 3952 3953 public enum ConsentDataMeaning { 3954 /** 3955 * The consent applies directly to the instance of the resource. 3956 */ 3957 INSTANCE, 3958 /** 3959 * The consent applies directly to the instance of the resource and instances it refers to. 3960 */ 3961 RELATED, 3962 /** 3963 * The consent applies directly to the instance of the resource and instances that refer to it. 3964 */ 3965 DEPENDENTS, 3966 /** 3967 * The consent applies to instances of resources that are authored by. 3968 */ 3969 AUTHOREDBY, 3970 /** 3971 * added to help the parsers 3972 */ 3973 NULL; 3974 public static ConsentDataMeaning fromCode(String codeString) throws FHIRException { 3975 if (codeString == null || "".equals(codeString)) 3976 return null; 3977 if ("instance".equals(codeString)) 3978 return INSTANCE; 3979 if ("related".equals(codeString)) 3980 return RELATED; 3981 if ("dependents".equals(codeString)) 3982 return DEPENDENTS; 3983 if ("authoredby".equals(codeString)) 3984 return AUTHOREDBY; 3985 throw new FHIRException("Unknown ConsentDataMeaning code '"+codeString+"'"); 3986 } 3987 public static boolean isValidCode(String codeString) { 3988 if (codeString == null || "".equals(codeString)) 3989 return false; 3990 return Utilities.existsInList(codeString, "instance", "related", "dependents", "authoredby"); 3991 } 3992 public String toCode() { 3993 switch (this) { 3994 case INSTANCE: return "instance"; 3995 case RELATED: return "related"; 3996 case DEPENDENTS: return "dependents"; 3997 case AUTHOREDBY: return "authoredby"; 3998 case NULL: return null; 3999 default: return "?"; 4000 } 4001 } 4002 public String getSystem() { 4003 switch (this) { 4004 case INSTANCE: return "http://hl7.org/fhir/consent-data-meaning"; 4005 case RELATED: return "http://hl7.org/fhir/consent-data-meaning"; 4006 case DEPENDENTS: return "http://hl7.org/fhir/consent-data-meaning"; 4007 case AUTHOREDBY: return "http://hl7.org/fhir/consent-data-meaning"; 4008 case NULL: return null; 4009 default: return "?"; 4010 } 4011 } 4012 public String getDefinition() { 4013 switch (this) { 4014 case INSTANCE: return "The consent applies directly to the instance of the resource."; 4015 case RELATED: return "The consent applies directly to the instance of the resource and instances it refers to."; 4016 case DEPENDENTS: return "The consent applies directly to the instance of the resource and instances that refer to it."; 4017 case AUTHOREDBY: return "The consent applies to instances of resources that are authored by."; 4018 case NULL: return null; 4019 default: return "?"; 4020 } 4021 } 4022 public String getDisplay() { 4023 switch (this) { 4024 case INSTANCE: return "Instance"; 4025 case RELATED: return "Related"; 4026 case DEPENDENTS: return "Dependents"; 4027 case AUTHOREDBY: return "AuthoredBy"; 4028 case NULL: return null; 4029 default: return "?"; 4030 } 4031 } 4032 } 4033 4034 public static class ConsentDataMeaningEnumFactory implements EnumFactory<ConsentDataMeaning> { 4035 public ConsentDataMeaning fromCode(String codeString) throws IllegalArgumentException { 4036 if (codeString == null || "".equals(codeString)) 4037 if (codeString == null || "".equals(codeString)) 4038 return null; 4039 if ("instance".equals(codeString)) 4040 return ConsentDataMeaning.INSTANCE; 4041 if ("related".equals(codeString)) 4042 return ConsentDataMeaning.RELATED; 4043 if ("dependents".equals(codeString)) 4044 return ConsentDataMeaning.DEPENDENTS; 4045 if ("authoredby".equals(codeString)) 4046 return ConsentDataMeaning.AUTHOREDBY; 4047 throw new IllegalArgumentException("Unknown ConsentDataMeaning code '"+codeString+"'"); 4048 } 4049 4050 public Enumeration<ConsentDataMeaning> fromType(PrimitiveType<?> code) throws FHIRException { 4051 if (code == null) 4052 return null; 4053 if (code.isEmpty()) 4054 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.NULL, code); 4055 String codeString = ((PrimitiveType) code).asStringValue(); 4056 if (codeString == null || "".equals(codeString)) 4057 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.NULL, code); 4058 if ("instance".equals(codeString)) 4059 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.INSTANCE, code); 4060 if ("related".equals(codeString)) 4061 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.RELATED, code); 4062 if ("dependents".equals(codeString)) 4063 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.DEPENDENTS, code); 4064 if ("authoredby".equals(codeString)) 4065 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.AUTHOREDBY, code); 4066 throw new FHIRException("Unknown ConsentDataMeaning code '"+codeString+"'"); 4067 } 4068 public String toCode(ConsentDataMeaning code) { 4069 if (code == ConsentDataMeaning.NULL) 4070 return null; 4071 if (code == ConsentDataMeaning.INSTANCE) 4072 return "instance"; 4073 if (code == ConsentDataMeaning.RELATED) 4074 return "related"; 4075 if (code == ConsentDataMeaning.DEPENDENTS) 4076 return "dependents"; 4077 if (code == ConsentDataMeaning.AUTHOREDBY) 4078 return "authoredby"; 4079 return "?"; 4080 } 4081 public String toSystem(ConsentDataMeaning code) { 4082 return code.getSystem(); 4083 } 4084 } 4085 4086 public enum ConsentProvisionType { 4087 /** 4088 * Consent is denied for actions meeting these rules. 4089 */ 4090 DENY, 4091 /** 4092 * Consent is provided for actions meeting these rules. 4093 */ 4094 PERMIT, 4095 /** 4096 * added to help the parsers 4097 */ 4098 NULL; 4099 public static ConsentProvisionType fromCode(String codeString) throws FHIRException { 4100 if (codeString == null || "".equals(codeString)) 4101 return null; 4102 if ("deny".equals(codeString)) 4103 return DENY; 4104 if ("permit".equals(codeString)) 4105 return PERMIT; 4106 throw new FHIRException("Unknown ConsentProvisionType code '"+codeString+"'"); 4107 } 4108 public static boolean isValidCode(String codeString) { 4109 if (codeString == null || "".equals(codeString)) 4110 return false; 4111 return Utilities.existsInList(codeString, "deny", "permit"); 4112 } 4113 public String toCode() { 4114 switch (this) { 4115 case DENY: return "deny"; 4116 case PERMIT: return "permit"; 4117 case NULL: return null; 4118 default: return "?"; 4119 } 4120 } 4121 public String getSystem() { 4122 switch (this) { 4123 case DENY: return "http://hl7.org/fhir/consent-provision-type"; 4124 case PERMIT: return "http://hl7.org/fhir/consent-provision-type"; 4125 case NULL: return null; 4126 default: return "?"; 4127 } 4128 } 4129 public String getDefinition() { 4130 switch (this) { 4131 case DENY: return "Consent is denied for actions meeting these rules."; 4132 case PERMIT: return "Consent is provided for actions meeting these rules."; 4133 case NULL: return null; 4134 default: return "?"; 4135 } 4136 } 4137 public String getDisplay() { 4138 switch (this) { 4139 case DENY: return "Deny"; 4140 case PERMIT: return "Permit"; 4141 case NULL: return null; 4142 default: return "?"; 4143 } 4144 } 4145 } 4146 4147 public static class ConsentProvisionTypeEnumFactory implements EnumFactory<ConsentProvisionType> { 4148 public ConsentProvisionType fromCode(String codeString) throws IllegalArgumentException { 4149 if (codeString == null || "".equals(codeString)) 4150 if (codeString == null || "".equals(codeString)) 4151 return null; 4152 if ("deny".equals(codeString)) 4153 return ConsentProvisionType.DENY; 4154 if ("permit".equals(codeString)) 4155 return ConsentProvisionType.PERMIT; 4156 throw new IllegalArgumentException("Unknown ConsentProvisionType code '"+codeString+"'"); 4157 } 4158 4159 public Enumeration<ConsentProvisionType> fromType(PrimitiveType<?> code) throws FHIRException { 4160 if (code == null) 4161 return null; 4162 if (code.isEmpty()) 4163 return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.NULL, code); 4164 String codeString = ((PrimitiveType) code).asStringValue(); 4165 if (codeString == null || "".equals(codeString)) 4166 return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.NULL, code); 4167 if ("deny".equals(codeString)) 4168 return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.DENY, code); 4169 if ("permit".equals(codeString)) 4170 return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.PERMIT, code); 4171 throw new FHIRException("Unknown ConsentProvisionType code '"+codeString+"'"); 4172 } 4173 public String toCode(ConsentProvisionType code) { 4174 if (code == ConsentProvisionType.NULL) 4175 return null; 4176 if (code == ConsentProvisionType.DENY) 4177 return "deny"; 4178 if (code == ConsentProvisionType.PERMIT) 4179 return "permit"; 4180 return "?"; 4181 } 4182 public String toSystem(ConsentProvisionType code) { 4183 return code.getSystem(); 4184 } 4185 } 4186 4187 public enum Currencies { 4188 /** 4189 * null 4190 */ 4191 AED, 4192 /** 4193 * null 4194 */ 4195 AFN, 4196 /** 4197 * null 4198 */ 4199 ALL, 4200 /** 4201 * null 4202 */ 4203 AMD, 4204 /** 4205 * null 4206 */ 4207 ANG, 4208 /** 4209 * null 4210 */ 4211 AOA, 4212 /** 4213 * null 4214 */ 4215 ARS, 4216 /** 4217 * null 4218 */ 4219 AUD, 4220 /** 4221 * null 4222 */ 4223 AWG, 4224 /** 4225 * null 4226 */ 4227 AZN, 4228 /** 4229 * null 4230 */ 4231 BAM, 4232 /** 4233 * null 4234 */ 4235 BBD, 4236 /** 4237 * null 4238 */ 4239 BDT, 4240 /** 4241 * null 4242 */ 4243 BGN, 4244 /** 4245 * null 4246 */ 4247 BHD, 4248 /** 4249 * null 4250 */ 4251 BIF, 4252 /** 4253 * null 4254 */ 4255 BMD, 4256 /** 4257 * null 4258 */ 4259 BND, 4260 /** 4261 * null 4262 */ 4263 BOB, 4264 /** 4265 * null 4266 */ 4267 BOV, 4268 /** 4269 * null 4270 */ 4271 BRL, 4272 /** 4273 * null 4274 */ 4275 BSD, 4276 /** 4277 * null 4278 */ 4279 BTN, 4280 /** 4281 * null 4282 */ 4283 BWP, 4284 /** 4285 * null 4286 */ 4287 BYN, 4288 /** 4289 * null 4290 */ 4291 BZD, 4292 /** 4293 * null 4294 */ 4295 CAD, 4296 /** 4297 * null 4298 */ 4299 CDF, 4300 /** 4301 * null 4302 */ 4303 CHE, 4304 /** 4305 * null 4306 */ 4307 CHF, 4308 /** 4309 * null 4310 */ 4311 CHW, 4312 /** 4313 * null 4314 */ 4315 CLF, 4316 /** 4317 * null 4318 */ 4319 CLP, 4320 /** 4321 * null 4322 */ 4323 CNY, 4324 /** 4325 * null 4326 */ 4327 COP, 4328 /** 4329 * null 4330 */ 4331 COU, 4332 /** 4333 * null 4334 */ 4335 CRC, 4336 /** 4337 * null 4338 */ 4339 CUC, 4340 /** 4341 * null 4342 */ 4343 CUP, 4344 /** 4345 * null 4346 */ 4347 CVE, 4348 /** 4349 * null 4350 */ 4351 CZK, 4352 /** 4353 * null 4354 */ 4355 DJF, 4356 /** 4357 * null 4358 */ 4359 DKK, 4360 /** 4361 * null 4362 */ 4363 DOP, 4364 /** 4365 * null 4366 */ 4367 DZD, 4368 /** 4369 * null 4370 */ 4371 EGP, 4372 /** 4373 * null 4374 */ 4375 ERN, 4376 /** 4377 * null 4378 */ 4379 ETB, 4380 /** 4381 * null 4382 */ 4383 EUR, 4384 /** 4385 * null 4386 */ 4387 FJD, 4388 /** 4389 * null 4390 */ 4391 FKP, 4392 /** 4393 * null 4394 */ 4395 GBP, 4396 /** 4397 * null 4398 */ 4399 GEL, 4400 /** 4401 * null 4402 */ 4403 GGP, 4404 /** 4405 * null 4406 */ 4407 GHS, 4408 /** 4409 * null 4410 */ 4411 GIP, 4412 /** 4413 * null 4414 */ 4415 GMD, 4416 /** 4417 * null 4418 */ 4419 GNF, 4420 /** 4421 * null 4422 */ 4423 GTQ, 4424 /** 4425 * null 4426 */ 4427 GYD, 4428 /** 4429 * null 4430 */ 4431 HKD, 4432 /** 4433 * null 4434 */ 4435 HNL, 4436 /** 4437 * null 4438 */ 4439 HRK, 4440 /** 4441 * null 4442 */ 4443 HTG, 4444 /** 4445 * null 4446 */ 4447 HUF, 4448 /** 4449 * null 4450 */ 4451 IDR, 4452 /** 4453 * null 4454 */ 4455 ILS, 4456 /** 4457 * null 4458 */ 4459 IMP, 4460 /** 4461 * null 4462 */ 4463 INR, 4464 /** 4465 * null 4466 */ 4467 IQD, 4468 /** 4469 * null 4470 */ 4471 IRR, 4472 /** 4473 * null 4474 */ 4475 ISK, 4476 /** 4477 * null 4478 */ 4479 JEP, 4480 /** 4481 * null 4482 */ 4483 JMD, 4484 /** 4485 * null 4486 */ 4487 JOD, 4488 /** 4489 * null 4490 */ 4491 JPY, 4492 /** 4493 * null 4494 */ 4495 KES, 4496 /** 4497 * null 4498 */ 4499 KGS, 4500 /** 4501 * null 4502 */ 4503 KHR, 4504 /** 4505 * null 4506 */ 4507 KMF, 4508 /** 4509 * null 4510 */ 4511 KPW, 4512 /** 4513 * null 4514 */ 4515 KRW, 4516 /** 4517 * null 4518 */ 4519 KWD, 4520 /** 4521 * null 4522 */ 4523 KYD, 4524 /** 4525 * null 4526 */ 4527 KZT, 4528 /** 4529 * null 4530 */ 4531 LAK, 4532 /** 4533 * null 4534 */ 4535 LBP, 4536 /** 4537 * null 4538 */ 4539 LKR, 4540 /** 4541 * null 4542 */ 4543 LRD, 4544 /** 4545 * null 4546 */ 4547 LSL, 4548 /** 4549 * null 4550 */ 4551 LYD, 4552 /** 4553 * null 4554 */ 4555 MAD, 4556 /** 4557 * null 4558 */ 4559 MDL, 4560 /** 4561 * null 4562 */ 4563 MGA, 4564 /** 4565 * null 4566 */ 4567 MKD, 4568 /** 4569 * null 4570 */ 4571 MMK, 4572 /** 4573 * null 4574 */ 4575 MNT, 4576 /** 4577 * null 4578 */ 4579 MOP, 4580 /** 4581 * null 4582 */ 4583 MRU, 4584 /** 4585 * null 4586 */ 4587 MUR, 4588 /** 4589 * null 4590 */ 4591 MVR, 4592 /** 4593 * null 4594 */ 4595 MWK, 4596 /** 4597 * null 4598 */ 4599 MXN, 4600 /** 4601 * null 4602 */ 4603 MXV, 4604 /** 4605 * null 4606 */ 4607 MYR, 4608 /** 4609 * null 4610 */ 4611 MZN, 4612 /** 4613 * null 4614 */ 4615 NAD, 4616 /** 4617 * null 4618 */ 4619 NGN, 4620 /** 4621 * null 4622 */ 4623 NIO, 4624 /** 4625 * null 4626 */ 4627 NOK, 4628 /** 4629 * null 4630 */ 4631 NPR, 4632 /** 4633 * null 4634 */ 4635 NZD, 4636 /** 4637 * null 4638 */ 4639 OMR, 4640 /** 4641 * null 4642 */ 4643 PAB, 4644 /** 4645 * null 4646 */ 4647 PEN, 4648 /** 4649 * null 4650 */ 4651 PGK, 4652 /** 4653 * null 4654 */ 4655 PHP, 4656 /** 4657 * null 4658 */ 4659 PKR, 4660 /** 4661 * null 4662 */ 4663 PLN, 4664 /** 4665 * null 4666 */ 4667 PYG, 4668 /** 4669 * null 4670 */ 4671 QAR, 4672 /** 4673 * null 4674 */ 4675 RON, 4676 /** 4677 * null 4678 */ 4679 RSD, 4680 /** 4681 * null 4682 */ 4683 RUB, 4684 /** 4685 * null 4686 */ 4687 RWF, 4688 /** 4689 * null 4690 */ 4691 SAR, 4692 /** 4693 * null 4694 */ 4695 SBD, 4696 /** 4697 * null 4698 */ 4699 SCR, 4700 /** 4701 * null 4702 */ 4703 SDG, 4704 /** 4705 * null 4706 */ 4707 SEK, 4708 /** 4709 * null 4710 */ 4711 SGD, 4712 /** 4713 * null 4714 */ 4715 SHP, 4716 /** 4717 * null 4718 */ 4719 SLL, 4720 /** 4721 * null 4722 */ 4723 SOS, 4724 /** 4725 * null 4726 */ 4727 SRD, 4728 /** 4729 * null 4730 */ 4731 SSP, 4732 /** 4733 * null 4734 */ 4735 STN, 4736 /** 4737 * null 4738 */ 4739 SVC, 4740 /** 4741 * null 4742 */ 4743 SYP, 4744 /** 4745 * null 4746 */ 4747 SZL, 4748 /** 4749 * null 4750 */ 4751 THB, 4752 /** 4753 * null 4754 */ 4755 TJS, 4756 /** 4757 * null 4758 */ 4759 TMT, 4760 /** 4761 * null 4762 */ 4763 TND, 4764 /** 4765 * null 4766 */ 4767 TOP, 4768 /** 4769 * null 4770 */ 4771 TRY, 4772 /** 4773 * null 4774 */ 4775 TTD, 4776 /** 4777 * null 4778 */ 4779 TVD, 4780 /** 4781 * null 4782 */ 4783 TWD, 4784 /** 4785 * null 4786 */ 4787 TZS, 4788 /** 4789 * null 4790 */ 4791 UAH, 4792 /** 4793 * null 4794 */ 4795 UGX, 4796 /** 4797 * null 4798 */ 4799 USD, 4800 /** 4801 * null 4802 */ 4803 USN, 4804 /** 4805 * null 4806 */ 4807 UYI, 4808 /** 4809 * null 4810 */ 4811 UYU, 4812 /** 4813 * null 4814 */ 4815 UZS, 4816 /** 4817 * null 4818 */ 4819 VEF, 4820 /** 4821 * null 4822 */ 4823 VND, 4824 /** 4825 * null 4826 */ 4827 VUV, 4828 /** 4829 * null 4830 */ 4831 WST, 4832 /** 4833 * null 4834 */ 4835 XAF, 4836 /** 4837 * null 4838 */ 4839 XAG, 4840 /** 4841 * null 4842 */ 4843 XAU, 4844 /** 4845 * null 4846 */ 4847 XBA, 4848 /** 4849 * null 4850 */ 4851 XBB, 4852 /** 4853 * null 4854 */ 4855 XBC, 4856 /** 4857 * null 4858 */ 4859 XBD, 4860 /** 4861 * null 4862 */ 4863 XCD, 4864 /** 4865 * null 4866 */ 4867 XDR, 4868 /** 4869 * null 4870 */ 4871 XOF, 4872 /** 4873 * null 4874 */ 4875 XPD, 4876 /** 4877 * null 4878 */ 4879 XPF, 4880 /** 4881 * null 4882 */ 4883 XPT, 4884 /** 4885 * null 4886 */ 4887 XSU, 4888 /** 4889 * null 4890 */ 4891 XTS, 4892 /** 4893 * null 4894 */ 4895 XUA, 4896 /** 4897 * null 4898 */ 4899 XXX, 4900 /** 4901 * null 4902 */ 4903 YER, 4904 /** 4905 * null 4906 */ 4907 ZAR, 4908 /** 4909 * null 4910 */ 4911 ZMW, 4912 /** 4913 * null 4914 */ 4915 ZWL, 4916 /** 4917 * added to help the parsers 4918 */ 4919 NULL; 4920 public static Currencies fromCode(String codeString) throws FHIRException { 4921 if (codeString == null || "".equals(codeString)) 4922 return null; 4923 if ("AED".equals(codeString)) 4924 return AED; 4925 if ("AFN".equals(codeString)) 4926 return AFN; 4927 if ("ALL".equals(codeString)) 4928 return ALL; 4929 if ("AMD".equals(codeString)) 4930 return AMD; 4931 if ("ANG".equals(codeString)) 4932 return ANG; 4933 if ("AOA".equals(codeString)) 4934 return AOA; 4935 if ("ARS".equals(codeString)) 4936 return ARS; 4937 if ("AUD".equals(codeString)) 4938 return AUD; 4939 if ("AWG".equals(codeString)) 4940 return AWG; 4941 if ("AZN".equals(codeString)) 4942 return AZN; 4943 if ("BAM".equals(codeString)) 4944 return BAM; 4945 if ("BBD".equals(codeString)) 4946 return BBD; 4947 if ("BDT".equals(codeString)) 4948 return BDT; 4949 if ("BGN".equals(codeString)) 4950 return BGN; 4951 if ("BHD".equals(codeString)) 4952 return BHD; 4953 if ("BIF".equals(codeString)) 4954 return BIF; 4955 if ("BMD".equals(codeString)) 4956 return BMD; 4957 if ("BND".equals(codeString)) 4958 return BND; 4959 if ("BOB".equals(codeString)) 4960 return BOB; 4961 if ("BOV".equals(codeString)) 4962 return BOV; 4963 if ("BRL".equals(codeString)) 4964 return BRL; 4965 if ("BSD".equals(codeString)) 4966 return BSD; 4967 if ("BTN".equals(codeString)) 4968 return BTN; 4969 if ("BWP".equals(codeString)) 4970 return BWP; 4971 if ("BYN".equals(codeString)) 4972 return BYN; 4973 if ("BZD".equals(codeString)) 4974 return BZD; 4975 if ("CAD".equals(codeString)) 4976 return CAD; 4977 if ("CDF".equals(codeString)) 4978 return CDF; 4979 if ("CHE".equals(codeString)) 4980 return CHE; 4981 if ("CHF".equals(codeString)) 4982 return CHF; 4983 if ("CHW".equals(codeString)) 4984 return CHW; 4985 if ("CLF".equals(codeString)) 4986 return CLF; 4987 if ("CLP".equals(codeString)) 4988 return CLP; 4989 if ("CNY".equals(codeString)) 4990 return CNY; 4991 if ("COP".equals(codeString)) 4992 return COP; 4993 if ("COU".equals(codeString)) 4994 return COU; 4995 if ("CRC".equals(codeString)) 4996 return CRC; 4997 if ("CUC".equals(codeString)) 4998 return CUC; 4999 if ("CUP".equals(codeString)) 5000 return CUP; 5001 if ("CVE".equals(codeString)) 5002 return CVE; 5003 if ("CZK".equals(codeString)) 5004 return CZK; 5005 if ("DJF".equals(codeString)) 5006 return DJF; 5007 if ("DKK".equals(codeString)) 5008 return DKK; 5009 if ("DOP".equals(codeString)) 5010 return DOP; 5011 if ("DZD".equals(codeString)) 5012 return DZD; 5013 if ("EGP".equals(codeString)) 5014 return EGP; 5015 if ("ERN".equals(codeString)) 5016 return ERN; 5017 if ("ETB".equals(codeString)) 5018 return ETB; 5019 if ("EUR".equals(codeString)) 5020 return EUR; 5021 if ("FJD".equals(codeString)) 5022 return FJD; 5023 if ("FKP".equals(codeString)) 5024 return FKP; 5025 if ("GBP".equals(codeString)) 5026 return GBP; 5027 if ("GEL".equals(codeString)) 5028 return GEL; 5029 if ("GGP".equals(codeString)) 5030 return GGP; 5031 if ("GHS".equals(codeString)) 5032 return GHS; 5033 if ("GIP".equals(codeString)) 5034 return GIP; 5035 if ("GMD".equals(codeString)) 5036 return GMD; 5037 if ("GNF".equals(codeString)) 5038 return GNF; 5039 if ("GTQ".equals(codeString)) 5040 return GTQ; 5041 if ("GYD".equals(codeString)) 5042 return GYD; 5043 if ("HKD".equals(codeString)) 5044 return HKD; 5045 if ("HNL".equals(codeString)) 5046 return HNL; 5047 if ("HRK".equals(codeString)) 5048 return HRK; 5049 if ("HTG".equals(codeString)) 5050 return HTG; 5051 if ("HUF".equals(codeString)) 5052 return HUF; 5053 if ("IDR".equals(codeString)) 5054 return IDR; 5055 if ("ILS".equals(codeString)) 5056 return ILS; 5057 if ("IMP".equals(codeString)) 5058 return IMP; 5059 if ("INR".equals(codeString)) 5060 return INR; 5061 if ("IQD".equals(codeString)) 5062 return IQD; 5063 if ("IRR".equals(codeString)) 5064 return IRR; 5065 if ("ISK".equals(codeString)) 5066 return ISK; 5067 if ("JEP".equals(codeString)) 5068 return JEP; 5069 if ("JMD".equals(codeString)) 5070 return JMD; 5071 if ("JOD".equals(codeString)) 5072 return JOD; 5073 if ("JPY".equals(codeString)) 5074 return JPY; 5075 if ("KES".equals(codeString)) 5076 return KES; 5077 if ("KGS".equals(codeString)) 5078 return KGS; 5079 if ("KHR".equals(codeString)) 5080 return KHR; 5081 if ("KMF".equals(codeString)) 5082 return KMF; 5083 if ("KPW".equals(codeString)) 5084 return KPW; 5085 if ("KRW".equals(codeString)) 5086 return KRW; 5087 if ("KWD".equals(codeString)) 5088 return KWD; 5089 if ("KYD".equals(codeString)) 5090 return KYD; 5091 if ("KZT".equals(codeString)) 5092 return KZT; 5093 if ("LAK".equals(codeString)) 5094 return LAK; 5095 if ("LBP".equals(codeString)) 5096 return LBP; 5097 if ("LKR".equals(codeString)) 5098 return LKR; 5099 if ("LRD".equals(codeString)) 5100 return LRD; 5101 if ("LSL".equals(codeString)) 5102 return LSL; 5103 if ("LYD".equals(codeString)) 5104 return LYD; 5105 if ("MAD".equals(codeString)) 5106 return MAD; 5107 if ("MDL".equals(codeString)) 5108 return MDL; 5109 if ("MGA".equals(codeString)) 5110 return MGA; 5111 if ("MKD".equals(codeString)) 5112 return MKD; 5113 if ("MMK".equals(codeString)) 5114 return MMK; 5115 if ("MNT".equals(codeString)) 5116 return MNT; 5117 if ("MOP".equals(codeString)) 5118 return MOP; 5119 if ("MRU".equals(codeString)) 5120 return MRU; 5121 if ("MUR".equals(codeString)) 5122 return MUR; 5123 if ("MVR".equals(codeString)) 5124 return MVR; 5125 if ("MWK".equals(codeString)) 5126 return MWK; 5127 if ("MXN".equals(codeString)) 5128 return MXN; 5129 if ("MXV".equals(codeString)) 5130 return MXV; 5131 if ("MYR".equals(codeString)) 5132 return MYR; 5133 if ("MZN".equals(codeString)) 5134 return MZN; 5135 if ("NAD".equals(codeString)) 5136 return NAD; 5137 if ("NGN".equals(codeString)) 5138 return NGN; 5139 if ("NIO".equals(codeString)) 5140 return NIO; 5141 if ("NOK".equals(codeString)) 5142 return NOK; 5143 if ("NPR".equals(codeString)) 5144 return NPR; 5145 if ("NZD".equals(codeString)) 5146 return NZD; 5147 if ("OMR".equals(codeString)) 5148 return OMR; 5149 if ("PAB".equals(codeString)) 5150 return PAB; 5151 if ("PEN".equals(codeString)) 5152 return PEN; 5153 if ("PGK".equals(codeString)) 5154 return PGK; 5155 if ("PHP".equals(codeString)) 5156 return PHP; 5157 if ("PKR".equals(codeString)) 5158 return PKR; 5159 if ("PLN".equals(codeString)) 5160 return PLN; 5161 if ("PYG".equals(codeString)) 5162 return PYG; 5163 if ("QAR".equals(codeString)) 5164 return QAR; 5165 if ("RON".equals(codeString)) 5166 return RON; 5167 if ("RSD".equals(codeString)) 5168 return RSD; 5169 if ("RUB".equals(codeString)) 5170 return RUB; 5171 if ("RWF".equals(codeString)) 5172 return RWF; 5173 if ("SAR".equals(codeString)) 5174 return SAR; 5175 if ("SBD".equals(codeString)) 5176 return SBD; 5177 if ("SCR".equals(codeString)) 5178 return SCR; 5179 if ("SDG".equals(codeString)) 5180 return SDG; 5181 if ("SEK".equals(codeString)) 5182 return SEK; 5183 if ("SGD".equals(codeString)) 5184 return SGD; 5185 if ("SHP".equals(codeString)) 5186 return SHP; 5187 if ("SLL".equals(codeString)) 5188 return SLL; 5189 if ("SOS".equals(codeString)) 5190 return SOS; 5191 if ("SRD".equals(codeString)) 5192 return SRD; 5193 if ("SSP".equals(codeString)) 5194 return SSP; 5195 if ("STN".equals(codeString)) 5196 return STN; 5197 if ("SVC".equals(codeString)) 5198 return SVC; 5199 if ("SYP".equals(codeString)) 5200 return SYP; 5201 if ("SZL".equals(codeString)) 5202 return SZL; 5203 if ("THB".equals(codeString)) 5204 return THB; 5205 if ("TJS".equals(codeString)) 5206 return TJS; 5207 if ("TMT".equals(codeString)) 5208 return TMT; 5209 if ("TND".equals(codeString)) 5210 return TND; 5211 if ("TOP".equals(codeString)) 5212 return TOP; 5213 if ("TRY".equals(codeString)) 5214 return TRY; 5215 if ("TTD".equals(codeString)) 5216 return TTD; 5217 if ("TVD".equals(codeString)) 5218 return TVD; 5219 if ("TWD".equals(codeString)) 5220 return TWD; 5221 if ("TZS".equals(codeString)) 5222 return TZS; 5223 if ("UAH".equals(codeString)) 5224 return UAH; 5225 if ("UGX".equals(codeString)) 5226 return UGX; 5227 if ("USD".equals(codeString)) 5228 return USD; 5229 if ("USN".equals(codeString)) 5230 return USN; 5231 if ("UYI".equals(codeString)) 5232 return UYI; 5233 if ("UYU".equals(codeString)) 5234 return UYU; 5235 if ("UZS".equals(codeString)) 5236 return UZS; 5237 if ("VEF".equals(codeString)) 5238 return VEF; 5239 if ("VND".equals(codeString)) 5240 return VND; 5241 if ("VUV".equals(codeString)) 5242 return VUV; 5243 if ("WST".equals(codeString)) 5244 return WST; 5245 if ("XAF".equals(codeString)) 5246 return XAF; 5247 if ("XAG".equals(codeString)) 5248 return XAG; 5249 if ("XAU".equals(codeString)) 5250 return XAU; 5251 if ("XBA".equals(codeString)) 5252 return XBA; 5253 if ("XBB".equals(codeString)) 5254 return XBB; 5255 if ("XBC".equals(codeString)) 5256 return XBC; 5257 if ("XBD".equals(codeString)) 5258 return XBD; 5259 if ("XCD".equals(codeString)) 5260 return XCD; 5261 if ("XDR".equals(codeString)) 5262 return XDR; 5263 if ("XOF".equals(codeString)) 5264 return XOF; 5265 if ("XPD".equals(codeString)) 5266 return XPD; 5267 if ("XPF".equals(codeString)) 5268 return XPF; 5269 if ("XPT".equals(codeString)) 5270 return XPT; 5271 if ("XSU".equals(codeString)) 5272 return XSU; 5273 if ("XTS".equals(codeString)) 5274 return XTS; 5275 if ("XUA".equals(codeString)) 5276 return XUA; 5277 if ("XXX".equals(codeString)) 5278 return XXX; 5279 if ("YER".equals(codeString)) 5280 return YER; 5281 if ("ZAR".equals(codeString)) 5282 return ZAR; 5283 if ("ZMW".equals(codeString)) 5284 return ZMW; 5285 if ("ZWL".equals(codeString)) 5286 return ZWL; 5287 throw new FHIRException("Unknown Currencies code '"+codeString+"'"); 5288 } 5289 public static boolean isValidCode(String codeString) { 5290 if (codeString == null || "".equals(codeString)) 5291 return false; 5292 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"); 5293 } 5294 public String toCode() { 5295 switch (this) { 5296 case AED: return "AED"; 5297 case AFN: return "AFN"; 5298 case ALL: return "ALL"; 5299 case AMD: return "AMD"; 5300 case ANG: return "ANG"; 5301 case AOA: return "AOA"; 5302 case ARS: return "ARS"; 5303 case AUD: return "AUD"; 5304 case AWG: return "AWG"; 5305 case AZN: return "AZN"; 5306 case BAM: return "BAM"; 5307 case BBD: return "BBD"; 5308 case BDT: return "BDT"; 5309 case BGN: return "BGN"; 5310 case BHD: return "BHD"; 5311 case BIF: return "BIF"; 5312 case BMD: return "BMD"; 5313 case BND: return "BND"; 5314 case BOB: return "BOB"; 5315 case BOV: return "BOV"; 5316 case BRL: return "BRL"; 5317 case BSD: return "BSD"; 5318 case BTN: return "BTN"; 5319 case BWP: return "BWP"; 5320 case BYN: return "BYN"; 5321 case BZD: return "BZD"; 5322 case CAD: return "CAD"; 5323 case CDF: return "CDF"; 5324 case CHE: return "CHE"; 5325 case CHF: return "CHF"; 5326 case CHW: return "CHW"; 5327 case CLF: return "CLF"; 5328 case CLP: return "CLP"; 5329 case CNY: return "CNY"; 5330 case COP: return "COP"; 5331 case COU: return "COU"; 5332 case CRC: return "CRC"; 5333 case CUC: return "CUC"; 5334 case CUP: return "CUP"; 5335 case CVE: return "CVE"; 5336 case CZK: return "CZK"; 5337 case DJF: return "DJF"; 5338 case DKK: return "DKK"; 5339 case DOP: return "DOP"; 5340 case DZD: return "DZD"; 5341 case EGP: return "EGP"; 5342 case ERN: return "ERN"; 5343 case ETB: return "ETB"; 5344 case EUR: return "EUR"; 5345 case FJD: return "FJD"; 5346 case FKP: return "FKP"; 5347 case GBP: return "GBP"; 5348 case GEL: return "GEL"; 5349 case GGP: return "GGP"; 5350 case GHS: return "GHS"; 5351 case GIP: return "GIP"; 5352 case GMD: return "GMD"; 5353 case GNF: return "GNF"; 5354 case GTQ: return "GTQ"; 5355 case GYD: return "GYD"; 5356 case HKD: return "HKD"; 5357 case HNL: return "HNL"; 5358 case HRK: return "HRK"; 5359 case HTG: return "HTG"; 5360 case HUF: return "HUF"; 5361 case IDR: return "IDR"; 5362 case ILS: return "ILS"; 5363 case IMP: return "IMP"; 5364 case INR: return "INR"; 5365 case IQD: return "IQD"; 5366 case IRR: return "IRR"; 5367 case ISK: return "ISK"; 5368 case JEP: return "JEP"; 5369 case JMD: return "JMD"; 5370 case JOD: return "JOD"; 5371 case JPY: return "JPY"; 5372 case KES: return "KES"; 5373 case KGS: return "KGS"; 5374 case KHR: return "KHR"; 5375 case KMF: return "KMF"; 5376 case KPW: return "KPW"; 5377 case KRW: return "KRW"; 5378 case KWD: return "KWD"; 5379 case KYD: return "KYD"; 5380 case KZT: return "KZT"; 5381 case LAK: return "LAK"; 5382 case LBP: return "LBP"; 5383 case LKR: return "LKR"; 5384 case LRD: return "LRD"; 5385 case LSL: return "LSL"; 5386 case LYD: return "LYD"; 5387 case MAD: return "MAD"; 5388 case MDL: return "MDL"; 5389 case MGA: return "MGA"; 5390 case MKD: return "MKD"; 5391 case MMK: return "MMK"; 5392 case MNT: return "MNT"; 5393 case MOP: return "MOP"; 5394 case MRU: return "MRU"; 5395 case MUR: return "MUR"; 5396 case MVR: return "MVR"; 5397 case MWK: return "MWK"; 5398 case MXN: return "MXN"; 5399 case MXV: return "MXV"; 5400 case MYR: return "MYR"; 5401 case MZN: return "MZN"; 5402 case NAD: return "NAD"; 5403 case NGN: return "NGN"; 5404 case NIO: return "NIO"; 5405 case NOK: return "NOK"; 5406 case NPR: return "NPR"; 5407 case NZD: return "NZD"; 5408 case OMR: return "OMR"; 5409 case PAB: return "PAB"; 5410 case PEN: return "PEN"; 5411 case PGK: return "PGK"; 5412 case PHP: return "PHP"; 5413 case PKR: return "PKR"; 5414 case PLN: return "PLN"; 5415 case PYG: return "PYG"; 5416 case QAR: return "QAR"; 5417 case RON: return "RON"; 5418 case RSD: return "RSD"; 5419 case RUB: return "RUB"; 5420 case RWF: return "RWF"; 5421 case SAR: return "SAR"; 5422 case SBD: return "SBD"; 5423 case SCR: return "SCR"; 5424 case SDG: return "SDG"; 5425 case SEK: return "SEK"; 5426 case SGD: return "SGD"; 5427 case SHP: return "SHP"; 5428 case SLL: return "SLL"; 5429 case SOS: return "SOS"; 5430 case SRD: return "SRD"; 5431 case SSP: return "SSP"; 5432 case STN: return "STN"; 5433 case SVC: return "SVC"; 5434 case SYP: return "SYP"; 5435 case SZL: return "SZL"; 5436 case THB: return "THB"; 5437 case TJS: return "TJS"; 5438 case TMT: return "TMT"; 5439 case TND: return "TND"; 5440 case TOP: return "TOP"; 5441 case TRY: return "TRY"; 5442 case TTD: return "TTD"; 5443 case TVD: return "TVD"; 5444 case TWD: return "TWD"; 5445 case TZS: return "TZS"; 5446 case UAH: return "UAH"; 5447 case UGX: return "UGX"; 5448 case USD: return "USD"; 5449 case USN: return "USN"; 5450 case UYI: return "UYI"; 5451 case UYU: return "UYU"; 5452 case UZS: return "UZS"; 5453 case VEF: return "VEF"; 5454 case VND: return "VND"; 5455 case VUV: return "VUV"; 5456 case WST: return "WST"; 5457 case XAF: return "XAF"; 5458 case XAG: return "XAG"; 5459 case XAU: return "XAU"; 5460 case XBA: return "XBA"; 5461 case XBB: return "XBB"; 5462 case XBC: return "XBC"; 5463 case XBD: return "XBD"; 5464 case XCD: return "XCD"; 5465 case XDR: return "XDR"; 5466 case XOF: return "XOF"; 5467 case XPD: return "XPD"; 5468 case XPF: return "XPF"; 5469 case XPT: return "XPT"; 5470 case XSU: return "XSU"; 5471 case XTS: return "XTS"; 5472 case XUA: return "XUA"; 5473 case XXX: return "XXX"; 5474 case YER: return "YER"; 5475 case ZAR: return "ZAR"; 5476 case ZMW: return "ZMW"; 5477 case ZWL: return "ZWL"; 5478 case NULL: return null; 5479 default: return "?"; 5480 } 5481 } 5482 public String getSystem() { 5483 switch (this) { 5484 case AED: return "urn:iso:std:iso:4217"; 5485 case AFN: return "urn:iso:std:iso:4217"; 5486 case ALL: return "urn:iso:std:iso:4217"; 5487 case AMD: return "urn:iso:std:iso:4217"; 5488 case ANG: return "urn:iso:std:iso:4217"; 5489 case AOA: return "urn:iso:std:iso:4217"; 5490 case ARS: return "urn:iso:std:iso:4217"; 5491 case AUD: return "urn:iso:std:iso:4217"; 5492 case AWG: return "urn:iso:std:iso:4217"; 5493 case AZN: return "urn:iso:std:iso:4217"; 5494 case BAM: return "urn:iso:std:iso:4217"; 5495 case BBD: return "urn:iso:std:iso:4217"; 5496 case BDT: return "urn:iso:std:iso:4217"; 5497 case BGN: return "urn:iso:std:iso:4217"; 5498 case BHD: return "urn:iso:std:iso:4217"; 5499 case BIF: return "urn:iso:std:iso:4217"; 5500 case BMD: return "urn:iso:std:iso:4217"; 5501 case BND: return "urn:iso:std:iso:4217"; 5502 case BOB: return "urn:iso:std:iso:4217"; 5503 case BOV: return "urn:iso:std:iso:4217"; 5504 case BRL: return "urn:iso:std:iso:4217"; 5505 case BSD: return "urn:iso:std:iso:4217"; 5506 case BTN: return "urn:iso:std:iso:4217"; 5507 case BWP: return "urn:iso:std:iso:4217"; 5508 case BYN: return "urn:iso:std:iso:4217"; 5509 case BZD: return "urn:iso:std:iso:4217"; 5510 case CAD: return "urn:iso:std:iso:4217"; 5511 case CDF: return "urn:iso:std:iso:4217"; 5512 case CHE: return "urn:iso:std:iso:4217"; 5513 case CHF: return "urn:iso:std:iso:4217"; 5514 case CHW: return "urn:iso:std:iso:4217"; 5515 case CLF: return "urn:iso:std:iso:4217"; 5516 case CLP: return "urn:iso:std:iso:4217"; 5517 case CNY: return "urn:iso:std:iso:4217"; 5518 case COP: return "urn:iso:std:iso:4217"; 5519 case COU: return "urn:iso:std:iso:4217"; 5520 case CRC: return "urn:iso:std:iso:4217"; 5521 case CUC: return "urn:iso:std:iso:4217"; 5522 case CUP: return "urn:iso:std:iso:4217"; 5523 case CVE: return "urn:iso:std:iso:4217"; 5524 case CZK: return "urn:iso:std:iso:4217"; 5525 case DJF: return "urn:iso:std:iso:4217"; 5526 case DKK: return "urn:iso:std:iso:4217"; 5527 case DOP: return "urn:iso:std:iso:4217"; 5528 case DZD: return "urn:iso:std:iso:4217"; 5529 case EGP: return "urn:iso:std:iso:4217"; 5530 case ERN: return "urn:iso:std:iso:4217"; 5531 case ETB: return "urn:iso:std:iso:4217"; 5532 case EUR: return "urn:iso:std:iso:4217"; 5533 case FJD: return "urn:iso:std:iso:4217"; 5534 case FKP: return "urn:iso:std:iso:4217"; 5535 case GBP: return "urn:iso:std:iso:4217"; 5536 case GEL: return "urn:iso:std:iso:4217"; 5537 case GGP: return "urn:iso:std:iso:4217"; 5538 case GHS: return "urn:iso:std:iso:4217"; 5539 case GIP: return "urn:iso:std:iso:4217"; 5540 case GMD: return "urn:iso:std:iso:4217"; 5541 case GNF: return "urn:iso:std:iso:4217"; 5542 case GTQ: return "urn:iso:std:iso:4217"; 5543 case GYD: return "urn:iso:std:iso:4217"; 5544 case HKD: return "urn:iso:std:iso:4217"; 5545 case HNL: return "urn:iso:std:iso:4217"; 5546 case HRK: return "urn:iso:std:iso:4217"; 5547 case HTG: return "urn:iso:std:iso:4217"; 5548 case HUF: return "urn:iso:std:iso:4217"; 5549 case IDR: return "urn:iso:std:iso:4217"; 5550 case ILS: return "urn:iso:std:iso:4217"; 5551 case IMP: return "urn:iso:std:iso:4217"; 5552 case INR: return "urn:iso:std:iso:4217"; 5553 case IQD: return "urn:iso:std:iso:4217"; 5554 case IRR: return "urn:iso:std:iso:4217"; 5555 case ISK: return "urn:iso:std:iso:4217"; 5556 case JEP: return "urn:iso:std:iso:4217"; 5557 case JMD: return "urn:iso:std:iso:4217"; 5558 case JOD: return "urn:iso:std:iso:4217"; 5559 case JPY: return "urn:iso:std:iso:4217"; 5560 case KES: return "urn:iso:std:iso:4217"; 5561 case KGS: return "urn:iso:std:iso:4217"; 5562 case KHR: return "urn:iso:std:iso:4217"; 5563 case KMF: return "urn:iso:std:iso:4217"; 5564 case KPW: return "urn:iso:std:iso:4217"; 5565 case KRW: return "urn:iso:std:iso:4217"; 5566 case KWD: return "urn:iso:std:iso:4217"; 5567 case KYD: return "urn:iso:std:iso:4217"; 5568 case KZT: return "urn:iso:std:iso:4217"; 5569 case LAK: return "urn:iso:std:iso:4217"; 5570 case LBP: return "urn:iso:std:iso:4217"; 5571 case LKR: return "urn:iso:std:iso:4217"; 5572 case LRD: return "urn:iso:std:iso:4217"; 5573 case LSL: return "urn:iso:std:iso:4217"; 5574 case LYD: return "urn:iso:std:iso:4217"; 5575 case MAD: return "urn:iso:std:iso:4217"; 5576 case MDL: return "urn:iso:std:iso:4217"; 5577 case MGA: return "urn:iso:std:iso:4217"; 5578 case MKD: return "urn:iso:std:iso:4217"; 5579 case MMK: return "urn:iso:std:iso:4217"; 5580 case MNT: return "urn:iso:std:iso:4217"; 5581 case MOP: return "urn:iso:std:iso:4217"; 5582 case MRU: return "urn:iso:std:iso:4217"; 5583 case MUR: return "urn:iso:std:iso:4217"; 5584 case MVR: return "urn:iso:std:iso:4217"; 5585 case MWK: return "urn:iso:std:iso:4217"; 5586 case MXN: return "urn:iso:std:iso:4217"; 5587 case MXV: return "urn:iso:std:iso:4217"; 5588 case MYR: return "urn:iso:std:iso:4217"; 5589 case MZN: return "urn:iso:std:iso:4217"; 5590 case NAD: return "urn:iso:std:iso:4217"; 5591 case NGN: return "urn:iso:std:iso:4217"; 5592 case NIO: return "urn:iso:std:iso:4217"; 5593 case NOK: return "urn:iso:std:iso:4217"; 5594 case NPR: return "urn:iso:std:iso:4217"; 5595 case NZD: return "urn:iso:std:iso:4217"; 5596 case OMR: return "urn:iso:std:iso:4217"; 5597 case PAB: return "urn:iso:std:iso:4217"; 5598 case PEN: return "urn:iso:std:iso:4217"; 5599 case PGK: return "urn:iso:std:iso:4217"; 5600 case PHP: return "urn:iso:std:iso:4217"; 5601 case PKR: return "urn:iso:std:iso:4217"; 5602 case PLN: return "urn:iso:std:iso:4217"; 5603 case PYG: return "urn:iso:std:iso:4217"; 5604 case QAR: return "urn:iso:std:iso:4217"; 5605 case RON: return "urn:iso:std:iso:4217"; 5606 case RSD: return "urn:iso:std:iso:4217"; 5607 case RUB: return "urn:iso:std:iso:4217"; 5608 case RWF: return "urn:iso:std:iso:4217"; 5609 case SAR: return "urn:iso:std:iso:4217"; 5610 case SBD: return "urn:iso:std:iso:4217"; 5611 case SCR: return "urn:iso:std:iso:4217"; 5612 case SDG: return "urn:iso:std:iso:4217"; 5613 case SEK: return "urn:iso:std:iso:4217"; 5614 case SGD: return "urn:iso:std:iso:4217"; 5615 case SHP: return "urn:iso:std:iso:4217"; 5616 case SLL: return "urn:iso:std:iso:4217"; 5617 case SOS: return "urn:iso:std:iso:4217"; 5618 case SRD: return "urn:iso:std:iso:4217"; 5619 case SSP: return "urn:iso:std:iso:4217"; 5620 case STN: return "urn:iso:std:iso:4217"; 5621 case SVC: return "urn:iso:std:iso:4217"; 5622 case SYP: return "urn:iso:std:iso:4217"; 5623 case SZL: return "urn:iso:std:iso:4217"; 5624 case THB: return "urn:iso:std:iso:4217"; 5625 case TJS: return "urn:iso:std:iso:4217"; 5626 case TMT: return "urn:iso:std:iso:4217"; 5627 case TND: return "urn:iso:std:iso:4217"; 5628 case TOP: return "urn:iso:std:iso:4217"; 5629 case TRY: return "urn:iso:std:iso:4217"; 5630 case TTD: return "urn:iso:std:iso:4217"; 5631 case TVD: return "urn:iso:std:iso:4217"; 5632 case TWD: return "urn:iso:std:iso:4217"; 5633 case TZS: return "urn:iso:std:iso:4217"; 5634 case UAH: return "urn:iso:std:iso:4217"; 5635 case UGX: return "urn:iso:std:iso:4217"; 5636 case USD: return "urn:iso:std:iso:4217"; 5637 case USN: return "urn:iso:std:iso:4217"; 5638 case UYI: return "urn:iso:std:iso:4217"; 5639 case UYU: return "urn:iso:std:iso:4217"; 5640 case UZS: return "urn:iso:std:iso:4217"; 5641 case VEF: return "urn:iso:std:iso:4217"; 5642 case VND: return "urn:iso:std:iso:4217"; 5643 case VUV: return "urn:iso:std:iso:4217"; 5644 case WST: return "urn:iso:std:iso:4217"; 5645 case XAF: return "urn:iso:std:iso:4217"; 5646 case XAG: return "urn:iso:std:iso:4217"; 5647 case XAU: return "urn:iso:std:iso:4217"; 5648 case XBA: return "urn:iso:std:iso:4217"; 5649 case XBB: return "urn:iso:std:iso:4217"; 5650 case XBC: return "urn:iso:std:iso:4217"; 5651 case XBD: return "urn:iso:std:iso:4217"; 5652 case XCD: return "urn:iso:std:iso:4217"; 5653 case XDR: return "urn:iso:std:iso:4217"; 5654 case XOF: return "urn:iso:std:iso:4217"; 5655 case XPD: return "urn:iso:std:iso:4217"; 5656 case XPF: return "urn:iso:std:iso:4217"; 5657 case XPT: return "urn:iso:std:iso:4217"; 5658 case XSU: return "urn:iso:std:iso:4217"; 5659 case XTS: return "urn:iso:std:iso:4217"; 5660 case XUA: return "urn:iso:std:iso:4217"; 5661 case XXX: return "urn:iso:std:iso:4217"; 5662 case YER: return "urn:iso:std:iso:4217"; 5663 case ZAR: return "urn:iso:std:iso:4217"; 5664 case ZMW: return "urn:iso:std:iso:4217"; 5665 case ZWL: return "urn:iso:std:iso:4217"; 5666 case NULL: return null; 5667 default: return "?"; 5668 } 5669 } 5670 public String getDefinition() { 5671 switch (this) { 5672 case AED: return ""; 5673 case AFN: return ""; 5674 case ALL: return ""; 5675 case AMD: return ""; 5676 case ANG: return ""; 5677 case AOA: return ""; 5678 case ARS: return ""; 5679 case AUD: return ""; 5680 case AWG: return ""; 5681 case AZN: return ""; 5682 case BAM: return ""; 5683 case BBD: return ""; 5684 case BDT: return ""; 5685 case BGN: return ""; 5686 case BHD: return ""; 5687 case BIF: return ""; 5688 case BMD: return ""; 5689 case BND: return ""; 5690 case BOB: return ""; 5691 case BOV: return ""; 5692 case BRL: return ""; 5693 case BSD: return ""; 5694 case BTN: return ""; 5695 case BWP: return ""; 5696 case BYN: return ""; 5697 case BZD: return ""; 5698 case CAD: return ""; 5699 case CDF: return ""; 5700 case CHE: return ""; 5701 case CHF: return ""; 5702 case CHW: return ""; 5703 case CLF: return ""; 5704 case CLP: return ""; 5705 case CNY: return ""; 5706 case COP: return ""; 5707 case COU: return ""; 5708 case CRC: return ""; 5709 case CUC: return ""; 5710 case CUP: return ""; 5711 case CVE: return ""; 5712 case CZK: return ""; 5713 case DJF: return ""; 5714 case DKK: return ""; 5715 case DOP: return ""; 5716 case DZD: return ""; 5717 case EGP: return ""; 5718 case ERN: return ""; 5719 case ETB: return ""; 5720 case EUR: return ""; 5721 case FJD: return ""; 5722 case FKP: return ""; 5723 case GBP: return ""; 5724 case GEL: return ""; 5725 case GGP: return ""; 5726 case GHS: return ""; 5727 case GIP: return ""; 5728 case GMD: return ""; 5729 case GNF: return ""; 5730 case GTQ: return ""; 5731 case GYD: return ""; 5732 case HKD: return ""; 5733 case HNL: return ""; 5734 case HRK: return ""; 5735 case HTG: return ""; 5736 case HUF: return ""; 5737 case IDR: return ""; 5738 case ILS: return ""; 5739 case IMP: return ""; 5740 case INR: return ""; 5741 case IQD: return ""; 5742 case IRR: return ""; 5743 case ISK: return ""; 5744 case JEP: return ""; 5745 case JMD: return ""; 5746 case JOD: return ""; 5747 case JPY: return ""; 5748 case KES: return ""; 5749 case KGS: return ""; 5750 case KHR: return ""; 5751 case KMF: return ""; 5752 case KPW: return ""; 5753 case KRW: return ""; 5754 case KWD: return ""; 5755 case KYD: return ""; 5756 case KZT: return ""; 5757 case LAK: return ""; 5758 case LBP: return ""; 5759 case LKR: return ""; 5760 case LRD: return ""; 5761 case LSL: return ""; 5762 case LYD: return ""; 5763 case MAD: return ""; 5764 case MDL: return ""; 5765 case MGA: return ""; 5766 case MKD: return ""; 5767 case MMK: return ""; 5768 case MNT: return ""; 5769 case MOP: return ""; 5770 case MRU: return ""; 5771 case MUR: return ""; 5772 case MVR: return ""; 5773 case MWK: return ""; 5774 case MXN: return ""; 5775 case MXV: return ""; 5776 case MYR: return ""; 5777 case MZN: return ""; 5778 case NAD: return ""; 5779 case NGN: return ""; 5780 case NIO: return ""; 5781 case NOK: return ""; 5782 case NPR: return ""; 5783 case NZD: return ""; 5784 case OMR: return ""; 5785 case PAB: return ""; 5786 case PEN: return ""; 5787 case PGK: return ""; 5788 case PHP: return ""; 5789 case PKR: return ""; 5790 case PLN: return ""; 5791 case PYG: return ""; 5792 case QAR: return ""; 5793 case RON: return ""; 5794 case RSD: return ""; 5795 case RUB: return ""; 5796 case RWF: return ""; 5797 case SAR: return ""; 5798 case SBD: return ""; 5799 case SCR: return ""; 5800 case SDG: return ""; 5801 case SEK: return ""; 5802 case SGD: return ""; 5803 case SHP: return ""; 5804 case SLL: return ""; 5805 case SOS: return ""; 5806 case SRD: return ""; 5807 case SSP: return ""; 5808 case STN: return ""; 5809 case SVC: return ""; 5810 case SYP: return ""; 5811 case SZL: return ""; 5812 case THB: return ""; 5813 case TJS: return ""; 5814 case TMT: return ""; 5815 case TND: return ""; 5816 case TOP: return ""; 5817 case TRY: return ""; 5818 case TTD: return ""; 5819 case TVD: return ""; 5820 case TWD: return ""; 5821 case TZS: return ""; 5822 case UAH: return ""; 5823 case UGX: return ""; 5824 case USD: return ""; 5825 case USN: return ""; 5826 case UYI: return ""; 5827 case UYU: return ""; 5828 case UZS: return ""; 5829 case VEF: return ""; 5830 case VND: return ""; 5831 case VUV: return ""; 5832 case WST: return ""; 5833 case XAF: return ""; 5834 case XAG: return ""; 5835 case XAU: return ""; 5836 case XBA: return ""; 5837 case XBB: return ""; 5838 case XBC: return ""; 5839 case XBD: return ""; 5840 case XCD: return ""; 5841 case XDR: return ""; 5842 case XOF: return ""; 5843 case XPD: return ""; 5844 case XPF: return ""; 5845 case XPT: return ""; 5846 case XSU: return ""; 5847 case XTS: return ""; 5848 case XUA: return ""; 5849 case XXX: return ""; 5850 case YER: return ""; 5851 case ZAR: return ""; 5852 case ZMW: return ""; 5853 case ZWL: return ""; 5854 case NULL: return null; 5855 default: return "?"; 5856 } 5857 } 5858 public String getDisplay() { 5859 switch (this) { 5860 case AED: return "United Arab Emirates dirham"; 5861 case AFN: return "Afghan afghani"; 5862 case ALL: return "Albanian lek"; 5863 case AMD: return "Armenian dram"; 5864 case ANG: return "Netherlands Antillean guilder"; 5865 case AOA: return "Angolan kwanza"; 5866 case ARS: return "Argentine peso"; 5867 case AUD: return "Australian dollar"; 5868 case AWG: return "Aruban florin"; 5869 case AZN: return "Azerbaijani manat"; 5870 case BAM: return "Bosnia and Herzegovina convertible mark"; 5871 case BBD: return "Barbados dollar"; 5872 case BDT: return "Bangladeshi taka"; 5873 case BGN: return "Bulgarian lev"; 5874 case BHD: return "Bahraini dinar"; 5875 case BIF: return "Burundian franc"; 5876 case BMD: return "Bermudian dollar"; 5877 case BND: return "Brunei dollar"; 5878 case BOB: return "Boliviano"; 5879 case BOV: return "Bolivian Mvdol (funds code)"; 5880 case BRL: return "Brazilian real"; 5881 case BSD: return "Bahamian dollar"; 5882 case BTN: return "Bhutanese ngultrum"; 5883 case BWP: return "Botswana pula"; 5884 case BYN: return "Belarusian ruble"; 5885 case BZD: return "Belize dollar"; 5886 case CAD: return "Canadian dollar"; 5887 case CDF: return "Congolese franc"; 5888 case CHE: return "WIR Euro (complementary currency)"; 5889 case CHF: return "Swiss franc"; 5890 case CHW: return "WIR Franc (complementary currency)"; 5891 case CLF: return "Unidad de Fomento (funds code)"; 5892 case CLP: return "Chilean peso"; 5893 case CNY: return "Renminbi (Chinese) yuan[8]"; 5894 case COP: return "Colombian peso"; 5895 case COU: return "Unidad de Valor Real (UVR) (funds code)[9]"; 5896 case CRC: return "Costa Rican colon"; 5897 case CUC: return "Cuban convertible peso"; 5898 case CUP: return "Cuban peso"; 5899 case CVE: return "Cape Verde escudo"; 5900 case CZK: return "Czech koruna"; 5901 case DJF: return "Djiboutian franc"; 5902 case DKK: return "Danish krone"; 5903 case DOP: return "Dominican peso"; 5904 case DZD: return "Algerian dinar"; 5905 case EGP: return "Egyptian pound"; 5906 case ERN: return "Eritrean nakfa"; 5907 case ETB: return "Ethiopian birr"; 5908 case EUR: return "Euro"; 5909 case FJD: return "Fiji dollar"; 5910 case FKP: return "Falkland Islands pound"; 5911 case GBP: return "Pound sterling"; 5912 case GEL: return "Georgian lari"; 5913 case GGP: return "Guernsey Pound"; 5914 case GHS: return "Ghanaian cedi"; 5915 case GIP: return "Gibraltar pound"; 5916 case GMD: return "Gambian dalasi"; 5917 case GNF: return "Guinean franc"; 5918 case GTQ: return "Guatemalan quetzal"; 5919 case GYD: return "Guyanese dollar"; 5920 case HKD: return "Hong Kong dollar"; 5921 case HNL: return "Honduran lempira"; 5922 case HRK: return "Croatian kuna"; 5923 case HTG: return "Haitian gourde"; 5924 case HUF: return "Hungarian forint"; 5925 case IDR: return "Indonesian rupiah"; 5926 case ILS: return "Israeli new shekel"; 5927 case IMP: return "Isle of Man Pound"; 5928 case INR: return "Indian rupee"; 5929 case IQD: return "Iraqi dinar"; 5930 case IRR: return "Iranian rial"; 5931 case ISK: return "Icelandic króna"; 5932 case JEP: return "Jersey Pound"; 5933 case JMD: return "Jamaican dollar"; 5934 case JOD: return "Jordanian dinar"; 5935 case JPY: return "Japanese yen"; 5936 case KES: return "Kenyan shilling"; 5937 case KGS: return "Kyrgyzstani som"; 5938 case KHR: return "Cambodian riel"; 5939 case KMF: return "Comoro franc"; 5940 case KPW: return "North Korean won"; 5941 case KRW: return "South Korean won"; 5942 case KWD: return "Kuwaiti dinar"; 5943 case KYD: return "Cayman Islands dollar"; 5944 case KZT: return "Kazakhstani tenge"; 5945 case LAK: return "Lao kip"; 5946 case LBP: return "Lebanese pound"; 5947 case LKR: return "Sri Lankan rupee"; 5948 case LRD: return "Liberian dollar"; 5949 case LSL: return "Lesotho loti"; 5950 case LYD: return "Libyan dinar"; 5951 case MAD: return "Moroccan dirham"; 5952 case MDL: return "Moldovan leu"; 5953 case MGA: return "Malagasy ariary"; 5954 case MKD: return "Macedonian denar"; 5955 case MMK: return "Myanmar kyat"; 5956 case MNT: return "Mongolian tögrög"; 5957 case MOP: return "Macanese pataca"; 5958 case MRU: return "Mauritanian ouguiya"; 5959 case MUR: return "Mauritian rupee"; 5960 case MVR: return "Maldivian rufiyaa"; 5961 case MWK: return "Malawian kwacha"; 5962 case MXN: return "Mexican peso"; 5963 case MXV: return "Mexican Unidad de Inversion (UDI) (funds code)"; 5964 case MYR: return "Malaysian ringgit"; 5965 case MZN: return "Mozambican metical"; 5966 case NAD: return "Namibian dollar"; 5967 case NGN: return "Nigerian naira"; 5968 case NIO: return "Nicaraguan córdoba"; 5969 case NOK: return "Norwegian krone"; 5970 case NPR: return "Nepalese rupee"; 5971 case NZD: return "New Zealand dollar"; 5972 case OMR: return "Omani rial"; 5973 case PAB: return "Panamanian balboa"; 5974 case PEN: return "Peruvian Sol"; 5975 case PGK: return "Papua New Guinean kina"; 5976 case PHP: return "Philippine piso[13]"; 5977 case PKR: return "Pakistani rupee"; 5978 case PLN: return "Polish z?oty"; 5979 case PYG: return "Paraguayan guaraní"; 5980 case QAR: return "Qatari riyal"; 5981 case RON: return "Romanian leu"; 5982 case RSD: return "Serbian dinar"; 5983 case RUB: return "Russian ruble"; 5984 case RWF: return "Rwandan franc"; 5985 case SAR: return "Saudi riyal"; 5986 case SBD: return "Solomon Islands dollar"; 5987 case SCR: return "Seychelles rupee"; 5988 case SDG: return "Sudanese pound"; 5989 case SEK: return "Swedish krona/kronor"; 5990 case SGD: return "Singapore dollar"; 5991 case SHP: return "Saint Helena pound"; 5992 case SLL: return "Sierra Leonean leone"; 5993 case SOS: return "Somali shilling"; 5994 case SRD: return "Surinamese dollar"; 5995 case SSP: return "South Sudanese pound"; 5996 case STN: return "São Tomé and Príncipe dobra"; 5997 case SVC: return "Salvadoran colón"; 5998 case SYP: return "Syrian pound"; 5999 case SZL: return "Swazi lilangeni"; 6000 case THB: return "Thai baht"; 6001 case TJS: return "Tajikistani somoni"; 6002 case TMT: return "Turkmenistan manat"; 6003 case TND: return "Tunisian dinar"; 6004 case TOP: return "Tongan pa?anga"; 6005 case TRY: return "Turkish lira"; 6006 case TTD: return "Trinidad and Tobago dollar"; 6007 case TVD: return "Tuvalu Dollar"; 6008 case TWD: return "New Taiwan dollar"; 6009 case TZS: return "Tanzanian shilling"; 6010 case UAH: return "Ukrainian hryvnia"; 6011 case UGX: return "Ugandan shilling"; 6012 case USD: return "United States dollar"; 6013 case USN: return "United States dollar (next day) (funds code)"; 6014 case UYI: return "Uruguay Peso en Unidades Indexadas (URUIURUI) (funds code)"; 6015 case UYU: return "Uruguayan peso"; 6016 case UZS: return "Uzbekistan som"; 6017 case VEF: return "Venezuelan bolívar"; 6018 case VND: return "Vietnamese ??ng"; 6019 case VUV: return "Vanuatu vatu"; 6020 case WST: return "Samoan tala"; 6021 case XAF: return "CFA franc BEAC"; 6022 case XAG: return "Silver (one troy ounce)"; 6023 case XAU: return "Gold (one troy ounce)"; 6024 case XBA: return "European Composite Unit (EURCO) (bond market unit)"; 6025 case XBB: return "European Monetary Unit (E.M.U.-6) (bond market unit)"; 6026 case XBC: return "European Unit of Account 9 (E.U.A.-9) (bond market unit)"; 6027 case XBD: return "European Unit of Account 17 (E.U.A.-17) (bond market unit)"; 6028 case XCD: return "East Caribbean dollar"; 6029 case XDR: return "Special drawing rights"; 6030 case XOF: return "CFA franc BCEAO"; 6031 case XPD: return "Palladium (one troy ounce)"; 6032 case XPF: return "CFP franc (franc Pacifique)"; 6033 case XPT: return "Platinum (one troy ounce)"; 6034 case XSU: return "SUCRE"; 6035 case XTS: return "Code reserved for testing purposes"; 6036 case XUA: return "ADB Unit of Account"; 6037 case XXX: return "No currency"; 6038 case YER: return "Yemeni rial"; 6039 case ZAR: return "South African rand"; 6040 case ZMW: return "Zambian kwacha"; 6041 case ZWL: return "Zimbabwean dollar A/10"; 6042 case NULL: return null; 6043 default: return "?"; 6044 } 6045 } 6046 } 6047 6048 public static class CurrenciesEnumFactory implements EnumFactory<Currencies> { 6049 public Currencies fromCode(String codeString) throws IllegalArgumentException { 6050 if (codeString == null || "".equals(codeString)) 6051 if (codeString == null || "".equals(codeString)) 6052 return null; 6053 if ("AED".equals(codeString)) 6054 return Currencies.AED; 6055 if ("AFN".equals(codeString)) 6056 return Currencies.AFN; 6057 if ("ALL".equals(codeString)) 6058 return Currencies.ALL; 6059 if ("AMD".equals(codeString)) 6060 return Currencies.AMD; 6061 if ("ANG".equals(codeString)) 6062 return Currencies.ANG; 6063 if ("AOA".equals(codeString)) 6064 return Currencies.AOA; 6065 if ("ARS".equals(codeString)) 6066 return Currencies.ARS; 6067 if ("AUD".equals(codeString)) 6068 return Currencies.AUD; 6069 if ("AWG".equals(codeString)) 6070 return Currencies.AWG; 6071 if ("AZN".equals(codeString)) 6072 return Currencies.AZN; 6073 if ("BAM".equals(codeString)) 6074 return Currencies.BAM; 6075 if ("BBD".equals(codeString)) 6076 return Currencies.BBD; 6077 if ("BDT".equals(codeString)) 6078 return Currencies.BDT; 6079 if ("BGN".equals(codeString)) 6080 return Currencies.BGN; 6081 if ("BHD".equals(codeString)) 6082 return Currencies.BHD; 6083 if ("BIF".equals(codeString)) 6084 return Currencies.BIF; 6085 if ("BMD".equals(codeString)) 6086 return Currencies.BMD; 6087 if ("BND".equals(codeString)) 6088 return Currencies.BND; 6089 if ("BOB".equals(codeString)) 6090 return Currencies.BOB; 6091 if ("BOV".equals(codeString)) 6092 return Currencies.BOV; 6093 if ("BRL".equals(codeString)) 6094 return Currencies.BRL; 6095 if ("BSD".equals(codeString)) 6096 return Currencies.BSD; 6097 if ("BTN".equals(codeString)) 6098 return Currencies.BTN; 6099 if ("BWP".equals(codeString)) 6100 return Currencies.BWP; 6101 if ("BYN".equals(codeString)) 6102 return Currencies.BYN; 6103 if ("BZD".equals(codeString)) 6104 return Currencies.BZD; 6105 if ("CAD".equals(codeString)) 6106 return Currencies.CAD; 6107 if ("CDF".equals(codeString)) 6108 return Currencies.CDF; 6109 if ("CHE".equals(codeString)) 6110 return Currencies.CHE; 6111 if ("CHF".equals(codeString)) 6112 return Currencies.CHF; 6113 if ("CHW".equals(codeString)) 6114 return Currencies.CHW; 6115 if ("CLF".equals(codeString)) 6116 return Currencies.CLF; 6117 if ("CLP".equals(codeString)) 6118 return Currencies.CLP; 6119 if ("CNY".equals(codeString)) 6120 return Currencies.CNY; 6121 if ("COP".equals(codeString)) 6122 return Currencies.COP; 6123 if ("COU".equals(codeString)) 6124 return Currencies.COU; 6125 if ("CRC".equals(codeString)) 6126 return Currencies.CRC; 6127 if ("CUC".equals(codeString)) 6128 return Currencies.CUC; 6129 if ("CUP".equals(codeString)) 6130 return Currencies.CUP; 6131 if ("CVE".equals(codeString)) 6132 return Currencies.CVE; 6133 if ("CZK".equals(codeString)) 6134 return Currencies.CZK; 6135 if ("DJF".equals(codeString)) 6136 return Currencies.DJF; 6137 if ("DKK".equals(codeString)) 6138 return Currencies.DKK; 6139 if ("DOP".equals(codeString)) 6140 return Currencies.DOP; 6141 if ("DZD".equals(codeString)) 6142 return Currencies.DZD; 6143 if ("EGP".equals(codeString)) 6144 return Currencies.EGP; 6145 if ("ERN".equals(codeString)) 6146 return Currencies.ERN; 6147 if ("ETB".equals(codeString)) 6148 return Currencies.ETB; 6149 if ("EUR".equals(codeString)) 6150 return Currencies.EUR; 6151 if ("FJD".equals(codeString)) 6152 return Currencies.FJD; 6153 if ("FKP".equals(codeString)) 6154 return Currencies.FKP; 6155 if ("GBP".equals(codeString)) 6156 return Currencies.GBP; 6157 if ("GEL".equals(codeString)) 6158 return Currencies.GEL; 6159 if ("GGP".equals(codeString)) 6160 return Currencies.GGP; 6161 if ("GHS".equals(codeString)) 6162 return Currencies.GHS; 6163 if ("GIP".equals(codeString)) 6164 return Currencies.GIP; 6165 if ("GMD".equals(codeString)) 6166 return Currencies.GMD; 6167 if ("GNF".equals(codeString)) 6168 return Currencies.GNF; 6169 if ("GTQ".equals(codeString)) 6170 return Currencies.GTQ; 6171 if ("GYD".equals(codeString)) 6172 return Currencies.GYD; 6173 if ("HKD".equals(codeString)) 6174 return Currencies.HKD; 6175 if ("HNL".equals(codeString)) 6176 return Currencies.HNL; 6177 if ("HRK".equals(codeString)) 6178 return Currencies.HRK; 6179 if ("HTG".equals(codeString)) 6180 return Currencies.HTG; 6181 if ("HUF".equals(codeString)) 6182 return Currencies.HUF; 6183 if ("IDR".equals(codeString)) 6184 return Currencies.IDR; 6185 if ("ILS".equals(codeString)) 6186 return Currencies.ILS; 6187 if ("IMP".equals(codeString)) 6188 return Currencies.IMP; 6189 if ("INR".equals(codeString)) 6190 return Currencies.INR; 6191 if ("IQD".equals(codeString)) 6192 return Currencies.IQD; 6193 if ("IRR".equals(codeString)) 6194 return Currencies.IRR; 6195 if ("ISK".equals(codeString)) 6196 return Currencies.ISK; 6197 if ("JEP".equals(codeString)) 6198 return Currencies.JEP; 6199 if ("JMD".equals(codeString)) 6200 return Currencies.JMD; 6201 if ("JOD".equals(codeString)) 6202 return Currencies.JOD; 6203 if ("JPY".equals(codeString)) 6204 return Currencies.JPY; 6205 if ("KES".equals(codeString)) 6206 return Currencies.KES; 6207 if ("KGS".equals(codeString)) 6208 return Currencies.KGS; 6209 if ("KHR".equals(codeString)) 6210 return Currencies.KHR; 6211 if ("KMF".equals(codeString)) 6212 return Currencies.KMF; 6213 if ("KPW".equals(codeString)) 6214 return Currencies.KPW; 6215 if ("KRW".equals(codeString)) 6216 return Currencies.KRW; 6217 if ("KWD".equals(codeString)) 6218 return Currencies.KWD; 6219 if ("KYD".equals(codeString)) 6220 return Currencies.KYD; 6221 if ("KZT".equals(codeString)) 6222 return Currencies.KZT; 6223 if ("LAK".equals(codeString)) 6224 return Currencies.LAK; 6225 if ("LBP".equals(codeString)) 6226 return Currencies.LBP; 6227 if ("LKR".equals(codeString)) 6228 return Currencies.LKR; 6229 if ("LRD".equals(codeString)) 6230 return Currencies.LRD; 6231 if ("LSL".equals(codeString)) 6232 return Currencies.LSL; 6233 if ("LYD".equals(codeString)) 6234 return Currencies.LYD; 6235 if ("MAD".equals(codeString)) 6236 return Currencies.MAD; 6237 if ("MDL".equals(codeString)) 6238 return Currencies.MDL; 6239 if ("MGA".equals(codeString)) 6240 return Currencies.MGA; 6241 if ("MKD".equals(codeString)) 6242 return Currencies.MKD; 6243 if ("MMK".equals(codeString)) 6244 return Currencies.MMK; 6245 if ("MNT".equals(codeString)) 6246 return Currencies.MNT; 6247 if ("MOP".equals(codeString)) 6248 return Currencies.MOP; 6249 if ("MRU".equals(codeString)) 6250 return Currencies.MRU; 6251 if ("MUR".equals(codeString)) 6252 return Currencies.MUR; 6253 if ("MVR".equals(codeString)) 6254 return Currencies.MVR; 6255 if ("MWK".equals(codeString)) 6256 return Currencies.MWK; 6257 if ("MXN".equals(codeString)) 6258 return Currencies.MXN; 6259 if ("MXV".equals(codeString)) 6260 return Currencies.MXV; 6261 if ("MYR".equals(codeString)) 6262 return Currencies.MYR; 6263 if ("MZN".equals(codeString)) 6264 return Currencies.MZN; 6265 if ("NAD".equals(codeString)) 6266 return Currencies.NAD; 6267 if ("NGN".equals(codeString)) 6268 return Currencies.NGN; 6269 if ("NIO".equals(codeString)) 6270 return Currencies.NIO; 6271 if ("NOK".equals(codeString)) 6272 return Currencies.NOK; 6273 if ("NPR".equals(codeString)) 6274 return Currencies.NPR; 6275 if ("NZD".equals(codeString)) 6276 return Currencies.NZD; 6277 if ("OMR".equals(codeString)) 6278 return Currencies.OMR; 6279 if ("PAB".equals(codeString)) 6280 return Currencies.PAB; 6281 if ("PEN".equals(codeString)) 6282 return Currencies.PEN; 6283 if ("PGK".equals(codeString)) 6284 return Currencies.PGK; 6285 if ("PHP".equals(codeString)) 6286 return Currencies.PHP; 6287 if ("PKR".equals(codeString)) 6288 return Currencies.PKR; 6289 if ("PLN".equals(codeString)) 6290 return Currencies.PLN; 6291 if ("PYG".equals(codeString)) 6292 return Currencies.PYG; 6293 if ("QAR".equals(codeString)) 6294 return Currencies.QAR; 6295 if ("RON".equals(codeString)) 6296 return Currencies.RON; 6297 if ("RSD".equals(codeString)) 6298 return Currencies.RSD; 6299 if ("RUB".equals(codeString)) 6300 return Currencies.RUB; 6301 if ("RWF".equals(codeString)) 6302 return Currencies.RWF; 6303 if ("SAR".equals(codeString)) 6304 return Currencies.SAR; 6305 if ("SBD".equals(codeString)) 6306 return Currencies.SBD; 6307 if ("SCR".equals(codeString)) 6308 return Currencies.SCR; 6309 if ("SDG".equals(codeString)) 6310 return Currencies.SDG; 6311 if ("SEK".equals(codeString)) 6312 return Currencies.SEK; 6313 if ("SGD".equals(codeString)) 6314 return Currencies.SGD; 6315 if ("SHP".equals(codeString)) 6316 return Currencies.SHP; 6317 if ("SLL".equals(codeString)) 6318 return Currencies.SLL; 6319 if ("SOS".equals(codeString)) 6320 return Currencies.SOS; 6321 if ("SRD".equals(codeString)) 6322 return Currencies.SRD; 6323 if ("SSP".equals(codeString)) 6324 return Currencies.SSP; 6325 if ("STN".equals(codeString)) 6326 return Currencies.STN; 6327 if ("SVC".equals(codeString)) 6328 return Currencies.SVC; 6329 if ("SYP".equals(codeString)) 6330 return Currencies.SYP; 6331 if ("SZL".equals(codeString)) 6332 return Currencies.SZL; 6333 if ("THB".equals(codeString)) 6334 return Currencies.THB; 6335 if ("TJS".equals(codeString)) 6336 return Currencies.TJS; 6337 if ("TMT".equals(codeString)) 6338 return Currencies.TMT; 6339 if ("TND".equals(codeString)) 6340 return Currencies.TND; 6341 if ("TOP".equals(codeString)) 6342 return Currencies.TOP; 6343 if ("TRY".equals(codeString)) 6344 return Currencies.TRY; 6345 if ("TTD".equals(codeString)) 6346 return Currencies.TTD; 6347 if ("TVD".equals(codeString)) 6348 return Currencies.TVD; 6349 if ("TWD".equals(codeString)) 6350 return Currencies.TWD; 6351 if ("TZS".equals(codeString)) 6352 return Currencies.TZS; 6353 if ("UAH".equals(codeString)) 6354 return Currencies.UAH; 6355 if ("UGX".equals(codeString)) 6356 return Currencies.UGX; 6357 if ("USD".equals(codeString)) 6358 return Currencies.USD; 6359 if ("USN".equals(codeString)) 6360 return Currencies.USN; 6361 if ("UYI".equals(codeString)) 6362 return Currencies.UYI; 6363 if ("UYU".equals(codeString)) 6364 return Currencies.UYU; 6365 if ("UZS".equals(codeString)) 6366 return Currencies.UZS; 6367 if ("VEF".equals(codeString)) 6368 return Currencies.VEF; 6369 if ("VND".equals(codeString)) 6370 return Currencies.VND; 6371 if ("VUV".equals(codeString)) 6372 return Currencies.VUV; 6373 if ("WST".equals(codeString)) 6374 return Currencies.WST; 6375 if ("XAF".equals(codeString)) 6376 return Currencies.XAF; 6377 if ("XAG".equals(codeString)) 6378 return Currencies.XAG; 6379 if ("XAU".equals(codeString)) 6380 return Currencies.XAU; 6381 if ("XBA".equals(codeString)) 6382 return Currencies.XBA; 6383 if ("XBB".equals(codeString)) 6384 return Currencies.XBB; 6385 if ("XBC".equals(codeString)) 6386 return Currencies.XBC; 6387 if ("XBD".equals(codeString)) 6388 return Currencies.XBD; 6389 if ("XCD".equals(codeString)) 6390 return Currencies.XCD; 6391 if ("XDR".equals(codeString)) 6392 return Currencies.XDR; 6393 if ("XOF".equals(codeString)) 6394 return Currencies.XOF; 6395 if ("XPD".equals(codeString)) 6396 return Currencies.XPD; 6397 if ("XPF".equals(codeString)) 6398 return Currencies.XPF; 6399 if ("XPT".equals(codeString)) 6400 return Currencies.XPT; 6401 if ("XSU".equals(codeString)) 6402 return Currencies.XSU; 6403 if ("XTS".equals(codeString)) 6404 return Currencies.XTS; 6405 if ("XUA".equals(codeString)) 6406 return Currencies.XUA; 6407 if ("XXX".equals(codeString)) 6408 return Currencies.XXX; 6409 if ("YER".equals(codeString)) 6410 return Currencies.YER; 6411 if ("ZAR".equals(codeString)) 6412 return Currencies.ZAR; 6413 if ("ZMW".equals(codeString)) 6414 return Currencies.ZMW; 6415 if ("ZWL".equals(codeString)) 6416 return Currencies.ZWL; 6417 throw new IllegalArgumentException("Unknown Currencies code '"+codeString+"'"); 6418 } 6419 6420 public Enumeration<Currencies> fromType(PrimitiveType<?> code) throws FHIRException { 6421 if (code == null) 6422 return null; 6423 if (code.isEmpty()) 6424 return new Enumeration<Currencies>(this, Currencies.NULL, code); 6425 String codeString = ((PrimitiveType) code).asStringValue(); 6426 if (codeString == null || "".equals(codeString)) 6427 return new Enumeration<Currencies>(this, Currencies.NULL, code); 6428 if ("AED".equals(codeString)) 6429 return new Enumeration<Currencies>(this, Currencies.AED, code); 6430 if ("AFN".equals(codeString)) 6431 return new Enumeration<Currencies>(this, Currencies.AFN, code); 6432 if ("ALL".equals(codeString)) 6433 return new Enumeration<Currencies>(this, Currencies.ALL, code); 6434 if ("AMD".equals(codeString)) 6435 return new Enumeration<Currencies>(this, Currencies.AMD, code); 6436 if ("ANG".equals(codeString)) 6437 return new Enumeration<Currencies>(this, Currencies.ANG, code); 6438 if ("AOA".equals(codeString)) 6439 return new Enumeration<Currencies>(this, Currencies.AOA, code); 6440 if ("ARS".equals(codeString)) 6441 return new Enumeration<Currencies>(this, Currencies.ARS, code); 6442 if ("AUD".equals(codeString)) 6443 return new Enumeration<Currencies>(this, Currencies.AUD, code); 6444 if ("AWG".equals(codeString)) 6445 return new Enumeration<Currencies>(this, Currencies.AWG, code); 6446 if ("AZN".equals(codeString)) 6447 return new Enumeration<Currencies>(this, Currencies.AZN, code); 6448 if ("BAM".equals(codeString)) 6449 return new Enumeration<Currencies>(this, Currencies.BAM, code); 6450 if ("BBD".equals(codeString)) 6451 return new Enumeration<Currencies>(this, Currencies.BBD, code); 6452 if ("BDT".equals(codeString)) 6453 return new Enumeration<Currencies>(this, Currencies.BDT, code); 6454 if ("BGN".equals(codeString)) 6455 return new Enumeration<Currencies>(this, Currencies.BGN, code); 6456 if ("BHD".equals(codeString)) 6457 return new Enumeration<Currencies>(this, Currencies.BHD, code); 6458 if ("BIF".equals(codeString)) 6459 return new Enumeration<Currencies>(this, Currencies.BIF, code); 6460 if ("BMD".equals(codeString)) 6461 return new Enumeration<Currencies>(this, Currencies.BMD, code); 6462 if ("BND".equals(codeString)) 6463 return new Enumeration<Currencies>(this, Currencies.BND, code); 6464 if ("BOB".equals(codeString)) 6465 return new Enumeration<Currencies>(this, Currencies.BOB, code); 6466 if ("BOV".equals(codeString)) 6467 return new Enumeration<Currencies>(this, Currencies.BOV, code); 6468 if ("BRL".equals(codeString)) 6469 return new Enumeration<Currencies>(this, Currencies.BRL, code); 6470 if ("BSD".equals(codeString)) 6471 return new Enumeration<Currencies>(this, Currencies.BSD, code); 6472 if ("BTN".equals(codeString)) 6473 return new Enumeration<Currencies>(this, Currencies.BTN, code); 6474 if ("BWP".equals(codeString)) 6475 return new Enumeration<Currencies>(this, Currencies.BWP, code); 6476 if ("BYN".equals(codeString)) 6477 return new Enumeration<Currencies>(this, Currencies.BYN, code); 6478 if ("BZD".equals(codeString)) 6479 return new Enumeration<Currencies>(this, Currencies.BZD, code); 6480 if ("CAD".equals(codeString)) 6481 return new Enumeration<Currencies>(this, Currencies.CAD, code); 6482 if ("CDF".equals(codeString)) 6483 return new Enumeration<Currencies>(this, Currencies.CDF, code); 6484 if ("CHE".equals(codeString)) 6485 return new Enumeration<Currencies>(this, Currencies.CHE, code); 6486 if ("CHF".equals(codeString)) 6487 return new Enumeration<Currencies>(this, Currencies.CHF, code); 6488 if ("CHW".equals(codeString)) 6489 return new Enumeration<Currencies>(this, Currencies.CHW, code); 6490 if ("CLF".equals(codeString)) 6491 return new Enumeration<Currencies>(this, Currencies.CLF, code); 6492 if ("CLP".equals(codeString)) 6493 return new Enumeration<Currencies>(this, Currencies.CLP, code); 6494 if ("CNY".equals(codeString)) 6495 return new Enumeration<Currencies>(this, Currencies.CNY, code); 6496 if ("COP".equals(codeString)) 6497 return new Enumeration<Currencies>(this, Currencies.COP, code); 6498 if ("COU".equals(codeString)) 6499 return new Enumeration<Currencies>(this, Currencies.COU, code); 6500 if ("CRC".equals(codeString)) 6501 return new Enumeration<Currencies>(this, Currencies.CRC, code); 6502 if ("CUC".equals(codeString)) 6503 return new Enumeration<Currencies>(this, Currencies.CUC, code); 6504 if ("CUP".equals(codeString)) 6505 return new Enumeration<Currencies>(this, Currencies.CUP, code); 6506 if ("CVE".equals(codeString)) 6507 return new Enumeration<Currencies>(this, Currencies.CVE, code); 6508 if ("CZK".equals(codeString)) 6509 return new Enumeration<Currencies>(this, Currencies.CZK, code); 6510 if ("DJF".equals(codeString)) 6511 return new Enumeration<Currencies>(this, Currencies.DJF, code); 6512 if ("DKK".equals(codeString)) 6513 return new Enumeration<Currencies>(this, Currencies.DKK, code); 6514 if ("DOP".equals(codeString)) 6515 return new Enumeration<Currencies>(this, Currencies.DOP, code); 6516 if ("DZD".equals(codeString)) 6517 return new Enumeration<Currencies>(this, Currencies.DZD, code); 6518 if ("EGP".equals(codeString)) 6519 return new Enumeration<Currencies>(this, Currencies.EGP, code); 6520 if ("ERN".equals(codeString)) 6521 return new Enumeration<Currencies>(this, Currencies.ERN, code); 6522 if ("ETB".equals(codeString)) 6523 return new Enumeration<Currencies>(this, Currencies.ETB, code); 6524 if ("EUR".equals(codeString)) 6525 return new Enumeration<Currencies>(this, Currencies.EUR, code); 6526 if ("FJD".equals(codeString)) 6527 return new Enumeration<Currencies>(this, Currencies.FJD, code); 6528 if ("FKP".equals(codeString)) 6529 return new Enumeration<Currencies>(this, Currencies.FKP, code); 6530 if ("GBP".equals(codeString)) 6531 return new Enumeration<Currencies>(this, Currencies.GBP, code); 6532 if ("GEL".equals(codeString)) 6533 return new Enumeration<Currencies>(this, Currencies.GEL, code); 6534 if ("GGP".equals(codeString)) 6535 return new Enumeration<Currencies>(this, Currencies.GGP, code); 6536 if ("GHS".equals(codeString)) 6537 return new Enumeration<Currencies>(this, Currencies.GHS, code); 6538 if ("GIP".equals(codeString)) 6539 return new Enumeration<Currencies>(this, Currencies.GIP, code); 6540 if ("GMD".equals(codeString)) 6541 return new Enumeration<Currencies>(this, Currencies.GMD, code); 6542 if ("GNF".equals(codeString)) 6543 return new Enumeration<Currencies>(this, Currencies.GNF, code); 6544 if ("GTQ".equals(codeString)) 6545 return new Enumeration<Currencies>(this, Currencies.GTQ, code); 6546 if ("GYD".equals(codeString)) 6547 return new Enumeration<Currencies>(this, Currencies.GYD, code); 6548 if ("HKD".equals(codeString)) 6549 return new Enumeration<Currencies>(this, Currencies.HKD, code); 6550 if ("HNL".equals(codeString)) 6551 return new Enumeration<Currencies>(this, Currencies.HNL, code); 6552 if ("HRK".equals(codeString)) 6553 return new Enumeration<Currencies>(this, Currencies.HRK, code); 6554 if ("HTG".equals(codeString)) 6555 return new Enumeration<Currencies>(this, Currencies.HTG, code); 6556 if ("HUF".equals(codeString)) 6557 return new Enumeration<Currencies>(this, Currencies.HUF, code); 6558 if ("IDR".equals(codeString)) 6559 return new Enumeration<Currencies>(this, Currencies.IDR, code); 6560 if ("ILS".equals(codeString)) 6561 return new Enumeration<Currencies>(this, Currencies.ILS, code); 6562 if ("IMP".equals(codeString)) 6563 return new Enumeration<Currencies>(this, Currencies.IMP, code); 6564 if ("INR".equals(codeString)) 6565 return new Enumeration<Currencies>(this, Currencies.INR, code); 6566 if ("IQD".equals(codeString)) 6567 return new Enumeration<Currencies>(this, Currencies.IQD, code); 6568 if ("IRR".equals(codeString)) 6569 return new Enumeration<Currencies>(this, Currencies.IRR, code); 6570 if ("ISK".equals(codeString)) 6571 return new Enumeration<Currencies>(this, Currencies.ISK, code); 6572 if ("JEP".equals(codeString)) 6573 return new Enumeration<Currencies>(this, Currencies.JEP, code); 6574 if ("JMD".equals(codeString)) 6575 return new Enumeration<Currencies>(this, Currencies.JMD, code); 6576 if ("JOD".equals(codeString)) 6577 return new Enumeration<Currencies>(this, Currencies.JOD, code); 6578 if ("JPY".equals(codeString)) 6579 return new Enumeration<Currencies>(this, Currencies.JPY, code); 6580 if ("KES".equals(codeString)) 6581 return new Enumeration<Currencies>(this, Currencies.KES, code); 6582 if ("KGS".equals(codeString)) 6583 return new Enumeration<Currencies>(this, Currencies.KGS, code); 6584 if ("KHR".equals(codeString)) 6585 return new Enumeration<Currencies>(this, Currencies.KHR, code); 6586 if ("KMF".equals(codeString)) 6587 return new Enumeration<Currencies>(this, Currencies.KMF, code); 6588 if ("KPW".equals(codeString)) 6589 return new Enumeration<Currencies>(this, Currencies.KPW, code); 6590 if ("KRW".equals(codeString)) 6591 return new Enumeration<Currencies>(this, Currencies.KRW, code); 6592 if ("KWD".equals(codeString)) 6593 return new Enumeration<Currencies>(this, Currencies.KWD, code); 6594 if ("KYD".equals(codeString)) 6595 return new Enumeration<Currencies>(this, Currencies.KYD, code); 6596 if ("KZT".equals(codeString)) 6597 return new Enumeration<Currencies>(this, Currencies.KZT, code); 6598 if ("LAK".equals(codeString)) 6599 return new Enumeration<Currencies>(this, Currencies.LAK, code); 6600 if ("LBP".equals(codeString)) 6601 return new Enumeration<Currencies>(this, Currencies.LBP, code); 6602 if ("LKR".equals(codeString)) 6603 return new Enumeration<Currencies>(this, Currencies.LKR, code); 6604 if ("LRD".equals(codeString)) 6605 return new Enumeration<Currencies>(this, Currencies.LRD, code); 6606 if ("LSL".equals(codeString)) 6607 return new Enumeration<Currencies>(this, Currencies.LSL, code); 6608 if ("LYD".equals(codeString)) 6609 return new Enumeration<Currencies>(this, Currencies.LYD, code); 6610 if ("MAD".equals(codeString)) 6611 return new Enumeration<Currencies>(this, Currencies.MAD, code); 6612 if ("MDL".equals(codeString)) 6613 return new Enumeration<Currencies>(this, Currencies.MDL, code); 6614 if ("MGA".equals(codeString)) 6615 return new Enumeration<Currencies>(this, Currencies.MGA, code); 6616 if ("MKD".equals(codeString)) 6617 return new Enumeration<Currencies>(this, Currencies.MKD, code); 6618 if ("MMK".equals(codeString)) 6619 return new Enumeration<Currencies>(this, Currencies.MMK, code); 6620 if ("MNT".equals(codeString)) 6621 return new Enumeration<Currencies>(this, Currencies.MNT, code); 6622 if ("MOP".equals(codeString)) 6623 return new Enumeration<Currencies>(this, Currencies.MOP, code); 6624 if ("MRU".equals(codeString)) 6625 return new Enumeration<Currencies>(this, Currencies.MRU, code); 6626 if ("MUR".equals(codeString)) 6627 return new Enumeration<Currencies>(this, Currencies.MUR, code); 6628 if ("MVR".equals(codeString)) 6629 return new Enumeration<Currencies>(this, Currencies.MVR, code); 6630 if ("MWK".equals(codeString)) 6631 return new Enumeration<Currencies>(this, Currencies.MWK, code); 6632 if ("MXN".equals(codeString)) 6633 return new Enumeration<Currencies>(this, Currencies.MXN, code); 6634 if ("MXV".equals(codeString)) 6635 return new Enumeration<Currencies>(this, Currencies.MXV, code); 6636 if ("MYR".equals(codeString)) 6637 return new Enumeration<Currencies>(this, Currencies.MYR, code); 6638 if ("MZN".equals(codeString)) 6639 return new Enumeration<Currencies>(this, Currencies.MZN, code); 6640 if ("NAD".equals(codeString)) 6641 return new Enumeration<Currencies>(this, Currencies.NAD, code); 6642 if ("NGN".equals(codeString)) 6643 return new Enumeration<Currencies>(this, Currencies.NGN, code); 6644 if ("NIO".equals(codeString)) 6645 return new Enumeration<Currencies>(this, Currencies.NIO, code); 6646 if ("NOK".equals(codeString)) 6647 return new Enumeration<Currencies>(this, Currencies.NOK, code); 6648 if ("NPR".equals(codeString)) 6649 return new Enumeration<Currencies>(this, Currencies.NPR, code); 6650 if ("NZD".equals(codeString)) 6651 return new Enumeration<Currencies>(this, Currencies.NZD, code); 6652 if ("OMR".equals(codeString)) 6653 return new Enumeration<Currencies>(this, Currencies.OMR, code); 6654 if ("PAB".equals(codeString)) 6655 return new Enumeration<Currencies>(this, Currencies.PAB, code); 6656 if ("PEN".equals(codeString)) 6657 return new Enumeration<Currencies>(this, Currencies.PEN, code); 6658 if ("PGK".equals(codeString)) 6659 return new Enumeration<Currencies>(this, Currencies.PGK, code); 6660 if ("PHP".equals(codeString)) 6661 return new Enumeration<Currencies>(this, Currencies.PHP, code); 6662 if ("PKR".equals(codeString)) 6663 return new Enumeration<Currencies>(this, Currencies.PKR, code); 6664 if ("PLN".equals(codeString)) 6665 return new Enumeration<Currencies>(this, Currencies.PLN, code); 6666 if ("PYG".equals(codeString)) 6667 return new Enumeration<Currencies>(this, Currencies.PYG, code); 6668 if ("QAR".equals(codeString)) 6669 return new Enumeration<Currencies>(this, Currencies.QAR, code); 6670 if ("RON".equals(codeString)) 6671 return new Enumeration<Currencies>(this, Currencies.RON, code); 6672 if ("RSD".equals(codeString)) 6673 return new Enumeration<Currencies>(this, Currencies.RSD, code); 6674 if ("RUB".equals(codeString)) 6675 return new Enumeration<Currencies>(this, Currencies.RUB, code); 6676 if ("RWF".equals(codeString)) 6677 return new Enumeration<Currencies>(this, Currencies.RWF, code); 6678 if ("SAR".equals(codeString)) 6679 return new Enumeration<Currencies>(this, Currencies.SAR, code); 6680 if ("SBD".equals(codeString)) 6681 return new Enumeration<Currencies>(this, Currencies.SBD, code); 6682 if ("SCR".equals(codeString)) 6683 return new Enumeration<Currencies>(this, Currencies.SCR, code); 6684 if ("SDG".equals(codeString)) 6685 return new Enumeration<Currencies>(this, Currencies.SDG, code); 6686 if ("SEK".equals(codeString)) 6687 return new Enumeration<Currencies>(this, Currencies.SEK, code); 6688 if ("SGD".equals(codeString)) 6689 return new Enumeration<Currencies>(this, Currencies.SGD, code); 6690 if ("SHP".equals(codeString)) 6691 return new Enumeration<Currencies>(this, Currencies.SHP, code); 6692 if ("SLL".equals(codeString)) 6693 return new Enumeration<Currencies>(this, Currencies.SLL, code); 6694 if ("SOS".equals(codeString)) 6695 return new Enumeration<Currencies>(this, Currencies.SOS, code); 6696 if ("SRD".equals(codeString)) 6697 return new Enumeration<Currencies>(this, Currencies.SRD, code); 6698 if ("SSP".equals(codeString)) 6699 return new Enumeration<Currencies>(this, Currencies.SSP, code); 6700 if ("STN".equals(codeString)) 6701 return new Enumeration<Currencies>(this, Currencies.STN, code); 6702 if ("SVC".equals(codeString)) 6703 return new Enumeration<Currencies>(this, Currencies.SVC, code); 6704 if ("SYP".equals(codeString)) 6705 return new Enumeration<Currencies>(this, Currencies.SYP, code); 6706 if ("SZL".equals(codeString)) 6707 return new Enumeration<Currencies>(this, Currencies.SZL, code); 6708 if ("THB".equals(codeString)) 6709 return new Enumeration<Currencies>(this, Currencies.THB, code); 6710 if ("TJS".equals(codeString)) 6711 return new Enumeration<Currencies>(this, Currencies.TJS, code); 6712 if ("TMT".equals(codeString)) 6713 return new Enumeration<Currencies>(this, Currencies.TMT, code); 6714 if ("TND".equals(codeString)) 6715 return new Enumeration<Currencies>(this, Currencies.TND, code); 6716 if ("TOP".equals(codeString)) 6717 return new Enumeration<Currencies>(this, Currencies.TOP, code); 6718 if ("TRY".equals(codeString)) 6719 return new Enumeration<Currencies>(this, Currencies.TRY, code); 6720 if ("TTD".equals(codeString)) 6721 return new Enumeration<Currencies>(this, Currencies.TTD, code); 6722 if ("TVD".equals(codeString)) 6723 return new Enumeration<Currencies>(this, Currencies.TVD, code); 6724 if ("TWD".equals(codeString)) 6725 return new Enumeration<Currencies>(this, Currencies.TWD, code); 6726 if ("TZS".equals(codeString)) 6727 return new Enumeration<Currencies>(this, Currencies.TZS, code); 6728 if ("UAH".equals(codeString)) 6729 return new Enumeration<Currencies>(this, Currencies.UAH, code); 6730 if ("UGX".equals(codeString)) 6731 return new Enumeration<Currencies>(this, Currencies.UGX, code); 6732 if ("USD".equals(codeString)) 6733 return new Enumeration<Currencies>(this, Currencies.USD, code); 6734 if ("USN".equals(codeString)) 6735 return new Enumeration<Currencies>(this, Currencies.USN, code); 6736 if ("UYI".equals(codeString)) 6737 return new Enumeration<Currencies>(this, Currencies.UYI, code); 6738 if ("UYU".equals(codeString)) 6739 return new Enumeration<Currencies>(this, Currencies.UYU, code); 6740 if ("UZS".equals(codeString)) 6741 return new Enumeration<Currencies>(this, Currencies.UZS, code); 6742 if ("VEF".equals(codeString)) 6743 return new Enumeration<Currencies>(this, Currencies.VEF, code); 6744 if ("VND".equals(codeString)) 6745 return new Enumeration<Currencies>(this, Currencies.VND, code); 6746 if ("VUV".equals(codeString)) 6747 return new Enumeration<Currencies>(this, Currencies.VUV, code); 6748 if ("WST".equals(codeString)) 6749 return new Enumeration<Currencies>(this, Currencies.WST, code); 6750 if ("XAF".equals(codeString)) 6751 return new Enumeration<Currencies>(this, Currencies.XAF, code); 6752 if ("XAG".equals(codeString)) 6753 return new Enumeration<Currencies>(this, Currencies.XAG, code); 6754 if ("XAU".equals(codeString)) 6755 return new Enumeration<Currencies>(this, Currencies.XAU, code); 6756 if ("XBA".equals(codeString)) 6757 return new Enumeration<Currencies>(this, Currencies.XBA, code); 6758 if ("XBB".equals(codeString)) 6759 return new Enumeration<Currencies>(this, Currencies.XBB, code); 6760 if ("XBC".equals(codeString)) 6761 return new Enumeration<Currencies>(this, Currencies.XBC, code); 6762 if ("XBD".equals(codeString)) 6763 return new Enumeration<Currencies>(this, Currencies.XBD, code); 6764 if ("XCD".equals(codeString)) 6765 return new Enumeration<Currencies>(this, Currencies.XCD, code); 6766 if ("XDR".equals(codeString)) 6767 return new Enumeration<Currencies>(this, Currencies.XDR, code); 6768 if ("XOF".equals(codeString)) 6769 return new Enumeration<Currencies>(this, Currencies.XOF, code); 6770 if ("XPD".equals(codeString)) 6771 return new Enumeration<Currencies>(this, Currencies.XPD, code); 6772 if ("XPF".equals(codeString)) 6773 return new Enumeration<Currencies>(this, Currencies.XPF, code); 6774 if ("XPT".equals(codeString)) 6775 return new Enumeration<Currencies>(this, Currencies.XPT, code); 6776 if ("XSU".equals(codeString)) 6777 return new Enumeration<Currencies>(this, Currencies.XSU, code); 6778 if ("XTS".equals(codeString)) 6779 return new Enumeration<Currencies>(this, Currencies.XTS, code); 6780 if ("XUA".equals(codeString)) 6781 return new Enumeration<Currencies>(this, Currencies.XUA, code); 6782 if ("XXX".equals(codeString)) 6783 return new Enumeration<Currencies>(this, Currencies.XXX, code); 6784 if ("YER".equals(codeString)) 6785 return new Enumeration<Currencies>(this, Currencies.YER, code); 6786 if ("ZAR".equals(codeString)) 6787 return new Enumeration<Currencies>(this, Currencies.ZAR, code); 6788 if ("ZMW".equals(codeString)) 6789 return new Enumeration<Currencies>(this, Currencies.ZMW, code); 6790 if ("ZWL".equals(codeString)) 6791 return new Enumeration<Currencies>(this, Currencies.ZWL, code); 6792 throw new FHIRException("Unknown Currencies code '"+codeString+"'"); 6793 } 6794 public String toCode(Currencies code) { 6795 if (code == Currencies.NULL) 6796 return null; 6797 if (code == Currencies.AED) 6798 return "AED"; 6799 if (code == Currencies.AFN) 6800 return "AFN"; 6801 if (code == Currencies.ALL) 6802 return "ALL"; 6803 if (code == Currencies.AMD) 6804 return "AMD"; 6805 if (code == Currencies.ANG) 6806 return "ANG"; 6807 if (code == Currencies.AOA) 6808 return "AOA"; 6809 if (code == Currencies.ARS) 6810 return "ARS"; 6811 if (code == Currencies.AUD) 6812 return "AUD"; 6813 if (code == Currencies.AWG) 6814 return "AWG"; 6815 if (code == Currencies.AZN) 6816 return "AZN"; 6817 if (code == Currencies.BAM) 6818 return "BAM"; 6819 if (code == Currencies.BBD) 6820 return "BBD"; 6821 if (code == Currencies.BDT) 6822 return "BDT"; 6823 if (code == Currencies.BGN) 6824 return "BGN"; 6825 if (code == Currencies.BHD) 6826 return "BHD"; 6827 if (code == Currencies.BIF) 6828 return "BIF"; 6829 if (code == Currencies.BMD) 6830 return "BMD"; 6831 if (code == Currencies.BND) 6832 return "BND"; 6833 if (code == Currencies.BOB) 6834 return "BOB"; 6835 if (code == Currencies.BOV) 6836 return "BOV"; 6837 if (code == Currencies.BRL) 6838 return "BRL"; 6839 if (code == Currencies.BSD) 6840 return "BSD"; 6841 if (code == Currencies.BTN) 6842 return "BTN"; 6843 if (code == Currencies.BWP) 6844 return "BWP"; 6845 if (code == Currencies.BYN) 6846 return "BYN"; 6847 if (code == Currencies.BZD) 6848 return "BZD"; 6849 if (code == Currencies.CAD) 6850 return "CAD"; 6851 if (code == Currencies.CDF) 6852 return "CDF"; 6853 if (code == Currencies.CHE) 6854 return "CHE"; 6855 if (code == Currencies.CHF) 6856 return "CHF"; 6857 if (code == Currencies.CHW) 6858 return "CHW"; 6859 if (code == Currencies.CLF) 6860 return "CLF"; 6861 if (code == Currencies.CLP) 6862 return "CLP"; 6863 if (code == Currencies.CNY) 6864 return "CNY"; 6865 if (code == Currencies.COP) 6866 return "COP"; 6867 if (code == Currencies.COU) 6868 return "COU"; 6869 if (code == Currencies.CRC) 6870 return "CRC"; 6871 if (code == Currencies.CUC) 6872 return "CUC"; 6873 if (code == Currencies.CUP) 6874 return "CUP"; 6875 if (code == Currencies.CVE) 6876 return "CVE"; 6877 if (code == Currencies.CZK) 6878 return "CZK"; 6879 if (code == Currencies.DJF) 6880 return "DJF"; 6881 if (code == Currencies.DKK) 6882 return "DKK"; 6883 if (code == Currencies.DOP) 6884 return "DOP"; 6885 if (code == Currencies.DZD) 6886 return "DZD"; 6887 if (code == Currencies.EGP) 6888 return "EGP"; 6889 if (code == Currencies.ERN) 6890 return "ERN"; 6891 if (code == Currencies.ETB) 6892 return "ETB"; 6893 if (code == Currencies.EUR) 6894 return "EUR"; 6895 if (code == Currencies.FJD) 6896 return "FJD"; 6897 if (code == Currencies.FKP) 6898 return "FKP"; 6899 if (code == Currencies.GBP) 6900 return "GBP"; 6901 if (code == Currencies.GEL) 6902 return "GEL"; 6903 if (code == Currencies.GGP) 6904 return "GGP"; 6905 if (code == Currencies.GHS) 6906 return "GHS"; 6907 if (code == Currencies.GIP) 6908 return "GIP"; 6909 if (code == Currencies.GMD) 6910 return "GMD"; 6911 if (code == Currencies.GNF) 6912 return "GNF"; 6913 if (code == Currencies.GTQ) 6914 return "GTQ"; 6915 if (code == Currencies.GYD) 6916 return "GYD"; 6917 if (code == Currencies.HKD) 6918 return "HKD"; 6919 if (code == Currencies.HNL) 6920 return "HNL"; 6921 if (code == Currencies.HRK) 6922 return "HRK"; 6923 if (code == Currencies.HTG) 6924 return "HTG"; 6925 if (code == Currencies.HUF) 6926 return "HUF"; 6927 if (code == Currencies.IDR) 6928 return "IDR"; 6929 if (code == Currencies.ILS) 6930 return "ILS"; 6931 if (code == Currencies.IMP) 6932 return "IMP"; 6933 if (code == Currencies.INR) 6934 return "INR"; 6935 if (code == Currencies.IQD) 6936 return "IQD"; 6937 if (code == Currencies.IRR) 6938 return "IRR"; 6939 if (code == Currencies.ISK) 6940 return "ISK"; 6941 if (code == Currencies.JEP) 6942 return "JEP"; 6943 if (code == Currencies.JMD) 6944 return "JMD"; 6945 if (code == Currencies.JOD) 6946 return "JOD"; 6947 if (code == Currencies.JPY) 6948 return "JPY"; 6949 if (code == Currencies.KES) 6950 return "KES"; 6951 if (code == Currencies.KGS) 6952 return "KGS"; 6953 if (code == Currencies.KHR) 6954 return "KHR"; 6955 if (code == Currencies.KMF) 6956 return "KMF"; 6957 if (code == Currencies.KPW) 6958 return "KPW"; 6959 if (code == Currencies.KRW) 6960 return "KRW"; 6961 if (code == Currencies.KWD) 6962 return "KWD"; 6963 if (code == Currencies.KYD) 6964 return "KYD"; 6965 if (code == Currencies.KZT) 6966 return "KZT"; 6967 if (code == Currencies.LAK) 6968 return "LAK"; 6969 if (code == Currencies.LBP) 6970 return "LBP"; 6971 if (code == Currencies.LKR) 6972 return "LKR"; 6973 if (code == Currencies.LRD) 6974 return "LRD"; 6975 if (code == Currencies.LSL) 6976 return "LSL"; 6977 if (code == Currencies.LYD) 6978 return "LYD"; 6979 if (code == Currencies.MAD) 6980 return "MAD"; 6981 if (code == Currencies.MDL) 6982 return "MDL"; 6983 if (code == Currencies.MGA) 6984 return "MGA"; 6985 if (code == Currencies.MKD) 6986 return "MKD"; 6987 if (code == Currencies.MMK) 6988 return "MMK"; 6989 if (code == Currencies.MNT) 6990 return "MNT"; 6991 if (code == Currencies.MOP) 6992 return "MOP"; 6993 if (code == Currencies.MRU) 6994 return "MRU"; 6995 if (code == Currencies.MUR) 6996 return "MUR"; 6997 if (code == Currencies.MVR) 6998 return "MVR"; 6999 if (code == Currencies.MWK) 7000 return "MWK"; 7001 if (code == Currencies.MXN) 7002 return "MXN"; 7003 if (code == Currencies.MXV) 7004 return "MXV"; 7005 if (code == Currencies.MYR) 7006 return "MYR"; 7007 if (code == Currencies.MZN) 7008 return "MZN"; 7009 if (code == Currencies.NAD) 7010 return "NAD"; 7011 if (code == Currencies.NGN) 7012 return "NGN"; 7013 if (code == Currencies.NIO) 7014 return "NIO"; 7015 if (code == Currencies.NOK) 7016 return "NOK"; 7017 if (code == Currencies.NPR) 7018 return "NPR"; 7019 if (code == Currencies.NZD) 7020 return "NZD"; 7021 if (code == Currencies.OMR) 7022 return "OMR"; 7023 if (code == Currencies.PAB) 7024 return "PAB"; 7025 if (code == Currencies.PEN) 7026 return "PEN"; 7027 if (code == Currencies.PGK) 7028 return "PGK"; 7029 if (code == Currencies.PHP) 7030 return "PHP"; 7031 if (code == Currencies.PKR) 7032 return "PKR"; 7033 if (code == Currencies.PLN) 7034 return "PLN"; 7035 if (code == Currencies.PYG) 7036 return "PYG"; 7037 if (code == Currencies.QAR) 7038 return "QAR"; 7039 if (code == Currencies.RON) 7040 return "RON"; 7041 if (code == Currencies.RSD) 7042 return "RSD"; 7043 if (code == Currencies.RUB) 7044 return "RUB"; 7045 if (code == Currencies.RWF) 7046 return "RWF"; 7047 if (code == Currencies.SAR) 7048 return "SAR"; 7049 if (code == Currencies.SBD) 7050 return "SBD"; 7051 if (code == Currencies.SCR) 7052 return "SCR"; 7053 if (code == Currencies.SDG) 7054 return "SDG"; 7055 if (code == Currencies.SEK) 7056 return "SEK"; 7057 if (code == Currencies.SGD) 7058 return "SGD"; 7059 if (code == Currencies.SHP) 7060 return "SHP"; 7061 if (code == Currencies.SLL) 7062 return "SLL"; 7063 if (code == Currencies.SOS) 7064 return "SOS"; 7065 if (code == Currencies.SRD) 7066 return "SRD"; 7067 if (code == Currencies.SSP) 7068 return "SSP"; 7069 if (code == Currencies.STN) 7070 return "STN"; 7071 if (code == Currencies.SVC) 7072 return "SVC"; 7073 if (code == Currencies.SYP) 7074 return "SYP"; 7075 if (code == Currencies.SZL) 7076 return "SZL"; 7077 if (code == Currencies.THB) 7078 return "THB"; 7079 if (code == Currencies.TJS) 7080 return "TJS"; 7081 if (code == Currencies.TMT) 7082 return "TMT"; 7083 if (code == Currencies.TND) 7084 return "TND"; 7085 if (code == Currencies.TOP) 7086 return "TOP"; 7087 if (code == Currencies.TRY) 7088 return "TRY"; 7089 if (code == Currencies.TTD) 7090 return "TTD"; 7091 if (code == Currencies.TVD) 7092 return "TVD"; 7093 if (code == Currencies.TWD) 7094 return "TWD"; 7095 if (code == Currencies.TZS) 7096 return "TZS"; 7097 if (code == Currencies.UAH) 7098 return "UAH"; 7099 if (code == Currencies.UGX) 7100 return "UGX"; 7101 if (code == Currencies.USD) 7102 return "USD"; 7103 if (code == Currencies.USN) 7104 return "USN"; 7105 if (code == Currencies.UYI) 7106 return "UYI"; 7107 if (code == Currencies.UYU) 7108 return "UYU"; 7109 if (code == Currencies.UZS) 7110 return "UZS"; 7111 if (code == Currencies.VEF) 7112 return "VEF"; 7113 if (code == Currencies.VND) 7114 return "VND"; 7115 if (code == Currencies.VUV) 7116 return "VUV"; 7117 if (code == Currencies.WST) 7118 return "WST"; 7119 if (code == Currencies.XAF) 7120 return "XAF"; 7121 if (code == Currencies.XAG) 7122 return "XAG"; 7123 if (code == Currencies.XAU) 7124 return "XAU"; 7125 if (code == Currencies.XBA) 7126 return "XBA"; 7127 if (code == Currencies.XBB) 7128 return "XBB"; 7129 if (code == Currencies.XBC) 7130 return "XBC"; 7131 if (code == Currencies.XBD) 7132 return "XBD"; 7133 if (code == Currencies.XCD) 7134 return "XCD"; 7135 if (code == Currencies.XDR) 7136 return "XDR"; 7137 if (code == Currencies.XOF) 7138 return "XOF"; 7139 if (code == Currencies.XPD) 7140 return "XPD"; 7141 if (code == Currencies.XPF) 7142 return "XPF"; 7143 if (code == Currencies.XPT) 7144 return "XPT"; 7145 if (code == Currencies.XSU) 7146 return "XSU"; 7147 if (code == Currencies.XTS) 7148 return "XTS"; 7149 if (code == Currencies.XUA) 7150 return "XUA"; 7151 if (code == Currencies.XXX) 7152 return "XXX"; 7153 if (code == Currencies.YER) 7154 return "YER"; 7155 if (code == Currencies.ZAR) 7156 return "ZAR"; 7157 if (code == Currencies.ZMW) 7158 return "ZMW"; 7159 if (code == Currencies.ZWL) 7160 return "ZWL"; 7161 return "?"; 7162 } 7163 public String toSystem(Currencies code) { 7164 return code.getSystem(); 7165 } 7166 } 7167 7168 public enum DaysOfWeek { 7169 /** 7170 * Monday. 7171 */ 7172 MON, 7173 /** 7174 * Tuesday. 7175 */ 7176 TUE, 7177 /** 7178 * Wednesday. 7179 */ 7180 WED, 7181 /** 7182 * Thursday. 7183 */ 7184 THU, 7185 /** 7186 * Friday. 7187 */ 7188 FRI, 7189 /** 7190 * Saturday. 7191 */ 7192 SAT, 7193 /** 7194 * Sunday. 7195 */ 7196 SUN, 7197 /** 7198 * added to help the parsers 7199 */ 7200 NULL; 7201 public static DaysOfWeek fromCode(String codeString) throws FHIRException { 7202 if (codeString == null || "".equals(codeString)) 7203 return null; 7204 if ("mon".equals(codeString)) 7205 return MON; 7206 if ("tue".equals(codeString)) 7207 return TUE; 7208 if ("wed".equals(codeString)) 7209 return WED; 7210 if ("thu".equals(codeString)) 7211 return THU; 7212 if ("fri".equals(codeString)) 7213 return FRI; 7214 if ("sat".equals(codeString)) 7215 return SAT; 7216 if ("sun".equals(codeString)) 7217 return SUN; 7218 throw new FHIRException("Unknown DaysOfWeek code '"+codeString+"'"); 7219 } 7220 public static boolean isValidCode(String codeString) { 7221 if (codeString == null || "".equals(codeString)) 7222 return false; 7223 return Utilities.existsInList(codeString, "mon", "tue", "wed", "thu", "fri", "sat", "sun"); 7224 } 7225 public String toCode() { 7226 switch (this) { 7227 case MON: return "mon"; 7228 case TUE: return "tue"; 7229 case WED: return "wed"; 7230 case THU: return "thu"; 7231 case FRI: return "fri"; 7232 case SAT: return "sat"; 7233 case SUN: return "sun"; 7234 case NULL: return null; 7235 default: return "?"; 7236 } 7237 } 7238 public String getSystem() { 7239 switch (this) { 7240 case MON: return "http://hl7.org/fhir/days-of-week"; 7241 case TUE: return "http://hl7.org/fhir/days-of-week"; 7242 case WED: return "http://hl7.org/fhir/days-of-week"; 7243 case THU: return "http://hl7.org/fhir/days-of-week"; 7244 case FRI: return "http://hl7.org/fhir/days-of-week"; 7245 case SAT: return "http://hl7.org/fhir/days-of-week"; 7246 case SUN: return "http://hl7.org/fhir/days-of-week"; 7247 case NULL: return null; 7248 default: return "?"; 7249 } 7250 } 7251 public String getDefinition() { 7252 switch (this) { 7253 case MON: return "Monday."; 7254 case TUE: return "Tuesday."; 7255 case WED: return "Wednesday."; 7256 case THU: return "Thursday."; 7257 case FRI: return "Friday."; 7258 case SAT: return "Saturday."; 7259 case SUN: return "Sunday."; 7260 case NULL: return null; 7261 default: return "?"; 7262 } 7263 } 7264 public String getDisplay() { 7265 switch (this) { 7266 case MON: return "Monday"; 7267 case TUE: return "Tuesday"; 7268 case WED: return "Wednesday"; 7269 case THU: return "Thursday"; 7270 case FRI: return "Friday"; 7271 case SAT: return "Saturday"; 7272 case SUN: return "Sunday"; 7273 case NULL: return null; 7274 default: return "?"; 7275 } 7276 } 7277 } 7278 7279 public static class DaysOfWeekEnumFactory implements EnumFactory<DaysOfWeek> { 7280 public DaysOfWeek fromCode(String codeString) throws IllegalArgumentException { 7281 if (codeString == null || "".equals(codeString)) 7282 if (codeString == null || "".equals(codeString)) 7283 return null; 7284 if ("mon".equals(codeString)) 7285 return DaysOfWeek.MON; 7286 if ("tue".equals(codeString)) 7287 return DaysOfWeek.TUE; 7288 if ("wed".equals(codeString)) 7289 return DaysOfWeek.WED; 7290 if ("thu".equals(codeString)) 7291 return DaysOfWeek.THU; 7292 if ("fri".equals(codeString)) 7293 return DaysOfWeek.FRI; 7294 if ("sat".equals(codeString)) 7295 return DaysOfWeek.SAT; 7296 if ("sun".equals(codeString)) 7297 return DaysOfWeek.SUN; 7298 throw new IllegalArgumentException("Unknown DaysOfWeek code '"+codeString+"'"); 7299 } 7300 7301 public Enumeration<DaysOfWeek> fromType(PrimitiveType<?> code) throws FHIRException { 7302 if (code == null) 7303 return null; 7304 if (code.isEmpty()) 7305 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.NULL, code); 7306 String codeString = ((PrimitiveType) code).asStringValue(); 7307 if (codeString == null || "".equals(codeString)) 7308 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.NULL, code); 7309 if ("mon".equals(codeString)) 7310 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.MON, code); 7311 if ("tue".equals(codeString)) 7312 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.TUE, code); 7313 if ("wed".equals(codeString)) 7314 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.WED, code); 7315 if ("thu".equals(codeString)) 7316 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.THU, code); 7317 if ("fri".equals(codeString)) 7318 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.FRI, code); 7319 if ("sat".equals(codeString)) 7320 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.SAT, code); 7321 if ("sun".equals(codeString)) 7322 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.SUN, code); 7323 throw new FHIRException("Unknown DaysOfWeek code '"+codeString+"'"); 7324 } 7325 public String toCode(DaysOfWeek code) { 7326 if (code == DaysOfWeek.NULL) 7327 return null; 7328 if (code == DaysOfWeek.MON) 7329 return "mon"; 7330 if (code == DaysOfWeek.TUE) 7331 return "tue"; 7332 if (code == DaysOfWeek.WED) 7333 return "wed"; 7334 if (code == DaysOfWeek.THU) 7335 return "thu"; 7336 if (code == DaysOfWeek.FRI) 7337 return "fri"; 7338 if (code == DaysOfWeek.SAT) 7339 return "sat"; 7340 if (code == DaysOfWeek.SUN) 7341 return "sun"; 7342 return "?"; 7343 } 7344 public String toSystem(DaysOfWeek code) { 7345 return code.getSystem(); 7346 } 7347 } 7348 7349 public enum DeviceNameType { 7350 /** 7351 * 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. 7352 */ 7353 REGISTEREDNAME, 7354 /** 7355 * 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. 7356 */ 7357 USERFRIENDLYNAME, 7358 /** 7359 * 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. 7360 */ 7361 PATIENTREPORTEDNAME, 7362 /** 7363 * added to help the parsers 7364 */ 7365 NULL; 7366 public static DeviceNameType fromCode(String codeString) throws FHIRException { 7367 if (codeString == null || "".equals(codeString)) 7368 return null; 7369 if ("registered-name".equals(codeString)) 7370 return REGISTEREDNAME; 7371 if ("user-friendly-name".equals(codeString)) 7372 return USERFRIENDLYNAME; 7373 if ("patient-reported-name".equals(codeString)) 7374 return PATIENTREPORTEDNAME; 7375 throw new FHIRException("Unknown DeviceNameType code '"+codeString+"'"); 7376 } 7377 public static boolean isValidCode(String codeString) { 7378 if (codeString == null || "".equals(codeString)) 7379 return false; 7380 return Utilities.existsInList(codeString, "registered-name", "user-friendly-name", "patient-reported-name"); 7381 } 7382 public String toCode() { 7383 switch (this) { 7384 case REGISTEREDNAME: return "registered-name"; 7385 case USERFRIENDLYNAME: return "user-friendly-name"; 7386 case PATIENTREPORTEDNAME: return "patient-reported-name"; 7387 case NULL: return null; 7388 default: return "?"; 7389 } 7390 } 7391 public String getSystem() { 7392 switch (this) { 7393 case REGISTEREDNAME: return "http://hl7.org/fhir/device-nametype"; 7394 case USERFRIENDLYNAME: return "http://hl7.org/fhir/device-nametype"; 7395 case PATIENTREPORTEDNAME: return "http://hl7.org/fhir/device-nametype"; 7396 case NULL: return null; 7397 default: return "?"; 7398 } 7399 } 7400 public String getDefinition() { 7401 switch (this) { 7402 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."; 7403 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."; 7404 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."; 7405 case NULL: return null; 7406 default: return "?"; 7407 } 7408 } 7409 public String getDisplay() { 7410 switch (this) { 7411 case REGISTEREDNAME: return "Registered name"; 7412 case USERFRIENDLYNAME: return "User Friendly name"; 7413 case PATIENTREPORTEDNAME: return "Patient Reported name"; 7414 case NULL: return null; 7415 default: return "?"; 7416 } 7417 } 7418 } 7419 7420 public static class DeviceNameTypeEnumFactory implements EnumFactory<DeviceNameType> { 7421 public DeviceNameType fromCode(String codeString) throws IllegalArgumentException { 7422 if (codeString == null || "".equals(codeString)) 7423 if (codeString == null || "".equals(codeString)) 7424 return null; 7425 if ("registered-name".equals(codeString)) 7426 return DeviceNameType.REGISTEREDNAME; 7427 if ("user-friendly-name".equals(codeString)) 7428 return DeviceNameType.USERFRIENDLYNAME; 7429 if ("patient-reported-name".equals(codeString)) 7430 return DeviceNameType.PATIENTREPORTEDNAME; 7431 throw new IllegalArgumentException("Unknown DeviceNameType code '"+codeString+"'"); 7432 } 7433 7434 public Enumeration<DeviceNameType> fromType(PrimitiveType<?> code) throws FHIRException { 7435 if (code == null) 7436 return null; 7437 if (code.isEmpty()) 7438 return new Enumeration<DeviceNameType>(this, DeviceNameType.NULL, code); 7439 String codeString = ((PrimitiveType) code).asStringValue(); 7440 if (codeString == null || "".equals(codeString)) 7441 return new Enumeration<DeviceNameType>(this, DeviceNameType.NULL, code); 7442 if ("registered-name".equals(codeString)) 7443 return new Enumeration<DeviceNameType>(this, DeviceNameType.REGISTEREDNAME, code); 7444 if ("user-friendly-name".equals(codeString)) 7445 return new Enumeration<DeviceNameType>(this, DeviceNameType.USERFRIENDLYNAME, code); 7446 if ("patient-reported-name".equals(codeString)) 7447 return new Enumeration<DeviceNameType>(this, DeviceNameType.PATIENTREPORTEDNAME, code); 7448 throw new FHIRException("Unknown DeviceNameType code '"+codeString+"'"); 7449 } 7450 public String toCode(DeviceNameType code) { 7451 if (code == DeviceNameType.NULL) 7452 return null; 7453 if (code == DeviceNameType.REGISTEREDNAME) 7454 return "registered-name"; 7455 if (code == DeviceNameType.USERFRIENDLYNAME) 7456 return "user-friendly-name"; 7457 if (code == DeviceNameType.PATIENTREPORTEDNAME) 7458 return "patient-reported-name"; 7459 return "?"; 7460 } 7461 public String toSystem(DeviceNameType code) { 7462 return code.getSystem(); 7463 } 7464 } 7465 7466 public enum EncounterStatus { 7467 /** 7468 * The Encounter has not yet started. 7469 */ 7470 PLANNED, 7471 /** 7472 * The Encounter has begun and the patient is present / the practitioner and the patient are meeting. 7473 */ 7474 INPROGRESS, 7475 /** 7476 * The Encounter has begun, but is currently on hold, e.g. because the patient is temporarily on leave. 7477 */ 7478 ONHOLD, 7479 /** 7480 * 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. 7481 */ 7482 DISCHARGED, 7483 /** 7484 * The Encounter has ended. 7485 */ 7486 COMPLETED, 7487 /** 7488 * The Encounter has ended before it has begun. 7489 */ 7490 CANCELLED, 7491 /** 7492 * 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. 7493 */ 7494 DISCONTINUED, 7495 /** 7496 * This instance should not have been part of this patient's medical record. 7497 */ 7498 ENTEREDINERROR, 7499 /** 7500 * 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". 7501 */ 7502 UNKNOWN, 7503 /** 7504 * added to help the parsers 7505 */ 7506 NULL; 7507 public static EncounterStatus fromCode(String codeString) throws FHIRException { 7508 if (codeString == null || "".equals(codeString)) 7509 return null; 7510 if ("planned".equals(codeString)) 7511 return PLANNED; 7512 if ("in-progress".equals(codeString)) 7513 return INPROGRESS; 7514 if ("on-hold".equals(codeString)) 7515 return ONHOLD; 7516 if ("discharged".equals(codeString)) 7517 return DISCHARGED; 7518 if ("completed".equals(codeString)) 7519 return COMPLETED; 7520 if ("cancelled".equals(codeString)) 7521 return CANCELLED; 7522 if ("discontinued".equals(codeString)) 7523 return DISCONTINUED; 7524 if ("entered-in-error".equals(codeString)) 7525 return ENTEREDINERROR; 7526 if ("unknown".equals(codeString)) 7527 return UNKNOWN; 7528 throw new FHIRException("Unknown EncounterStatus code '"+codeString+"'"); 7529 } 7530 public static boolean isValidCode(String codeString) { 7531 if (codeString == null || "".equals(codeString)) 7532 return false; 7533 return Utilities.existsInList(codeString, "planned", "in-progress", "on-hold", "discharged", "completed", "cancelled", "discontinued", "entered-in-error", "unknown"); 7534 } 7535 public String toCode() { 7536 switch (this) { 7537 case PLANNED: return "planned"; 7538 case INPROGRESS: return "in-progress"; 7539 case ONHOLD: return "on-hold"; 7540 case DISCHARGED: return "discharged"; 7541 case COMPLETED: return "completed"; 7542 case CANCELLED: return "cancelled"; 7543 case DISCONTINUED: return "discontinued"; 7544 case ENTEREDINERROR: return "entered-in-error"; 7545 case UNKNOWN: return "unknown"; 7546 case NULL: return null; 7547 default: return "?"; 7548 } 7549 } 7550 public String getSystem() { 7551 switch (this) { 7552 case PLANNED: return "http://hl7.org/fhir/encounter-status"; 7553 case INPROGRESS: return "http://hl7.org/fhir/encounter-status"; 7554 case ONHOLD: return "http://hl7.org/fhir/encounter-status"; 7555 case DISCHARGED: return "http://hl7.org/fhir/encounter-status"; 7556 case COMPLETED: return "http://hl7.org/fhir/encounter-status"; 7557 case CANCELLED: return "http://hl7.org/fhir/encounter-status"; 7558 case DISCONTINUED: return "http://hl7.org/fhir/encounter-status"; 7559 case ENTEREDINERROR: return "http://hl7.org/fhir/encounter-status"; 7560 case UNKNOWN: return "http://hl7.org/fhir/encounter-status"; 7561 case NULL: return null; 7562 default: return "?"; 7563 } 7564 } 7565 public String getDefinition() { 7566 switch (this) { 7567 case PLANNED: return "The Encounter has not yet started."; 7568 case INPROGRESS: return "The Encounter has begun and the patient is present / the practitioner and the patient are meeting."; 7569 case ONHOLD: return "The Encounter has begun, but is currently on hold, e.g. because the patient is temporarily on leave."; 7570 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."; 7571 case COMPLETED: return "The Encounter has ended."; 7572 case CANCELLED: return "The Encounter has ended before it has begun."; 7573 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."; 7574 case ENTEREDINERROR: return "This instance should not have been part of this patient's medical record."; 7575 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\"."; 7576 case NULL: return null; 7577 default: return "?"; 7578 } 7579 } 7580 public String getDisplay() { 7581 switch (this) { 7582 case PLANNED: return "Planned"; 7583 case INPROGRESS: return "In Progress"; 7584 case ONHOLD: return "On Hold"; 7585 case DISCHARGED: return "Discharged"; 7586 case COMPLETED: return "Completed"; 7587 case CANCELLED: return "Cancelled"; 7588 case DISCONTINUED: return "Discontinued"; 7589 case ENTEREDINERROR: return "Entered in Error"; 7590 case UNKNOWN: return "Unknown"; 7591 case NULL: return null; 7592 default: return "?"; 7593 } 7594 } 7595 } 7596 7597 public static class EncounterStatusEnumFactory implements EnumFactory<EncounterStatus> { 7598 public EncounterStatus fromCode(String codeString) throws IllegalArgumentException { 7599 if (codeString == null || "".equals(codeString)) 7600 if (codeString == null || "".equals(codeString)) 7601 return null; 7602 if ("planned".equals(codeString)) 7603 return EncounterStatus.PLANNED; 7604 if ("in-progress".equals(codeString)) 7605 return EncounterStatus.INPROGRESS; 7606 if ("on-hold".equals(codeString)) 7607 return EncounterStatus.ONHOLD; 7608 if ("discharged".equals(codeString)) 7609 return EncounterStatus.DISCHARGED; 7610 if ("completed".equals(codeString)) 7611 return EncounterStatus.COMPLETED; 7612 if ("cancelled".equals(codeString)) 7613 return EncounterStatus.CANCELLED; 7614 if ("discontinued".equals(codeString)) 7615 return EncounterStatus.DISCONTINUED; 7616 if ("entered-in-error".equals(codeString)) 7617 return EncounterStatus.ENTEREDINERROR; 7618 if ("unknown".equals(codeString)) 7619 return EncounterStatus.UNKNOWN; 7620 throw new IllegalArgumentException("Unknown EncounterStatus code '"+codeString+"'"); 7621 } 7622 7623 public Enumeration<EncounterStatus> fromType(PrimitiveType<?> code) throws FHIRException { 7624 if (code == null) 7625 return null; 7626 if (code.isEmpty()) 7627 return new Enumeration<EncounterStatus>(this, EncounterStatus.NULL, code); 7628 String codeString = ((PrimitiveType) code).asStringValue(); 7629 if (codeString == null || "".equals(codeString)) 7630 return new Enumeration<EncounterStatus>(this, EncounterStatus.NULL, code); 7631 if ("planned".equals(codeString)) 7632 return new Enumeration<EncounterStatus>(this, EncounterStatus.PLANNED, code); 7633 if ("in-progress".equals(codeString)) 7634 return new Enumeration<EncounterStatus>(this, EncounterStatus.INPROGRESS, code); 7635 if ("on-hold".equals(codeString)) 7636 return new Enumeration<EncounterStatus>(this, EncounterStatus.ONHOLD, code); 7637 if ("discharged".equals(codeString)) 7638 return new Enumeration<EncounterStatus>(this, EncounterStatus.DISCHARGED, code); 7639 if ("completed".equals(codeString)) 7640 return new Enumeration<EncounterStatus>(this, EncounterStatus.COMPLETED, code); 7641 if ("cancelled".equals(codeString)) 7642 return new Enumeration<EncounterStatus>(this, EncounterStatus.CANCELLED, code); 7643 if ("discontinued".equals(codeString)) 7644 return new Enumeration<EncounterStatus>(this, EncounterStatus.DISCONTINUED, code); 7645 if ("entered-in-error".equals(codeString)) 7646 return new Enumeration<EncounterStatus>(this, EncounterStatus.ENTEREDINERROR, code); 7647 if ("unknown".equals(codeString)) 7648 return new Enumeration<EncounterStatus>(this, EncounterStatus.UNKNOWN, code); 7649 throw new FHIRException("Unknown EncounterStatus code '"+codeString+"'"); 7650 } 7651 public String toCode(EncounterStatus code) { 7652 if (code == EncounterStatus.NULL) 7653 return null; 7654 if (code == EncounterStatus.PLANNED) 7655 return "planned"; 7656 if (code == EncounterStatus.INPROGRESS) 7657 return "in-progress"; 7658 if (code == EncounterStatus.ONHOLD) 7659 return "on-hold"; 7660 if (code == EncounterStatus.DISCHARGED) 7661 return "discharged"; 7662 if (code == EncounterStatus.COMPLETED) 7663 return "completed"; 7664 if (code == EncounterStatus.CANCELLED) 7665 return "cancelled"; 7666 if (code == EncounterStatus.DISCONTINUED) 7667 return "discontinued"; 7668 if (code == EncounterStatus.ENTEREDINERROR) 7669 return "entered-in-error"; 7670 if (code == EncounterStatus.UNKNOWN) 7671 return "unknown"; 7672 return "?"; 7673 } 7674 public String toSystem(EncounterStatus code) { 7675 return code.getSystem(); 7676 } 7677 } 7678 7679 public enum EventStatus { 7680 /** 7681 * 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. 7682 */ 7683 PREPARATION, 7684 /** 7685 * The event is currently occurring. 7686 */ 7687 INPROGRESS, 7688 /** 7689 * 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. 7690 */ 7691 NOTDONE, 7692 /** 7693 * The event has been temporarily stopped but is expected to resume in the future. 7694 */ 7695 ONHOLD, 7696 /** 7697 * 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. 7698 */ 7699 STOPPED, 7700 /** 7701 * The event has now concluded. 7702 */ 7703 COMPLETED, 7704 /** 7705 * 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".). 7706 */ 7707 ENTEREDINERROR, 7708 /** 7709 * 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. 7710 */ 7711 UNKNOWN, 7712 /** 7713 * added to help the parsers 7714 */ 7715 NULL; 7716 public static EventStatus fromCode(String codeString) throws FHIRException { 7717 if (codeString == null || "".equals(codeString)) 7718 return null; 7719 if ("preparation".equals(codeString)) 7720 return PREPARATION; 7721 if ("in-progress".equals(codeString)) 7722 return INPROGRESS; 7723 if ("not-done".equals(codeString)) 7724 return NOTDONE; 7725 if ("on-hold".equals(codeString)) 7726 return ONHOLD; 7727 if ("stopped".equals(codeString)) 7728 return STOPPED; 7729 if ("completed".equals(codeString)) 7730 return COMPLETED; 7731 if ("entered-in-error".equals(codeString)) 7732 return ENTEREDINERROR; 7733 if ("unknown".equals(codeString)) 7734 return UNKNOWN; 7735 throw new FHIRException("Unknown EventStatus code '"+codeString+"'"); 7736 } 7737 public static boolean isValidCode(String codeString) { 7738 if (codeString == null || "".equals(codeString)) 7739 return false; 7740 return Utilities.existsInList(codeString, "preparation", "in-progress", "not-done", "on-hold", "stopped", "completed", "entered-in-error", "unknown"); 7741 } 7742 public String toCode() { 7743 switch (this) { 7744 case PREPARATION: return "preparation"; 7745 case INPROGRESS: return "in-progress"; 7746 case NOTDONE: return "not-done"; 7747 case ONHOLD: return "on-hold"; 7748 case STOPPED: return "stopped"; 7749 case COMPLETED: return "completed"; 7750 case ENTEREDINERROR: return "entered-in-error"; 7751 case UNKNOWN: return "unknown"; 7752 case NULL: return null; 7753 default: return "?"; 7754 } 7755 } 7756 public String getSystem() { 7757 switch (this) { 7758 case PREPARATION: return "http://hl7.org/fhir/event-status"; 7759 case INPROGRESS: return "http://hl7.org/fhir/event-status"; 7760 case NOTDONE: return "http://hl7.org/fhir/event-status"; 7761 case ONHOLD: return "http://hl7.org/fhir/event-status"; 7762 case STOPPED: return "http://hl7.org/fhir/event-status"; 7763 case COMPLETED: return "http://hl7.org/fhir/event-status"; 7764 case ENTEREDINERROR: return "http://hl7.org/fhir/event-status"; 7765 case UNKNOWN: return "http://hl7.org/fhir/event-status"; 7766 case NULL: return null; 7767 default: return "?"; 7768 } 7769 } 7770 public String getDefinition() { 7771 switch (this) { 7772 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."; 7773 case INPROGRESS: return "The event is currently occurring."; 7774 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."; 7775 case ONHOLD: return "The event has been temporarily stopped but is expected to resume in the future."; 7776 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."; 7777 case COMPLETED: return "The event has now concluded."; 7778 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\".)."; 7779 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."; 7780 case NULL: return null; 7781 default: return "?"; 7782 } 7783 } 7784 public String getDisplay() { 7785 switch (this) { 7786 case PREPARATION: return "Preparation"; 7787 case INPROGRESS: return "In Progress"; 7788 case NOTDONE: return "Not Done"; 7789 case ONHOLD: return "On Hold"; 7790 case STOPPED: return "Stopped"; 7791 case COMPLETED: return "Completed"; 7792 case ENTEREDINERROR: return "Entered in Error"; 7793 case UNKNOWN: return "Unknown"; 7794 case NULL: return null; 7795 default: return "?"; 7796 } 7797 } 7798 } 7799 7800 public static class EventStatusEnumFactory implements EnumFactory<EventStatus> { 7801 public EventStatus fromCode(String codeString) throws IllegalArgumentException { 7802 if (codeString == null || "".equals(codeString)) 7803 if (codeString == null || "".equals(codeString)) 7804 return null; 7805 if ("preparation".equals(codeString)) 7806 return EventStatus.PREPARATION; 7807 if ("in-progress".equals(codeString)) 7808 return EventStatus.INPROGRESS; 7809 if ("not-done".equals(codeString)) 7810 return EventStatus.NOTDONE; 7811 if ("on-hold".equals(codeString)) 7812 return EventStatus.ONHOLD; 7813 if ("stopped".equals(codeString)) 7814 return EventStatus.STOPPED; 7815 if ("completed".equals(codeString)) 7816 return EventStatus.COMPLETED; 7817 if ("entered-in-error".equals(codeString)) 7818 return EventStatus.ENTEREDINERROR; 7819 if ("unknown".equals(codeString)) 7820 return EventStatus.UNKNOWN; 7821 throw new IllegalArgumentException("Unknown EventStatus code '"+codeString+"'"); 7822 } 7823 7824 public Enumeration<EventStatus> fromType(PrimitiveType<?> code) throws FHIRException { 7825 if (code == null) 7826 return null; 7827 if (code.isEmpty()) 7828 return new Enumeration<EventStatus>(this, EventStatus.NULL, code); 7829 String codeString = ((PrimitiveType) code).asStringValue(); 7830 if (codeString == null || "".equals(codeString)) 7831 return new Enumeration<EventStatus>(this, EventStatus.NULL, code); 7832 if ("preparation".equals(codeString)) 7833 return new Enumeration<EventStatus>(this, EventStatus.PREPARATION, code); 7834 if ("in-progress".equals(codeString)) 7835 return new Enumeration<EventStatus>(this, EventStatus.INPROGRESS, code); 7836 if ("not-done".equals(codeString)) 7837 return new Enumeration<EventStatus>(this, EventStatus.NOTDONE, code); 7838 if ("on-hold".equals(codeString)) 7839 return new Enumeration<EventStatus>(this, EventStatus.ONHOLD, code); 7840 if ("stopped".equals(codeString)) 7841 return new Enumeration<EventStatus>(this, EventStatus.STOPPED, code); 7842 if ("completed".equals(codeString)) 7843 return new Enumeration<EventStatus>(this, EventStatus.COMPLETED, code); 7844 if ("entered-in-error".equals(codeString)) 7845 return new Enumeration<EventStatus>(this, EventStatus.ENTEREDINERROR, code); 7846 if ("unknown".equals(codeString)) 7847 return new Enumeration<EventStatus>(this, EventStatus.UNKNOWN, code); 7848 throw new FHIRException("Unknown EventStatus code '"+codeString+"'"); 7849 } 7850 public String toCode(EventStatus code) { 7851 if (code == EventStatus.NULL) 7852 return null; 7853 if (code == EventStatus.PREPARATION) 7854 return "preparation"; 7855 if (code == EventStatus.INPROGRESS) 7856 return "in-progress"; 7857 if (code == EventStatus.NOTDONE) 7858 return "not-done"; 7859 if (code == EventStatus.ONHOLD) 7860 return "on-hold"; 7861 if (code == EventStatus.STOPPED) 7862 return "stopped"; 7863 if (code == EventStatus.COMPLETED) 7864 return "completed"; 7865 if (code == EventStatus.ENTEREDINERROR) 7866 return "entered-in-error"; 7867 if (code == EventStatus.UNKNOWN) 7868 return "unknown"; 7869 return "?"; 7870 } 7871 public String toSystem(EventStatus code) { 7872 return code.getSystem(); 7873 } 7874 } 7875 7876 public enum EvidenceVariableHandling { 7877 /** 7878 * 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). 7879 */ 7880 CONTINUOUS, 7881 /** 7882 * 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). 7883 */ 7884 DICHOTOMOUS, 7885 /** 7886 * 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). 7887 */ 7888 ORDINAL, 7889 /** 7890 * 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. 7891 */ 7892 POLYCHOTOMOUS, 7893 /** 7894 * added to help the parsers 7895 */ 7896 NULL; 7897 public static EvidenceVariableHandling fromCode(String codeString) throws FHIRException { 7898 if (codeString == null || "".equals(codeString)) 7899 return null; 7900 if ("continuous".equals(codeString)) 7901 return CONTINUOUS; 7902 if ("dichotomous".equals(codeString)) 7903 return DICHOTOMOUS; 7904 if ("ordinal".equals(codeString)) 7905 return ORDINAL; 7906 if ("polychotomous".equals(codeString)) 7907 return POLYCHOTOMOUS; 7908 throw new FHIRException("Unknown EvidenceVariableHandling code '"+codeString+"'"); 7909 } 7910 public static boolean isValidCode(String codeString) { 7911 if (codeString == null || "".equals(codeString)) 7912 return false; 7913 return Utilities.existsInList(codeString, "continuous", "dichotomous", "ordinal", "polychotomous"); 7914 } 7915 public String toCode() { 7916 switch (this) { 7917 case CONTINUOUS: return "continuous"; 7918 case DICHOTOMOUS: return "dichotomous"; 7919 case ORDINAL: return "ordinal"; 7920 case POLYCHOTOMOUS: return "polychotomous"; 7921 case NULL: return null; 7922 default: return "?"; 7923 } 7924 } 7925 public String getSystem() { 7926 switch (this) { 7927 case CONTINUOUS: return "http://hl7.org/fhir/variable-handling"; 7928 case DICHOTOMOUS: return "http://hl7.org/fhir/variable-handling"; 7929 case ORDINAL: return "http://hl7.org/fhir/variable-handling"; 7930 case POLYCHOTOMOUS: return "http://hl7.org/fhir/variable-handling"; 7931 case NULL: return null; 7932 default: return "?"; 7933 } 7934 } 7935 public String getDefinition() { 7936 switch (this) { 7937 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)."; 7938 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)."; 7939 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)."; 7940 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."; 7941 case NULL: return null; 7942 default: return "?"; 7943 } 7944 } 7945 public String getDisplay() { 7946 switch (this) { 7947 case CONTINUOUS: return "continuous variable"; 7948 case DICHOTOMOUS: return "dichotomous variable"; 7949 case ORDINAL: return "ordinal variable"; 7950 case POLYCHOTOMOUS: return "polychotomous variable"; 7951 case NULL: return null; 7952 default: return "?"; 7953 } 7954 } 7955 } 7956 7957 public static class EvidenceVariableHandlingEnumFactory implements EnumFactory<EvidenceVariableHandling> { 7958 public EvidenceVariableHandling fromCode(String codeString) throws IllegalArgumentException { 7959 if (codeString == null || "".equals(codeString)) 7960 if (codeString == null || "".equals(codeString)) 7961 return null; 7962 if ("continuous".equals(codeString)) 7963 return EvidenceVariableHandling.CONTINUOUS; 7964 if ("dichotomous".equals(codeString)) 7965 return EvidenceVariableHandling.DICHOTOMOUS; 7966 if ("ordinal".equals(codeString)) 7967 return EvidenceVariableHandling.ORDINAL; 7968 if ("polychotomous".equals(codeString)) 7969 return EvidenceVariableHandling.POLYCHOTOMOUS; 7970 throw new IllegalArgumentException("Unknown EvidenceVariableHandling code '"+codeString+"'"); 7971 } 7972 7973 public Enumeration<EvidenceVariableHandling> fromType(PrimitiveType<?> code) throws FHIRException { 7974 if (code == null) 7975 return null; 7976 if (code.isEmpty()) 7977 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.NULL, code); 7978 String codeString = ((PrimitiveType) code).asStringValue(); 7979 if (codeString == null || "".equals(codeString)) 7980 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.NULL, code); 7981 if ("continuous".equals(codeString)) 7982 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.CONTINUOUS, code); 7983 if ("dichotomous".equals(codeString)) 7984 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.DICHOTOMOUS, code); 7985 if ("ordinal".equals(codeString)) 7986 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.ORDINAL, code); 7987 if ("polychotomous".equals(codeString)) 7988 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.POLYCHOTOMOUS, code); 7989 throw new FHIRException("Unknown EvidenceVariableHandling code '"+codeString+"'"); 7990 } 7991 public String toCode(EvidenceVariableHandling code) { 7992 if (code == EvidenceVariableHandling.NULL) 7993 return null; 7994 if (code == EvidenceVariableHandling.CONTINUOUS) 7995 return "continuous"; 7996 if (code == EvidenceVariableHandling.DICHOTOMOUS) 7997 return "dichotomous"; 7998 if (code == EvidenceVariableHandling.ORDINAL) 7999 return "ordinal"; 8000 if (code == EvidenceVariableHandling.POLYCHOTOMOUS) 8001 return "polychotomous"; 8002 return "?"; 8003 } 8004 public String toSystem(EvidenceVariableHandling code) { 8005 return code.getSystem(); 8006 } 8007 } 8008 8009 public enum ExampleScenarioActorType { 8010 /** 8011 * A human actor 8012 */ 8013 PERSON, 8014 /** 8015 * A software application or other system 8016 */ 8017 SYSTEM, 8018 /** 8019 * added to help the parsers 8020 */ 8021 NULL; 8022 public static ExampleScenarioActorType fromCode(String codeString) throws FHIRException { 8023 if (codeString == null || "".equals(codeString)) 8024 return null; 8025 if ("person".equals(codeString)) 8026 return PERSON; 8027 if ("system".equals(codeString)) 8028 return SYSTEM; 8029 throw new FHIRException("Unknown ExampleScenarioActorType code '"+codeString+"'"); 8030 } 8031 public static boolean isValidCode(String codeString) { 8032 if (codeString == null || "".equals(codeString)) 8033 return false; 8034 return Utilities.existsInList(codeString, "person", "system"); 8035 } 8036 public String toCode() { 8037 switch (this) { 8038 case PERSON: return "person"; 8039 case SYSTEM: return "system"; 8040 case NULL: return null; 8041 default: return "?"; 8042 } 8043 } 8044 public String getSystem() { 8045 switch (this) { 8046 case PERSON: return "http://hl7.org/fhir/examplescenario-actor-type"; 8047 case SYSTEM: return "http://hl7.org/fhir/examplescenario-actor-type"; 8048 case NULL: return null; 8049 default: return "?"; 8050 } 8051 } 8052 public String getDefinition() { 8053 switch (this) { 8054 case PERSON: return "A human actor"; 8055 case SYSTEM: return "A software application or other system"; 8056 case NULL: return null; 8057 default: return "?"; 8058 } 8059 } 8060 public String getDisplay() { 8061 switch (this) { 8062 case PERSON: return "Person"; 8063 case SYSTEM: return "System"; 8064 case NULL: return null; 8065 default: return "?"; 8066 } 8067 } 8068 } 8069 8070 public static class ExampleScenarioActorTypeEnumFactory implements EnumFactory<ExampleScenarioActorType> { 8071 public ExampleScenarioActorType fromCode(String codeString) throws IllegalArgumentException { 8072 if (codeString == null || "".equals(codeString)) 8073 if (codeString == null || "".equals(codeString)) 8074 return null; 8075 if ("person".equals(codeString)) 8076 return ExampleScenarioActorType.PERSON; 8077 if ("system".equals(codeString)) 8078 return ExampleScenarioActorType.SYSTEM; 8079 throw new IllegalArgumentException("Unknown ExampleScenarioActorType code '"+codeString+"'"); 8080 } 8081 8082 public Enumeration<ExampleScenarioActorType> fromType(PrimitiveType<?> code) throws FHIRException { 8083 if (code == null) 8084 return null; 8085 if (code.isEmpty()) 8086 return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.NULL, code); 8087 String codeString = ((PrimitiveType) code).asStringValue(); 8088 if (codeString == null || "".equals(codeString)) 8089 return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.NULL, code); 8090 if ("person".equals(codeString)) 8091 return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.PERSON, code); 8092 if ("system".equals(codeString)) 8093 return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.SYSTEM, code); 8094 throw new FHIRException("Unknown ExampleScenarioActorType code '"+codeString+"'"); 8095 } 8096 public String toCode(ExampleScenarioActorType code) { 8097 if (code == ExampleScenarioActorType.NULL) 8098 return null; 8099 if (code == ExampleScenarioActorType.PERSON) 8100 return "person"; 8101 if (code == ExampleScenarioActorType.SYSTEM) 8102 return "system"; 8103 return "?"; 8104 } 8105 public String toSystem(ExampleScenarioActorType code) { 8106 return code.getSystem(); 8107 } 8108 } 8109 8110 public enum FHIRTypes { 8111 /** 8112 * Base Type: Base definition for all types defined in FHIR type system. 8113 */ 8114 BASE, 8115 /** 8116 * Element Type: Base definition for all elements in a resource. 8117 */ 8118 ELEMENT, 8119 /** 8120 * BackboneElement Type: Base definition for all elements that are defined inside a resource - but not those in a data type. 8121 */ 8122 BACKBONEELEMENT, 8123 /** 8124 * DataType Type: The base class for all re-useable types defined as part of the FHIR Specification. 8125 */ 8126 DATATYPE, 8127 /** 8128 * 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. 8129The ISO21090-codedString may be used to provide a coded representation of the contents of strings in an Address. 8130 */ 8131 ADDRESS, 8132 /** 8133 * Annotation Type: A text note which also contains information about who made the statement and when. 8134 */ 8135 ANNOTATION, 8136 /** 8137 * Attachment Type: For referring to data content defined in other formats. 8138 */ 8139 ATTACHMENT, 8140 /** 8141 * Availability Type: Availability data for an {item}. 8142 */ 8143 AVAILABILITY, 8144 /** 8145 * BackboneType Type: Base definition for the few data types that are allowed to carry modifier extensions. 8146 */ 8147 BACKBONETYPE, 8148 /** 8149 * Dosage Type: Indicates how the medication is/was taken or should be taken by the patient. 8150 */ 8151 DOSAGE, 8152 /** 8153 * ElementDefinition Type: Captures constraints on each element within the resource, profile, or extension. 8154 */ 8155 ELEMENTDEFINITION, 8156 /** 8157 * 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. 8158 */ 8159 MARKETINGSTATUS, 8160 /** 8161 * ProductShelfLife Type: The shelf-life and storage information for a medicinal product item or container can be described using this class. 8162 */ 8163 PRODUCTSHELFLIFE, 8164 /** 8165 * 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. 8166 */ 8167 TIMING, 8168 /** 8169 * CodeableConcept Type: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text. 8170 */ 8171 CODEABLECONCEPT, 8172 /** 8173 * CodeableReference Type: A reference to a resource (by instance), or instead, a reference to a concept defined in a terminology or ontology (by class). 8174 */ 8175 CODEABLEREFERENCE, 8176 /** 8177 * Coding Type: A reference to a code defined by a terminology system. 8178 */ 8179 CODING, 8180 /** 8181 * ContactDetail Type: Specifies contact information for a person or organization. 8182 */ 8183 CONTACTDETAIL, 8184 /** 8185 * ContactPoint Type: Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc. 8186 */ 8187 CONTACTPOINT, 8188 /** 8189 * Contributor Type: A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers. 8190 */ 8191 CONTRIBUTOR, 8192 /** 8193 * 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. 8194 */ 8195 DATAREQUIREMENT, 8196 /** 8197 * 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. 8198 */ 8199 EXPRESSION, 8200 /** 8201 * 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. 8202 */ 8203 EXTENDEDCONTACTDETAIL, 8204 /** 8205 * Extension Type: Optional Extension Element - found in all resources. 8206 */ 8207 EXTENSION, 8208 /** 8209 * 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. 8210 */ 8211 HUMANNAME, 8212 /** 8213 * Identifier Type: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers. 8214 */ 8215 IDENTIFIER, 8216 /** 8217 * 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. 8218 */ 8219 META, 8220 /** 8221 * MonetaryComponent Type: Availability data for an {item}. 8222 */ 8223 MONETARYCOMPONENT, 8224 /** 8225 * Money Type: An amount of economic utility in some recognized currency. 8226 */ 8227 MONEY, 8228 /** 8229 * Narrative Type: A human-readable summary of the resource conveying the essential clinical and business information for the resource. 8230 */ 8231 NARRATIVE, 8232 /** 8233 * 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. 8234 */ 8235 PARAMETERDEFINITION, 8236 /** 8237 * Period Type: A time period defined by a start and end date and optionally time. 8238 */ 8239 PERIOD, 8240 /** 8241 * PrimitiveType Type: The base type for all re-useable types defined that have a simple property. 8242 */ 8243 PRIMITIVETYPE, 8244 /** 8245 * base64Binary Type: A stream of bytes 8246 */ 8247 BASE64BINARY, 8248 /** 8249 * boolean Type: Value of "true" or "false" 8250 */ 8251 BOOLEAN, 8252 /** 8253 * 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. 8254 */ 8255 DATE, 8256 /** 8257 * 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. 8258 */ 8259 DATETIME, 8260 /** 8261 * decimal Type: A rational number with implicit precision 8262 */ 8263 DECIMAL, 8264 /** 8265 * instant Type: An instant in time - known at least to the second 8266 */ 8267 INSTANT, 8268 /** 8269 * integer Type: A whole number 8270 */ 8271 INTEGER, 8272 /** 8273 * positiveInt type: An integer with a value that is positive (e.g. >0) 8274 */ 8275 POSITIVEINT, 8276 /** 8277 * unsignedInt type: An integer with a value that is not negative (e.g. >= 0) 8278 */ 8279 UNSIGNEDINT, 8280 /** 8281 * integer64 Type: A very large whole number 8282 */ 8283 INTEGER64, 8284 /** 8285 * string Type: A sequence of Unicode characters 8286 */ 8287 STRING, 8288 /** 8289 * 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 8290 */ 8291 CODE, 8292 /** 8293 * 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. 8294 */ 8295 ID, 8296 /** 8297 * markdown type: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine 8298 */ 8299 MARKDOWN, 8300 /** 8301 * time Type: A time during the day, with no date specified 8302 */ 8303 TIME, 8304 /** 8305 * uri Type: String of characters used to identify a name or a resource 8306 */ 8307 URI, 8308 /** 8309 * canonical type: A URI that is a reference to a canonical URL on a FHIR resource 8310 */ 8311 CANONICAL, 8312 /** 8313 * oid type: An OID represented as a URI 8314 */ 8315 OID, 8316 /** 8317 * url type: A URI that is a literal reference 8318 */ 8319 URL, 8320 /** 8321 * uuid type: A UUID, represented as a URI 8322 */ 8323 UUID, 8324 /** 8325 * 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. 8326 */ 8327 QUANTITY, 8328 /** 8329 * Age Type: A duration of time during which an organism (or a process) has existed. 8330 */ 8331 AGE, 8332 /** 8333 * 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. 8334 */ 8335 COUNT, 8336 /** 8337 * Distance Type: A length - a value with a unit that is a physical distance. 8338 */ 8339 DISTANCE, 8340 /** 8341 * Duration Type: A length of time. 8342 */ 8343 DURATION, 8344 /** 8345 * Range Type: A set of ordered Quantities defined by a low and high limit. 8346 */ 8347 RANGE, 8348 /** 8349 * Ratio Type: A relationship of two Quantity values - expressed as a numerator and a denominator. 8350 */ 8351 RATIO, 8352 /** 8353 * RatioRange Type: A range of ratios expressed as a low and high numerator and a denominator. 8354 */ 8355 RATIORANGE, 8356 /** 8357 * Reference Type: A reference from one resource to another. 8358 */ 8359 REFERENCE, 8360 /** 8361 * RelatedArtifact Type: Related artifacts such as additional documentation, justification, or bibliographic references. 8362 */ 8363 RELATEDARTIFACT, 8364 /** 8365 * 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. 8366 */ 8367 SAMPLEDDATA, 8368 /** 8369 * 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. 8370 */ 8371 SIGNATURE, 8372 /** 8373 * TriggerDefinition Type: A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element. 8374 */ 8375 TRIGGERDEFINITION, 8376 /** 8377 * 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). 8378 */ 8379 USAGECONTEXT, 8380 /** 8381 * VirtualServiceDetail Type: Virtual Service Contact Details. 8382 */ 8383 VIRTUALSERVICEDETAIL, 8384 /** 8385 * xhtml Type definition 8386 */ 8387 XHTML, 8388 /** 8389 * This is the base resource type for everything. 8390 */ 8391 RESOURCE, 8392 /** 8393 * 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. 8394 */ 8395 BINARY, 8396 /** 8397 * A container for a collection of resources. 8398 */ 8399 BUNDLE, 8400 /** 8401 * A resource that includes narrative, extensions, and contained resources. 8402 */ 8403 DOMAINRESOURCE, 8404 /** 8405 * 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. 8406 */ 8407 ACCOUNT, 8408 /** 8409 * This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context. 8410 */ 8411 ACTIVITYDEFINITION, 8412 /** 8413 * 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. 8414 */ 8415 ACTORDEFINITION, 8416 /** 8417 * 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). 8418 */ 8419 ADMINISTRABLEPRODUCTDEFINITION, 8420 /** 8421 * 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. 8422 */ 8423 ADVERSEEVENT, 8424 /** 8425 * Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance. 8426 */ 8427 ALLERGYINTOLERANCE, 8428 /** 8429 * 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). 8430 */ 8431 APPOINTMENT, 8432 /** 8433 * A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection. 8434 */ 8435 APPOINTMENTRESPONSE, 8436 /** 8437 * This Resource provides one or more comments, classifiers or ratings about a Resource and supports attribution and rights management metadata for the added content. 8438 */ 8439 ARTIFACTASSESSMENT, 8440 /** 8441 * A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis. 8442 */ 8443 AUDITEVENT, 8444 /** 8445 * 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. 8446 */ 8447 BASIC, 8448 /** 8449 * A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity. 8450 */ 8451 BIOLOGICALLYDERIVEDPRODUCT, 8452 /** 8453 * A record of dispensation of a biologically derived product. 8454 */ 8455 BIOLOGICALLYDERIVEDPRODUCTDISPENSE, 8456 /** 8457 * 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. 8458 */ 8459 BODYSTRUCTURE, 8460 /** 8461 * Common Interface declaration for conformance and knowledge artifact resources. 8462 */ 8463 CANONICALRESOURCE, 8464 /** 8465 * 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. 8466 */ 8467 CAPABILITYSTATEMENT, 8468 /** 8469 * 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. 8470 */ 8471 CAREPLAN, 8472 /** 8473 * The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care. 8474 */ 8475 CARETEAM, 8476 /** 8477 * 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. 8478 */ 8479 CHARGEITEM, 8480 /** 8481 * 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. 8482 */ 8483 CHARGEITEMDEFINITION, 8484 /** 8485 * 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. 8486 */ 8487 CITATION, 8488 /** 8489 * 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. 8490 */ 8491 CLAIM, 8492 /** 8493 * This resource provides the adjudication details from the processing of a Claim resource. 8494 */ 8495 CLAIMRESPONSE, 8496 /** 8497 * 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. 8498 */ 8499 CLINICALIMPRESSION, 8500 /** 8501 * A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure. 8502 */ 8503 CLINICALUSEDEFINITION, 8504 /** 8505 * 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. 8506 */ 8507 CODESYSTEM, 8508 /** 8509 * 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. 8510 */ 8511 COMMUNICATION, 8512 /** 8513 * 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. 8514 */ 8515 COMMUNICATIONREQUEST, 8516 /** 8517 * A compartment definition that defines how resources are accessed on a server. 8518 */ 8519 COMPARTMENTDEFINITION, 8520 /** 8521 * 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.). 8522 */ 8523 COMPOSITION, 8524 /** 8525 * 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. 8526 */ 8527 CONCEPTMAP, 8528 /** 8529 * A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern. 8530 */ 8531 CONDITION, 8532 /** 8533 * A definition of a condition and information relevant to managing it. 8534 */ 8535 CONDITIONDEFINITION, 8536 /** 8537 * 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. 8538 */ 8539 CONSENT, 8540 /** 8541 * Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement. 8542 */ 8543 CONTRACT, 8544 /** 8545 * Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment. 8546 */ 8547 COVERAGE, 8548 /** 8549 * 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. 8550 */ 8551 COVERAGEELIGIBILITYREQUEST, 8552 /** 8553 * This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource. 8554 */ 8555 COVERAGEELIGIBILITYRESPONSE, 8556 /** 8557 * 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. 8558 */ 8559 DETECTEDISSUE, 8560 /** 8561 * 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. 8562 */ 8563 DEVICE, 8564 /** 8565 * A record of association of a device. 8566 */ 8567 DEVICEASSOCIATION, 8568 /** 8569 * This is a specialized resource that defines the characteristics and capabilities of a device. 8570 */ 8571 DEVICEDEFINITION, 8572 /** 8573 * 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. 8574 */ 8575 DEVICEDISPENSE, 8576 /** 8577 * 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. 8578 */ 8579 DEVICEMETRIC, 8580 /** 8581 * 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. 8582 */ 8583 DEVICEREQUEST, 8584 /** 8585 * 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. 8586 */ 8587 DEVICEUSAGE, 8588 /** 8589 * 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. 8590 */ 8591 DIAGNOSTICREPORT, 8592 /** 8593 * 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. 8594 */ 8595 DOCUMENTREFERENCE, 8596 /** 8597 * 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). 8598 */ 8599 ENCOUNTER, 8600 /** 8601 * A record of significant events/milestones key data throughout the history of an Encounter 8602 */ 8603 ENCOUNTERHISTORY, 8604 /** 8605 * 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. 8606 */ 8607 ENDPOINT, 8608 /** 8609 * This resource provides the insurance enrollment details to the insurer regarding a specified coverage. 8610 */ 8611 ENROLLMENTREQUEST, 8612 /** 8613 * This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource. 8614 */ 8615 ENROLLMENTRESPONSE, 8616 /** 8617 * 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. 8618 */ 8619 EPISODEOFCARE, 8620 /** 8621 * The EventDefinition resource provides a reusable description of when a particular event can occur. 8622 */ 8623 EVENTDEFINITION, 8624 /** 8625 * 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. 8626 */ 8627 EVIDENCE, 8628 /** 8629 * 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. 8630 */ 8631 EVIDENCEREPORT, 8632 /** 8633 * The EvidenceVariable resource describes an element that knowledge (Evidence) is about. 8634 */ 8635 EVIDENCEVARIABLE, 8636 /** 8637 * A walkthrough of a workflow showing the interaction between systems and the instances shared, possibly including the evolution of instances over time. 8638 */ 8639 EXAMPLESCENARIO, 8640 /** 8641 * 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. 8642 */ 8643 EXPLANATIONOFBENEFIT, 8644 /** 8645 * Significant health conditions for a person related to the patient relevant in the context of care for the patient. 8646 */ 8647 FAMILYMEMBERHISTORY, 8648 /** 8649 * Prospective warnings of potential issues when providing care to the patient. 8650 */ 8651 FLAG, 8652 /** 8653 * 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. 8654 */ 8655 FORMULARYITEM, 8656 /** 8657 * A set of analyses performed to analyze and generate genomic data. 8658 */ 8659 GENOMICSTUDY, 8660 /** 8661 * 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. 8662 */ 8663 GOAL, 8664 /** 8665 * 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. 8666 */ 8667 GRAPHDEFINITION, 8668 /** 8669 * 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. 8670 */ 8671 GROUP, 8672 /** 8673 * 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. 8674 */ 8675 GUIDANCERESPONSE, 8676 /** 8677 * 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. 8678 */ 8679 HEALTHCARESERVICE, 8680 /** 8681 * 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. 8682 */ 8683 IMAGINGSELECTION, 8684 /** 8685 * 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. 8686 */ 8687 IMAGINGSTUDY, 8688 /** 8689 * 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. 8690 */ 8691 IMMUNIZATION, 8692 /** 8693 * Describes a comparison of an immunization event against published recommendations to determine if the administration is "valid" in relation to those recommendations. 8694 */ 8695 IMMUNIZATIONEVALUATION, 8696 /** 8697 * A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification. 8698 */ 8699 IMMUNIZATIONRECOMMENDATION, 8700 /** 8701 * 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. 8702 */ 8703 IMPLEMENTATIONGUIDE, 8704 /** 8705 * An ingredient of a manufactured item or pharmaceutical product. 8706 */ 8707 INGREDIENT, 8708 /** 8709 * Details of a Health Insurance product/plan provided by an organization. 8710 */ 8711 INSURANCEPLAN, 8712 /** 8713 * functional description of an inventory item used in inventory and supply-related workflows. 8714 */ 8715 INVENTORYITEM, 8716 /** 8717 * A report of inventory or stock items. 8718 */ 8719 INVENTORYREPORT, 8720 /** 8721 * Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose. 8722 */ 8723 INVOICE, 8724 /** 8725 * 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. 8726 */ 8727 LIBRARY, 8728 /** 8729 * Identifies two or more records (resource instances) that refer to the same real-world "occurrence". 8730 */ 8731 LINKAGE, 8732 /** 8733 * A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc. 8734 */ 8735 LIST, 8736 /** 8737 * Details and position information for a place where services are provided and resources and participants may be stored, found, contained, or accommodated. 8738 */ 8739 LOCATION, 8740 /** 8741 * The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product. 8742 */ 8743 MANUFACTUREDITEMDEFINITION, 8744 /** 8745 * The Measure resource provides the definition of a quality measure. 8746 */ 8747 MEASURE, 8748 /** 8749 * The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation. 8750 */ 8751 MEASUREREPORT, 8752 /** 8753 * 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. 8754 */ 8755 MEDICATION, 8756 /** 8757 * 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. 8758 */ 8759 MEDICATIONADMINISTRATION, 8760 /** 8761 * 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. 8762 */ 8763 MEDICATIONDISPENSE, 8764 /** 8765 * Information about a medication that is used to support knowledge. 8766 */ 8767 MEDICATIONKNOWLEDGE, 8768 /** 8769 * 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. 8770 */ 8771 MEDICATIONREQUEST, 8772 /** 8773 * 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. 8774 8775The 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. 8776 */ 8777 MEDICATIONSTATEMENT, 8778 /** 8779 * 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.). 8780 */ 8781 MEDICINALPRODUCTDEFINITION, 8782 /** 8783 * 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. 8784 */ 8785 MESSAGEDEFINITION, 8786 /** 8787 * 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. 8788 */ 8789 MESSAGEHEADER, 8790 /** 8791 * Common Interface declaration for conformance and knowledge artifact resources. 8792 */ 8793 METADATARESOURCE, 8794 /** 8795 * Representation of a molecular sequence. 8796 */ 8797 MOLECULARSEQUENCE, 8798 /** 8799 * 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. 8800 */ 8801 NAMINGSYSTEM, 8802 /** 8803 * 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. 8804 */ 8805 NUTRITIONINTAKE, 8806 /** 8807 * A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident. 8808 */ 8809 NUTRITIONORDER, 8810 /** 8811 * A food or supplement that is consumed by patients. 8812 */ 8813 NUTRITIONPRODUCT, 8814 /** 8815 * Measurements and simple assertions made about a patient, device or other subject. 8816 */ 8817 OBSERVATION, 8818 /** 8819 * Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service. 8820 */ 8821 OBSERVATIONDEFINITION, 8822 /** 8823 * A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction). 8824 */ 8825 OPERATIONDEFINITION, 8826 /** 8827 * A collection of error, warning, or information messages that result from a system action. 8828 */ 8829 OPERATIONOUTCOME, 8830 /** 8831 * 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. 8832 */ 8833 ORGANIZATION, 8834 /** 8835 * Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship. 8836 */ 8837 ORGANIZATIONAFFILIATION, 8838 /** 8839 * A medically related item or items, in a container or package. 8840 */ 8841 PACKAGEDPRODUCTDEFINITION, 8842 /** 8843 * Demographics and other administrative information about an individual or animal receiving care or other health-related services. 8844 */ 8845 PATIENT, 8846 /** 8847 * This resource provides the status of the payment for goods and services rendered, and the request and response resource references. 8848 */ 8849 PAYMENTNOTICE, 8850 /** 8851 * This resource provides the details including amount of a payment and allocates the payment items being paid. 8852 */ 8853 PAYMENTRECONCILIATION, 8854 /** 8855 * Permission resource holds access rules for a given data and context. 8856 */ 8857 PERMISSION, 8858 /** 8859 * Demographics and administrative information about a person independent of a specific health-related context. 8860 */ 8861 PERSON, 8862 /** 8863 * 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. 8864 */ 8865 PLANDEFINITION, 8866 /** 8867 * A person who is directly or indirectly involved in the provisioning of healthcare or related services. 8868 */ 8869 PRACTITIONER, 8870 /** 8871 * A specific set of Roles/Locations/specialties/services that a practitioner may perform, or has performed at an organization during a period of time. 8872 */ 8873 PRACTITIONERROLE, 8874 /** 8875 * 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. 8876 */ 8877 PROCEDURE, 8878 /** 8879 * 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. 8880 */ 8881 PROVENANCE, 8882 /** 8883 * 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. 8884 */ 8885 QUESTIONNAIRE, 8886 /** 8887 * 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. 8888 */ 8889 QUESTIONNAIRERESPONSE, 8890 /** 8891 * 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. 8892 */ 8893 REGULATEDAUTHORIZATION, 8894 /** 8895 * 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. 8896 */ 8897 RELATEDPERSON, 8898 /** 8899 * 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". 8900 */ 8901 REQUESTORCHESTRATION, 8902 /** 8903 * 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. 8904 */ 8905 REQUIREMENTS, 8906 /** 8907 * 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. 8908 */ 8909 RESEARCHSTUDY, 8910 /** 8911 * A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study. 8912 */ 8913 RESEARCHSUBJECT, 8914 /** 8915 * An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome. 8916 */ 8917 RISKASSESSMENT, 8918 /** 8919 * A container for slots of time that may be available for booking appointments. 8920 */ 8921 SCHEDULE, 8922 /** 8923 * A search parameter that defines a named search item that can be used to search/filter on a resource. 8924 */ 8925 SEARCHPARAMETER, 8926 /** 8927 * A record of a request for service such as diagnostic investigations, treatments, or operations to be performed. 8928 */ 8929 SERVICEREQUEST, 8930 /** 8931 * A slot of time on a schedule that may be available for booking appointments. 8932 */ 8933 SLOT, 8934 /** 8935 * A sample to be used for analysis. 8936 */ 8937 SPECIMEN, 8938 /** 8939 * A kind of specimen with associated set of requirements. 8940 */ 8941 SPECIMENDEFINITION, 8942 /** 8943 * 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. 8944 */ 8945 STRUCTUREDEFINITION, 8946 /** 8947 * A Map of relationships between 2 structures that can be used to transform data. 8948 */ 8949 STRUCTUREMAP, 8950 /** 8951 * The subscription resource describes a particular client's request to be notified about a SubscriptionTopic. 8952 */ 8953 SUBSCRIPTION, 8954 /** 8955 * The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted. 8956 */ 8957 SUBSCRIPTIONSTATUS, 8958 /** 8959 * Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic. 8960 */ 8961 SUBSCRIPTIONTOPIC, 8962 /** 8963 * A homogeneous material with a definite composition. 8964 */ 8965 SUBSTANCE, 8966 /** 8967 * The detailed description of a substance, typically at a level beyond what is used for prescribing. 8968 */ 8969 SUBSTANCEDEFINITION, 8970 /** 8971 * 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. 8972 */ 8973 SUBSTANCENUCLEICACID, 8974 /** 8975 * Properties of a substance specific to it being a polymer. 8976 */ 8977 SUBSTANCEPOLYMER, 8978 /** 8979 * 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. 8980 */ 8981 SUBSTANCEPROTEIN, 8982 /** 8983 * Todo. 8984 */ 8985 SUBSTANCEREFERENCEINFORMATION, 8986 /** 8987 * 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. 8988 */ 8989 SUBSTANCESOURCEMATERIAL, 8990 /** 8991 * Record of delivery of what is supplied. 8992 */ 8993 SUPPLYDELIVERY, 8994 /** 8995 * 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. 8996 */ 8997 SUPPLYREQUEST, 8998 /** 8999 * A task to be performed. 9000 */ 9001 TASK, 9002 /** 9003 * 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. 9004 */ 9005 TERMINOLOGYCAPABILITIES, 9006 /** 9007 * A plan for executing testing on an artifact or specifications 9008 */ 9009 TESTPLAN, 9010 /** 9011 * A summary of information based on the results of executing a TestScript. 9012 */ 9013 TESTREPORT, 9014 /** 9015 * A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification. 9016 */ 9017 TESTSCRIPT, 9018 /** 9019 * Record of transport. 9020 */ 9021 TRANSPORT, 9022 /** 9023 * 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). 9024 */ 9025 VALUESET, 9026 /** 9027 * Describes validation requirements, source(s), status and dates for one or more elements. 9028 */ 9029 VERIFICATIONRESULT, 9030 /** 9031 * An authorization for the provision of glasses and/or contact lenses to a patient. 9032 */ 9033 VISIONPRESCRIPTION, 9034 /** 9035 * 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. 9036 */ 9037 PARAMETERS, 9038 /** 9039 * added to help the parsers 9040 */ 9041 NULL; 9042 public static FHIRTypes fromCode(String codeString) throws FHIRException { 9043 if (codeString == null || "".equals(codeString)) 9044 return null; 9045 if ("Base".equals(codeString)) 9046 return BASE; 9047 if ("Element".equals(codeString)) 9048 return ELEMENT; 9049 if ("BackboneElement".equals(codeString)) 9050 return BACKBONEELEMENT; 9051 if ("DataType".equals(codeString)) 9052 return DATATYPE; 9053 if ("Address".equals(codeString)) 9054 return ADDRESS; 9055 if ("Annotation".equals(codeString)) 9056 return ANNOTATION; 9057 if ("Attachment".equals(codeString)) 9058 return ATTACHMENT; 9059 if ("Availability".equals(codeString)) 9060 return AVAILABILITY; 9061 if ("BackboneType".equals(codeString)) 9062 return BACKBONETYPE; 9063 if ("Dosage".equals(codeString)) 9064 return DOSAGE; 9065 if ("ElementDefinition".equals(codeString)) 9066 return ELEMENTDEFINITION; 9067 if ("MarketingStatus".equals(codeString)) 9068 return MARKETINGSTATUS; 9069 if ("ProductShelfLife".equals(codeString)) 9070 return PRODUCTSHELFLIFE; 9071 if ("Timing".equals(codeString)) 9072 return TIMING; 9073 if ("CodeableConcept".equals(codeString)) 9074 return CODEABLECONCEPT; 9075 if ("CodeableReference".equals(codeString)) 9076 return CODEABLEREFERENCE; 9077 if ("Coding".equals(codeString)) 9078 return CODING; 9079 if ("ContactDetail".equals(codeString)) 9080 return CONTACTDETAIL; 9081 if ("ContactPoint".equals(codeString)) 9082 return CONTACTPOINT; 9083 if ("Contributor".equals(codeString)) 9084 return CONTRIBUTOR; 9085 if ("DataRequirement".equals(codeString)) 9086 return DATAREQUIREMENT; 9087 if ("Expression".equals(codeString)) 9088 return EXPRESSION; 9089 if ("ExtendedContactDetail".equals(codeString)) 9090 return EXTENDEDCONTACTDETAIL; 9091 if ("Extension".equals(codeString)) 9092 return EXTENSION; 9093 if ("HumanName".equals(codeString)) 9094 return HUMANNAME; 9095 if ("Identifier".equals(codeString)) 9096 return IDENTIFIER; 9097 if ("Meta".equals(codeString)) 9098 return META; 9099 if ("MonetaryComponent".equals(codeString)) 9100 return MONETARYCOMPONENT; 9101 if ("Money".equals(codeString)) 9102 return MONEY; 9103 if ("Narrative".equals(codeString)) 9104 return NARRATIVE; 9105 if ("ParameterDefinition".equals(codeString)) 9106 return PARAMETERDEFINITION; 9107 if ("Period".equals(codeString)) 9108 return PERIOD; 9109 if ("PrimitiveType".equals(codeString)) 9110 return PRIMITIVETYPE; 9111 if ("base64Binary".equals(codeString)) 9112 return BASE64BINARY; 9113 if ("boolean".equals(codeString)) 9114 return BOOLEAN; 9115 if ("date".equals(codeString)) 9116 return DATE; 9117 if ("dateTime".equals(codeString)) 9118 return DATETIME; 9119 if ("decimal".equals(codeString)) 9120 return DECIMAL; 9121 if ("instant".equals(codeString)) 9122 return INSTANT; 9123 if ("integer".equals(codeString)) 9124 return INTEGER; 9125 if ("positiveInt".equals(codeString)) 9126 return POSITIVEINT; 9127 if ("unsignedInt".equals(codeString)) 9128 return UNSIGNEDINT; 9129 if ("integer64".equals(codeString)) 9130 return INTEGER64; 9131 if ("string".equals(codeString)) 9132 return STRING; 9133 if ("code".equals(codeString)) 9134 return CODE; 9135 if ("id".equals(codeString)) 9136 return ID; 9137 if ("markdown".equals(codeString)) 9138 return MARKDOWN; 9139 if ("time".equals(codeString)) 9140 return TIME; 9141 if ("uri".equals(codeString)) 9142 return URI; 9143 if ("canonical".equals(codeString)) 9144 return CANONICAL; 9145 if ("oid".equals(codeString)) 9146 return OID; 9147 if ("url".equals(codeString)) 9148 return URL; 9149 if ("uuid".equals(codeString)) 9150 return UUID; 9151 if ("Quantity".equals(codeString)) 9152 return QUANTITY; 9153 if ("Age".equals(codeString)) 9154 return AGE; 9155 if ("Count".equals(codeString)) 9156 return COUNT; 9157 if ("Distance".equals(codeString)) 9158 return DISTANCE; 9159 if ("Duration".equals(codeString)) 9160 return DURATION; 9161 if ("Range".equals(codeString)) 9162 return RANGE; 9163 if ("Ratio".equals(codeString)) 9164 return RATIO; 9165 if ("RatioRange".equals(codeString)) 9166 return RATIORANGE; 9167 if ("Reference".equals(codeString)) 9168 return REFERENCE; 9169 if ("RelatedArtifact".equals(codeString)) 9170 return RELATEDARTIFACT; 9171 if ("SampledData".equals(codeString)) 9172 return SAMPLEDDATA; 9173 if ("Signature".equals(codeString)) 9174 return SIGNATURE; 9175 if ("TriggerDefinition".equals(codeString)) 9176 return TRIGGERDEFINITION; 9177 if ("UsageContext".equals(codeString)) 9178 return USAGECONTEXT; 9179 if ("VirtualServiceDetail".equals(codeString)) 9180 return VIRTUALSERVICEDETAIL; 9181 if ("xhtml".equals(codeString)) 9182 return XHTML; 9183 if ("Resource".equals(codeString) || "Any".equals(codeString)) 9184 return RESOURCE; 9185 if ("Binary".equals(codeString)) 9186 return BINARY; 9187 if ("Bundle".equals(codeString)) 9188 return BUNDLE; 9189 if ("DomainResource".equals(codeString)) 9190 return DOMAINRESOURCE; 9191 if ("Account".equals(codeString)) 9192 return ACCOUNT; 9193 if ("ActivityDefinition".equals(codeString)) 9194 return ACTIVITYDEFINITION; 9195 if ("ActorDefinition".equals(codeString)) 9196 return ACTORDEFINITION; 9197 if ("AdministrableProductDefinition".equals(codeString)) 9198 return ADMINISTRABLEPRODUCTDEFINITION; 9199 if ("AdverseEvent".equals(codeString)) 9200 return ADVERSEEVENT; 9201 if ("AllergyIntolerance".equals(codeString)) 9202 return ALLERGYINTOLERANCE; 9203 if ("Appointment".equals(codeString)) 9204 return APPOINTMENT; 9205 if ("AppointmentResponse".equals(codeString)) 9206 return APPOINTMENTRESPONSE; 9207 if ("ArtifactAssessment".equals(codeString)) 9208 return ARTIFACTASSESSMENT; 9209 if ("AuditEvent".equals(codeString)) 9210 return AUDITEVENT; 9211 if ("Basic".equals(codeString)) 9212 return BASIC; 9213 if ("BiologicallyDerivedProduct".equals(codeString)) 9214 return BIOLOGICALLYDERIVEDPRODUCT; 9215 if ("BiologicallyDerivedProductDispense".equals(codeString)) 9216 return BIOLOGICALLYDERIVEDPRODUCTDISPENSE; 9217 if ("BodyStructure".equals(codeString)) 9218 return BODYSTRUCTURE; 9219 if ("CanonicalResource".equals(codeString)) 9220 return CANONICALRESOURCE; 9221 if ("CapabilityStatement".equals(codeString)) 9222 return CAPABILITYSTATEMENT; 9223 if ("CarePlan".equals(codeString)) 9224 return CAREPLAN; 9225 if ("CareTeam".equals(codeString)) 9226 return CARETEAM; 9227 if ("ChargeItem".equals(codeString)) 9228 return CHARGEITEM; 9229 if ("ChargeItemDefinition".equals(codeString)) 9230 return CHARGEITEMDEFINITION; 9231 if ("Citation".equals(codeString)) 9232 return CITATION; 9233 if ("Claim".equals(codeString)) 9234 return CLAIM; 9235 if ("ClaimResponse".equals(codeString)) 9236 return CLAIMRESPONSE; 9237 if ("ClinicalImpression".equals(codeString)) 9238 return CLINICALIMPRESSION; 9239 if ("ClinicalUseDefinition".equals(codeString)) 9240 return CLINICALUSEDEFINITION; 9241 if ("CodeSystem".equals(codeString)) 9242 return CODESYSTEM; 9243 if ("Communication".equals(codeString)) 9244 return COMMUNICATION; 9245 if ("CommunicationRequest".equals(codeString)) 9246 return COMMUNICATIONREQUEST; 9247 if ("CompartmentDefinition".equals(codeString)) 9248 return COMPARTMENTDEFINITION; 9249 if ("Composition".equals(codeString)) 9250 return COMPOSITION; 9251 if ("ConceptMap".equals(codeString)) 9252 return CONCEPTMAP; 9253 if ("Condition".equals(codeString)) 9254 return CONDITION; 9255 if ("ConditionDefinition".equals(codeString)) 9256 return CONDITIONDEFINITION; 9257 if ("Consent".equals(codeString)) 9258 return CONSENT; 9259 if ("Contract".equals(codeString)) 9260 return CONTRACT; 9261 if ("Coverage".equals(codeString)) 9262 return COVERAGE; 9263 if ("CoverageEligibilityRequest".equals(codeString)) 9264 return COVERAGEELIGIBILITYREQUEST; 9265 if ("CoverageEligibilityResponse".equals(codeString)) 9266 return COVERAGEELIGIBILITYRESPONSE; 9267 if ("DetectedIssue".equals(codeString)) 9268 return DETECTEDISSUE; 9269 if ("Device".equals(codeString)) 9270 return DEVICE; 9271 if ("DeviceAssociation".equals(codeString)) 9272 return DEVICEASSOCIATION; 9273 if ("DeviceDefinition".equals(codeString)) 9274 return DEVICEDEFINITION; 9275 if ("DeviceDispense".equals(codeString)) 9276 return DEVICEDISPENSE; 9277 if ("DeviceMetric".equals(codeString)) 9278 return DEVICEMETRIC; 9279 if ("DeviceRequest".equals(codeString)) 9280 return DEVICEREQUEST; 9281 if ("DeviceUsage".equals(codeString)) 9282 return DEVICEUSAGE; 9283 if ("DiagnosticReport".equals(codeString)) 9284 return DIAGNOSTICREPORT; 9285 if ("DocumentReference".equals(codeString)) 9286 return DOCUMENTREFERENCE; 9287 if ("Encounter".equals(codeString)) 9288 return ENCOUNTER; 9289 if ("EncounterHistory".equals(codeString)) 9290 return ENCOUNTERHISTORY; 9291 if ("Endpoint".equals(codeString)) 9292 return ENDPOINT; 9293 if ("EnrollmentRequest".equals(codeString)) 9294 return ENROLLMENTREQUEST; 9295 if ("EnrollmentResponse".equals(codeString)) 9296 return ENROLLMENTRESPONSE; 9297 if ("EpisodeOfCare".equals(codeString)) 9298 return EPISODEOFCARE; 9299 if ("EventDefinition".equals(codeString)) 9300 return EVENTDEFINITION; 9301 if ("Evidence".equals(codeString)) 9302 return EVIDENCE; 9303 if ("EvidenceReport".equals(codeString)) 9304 return EVIDENCEREPORT; 9305 if ("EvidenceVariable".equals(codeString)) 9306 return EVIDENCEVARIABLE; 9307 if ("ExampleScenario".equals(codeString)) 9308 return EXAMPLESCENARIO; 9309 if ("ExplanationOfBenefit".equals(codeString)) 9310 return EXPLANATIONOFBENEFIT; 9311 if ("FamilyMemberHistory".equals(codeString)) 9312 return FAMILYMEMBERHISTORY; 9313 if ("Flag".equals(codeString)) 9314 return FLAG; 9315 if ("FormularyItem".equals(codeString)) 9316 return FORMULARYITEM; 9317 if ("GenomicStudy".equals(codeString)) 9318 return GENOMICSTUDY; 9319 if ("Goal".equals(codeString)) 9320 return GOAL; 9321 if ("GraphDefinition".equals(codeString)) 9322 return GRAPHDEFINITION; 9323 if ("Group".equals(codeString)) 9324 return GROUP; 9325 if ("GuidanceResponse".equals(codeString)) 9326 return GUIDANCERESPONSE; 9327 if ("HealthcareService".equals(codeString)) 9328 return HEALTHCARESERVICE; 9329 if ("ImagingSelection".equals(codeString)) 9330 return IMAGINGSELECTION; 9331 if ("ImagingStudy".equals(codeString)) 9332 return IMAGINGSTUDY; 9333 if ("Immunization".equals(codeString)) 9334 return IMMUNIZATION; 9335 if ("ImmunizationEvaluation".equals(codeString)) 9336 return IMMUNIZATIONEVALUATION; 9337 if ("ImmunizationRecommendation".equals(codeString)) 9338 return IMMUNIZATIONRECOMMENDATION; 9339 if ("ImplementationGuide".equals(codeString)) 9340 return IMPLEMENTATIONGUIDE; 9341 if ("Ingredient".equals(codeString)) 9342 return INGREDIENT; 9343 if ("InsurancePlan".equals(codeString)) 9344 return INSURANCEPLAN; 9345 if ("InventoryItem".equals(codeString)) 9346 return INVENTORYITEM; 9347 if ("InventoryReport".equals(codeString)) 9348 return INVENTORYREPORT; 9349 if ("Invoice".equals(codeString)) 9350 return INVOICE; 9351 if ("Library".equals(codeString)) 9352 return LIBRARY; 9353 if ("Linkage".equals(codeString)) 9354 return LINKAGE; 9355 if ("List".equals(codeString)) 9356 return LIST; 9357 if ("Location".equals(codeString)) 9358 return LOCATION; 9359 if ("ManufacturedItemDefinition".equals(codeString)) 9360 return MANUFACTUREDITEMDEFINITION; 9361 if ("Measure".equals(codeString)) 9362 return MEASURE; 9363 if ("MeasureReport".equals(codeString)) 9364 return MEASUREREPORT; 9365 if ("Medication".equals(codeString)) 9366 return MEDICATION; 9367 if ("MedicationAdministration".equals(codeString)) 9368 return MEDICATIONADMINISTRATION; 9369 if ("MedicationDispense".equals(codeString)) 9370 return MEDICATIONDISPENSE; 9371 if ("MedicationKnowledge".equals(codeString)) 9372 return MEDICATIONKNOWLEDGE; 9373 if ("MedicationRequest".equals(codeString)) 9374 return MEDICATIONREQUEST; 9375 if ("MedicationStatement".equals(codeString)) 9376 return MEDICATIONSTATEMENT; 9377 if ("MedicinalProductDefinition".equals(codeString)) 9378 return MEDICINALPRODUCTDEFINITION; 9379 if ("MessageDefinition".equals(codeString)) 9380 return MESSAGEDEFINITION; 9381 if ("MessageHeader".equals(codeString)) 9382 return MESSAGEHEADER; 9383 if ("MetadataResource".equals(codeString)) 9384 return METADATARESOURCE; 9385 if ("MolecularSequence".equals(codeString)) 9386 return MOLECULARSEQUENCE; 9387 if ("NamingSystem".equals(codeString)) 9388 return NAMINGSYSTEM; 9389 if ("NutritionIntake".equals(codeString)) 9390 return NUTRITIONINTAKE; 9391 if ("NutritionOrder".equals(codeString)) 9392 return NUTRITIONORDER; 9393 if ("NutritionProduct".equals(codeString)) 9394 return NUTRITIONPRODUCT; 9395 if ("Observation".equals(codeString)) 9396 return OBSERVATION; 9397 if ("ObservationDefinition".equals(codeString)) 9398 return OBSERVATIONDEFINITION; 9399 if ("OperationDefinition".equals(codeString)) 9400 return OPERATIONDEFINITION; 9401 if ("OperationOutcome".equals(codeString)) 9402 return OPERATIONOUTCOME; 9403 if ("Organization".equals(codeString)) 9404 return ORGANIZATION; 9405 if ("OrganizationAffiliation".equals(codeString)) 9406 return ORGANIZATIONAFFILIATION; 9407 if ("PackagedProductDefinition".equals(codeString)) 9408 return PACKAGEDPRODUCTDEFINITION; 9409 if ("Patient".equals(codeString)) 9410 return PATIENT; 9411 if ("PaymentNotice".equals(codeString)) 9412 return PAYMENTNOTICE; 9413 if ("PaymentReconciliation".equals(codeString)) 9414 return PAYMENTRECONCILIATION; 9415 if ("Permission".equals(codeString)) 9416 return PERMISSION; 9417 if ("Person".equals(codeString)) 9418 return PERSON; 9419 if ("PlanDefinition".equals(codeString)) 9420 return PLANDEFINITION; 9421 if ("Practitioner".equals(codeString)) 9422 return PRACTITIONER; 9423 if ("PractitionerRole".equals(codeString)) 9424 return PRACTITIONERROLE; 9425 if ("Procedure".equals(codeString)) 9426 return PROCEDURE; 9427 if ("Provenance".equals(codeString)) 9428 return PROVENANCE; 9429 if ("Questionnaire".equals(codeString)) 9430 return QUESTIONNAIRE; 9431 if ("QuestionnaireResponse".equals(codeString)) 9432 return QUESTIONNAIRERESPONSE; 9433 if ("RegulatedAuthorization".equals(codeString)) 9434 return REGULATEDAUTHORIZATION; 9435 if ("RelatedPerson".equals(codeString)) 9436 return RELATEDPERSON; 9437 if ("RequestOrchestration".equals(codeString)) 9438 return REQUESTORCHESTRATION; 9439 if ("Requirements".equals(codeString)) 9440 return REQUIREMENTS; 9441 if ("ResearchStudy".equals(codeString)) 9442 return RESEARCHSTUDY; 9443 if ("ResearchSubject".equals(codeString)) 9444 return RESEARCHSUBJECT; 9445 if ("RiskAssessment".equals(codeString)) 9446 return RISKASSESSMENT; 9447 if ("Schedule".equals(codeString)) 9448 return SCHEDULE; 9449 if ("SearchParameter".equals(codeString)) 9450 return SEARCHPARAMETER; 9451 if ("ServiceRequest".equals(codeString)) 9452 return SERVICEREQUEST; 9453 if ("Slot".equals(codeString)) 9454 return SLOT; 9455 if ("Specimen".equals(codeString)) 9456 return SPECIMEN; 9457 if ("SpecimenDefinition".equals(codeString)) 9458 return SPECIMENDEFINITION; 9459 if ("StructureDefinition".equals(codeString)) 9460 return STRUCTUREDEFINITION; 9461 if ("StructureMap".equals(codeString)) 9462 return STRUCTUREMAP; 9463 if ("Subscription".equals(codeString)) 9464 return SUBSCRIPTION; 9465 if ("SubscriptionStatus".equals(codeString)) 9466 return SUBSCRIPTIONSTATUS; 9467 if ("SubscriptionTopic".equals(codeString)) 9468 return SUBSCRIPTIONTOPIC; 9469 if ("Substance".equals(codeString)) 9470 return SUBSTANCE; 9471 if ("SubstanceDefinition".equals(codeString)) 9472 return SUBSTANCEDEFINITION; 9473 if ("SubstanceNucleicAcid".equals(codeString)) 9474 return SUBSTANCENUCLEICACID; 9475 if ("SubstancePolymer".equals(codeString)) 9476 return SUBSTANCEPOLYMER; 9477 if ("SubstanceProtein".equals(codeString)) 9478 return SUBSTANCEPROTEIN; 9479 if ("SubstanceReferenceInformation".equals(codeString)) 9480 return SUBSTANCEREFERENCEINFORMATION; 9481 if ("SubstanceSourceMaterial".equals(codeString)) 9482 return SUBSTANCESOURCEMATERIAL; 9483 if ("SupplyDelivery".equals(codeString)) 9484 return SUPPLYDELIVERY; 9485 if ("SupplyRequest".equals(codeString)) 9486 return SUPPLYREQUEST; 9487 if ("Task".equals(codeString)) 9488 return TASK; 9489 if ("TerminologyCapabilities".equals(codeString)) 9490 return TERMINOLOGYCAPABILITIES; 9491 if ("TestPlan".equals(codeString)) 9492 return TESTPLAN; 9493 if ("TestReport".equals(codeString)) 9494 return TESTREPORT; 9495 if ("TestScript".equals(codeString)) 9496 return TESTSCRIPT; 9497 if ("Transport".equals(codeString)) 9498 return TRANSPORT; 9499 if ("ValueSet".equals(codeString)) 9500 return VALUESET; 9501 if ("VerificationResult".equals(codeString)) 9502 return VERIFICATIONRESULT; 9503 if ("VisionPrescription".equals(codeString)) 9504 return VISIONPRESCRIPTION; 9505 if ("Parameters".equals(codeString)) 9506 return PARAMETERS; 9507 throw new FHIRException("Unknown FHIRTypes code '"+codeString+"'"); 9508 } 9509 public static boolean isValidCode(String codeString) { 9510 if (codeString == null || "".equals(codeString)) 9511 return false; 9512 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"); 9513 } 9514 public String toCode() { 9515 switch (this) { 9516 case BASE: return "Base"; 9517 case ELEMENT: return "Element"; 9518 case BACKBONEELEMENT: return "BackboneElement"; 9519 case DATATYPE: return "DataType"; 9520 case ADDRESS: return "Address"; 9521 case ANNOTATION: return "Annotation"; 9522 case ATTACHMENT: return "Attachment"; 9523 case AVAILABILITY: return "Availability"; 9524 case BACKBONETYPE: return "BackboneType"; 9525 case DOSAGE: return "Dosage"; 9526 case ELEMENTDEFINITION: return "ElementDefinition"; 9527 case MARKETINGSTATUS: return "MarketingStatus"; 9528 case PRODUCTSHELFLIFE: return "ProductShelfLife"; 9529 case TIMING: return "Timing"; 9530 case CODEABLECONCEPT: return "CodeableConcept"; 9531 case CODEABLEREFERENCE: return "CodeableReference"; 9532 case CODING: return "Coding"; 9533 case CONTACTDETAIL: return "ContactDetail"; 9534 case CONTACTPOINT: return "ContactPoint"; 9535 case CONTRIBUTOR: return "Contributor"; 9536 case DATAREQUIREMENT: return "DataRequirement"; 9537 case EXPRESSION: return "Expression"; 9538 case EXTENDEDCONTACTDETAIL: return "ExtendedContactDetail"; 9539 case EXTENSION: return "Extension"; 9540 case HUMANNAME: return "HumanName"; 9541 case IDENTIFIER: return "Identifier"; 9542 case META: return "Meta"; 9543 case MONETARYCOMPONENT: return "MonetaryComponent"; 9544 case MONEY: return "Money"; 9545 case NARRATIVE: return "Narrative"; 9546 case PARAMETERDEFINITION: return "ParameterDefinition"; 9547 case PERIOD: return "Period"; 9548 case PRIMITIVETYPE: return "PrimitiveType"; 9549 case BASE64BINARY: return "base64Binary"; 9550 case BOOLEAN: return "boolean"; 9551 case DATE: return "date"; 9552 case DATETIME: return "dateTime"; 9553 case DECIMAL: return "decimal"; 9554 case INSTANT: return "instant"; 9555 case INTEGER: return "integer"; 9556 case POSITIVEINT: return "positiveInt"; 9557 case UNSIGNEDINT: return "unsignedInt"; 9558 case INTEGER64: return "integer64"; 9559 case STRING: return "string"; 9560 case CODE: return "code"; 9561 case ID: return "id"; 9562 case MARKDOWN: return "markdown"; 9563 case TIME: return "time"; 9564 case URI: return "uri"; 9565 case CANONICAL: return "canonical"; 9566 case OID: return "oid"; 9567 case URL: return "url"; 9568 case UUID: return "uuid"; 9569 case QUANTITY: return "Quantity"; 9570 case AGE: return "Age"; 9571 case COUNT: return "Count"; 9572 case DISTANCE: return "Distance"; 9573 case DURATION: return "Duration"; 9574 case RANGE: return "Range"; 9575 case RATIO: return "Ratio"; 9576 case RATIORANGE: return "RatioRange"; 9577 case REFERENCE: return "Reference"; 9578 case RELATEDARTIFACT: return "RelatedArtifact"; 9579 case SAMPLEDDATA: return "SampledData"; 9580 case SIGNATURE: return "Signature"; 9581 case TRIGGERDEFINITION: return "TriggerDefinition"; 9582 case USAGECONTEXT: return "UsageContext"; 9583 case VIRTUALSERVICEDETAIL: return "VirtualServiceDetail"; 9584 case XHTML: return "xhtml"; 9585 case RESOURCE: return "Resource"; 9586 case BINARY: return "Binary"; 9587 case BUNDLE: return "Bundle"; 9588 case DOMAINRESOURCE: return "DomainResource"; 9589 case ACCOUNT: return "Account"; 9590 case ACTIVITYDEFINITION: return "ActivityDefinition"; 9591 case ACTORDEFINITION: return "ActorDefinition"; 9592 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 9593 case ADVERSEEVENT: return "AdverseEvent"; 9594 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 9595 case APPOINTMENT: return "Appointment"; 9596 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 9597 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 9598 case AUDITEVENT: return "AuditEvent"; 9599 case BASIC: return "Basic"; 9600 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 9601 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "BiologicallyDerivedProductDispense"; 9602 case BODYSTRUCTURE: return "BodyStructure"; 9603 case CANONICALRESOURCE: return "CanonicalResource"; 9604 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 9605 case CAREPLAN: return "CarePlan"; 9606 case CARETEAM: return "CareTeam"; 9607 case CHARGEITEM: return "ChargeItem"; 9608 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 9609 case CITATION: return "Citation"; 9610 case CLAIM: return "Claim"; 9611 case CLAIMRESPONSE: return "ClaimResponse"; 9612 case CLINICALIMPRESSION: return "ClinicalImpression"; 9613 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 9614 case CODESYSTEM: return "CodeSystem"; 9615 case COMMUNICATION: return "Communication"; 9616 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 9617 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 9618 case COMPOSITION: return "Composition"; 9619 case CONCEPTMAP: return "ConceptMap"; 9620 case CONDITION: return "Condition"; 9621 case CONDITIONDEFINITION: return "ConditionDefinition"; 9622 case CONSENT: return "Consent"; 9623 case CONTRACT: return "Contract"; 9624 case COVERAGE: return "Coverage"; 9625 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 9626 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 9627 case DETECTEDISSUE: return "DetectedIssue"; 9628 case DEVICE: return "Device"; 9629 case DEVICEASSOCIATION: return "DeviceAssociation"; 9630 case DEVICEDEFINITION: return "DeviceDefinition"; 9631 case DEVICEDISPENSE: return "DeviceDispense"; 9632 case DEVICEMETRIC: return "DeviceMetric"; 9633 case DEVICEREQUEST: return "DeviceRequest"; 9634 case DEVICEUSAGE: return "DeviceUsage"; 9635 case DIAGNOSTICREPORT: return "DiagnosticReport"; 9636 case DOCUMENTREFERENCE: return "DocumentReference"; 9637 case ENCOUNTER: return "Encounter"; 9638 case ENCOUNTERHISTORY: return "EncounterHistory"; 9639 case ENDPOINT: return "Endpoint"; 9640 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 9641 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 9642 case EPISODEOFCARE: return "EpisodeOfCare"; 9643 case EVENTDEFINITION: return "EventDefinition"; 9644 case EVIDENCE: return "Evidence"; 9645 case EVIDENCEREPORT: return "EvidenceReport"; 9646 case EVIDENCEVARIABLE: return "EvidenceVariable"; 9647 case EXAMPLESCENARIO: return "ExampleScenario"; 9648 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 9649 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 9650 case FLAG: return "Flag"; 9651 case FORMULARYITEM: return "FormularyItem"; 9652 case GENOMICSTUDY: return "GenomicStudy"; 9653 case GOAL: return "Goal"; 9654 case GRAPHDEFINITION: return "GraphDefinition"; 9655 case GROUP: return "Group"; 9656 case GUIDANCERESPONSE: return "GuidanceResponse"; 9657 case HEALTHCARESERVICE: return "HealthcareService"; 9658 case IMAGINGSELECTION: return "ImagingSelection"; 9659 case IMAGINGSTUDY: return "ImagingStudy"; 9660 case IMMUNIZATION: return "Immunization"; 9661 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 9662 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 9663 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 9664 case INGREDIENT: return "Ingredient"; 9665 case INSURANCEPLAN: return "InsurancePlan"; 9666 case INVENTORYITEM: return "InventoryItem"; 9667 case INVENTORYREPORT: return "InventoryReport"; 9668 case INVOICE: return "Invoice"; 9669 case LIBRARY: return "Library"; 9670 case LINKAGE: return "Linkage"; 9671 case LIST: return "List"; 9672 case LOCATION: return "Location"; 9673 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 9674 case MEASURE: return "Measure"; 9675 case MEASUREREPORT: return "MeasureReport"; 9676 case MEDICATION: return "Medication"; 9677 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 9678 case MEDICATIONDISPENSE: return "MedicationDispense"; 9679 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 9680 case MEDICATIONREQUEST: return "MedicationRequest"; 9681 case MEDICATIONSTATEMENT: return "MedicationStatement"; 9682 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 9683 case MESSAGEDEFINITION: return "MessageDefinition"; 9684 case MESSAGEHEADER: return "MessageHeader"; 9685 case METADATARESOURCE: return "MetadataResource"; 9686 case MOLECULARSEQUENCE: return "MolecularSequence"; 9687 case NAMINGSYSTEM: return "NamingSystem"; 9688 case NUTRITIONINTAKE: return "NutritionIntake"; 9689 case NUTRITIONORDER: return "NutritionOrder"; 9690 case NUTRITIONPRODUCT: return "NutritionProduct"; 9691 case OBSERVATION: return "Observation"; 9692 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 9693 case OPERATIONDEFINITION: return "OperationDefinition"; 9694 case OPERATIONOUTCOME: return "OperationOutcome"; 9695 case ORGANIZATION: return "Organization"; 9696 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 9697 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 9698 case PATIENT: return "Patient"; 9699 case PAYMENTNOTICE: return "PaymentNotice"; 9700 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 9701 case PERMISSION: return "Permission"; 9702 case PERSON: return "Person"; 9703 case PLANDEFINITION: return "PlanDefinition"; 9704 case PRACTITIONER: return "Practitioner"; 9705 case PRACTITIONERROLE: return "PractitionerRole"; 9706 case PROCEDURE: return "Procedure"; 9707 case PROVENANCE: return "Provenance"; 9708 case QUESTIONNAIRE: return "Questionnaire"; 9709 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 9710 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 9711 case RELATEDPERSON: return "RelatedPerson"; 9712 case REQUESTORCHESTRATION: return "RequestOrchestration"; 9713 case REQUIREMENTS: return "Requirements"; 9714 case RESEARCHSTUDY: return "ResearchStudy"; 9715 case RESEARCHSUBJECT: return "ResearchSubject"; 9716 case RISKASSESSMENT: return "RiskAssessment"; 9717 case SCHEDULE: return "Schedule"; 9718 case SEARCHPARAMETER: return "SearchParameter"; 9719 case SERVICEREQUEST: return "ServiceRequest"; 9720 case SLOT: return "Slot"; 9721 case SPECIMEN: return "Specimen"; 9722 case SPECIMENDEFINITION: return "SpecimenDefinition"; 9723 case STRUCTUREDEFINITION: return "StructureDefinition"; 9724 case STRUCTUREMAP: return "StructureMap"; 9725 case SUBSCRIPTION: return "Subscription"; 9726 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 9727 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 9728 case SUBSTANCE: return "Substance"; 9729 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 9730 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 9731 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 9732 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 9733 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 9734 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 9735 case SUPPLYDELIVERY: return "SupplyDelivery"; 9736 case SUPPLYREQUEST: return "SupplyRequest"; 9737 case TASK: return "Task"; 9738 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 9739 case TESTPLAN: return "TestPlan"; 9740 case TESTREPORT: return "TestReport"; 9741 case TESTSCRIPT: return "TestScript"; 9742 case TRANSPORT: return "Transport"; 9743 case VALUESET: return "ValueSet"; 9744 case VERIFICATIONRESULT: return "VerificationResult"; 9745 case VISIONPRESCRIPTION: return "VisionPrescription"; 9746 case PARAMETERS: return "Parameters"; 9747 case NULL: return null; 9748 default: return "?"; 9749 } 9750 } 9751 public String getSystem() { 9752 switch (this) { 9753 case BASE: return "http://hl7.org/fhir/fhir-types"; 9754 case ELEMENT: return "http://hl7.org/fhir/fhir-types"; 9755 case BACKBONEELEMENT: return "http://hl7.org/fhir/fhir-types"; 9756 case DATATYPE: return "http://hl7.org/fhir/fhir-types"; 9757 case ADDRESS: return "http://hl7.org/fhir/fhir-types"; 9758 case ANNOTATION: return "http://hl7.org/fhir/fhir-types"; 9759 case ATTACHMENT: return "http://hl7.org/fhir/fhir-types"; 9760 case AVAILABILITY: return "http://hl7.org/fhir/fhir-types"; 9761 case BACKBONETYPE: return "http://hl7.org/fhir/fhir-types"; 9762 case DOSAGE: return "http://hl7.org/fhir/fhir-types"; 9763 case ELEMENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9764 case MARKETINGSTATUS: return "http://hl7.org/fhir/fhir-types"; 9765 case PRODUCTSHELFLIFE: return "http://hl7.org/fhir/fhir-types"; 9766 case TIMING: return "http://hl7.org/fhir/fhir-types"; 9767 case CODEABLECONCEPT: return "http://hl7.org/fhir/fhir-types"; 9768 case CODEABLEREFERENCE: return "http://hl7.org/fhir/fhir-types"; 9769 case CODING: return "http://hl7.org/fhir/fhir-types"; 9770 case CONTACTDETAIL: return "http://hl7.org/fhir/fhir-types"; 9771 case CONTACTPOINT: return "http://hl7.org/fhir/fhir-types"; 9772 case CONTRIBUTOR: return "http://hl7.org/fhir/fhir-types"; 9773 case DATAREQUIREMENT: return "http://hl7.org/fhir/fhir-types"; 9774 case EXPRESSION: return "http://hl7.org/fhir/fhir-types"; 9775 case EXTENDEDCONTACTDETAIL: return "http://hl7.org/fhir/fhir-types"; 9776 case EXTENSION: return "http://hl7.org/fhir/fhir-types"; 9777 case HUMANNAME: return "http://hl7.org/fhir/fhir-types"; 9778 case IDENTIFIER: return "http://hl7.org/fhir/fhir-types"; 9779 case META: return "http://hl7.org/fhir/fhir-types"; 9780 case MONETARYCOMPONENT: return "http://hl7.org/fhir/fhir-types"; 9781 case MONEY: return "http://hl7.org/fhir/fhir-types"; 9782 case NARRATIVE: return "http://hl7.org/fhir/fhir-types"; 9783 case PARAMETERDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9784 case PERIOD: return "http://hl7.org/fhir/fhir-types"; 9785 case PRIMITIVETYPE: return "http://hl7.org/fhir/fhir-types"; 9786 case BASE64BINARY: return "http://hl7.org/fhir/fhir-types"; 9787 case BOOLEAN: return "http://hl7.org/fhir/fhir-types"; 9788 case DATE: return "http://hl7.org/fhir/fhir-types"; 9789 case DATETIME: return "http://hl7.org/fhir/fhir-types"; 9790 case DECIMAL: return "http://hl7.org/fhir/fhir-types"; 9791 case INSTANT: return "http://hl7.org/fhir/fhir-types"; 9792 case INTEGER: return "http://hl7.org/fhir/fhir-types"; 9793 case POSITIVEINT: return "http://hl7.org/fhir/fhir-types"; 9794 case UNSIGNEDINT: return "http://hl7.org/fhir/fhir-types"; 9795 case INTEGER64: return "http://hl7.org/fhir/fhir-types"; 9796 case STRING: return "http://hl7.org/fhir/fhir-types"; 9797 case CODE: return "http://hl7.org/fhir/fhir-types"; 9798 case ID: return "http://hl7.org/fhir/fhir-types"; 9799 case MARKDOWN: return "http://hl7.org/fhir/fhir-types"; 9800 case TIME: return "http://hl7.org/fhir/fhir-types"; 9801 case URI: return "http://hl7.org/fhir/fhir-types"; 9802 case CANONICAL: return "http://hl7.org/fhir/fhir-types"; 9803 case OID: return "http://hl7.org/fhir/fhir-types"; 9804 case URL: return "http://hl7.org/fhir/fhir-types"; 9805 case UUID: return "http://hl7.org/fhir/fhir-types"; 9806 case QUANTITY: return "http://hl7.org/fhir/fhir-types"; 9807 case AGE: return "http://hl7.org/fhir/fhir-types"; 9808 case COUNT: return "http://hl7.org/fhir/fhir-types"; 9809 case DISTANCE: return "http://hl7.org/fhir/fhir-types"; 9810 case DURATION: return "http://hl7.org/fhir/fhir-types"; 9811 case RANGE: return "http://hl7.org/fhir/fhir-types"; 9812 case RATIO: return "http://hl7.org/fhir/fhir-types"; 9813 case RATIORANGE: return "http://hl7.org/fhir/fhir-types"; 9814 case REFERENCE: return "http://hl7.org/fhir/fhir-types"; 9815 case RELATEDARTIFACT: return "http://hl7.org/fhir/fhir-types"; 9816 case SAMPLEDDATA: return "http://hl7.org/fhir/fhir-types"; 9817 case SIGNATURE: return "http://hl7.org/fhir/fhir-types"; 9818 case TRIGGERDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9819 case USAGECONTEXT: return "http://hl7.org/fhir/fhir-types"; 9820 case VIRTUALSERVICEDETAIL: return "http://hl7.org/fhir/fhir-types"; 9821 case XHTML: return "http://hl7.org/fhir/fhir-types"; 9822 case RESOURCE: return "http://hl7.org/fhir/fhir-types"; 9823 case BINARY: return "http://hl7.org/fhir/fhir-types"; 9824 case BUNDLE: return "http://hl7.org/fhir/fhir-types"; 9825 case DOMAINRESOURCE: return "http://hl7.org/fhir/fhir-types"; 9826 case ACCOUNT: return "http://hl7.org/fhir/fhir-types"; 9827 case ACTIVITYDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9828 case ACTORDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9829 case ADMINISTRABLEPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9830 case ADVERSEEVENT: return "http://hl7.org/fhir/fhir-types"; 9831 case ALLERGYINTOLERANCE: return "http://hl7.org/fhir/fhir-types"; 9832 case APPOINTMENT: return "http://hl7.org/fhir/fhir-types"; 9833 case APPOINTMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 9834 case ARTIFACTASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 9835 case AUDITEVENT: return "http://hl7.org/fhir/fhir-types"; 9836 case BASIC: return "http://hl7.org/fhir/fhir-types"; 9837 case BIOLOGICALLYDERIVEDPRODUCT: return "http://hl7.org/fhir/fhir-types"; 9838 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "http://hl7.org/fhir/fhir-types"; 9839 case BODYSTRUCTURE: return "http://hl7.org/fhir/fhir-types"; 9840 case CANONICALRESOURCE: return "http://hl7.org/fhir/fhir-types"; 9841 case CAPABILITYSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 9842 case CAREPLAN: return "http://hl7.org/fhir/fhir-types"; 9843 case CARETEAM: return "http://hl7.org/fhir/fhir-types"; 9844 case CHARGEITEM: return "http://hl7.org/fhir/fhir-types"; 9845 case CHARGEITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9846 case CITATION: return "http://hl7.org/fhir/fhir-types"; 9847 case CLAIM: return "http://hl7.org/fhir/fhir-types"; 9848 case CLAIMRESPONSE: return "http://hl7.org/fhir/fhir-types"; 9849 case CLINICALIMPRESSION: return "http://hl7.org/fhir/fhir-types"; 9850 case CLINICALUSEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9851 case CODESYSTEM: return "http://hl7.org/fhir/fhir-types"; 9852 case COMMUNICATION: return "http://hl7.org/fhir/fhir-types"; 9853 case COMMUNICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 9854 case COMPARTMENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9855 case COMPOSITION: return "http://hl7.org/fhir/fhir-types"; 9856 case CONCEPTMAP: return "http://hl7.org/fhir/fhir-types"; 9857 case CONDITION: return "http://hl7.org/fhir/fhir-types"; 9858 case CONDITIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9859 case CONSENT: return "http://hl7.org/fhir/fhir-types"; 9860 case CONTRACT: return "http://hl7.org/fhir/fhir-types"; 9861 case COVERAGE: return "http://hl7.org/fhir/fhir-types"; 9862 case COVERAGEELIGIBILITYREQUEST: return "http://hl7.org/fhir/fhir-types"; 9863 case COVERAGEELIGIBILITYRESPONSE: return "http://hl7.org/fhir/fhir-types"; 9864 case DETECTEDISSUE: return "http://hl7.org/fhir/fhir-types"; 9865 case DEVICE: return "http://hl7.org/fhir/fhir-types"; 9866 case DEVICEASSOCIATION: return "http://hl7.org/fhir/fhir-types"; 9867 case DEVICEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9868 case DEVICEDISPENSE: return "http://hl7.org/fhir/fhir-types"; 9869 case DEVICEMETRIC: return "http://hl7.org/fhir/fhir-types"; 9870 case DEVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 9871 case DEVICEUSAGE: return "http://hl7.org/fhir/fhir-types"; 9872 case DIAGNOSTICREPORT: return "http://hl7.org/fhir/fhir-types"; 9873 case DOCUMENTREFERENCE: return "http://hl7.org/fhir/fhir-types"; 9874 case ENCOUNTER: return "http://hl7.org/fhir/fhir-types"; 9875 case ENCOUNTERHISTORY: return "http://hl7.org/fhir/fhir-types"; 9876 case ENDPOINT: return "http://hl7.org/fhir/fhir-types"; 9877 case ENROLLMENTREQUEST: return "http://hl7.org/fhir/fhir-types"; 9878 case ENROLLMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 9879 case EPISODEOFCARE: return "http://hl7.org/fhir/fhir-types"; 9880 case EVENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9881 case EVIDENCE: return "http://hl7.org/fhir/fhir-types"; 9882 case EVIDENCEREPORT: return "http://hl7.org/fhir/fhir-types"; 9883 case EVIDENCEVARIABLE: return "http://hl7.org/fhir/fhir-types"; 9884 case EXAMPLESCENARIO: return "http://hl7.org/fhir/fhir-types"; 9885 case EXPLANATIONOFBENEFIT: return "http://hl7.org/fhir/fhir-types"; 9886 case FAMILYMEMBERHISTORY: return "http://hl7.org/fhir/fhir-types"; 9887 case FLAG: return "http://hl7.org/fhir/fhir-types"; 9888 case FORMULARYITEM: return "http://hl7.org/fhir/fhir-types"; 9889 case GENOMICSTUDY: return "http://hl7.org/fhir/fhir-types"; 9890 case GOAL: return "http://hl7.org/fhir/fhir-types"; 9891 case GRAPHDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9892 case GROUP: return "http://hl7.org/fhir/fhir-types"; 9893 case GUIDANCERESPONSE: return "http://hl7.org/fhir/fhir-types"; 9894 case HEALTHCARESERVICE: return "http://hl7.org/fhir/fhir-types"; 9895 case IMAGINGSELECTION: return "http://hl7.org/fhir/fhir-types"; 9896 case IMAGINGSTUDY: return "http://hl7.org/fhir/fhir-types"; 9897 case IMMUNIZATION: return "http://hl7.org/fhir/fhir-types"; 9898 case IMMUNIZATIONEVALUATION: return "http://hl7.org/fhir/fhir-types"; 9899 case IMMUNIZATIONRECOMMENDATION: return "http://hl7.org/fhir/fhir-types"; 9900 case IMPLEMENTATIONGUIDE: return "http://hl7.org/fhir/fhir-types"; 9901 case INGREDIENT: return "http://hl7.org/fhir/fhir-types"; 9902 case INSURANCEPLAN: return "http://hl7.org/fhir/fhir-types"; 9903 case INVENTORYITEM: return "http://hl7.org/fhir/fhir-types"; 9904 case INVENTORYREPORT: return "http://hl7.org/fhir/fhir-types"; 9905 case INVOICE: return "http://hl7.org/fhir/fhir-types"; 9906 case LIBRARY: return "http://hl7.org/fhir/fhir-types"; 9907 case LINKAGE: return "http://hl7.org/fhir/fhir-types"; 9908 case LIST: return "http://hl7.org/fhir/fhir-types"; 9909 case LOCATION: return "http://hl7.org/fhir/fhir-types"; 9910 case MANUFACTUREDITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9911 case MEASURE: return "http://hl7.org/fhir/fhir-types"; 9912 case MEASUREREPORT: return "http://hl7.org/fhir/fhir-types"; 9913 case MEDICATION: return "http://hl7.org/fhir/fhir-types"; 9914 case MEDICATIONADMINISTRATION: return "http://hl7.org/fhir/fhir-types"; 9915 case MEDICATIONDISPENSE: return "http://hl7.org/fhir/fhir-types"; 9916 case MEDICATIONKNOWLEDGE: return "http://hl7.org/fhir/fhir-types"; 9917 case MEDICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 9918 case MEDICATIONSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 9919 case MEDICINALPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9920 case MESSAGEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9921 case MESSAGEHEADER: return "http://hl7.org/fhir/fhir-types"; 9922 case METADATARESOURCE: return "http://hl7.org/fhir/fhir-types"; 9923 case MOLECULARSEQUENCE: return "http://hl7.org/fhir/fhir-types"; 9924 case NAMINGSYSTEM: return "http://hl7.org/fhir/fhir-types"; 9925 case NUTRITIONINTAKE: return "http://hl7.org/fhir/fhir-types"; 9926 case NUTRITIONORDER: return "http://hl7.org/fhir/fhir-types"; 9927 case NUTRITIONPRODUCT: return "http://hl7.org/fhir/fhir-types"; 9928 case OBSERVATION: return "http://hl7.org/fhir/fhir-types"; 9929 case OBSERVATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9930 case OPERATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9931 case OPERATIONOUTCOME: return "http://hl7.org/fhir/fhir-types"; 9932 case ORGANIZATION: return "http://hl7.org/fhir/fhir-types"; 9933 case ORGANIZATIONAFFILIATION: return "http://hl7.org/fhir/fhir-types"; 9934 case PACKAGEDPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9935 case PATIENT: return "http://hl7.org/fhir/fhir-types"; 9936 case PAYMENTNOTICE: return "http://hl7.org/fhir/fhir-types"; 9937 case PAYMENTRECONCILIATION: return "http://hl7.org/fhir/fhir-types"; 9938 case PERMISSION: return "http://hl7.org/fhir/fhir-types"; 9939 case PERSON: return "http://hl7.org/fhir/fhir-types"; 9940 case PLANDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9941 case PRACTITIONER: return "http://hl7.org/fhir/fhir-types"; 9942 case PRACTITIONERROLE: return "http://hl7.org/fhir/fhir-types"; 9943 case PROCEDURE: return "http://hl7.org/fhir/fhir-types"; 9944 case PROVENANCE: return "http://hl7.org/fhir/fhir-types"; 9945 case QUESTIONNAIRE: return "http://hl7.org/fhir/fhir-types"; 9946 case QUESTIONNAIRERESPONSE: return "http://hl7.org/fhir/fhir-types"; 9947 case REGULATEDAUTHORIZATION: return "http://hl7.org/fhir/fhir-types"; 9948 case RELATEDPERSON: return "http://hl7.org/fhir/fhir-types"; 9949 case REQUESTORCHESTRATION: return "http://hl7.org/fhir/fhir-types"; 9950 case REQUIREMENTS: return "http://hl7.org/fhir/fhir-types"; 9951 case RESEARCHSTUDY: return "http://hl7.org/fhir/fhir-types"; 9952 case RESEARCHSUBJECT: return "http://hl7.org/fhir/fhir-types"; 9953 case RISKASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 9954 case SCHEDULE: return "http://hl7.org/fhir/fhir-types"; 9955 case SEARCHPARAMETER: return "http://hl7.org/fhir/fhir-types"; 9956 case SERVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 9957 case SLOT: return "http://hl7.org/fhir/fhir-types"; 9958 case SPECIMEN: return "http://hl7.org/fhir/fhir-types"; 9959 case SPECIMENDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9960 case STRUCTUREDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9961 case STRUCTUREMAP: return "http://hl7.org/fhir/fhir-types"; 9962 case SUBSCRIPTION: return "http://hl7.org/fhir/fhir-types"; 9963 case SUBSCRIPTIONSTATUS: return "http://hl7.org/fhir/fhir-types"; 9964 case SUBSCRIPTIONTOPIC: return "http://hl7.org/fhir/fhir-types"; 9965 case SUBSTANCE: return "http://hl7.org/fhir/fhir-types"; 9966 case SUBSTANCEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9967 case SUBSTANCENUCLEICACID: return "http://hl7.org/fhir/fhir-types"; 9968 case SUBSTANCEPOLYMER: return "http://hl7.org/fhir/fhir-types"; 9969 case SUBSTANCEPROTEIN: return "http://hl7.org/fhir/fhir-types"; 9970 case SUBSTANCEREFERENCEINFORMATION: return "http://hl7.org/fhir/fhir-types"; 9971 case SUBSTANCESOURCEMATERIAL: return "http://hl7.org/fhir/fhir-types"; 9972 case SUPPLYDELIVERY: return "http://hl7.org/fhir/fhir-types"; 9973 case SUPPLYREQUEST: return "http://hl7.org/fhir/fhir-types"; 9974 case TASK: return "http://hl7.org/fhir/fhir-types"; 9975 case TERMINOLOGYCAPABILITIES: return "http://hl7.org/fhir/fhir-types"; 9976 case TESTPLAN: return "http://hl7.org/fhir/fhir-types"; 9977 case TESTREPORT: return "http://hl7.org/fhir/fhir-types"; 9978 case TESTSCRIPT: return "http://hl7.org/fhir/fhir-types"; 9979 case TRANSPORT: return "http://hl7.org/fhir/fhir-types"; 9980 case VALUESET: return "http://hl7.org/fhir/fhir-types"; 9981 case VERIFICATIONRESULT: return "http://hl7.org/fhir/fhir-types"; 9982 case VISIONPRESCRIPTION: return "http://hl7.org/fhir/fhir-types"; 9983 case PARAMETERS: return "http://hl7.org/fhir/fhir-types"; 9984 case NULL: return null; 9985 default: return "?"; 9986 } 9987 } 9988 public String getDefinition() { 9989 switch (this) { 9990 case BASE: return "Base Type: Base definition for all types defined in FHIR type system."; 9991 case ELEMENT: return "Element Type: Base definition for all elements in a resource."; 9992 case BACKBONEELEMENT: return "BackboneElement Type: Base definition for all elements that are defined inside a resource - but not those in a data type."; 9993 case DATATYPE: return "DataType Type: The base class for all re-useable types defined as part of the FHIR Specification."; 9994 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."; 9995 case ANNOTATION: return "Annotation Type: A text note which also contains information about who made the statement and when."; 9996 case ATTACHMENT: return "Attachment Type: For referring to data content defined in other formats."; 9997 case AVAILABILITY: return "Availability Type: Availability data for an {item}."; 9998 case BACKBONETYPE: return "BackboneType Type: Base definition for the few data types that are allowed to carry modifier extensions."; 9999 case DOSAGE: return "Dosage Type: Indicates how the medication is/was taken or should be taken by the patient."; 10000 case ELEMENTDEFINITION: return "ElementDefinition Type: Captures constraints on each element within the resource, profile, or extension."; 10001 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."; 10002 case PRODUCTSHELFLIFE: return "ProductShelfLife Type: The shelf-life and storage information for a medicinal product item or container can be described using this class."; 10003 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."; 10004 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."; 10005 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)."; 10006 case CODING: return "Coding Type: A reference to a code defined by a terminology system."; 10007 case CONTACTDETAIL: return "ContactDetail Type: Specifies contact information for a person or organization."; 10008 case CONTACTPOINT: return "ContactPoint Type: Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc."; 10009 case CONTRIBUTOR: return "Contributor Type: A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers."; 10010 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."; 10011 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."; 10012 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."; 10013 case EXTENSION: return "Extension Type: Optional Extension Element - found in all resources."; 10014 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."; 10015 case IDENTIFIER: return "Identifier Type: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers."; 10016 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."; 10017 case MONETARYCOMPONENT: return "MonetaryComponent Type: Availability data for an {item}."; 10018 case MONEY: return "Money Type: An amount of economic utility in some recognized currency."; 10019 case NARRATIVE: return "Narrative Type: A human-readable summary of the resource conveying the essential clinical and business information for the resource."; 10020 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."; 10021 case PERIOD: return "Period Type: A time period defined by a start and end date and optionally time."; 10022 case PRIMITIVETYPE: return "PrimitiveType Type: The base type for all re-useable types defined that have a simple property."; 10023 case BASE64BINARY: return "base64Binary Type: A stream of bytes"; 10024 case BOOLEAN: return "boolean Type: Value of \"true\" or \"false\""; 10025 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."; 10026 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."; 10027 case DECIMAL: return "decimal Type: A rational number with implicit precision"; 10028 case INSTANT: return "instant Type: An instant in time - known at least to the second"; 10029 case INTEGER: return "integer Type: A whole number"; 10030 case POSITIVEINT: return "positiveInt type: An integer with a value that is positive (e.g. >0)"; 10031 case UNSIGNEDINT: return "unsignedInt type: An integer with a value that is not negative (e.g. >= 0)"; 10032 case INTEGER64: return "integer64 Type: A very large whole number"; 10033 case STRING: return "string Type: A sequence of Unicode characters"; 10034 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"; 10035 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."; 10036 case MARKDOWN: return "markdown type: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine"; 10037 case TIME: return "time Type: A time during the day, with no date specified"; 10038 case URI: return "uri Type: String of characters used to identify a name or a resource"; 10039 case CANONICAL: return "canonical type: A URI that is a reference to a canonical URL on a FHIR resource"; 10040 case OID: return "oid type: An OID represented as a URI"; 10041 case URL: return "url type: A URI that is a literal reference"; 10042 case UUID: return "uuid type: A UUID, represented as a URI"; 10043 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."; 10044 case AGE: return "Age Type: A duration of time during which an organism (or a process) has existed."; 10045 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."; 10046 case DISTANCE: return "Distance Type: A length - a value with a unit that is a physical distance."; 10047 case DURATION: return "Duration Type: A length of time."; 10048 case RANGE: return "Range Type: A set of ordered Quantities defined by a low and high limit."; 10049 case RATIO: return "Ratio Type: A relationship of two Quantity values - expressed as a numerator and a denominator."; 10050 case RATIORANGE: return "RatioRange Type: A range of ratios expressed as a low and high numerator and a denominator."; 10051 case REFERENCE: return "Reference Type: A reference from one resource to another."; 10052 case RELATEDARTIFACT: return "RelatedArtifact Type: Related artifacts such as additional documentation, justification, or bibliographic references."; 10053 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."; 10054 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."; 10055 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."; 10056 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)."; 10057 case VIRTUALSERVICEDETAIL: return "VirtualServiceDetail Type: Virtual Service Contact Details."; 10058 case XHTML: return "xhtml Type definition"; 10059 case RESOURCE: return "This is the base resource type for everything."; 10060 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."; 10061 case BUNDLE: return "A container for a collection of resources."; 10062 case DOMAINRESOURCE: return "A resource that includes narrative, extensions, and contained resources."; 10063 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."; 10064 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."; 10065 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."; 10066 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)."; 10067 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."; 10068 case ALLERGYINTOLERANCE: return "Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance."; 10069 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)."; 10070 case APPOINTMENTRESPONSE: return "A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection."; 10071 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."; 10072 case AUDITEVENT: return "A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis."; 10073 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."; 10074 case BIOLOGICALLYDERIVEDPRODUCT: return "A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity."; 10075 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "A record of dispensation of a biologically derived product."; 10076 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."; 10077 case CANONICALRESOURCE: return "Common Interface declaration for conformance and knowledge artifact resources."; 10078 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."; 10079 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."; 10080 case CARETEAM: return "The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care."; 10081 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."; 10082 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."; 10083 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."; 10084 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."; 10085 case CLAIMRESPONSE: return "This resource provides the adjudication details from the processing of a Claim resource."; 10086 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."; 10087 case CLINICALUSEDEFINITION: return "A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure."; 10088 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."; 10089 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."; 10090 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."; 10091 case COMPARTMENTDEFINITION: return "A compartment definition that defines how resources are accessed on a server."; 10092 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.)."; 10093 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."; 10094 case CONDITION: return "A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern."; 10095 case CONDITIONDEFINITION: return "A definition of a condition and information relevant to managing it."; 10096 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."; 10097 case CONTRACT: return "Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement."; 10098 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."; 10099 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."; 10100 case COVERAGEELIGIBILITYRESPONSE: return "This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource."; 10101 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."; 10102 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."; 10103 case DEVICEASSOCIATION: return "A record of association of a device."; 10104 case DEVICEDEFINITION: return "This is a specialized resource that defines the characteristics and capabilities of a device."; 10105 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."; 10106 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. "; 10107 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."; 10108 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."; 10109 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."; 10110 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."; 10111 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)."; 10112 case ENCOUNTERHISTORY: return "A record of significant events/milestones key data throughout the history of an Encounter"; 10113 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."; 10114 case ENROLLMENTREQUEST: return "This resource provides the insurance enrollment details to the insurer regarding a specified coverage."; 10115 case ENROLLMENTRESPONSE: return "This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource."; 10116 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."; 10117 case EVENTDEFINITION: return "The EventDefinition resource provides a reusable description of when a particular event can occur."; 10118 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."; 10119 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."; 10120 case EVIDENCEVARIABLE: return "The EvidenceVariable resource describes an element that knowledge (Evidence) is about."; 10121 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."; 10122 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."; 10123 case FAMILYMEMBERHISTORY: return "Significant health conditions for a person related to the patient relevant in the context of care for the patient."; 10124 case FLAG: return "Prospective warnings of potential issues when providing care to the patient."; 10125 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."; 10126 case GENOMICSTUDY: return "A set of analyses performed to analyze and generate genomic data."; 10127 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."; 10128 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."; 10129 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."; 10130 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."; 10131 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."; 10132 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."; 10133 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."; 10134 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."; 10135 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."; 10136 case IMMUNIZATIONRECOMMENDATION: return "A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification."; 10137 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."; 10138 case INGREDIENT: return "An ingredient of a manufactured item or pharmaceutical product."; 10139 case INSURANCEPLAN: return "Details of a Health Insurance product/plan provided by an organization."; 10140 case INVENTORYITEM: return "functional description of an inventory item used in inventory and supply-related workflows."; 10141 case INVENTORYREPORT: return "A report of inventory or stock items."; 10142 case INVOICE: return "Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose."; 10143 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."; 10144 case LINKAGE: return "Identifies two or more records (resource instances) that refer to the same real-world \"occurrence\"."; 10145 case LIST: return "A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc."; 10146 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."; 10147 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."; 10148 case MEASURE: return "The Measure resource provides the definition of a quality measure."; 10149 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."; 10150 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."; 10151 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."; 10152 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."; 10153 case MEDICATIONKNOWLEDGE: return "Information about a medication that is used to support knowledge."; 10154 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."; 10155 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."; 10156 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.)."; 10157 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."; 10158 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."; 10159 case METADATARESOURCE: return "Common Interface declaration for conformance and knowledge artifact resources."; 10160 case MOLECULARSEQUENCE: return "Representation of a molecular sequence."; 10161 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."; 10162 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."; 10163 case NUTRITIONORDER: return "A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident."; 10164 case NUTRITIONPRODUCT: return "A food or supplement that is consumed by patients."; 10165 case OBSERVATION: return "Measurements and simple assertions made about a patient, device or other subject."; 10166 case OBSERVATIONDEFINITION: return "Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service."; 10167 case OPERATIONDEFINITION: return "A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction)."; 10168 case OPERATIONOUTCOME: return "A collection of error, warning, or information messages that result from a system action."; 10169 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."; 10170 case ORGANIZATIONAFFILIATION: return "Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship."; 10171 case PACKAGEDPRODUCTDEFINITION: return "A medically related item or items, in a container or package."; 10172 case PATIENT: return "Demographics and other administrative information about an individual or animal receiving care or other health-related services."; 10173 case PAYMENTNOTICE: return "This resource provides the status of the payment for goods and services rendered, and the request and response resource references."; 10174 case PAYMENTRECONCILIATION: return "This resource provides the details including amount of a payment and allocates the payment items being paid."; 10175 case PERMISSION: return "Permission resource holds access rules for a given data and context."; 10176 case PERSON: return "Demographics and administrative information about a person independent of a specific health-related context."; 10177 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."; 10178 case PRACTITIONER: return "A person who is directly or indirectly involved in the provisioning of healthcare or related services."; 10179 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."; 10180 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."; 10181 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."; 10182 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."; 10183 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."; 10184 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."; 10185 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."; 10186 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\"."; 10187 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."; 10188 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."; 10189 case RESEARCHSUBJECT: return "A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study."; 10190 case RISKASSESSMENT: return "An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome."; 10191 case SCHEDULE: return "A container for slots of time that may be available for booking appointments."; 10192 case SEARCHPARAMETER: return "A search parameter that defines a named search item that can be used to search/filter on a resource."; 10193 case SERVICEREQUEST: return "A record of a request for service such as diagnostic investigations, treatments, or operations to be performed."; 10194 case SLOT: return "A slot of time on a schedule that may be available for booking appointments."; 10195 case SPECIMEN: return "A sample to be used for analysis."; 10196 case SPECIMENDEFINITION: return "A kind of specimen with associated set of requirements."; 10197 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."; 10198 case STRUCTUREMAP: return "A Map of relationships between 2 structures that can be used to transform data."; 10199 case SUBSCRIPTION: return "The subscription resource describes a particular client's request to be notified about a SubscriptionTopic."; 10200 case SUBSCRIPTIONSTATUS: return "The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted."; 10201 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."; 10202 case SUBSTANCE: return "A homogeneous material with a definite composition."; 10203 case SUBSTANCEDEFINITION: return "The detailed description of a substance, typically at a level beyond what is used for prescribing."; 10204 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."; 10205 case SUBSTANCEPOLYMER: return "Properties of a substance specific to it being a polymer."; 10206 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."; 10207 case SUBSTANCEREFERENCEINFORMATION: return "Todo."; 10208 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."; 10209 case SUPPLYDELIVERY: return "Record of delivery of what is supplied."; 10210 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."; 10211 case TASK: return "A task to be performed."; 10212 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."; 10213 case TESTPLAN: return "A plan for executing testing on an artifact or specifications"; 10214 case TESTREPORT: return "A summary of information based on the results of executing a TestScript."; 10215 case TESTSCRIPT: return "A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification."; 10216 case TRANSPORT: return "Record of transport."; 10217 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)."; 10218 case VERIFICATIONRESULT: return "Describes validation requirements, source(s), status and dates for one or more elements."; 10219 case VISIONPRESCRIPTION: return "An authorization for the provision of glasses and/or contact lenses to a patient."; 10220 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."; 10221 case NULL: return null; 10222 default: return "?"; 10223 } 10224 } 10225 public String getDisplay() { 10226 switch (this) { 10227 case BASE: return "Base"; 10228 case ELEMENT: return "Element"; 10229 case BACKBONEELEMENT: return "BackboneElement"; 10230 case DATATYPE: return "DataType"; 10231 case ADDRESS: return "Address"; 10232 case ANNOTATION: return "Annotation"; 10233 case ATTACHMENT: return "Attachment"; 10234 case AVAILABILITY: return "Availability"; 10235 case BACKBONETYPE: return "BackboneType"; 10236 case DOSAGE: return "Dosage"; 10237 case ELEMENTDEFINITION: return "ElementDefinition"; 10238 case MARKETINGSTATUS: return "MarketingStatus"; 10239 case PRODUCTSHELFLIFE: return "ProductShelfLife"; 10240 case TIMING: return "Timing"; 10241 case CODEABLECONCEPT: return "CodeableConcept"; 10242 case CODEABLEREFERENCE: return "CodeableReference"; 10243 case CODING: return "Coding"; 10244 case CONTACTDETAIL: return "ContactDetail"; 10245 case CONTACTPOINT: return "ContactPoint"; 10246 case CONTRIBUTOR: return "Contributor"; 10247 case DATAREQUIREMENT: return "DataRequirement"; 10248 case EXPRESSION: return "Expression"; 10249 case EXTENDEDCONTACTDETAIL: return "ExtendedContactDetail"; 10250 case EXTENSION: return "Extension"; 10251 case HUMANNAME: return "HumanName"; 10252 case IDENTIFIER: return "Identifier"; 10253 case META: return "Meta"; 10254 case MONETARYCOMPONENT: return "MonetaryComponent"; 10255 case MONEY: return "Money"; 10256 case NARRATIVE: return "Narrative"; 10257 case PARAMETERDEFINITION: return "ParameterDefinition"; 10258 case PERIOD: return "Period"; 10259 case PRIMITIVETYPE: return "PrimitiveType"; 10260 case BASE64BINARY: return "base64Binary"; 10261 case BOOLEAN: return "boolean"; 10262 case DATE: return "date"; 10263 case DATETIME: return "dateTime"; 10264 case DECIMAL: return "decimal"; 10265 case INSTANT: return "instant"; 10266 case INTEGER: return "integer"; 10267 case POSITIVEINT: return "positiveInt"; 10268 case UNSIGNEDINT: return "unsignedInt"; 10269 case INTEGER64: return "integer64"; 10270 case STRING: return "string"; 10271 case CODE: return "code"; 10272 case ID: return "id"; 10273 case MARKDOWN: return "markdown"; 10274 case TIME: return "time"; 10275 case URI: return "uri"; 10276 case CANONICAL: return "canonical"; 10277 case OID: return "oid"; 10278 case URL: return "url"; 10279 case UUID: return "uuid"; 10280 case QUANTITY: return "Quantity"; 10281 case AGE: return "Age"; 10282 case COUNT: return "Count"; 10283 case DISTANCE: return "Distance"; 10284 case DURATION: return "Duration"; 10285 case RANGE: return "Range"; 10286 case RATIO: return "Ratio"; 10287 case RATIORANGE: return "RatioRange"; 10288 case REFERENCE: return "Reference"; 10289 case RELATEDARTIFACT: return "RelatedArtifact"; 10290 case SAMPLEDDATA: return "SampledData"; 10291 case SIGNATURE: return "Signature"; 10292 case TRIGGERDEFINITION: return "TriggerDefinition"; 10293 case USAGECONTEXT: return "UsageContext"; 10294 case VIRTUALSERVICEDETAIL: return "VirtualServiceDetail"; 10295 case XHTML: return "xhtml"; 10296 case RESOURCE: return "Resource"; 10297 case BINARY: return "Binary"; 10298 case BUNDLE: return "Bundle"; 10299 case DOMAINRESOURCE: return "DomainResource"; 10300 case ACCOUNT: return "Account"; 10301 case ACTIVITYDEFINITION: return "ActivityDefinition"; 10302 case ACTORDEFINITION: return "ActorDefinition"; 10303 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 10304 case ADVERSEEVENT: return "AdverseEvent"; 10305 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 10306 case APPOINTMENT: return "Appointment"; 10307 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 10308 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 10309 case AUDITEVENT: return "AuditEvent"; 10310 case BASIC: return "Basic"; 10311 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 10312 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "BiologicallyDerivedProductDispense"; 10313 case BODYSTRUCTURE: return "BodyStructure"; 10314 case CANONICALRESOURCE: return "CanonicalResource"; 10315 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 10316 case CAREPLAN: return "CarePlan"; 10317 case CARETEAM: return "CareTeam"; 10318 case CHARGEITEM: return "ChargeItem"; 10319 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 10320 case CITATION: return "Citation"; 10321 case CLAIM: return "Claim"; 10322 case CLAIMRESPONSE: return "ClaimResponse"; 10323 case CLINICALIMPRESSION: return "ClinicalImpression"; 10324 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 10325 case CODESYSTEM: return "CodeSystem"; 10326 case COMMUNICATION: return "Communication"; 10327 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 10328 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 10329 case COMPOSITION: return "Composition"; 10330 case CONCEPTMAP: return "ConceptMap"; 10331 case CONDITION: return "Condition"; 10332 case CONDITIONDEFINITION: return "ConditionDefinition"; 10333 case CONSENT: return "Consent"; 10334 case CONTRACT: return "Contract"; 10335 case COVERAGE: return "Coverage"; 10336 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 10337 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 10338 case DETECTEDISSUE: return "DetectedIssue"; 10339 case DEVICE: return "Device"; 10340 case DEVICEASSOCIATION: return "DeviceAssociation"; 10341 case DEVICEDEFINITION: return "DeviceDefinition"; 10342 case DEVICEDISPENSE: return "DeviceDispense"; 10343 case DEVICEMETRIC: return "DeviceMetric"; 10344 case DEVICEREQUEST: return "DeviceRequest"; 10345 case DEVICEUSAGE: return "DeviceUsage"; 10346 case DIAGNOSTICREPORT: return "DiagnosticReport"; 10347 case DOCUMENTREFERENCE: return "DocumentReference"; 10348 case ENCOUNTER: return "Encounter"; 10349 case ENCOUNTERHISTORY: return "EncounterHistory"; 10350 case ENDPOINT: return "Endpoint"; 10351 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 10352 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 10353 case EPISODEOFCARE: return "EpisodeOfCare"; 10354 case EVENTDEFINITION: return "EventDefinition"; 10355 case EVIDENCE: return "Evidence"; 10356 case EVIDENCEREPORT: return "EvidenceReport"; 10357 case EVIDENCEVARIABLE: return "EvidenceVariable"; 10358 case EXAMPLESCENARIO: return "ExampleScenario"; 10359 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 10360 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 10361 case FLAG: return "Flag"; 10362 case FORMULARYITEM: return "FormularyItem"; 10363 case GENOMICSTUDY: return "GenomicStudy"; 10364 case GOAL: return "Goal"; 10365 case GRAPHDEFINITION: return "GraphDefinition"; 10366 case GROUP: return "Group"; 10367 case GUIDANCERESPONSE: return "GuidanceResponse"; 10368 case HEALTHCARESERVICE: return "HealthcareService"; 10369 case IMAGINGSELECTION: return "ImagingSelection"; 10370 case IMAGINGSTUDY: return "ImagingStudy"; 10371 case IMMUNIZATION: return "Immunization"; 10372 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 10373 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 10374 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 10375 case INGREDIENT: return "Ingredient"; 10376 case INSURANCEPLAN: return "InsurancePlan"; 10377 case INVENTORYITEM: return "InventoryItem"; 10378 case INVENTORYREPORT: return "InventoryReport"; 10379 case INVOICE: return "Invoice"; 10380 case LIBRARY: return "Library"; 10381 case LINKAGE: return "Linkage"; 10382 case LIST: return "List"; 10383 case LOCATION: return "Location"; 10384 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 10385 case MEASURE: return "Measure"; 10386 case MEASUREREPORT: return "MeasureReport"; 10387 case MEDICATION: return "Medication"; 10388 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 10389 case MEDICATIONDISPENSE: return "MedicationDispense"; 10390 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 10391 case MEDICATIONREQUEST: return "MedicationRequest"; 10392 case MEDICATIONSTATEMENT: return "MedicationStatement"; 10393 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 10394 case MESSAGEDEFINITION: return "MessageDefinition"; 10395 case MESSAGEHEADER: return "MessageHeader"; 10396 case METADATARESOURCE: return "MetadataResource"; 10397 case MOLECULARSEQUENCE: return "MolecularSequence"; 10398 case NAMINGSYSTEM: return "NamingSystem"; 10399 case NUTRITIONINTAKE: return "NutritionIntake"; 10400 case NUTRITIONORDER: return "NutritionOrder"; 10401 case NUTRITIONPRODUCT: return "NutritionProduct"; 10402 case OBSERVATION: return "Observation"; 10403 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 10404 case OPERATIONDEFINITION: return "OperationDefinition"; 10405 case OPERATIONOUTCOME: return "OperationOutcome"; 10406 case ORGANIZATION: return "Organization"; 10407 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 10408 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 10409 case PATIENT: return "Patient"; 10410 case PAYMENTNOTICE: return "PaymentNotice"; 10411 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 10412 case PERMISSION: return "Permission"; 10413 case PERSON: return "Person"; 10414 case PLANDEFINITION: return "PlanDefinition"; 10415 case PRACTITIONER: return "Practitioner"; 10416 case PRACTITIONERROLE: return "PractitionerRole"; 10417 case PROCEDURE: return "Procedure"; 10418 case PROVENANCE: return "Provenance"; 10419 case QUESTIONNAIRE: return "Questionnaire"; 10420 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 10421 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 10422 case RELATEDPERSON: return "RelatedPerson"; 10423 case REQUESTORCHESTRATION: return "RequestOrchestration"; 10424 case REQUIREMENTS: return "Requirements"; 10425 case RESEARCHSTUDY: return "ResearchStudy"; 10426 case RESEARCHSUBJECT: return "ResearchSubject"; 10427 case RISKASSESSMENT: return "RiskAssessment"; 10428 case SCHEDULE: return "Schedule"; 10429 case SEARCHPARAMETER: return "SearchParameter"; 10430 case SERVICEREQUEST: return "ServiceRequest"; 10431 case SLOT: return "Slot"; 10432 case SPECIMEN: return "Specimen"; 10433 case SPECIMENDEFINITION: return "SpecimenDefinition"; 10434 case STRUCTUREDEFINITION: return "StructureDefinition"; 10435 case STRUCTUREMAP: return "StructureMap"; 10436 case SUBSCRIPTION: return "Subscription"; 10437 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 10438 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 10439 case SUBSTANCE: return "Substance"; 10440 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 10441 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 10442 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 10443 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 10444 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 10445 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 10446 case SUPPLYDELIVERY: return "SupplyDelivery"; 10447 case SUPPLYREQUEST: return "SupplyRequest"; 10448 case TASK: return "Task"; 10449 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 10450 case TESTPLAN: return "TestPlan"; 10451 case TESTREPORT: return "TestReport"; 10452 case TESTSCRIPT: return "TestScript"; 10453 case TRANSPORT: return "Transport"; 10454 case VALUESET: return "ValueSet"; 10455 case VERIFICATIONRESULT: return "VerificationResult"; 10456 case VISIONPRESCRIPTION: return "VisionPrescription"; 10457 case PARAMETERS: return "Parameters"; 10458 case NULL: return null; 10459 default: return "?"; 10460 } 10461 } 10462 } 10463 10464 public static class FHIRTypesEnumFactory implements EnumFactory<FHIRTypes> { 10465 public FHIRTypes fromCode(String codeString) throws IllegalArgumentException { 10466 if (codeString == null || "".equals(codeString)) 10467 if (codeString == null || "".equals(codeString)) 10468 return null; 10469 if ("Base".equals(codeString)) 10470 return FHIRTypes.BASE; 10471 if ("Element".equals(codeString)) 10472 return FHIRTypes.ELEMENT; 10473 if ("BackboneElement".equals(codeString)) 10474 return FHIRTypes.BACKBONEELEMENT; 10475 if ("DataType".equals(codeString)) 10476 return FHIRTypes.DATATYPE; 10477 if ("Address".equals(codeString)) 10478 return FHIRTypes.ADDRESS; 10479 if ("Annotation".equals(codeString)) 10480 return FHIRTypes.ANNOTATION; 10481 if ("Attachment".equals(codeString)) 10482 return FHIRTypes.ATTACHMENT; 10483 if ("Availability".equals(codeString)) 10484 return FHIRTypes.AVAILABILITY; 10485 if ("BackboneType".equals(codeString)) 10486 return FHIRTypes.BACKBONETYPE; 10487 if ("Dosage".equals(codeString)) 10488 return FHIRTypes.DOSAGE; 10489 if ("ElementDefinition".equals(codeString)) 10490 return FHIRTypes.ELEMENTDEFINITION; 10491 if ("MarketingStatus".equals(codeString)) 10492 return FHIRTypes.MARKETINGSTATUS; 10493 if ("ProductShelfLife".equals(codeString)) 10494 return FHIRTypes.PRODUCTSHELFLIFE; 10495 if ("Timing".equals(codeString)) 10496 return FHIRTypes.TIMING; 10497 if ("CodeableConcept".equals(codeString)) 10498 return FHIRTypes.CODEABLECONCEPT; 10499 if ("CodeableReference".equals(codeString)) 10500 return FHIRTypes.CODEABLEREFERENCE; 10501 if ("Coding".equals(codeString)) 10502 return FHIRTypes.CODING; 10503 if ("ContactDetail".equals(codeString)) 10504 return FHIRTypes.CONTACTDETAIL; 10505 if ("ContactPoint".equals(codeString)) 10506 return FHIRTypes.CONTACTPOINT; 10507 if ("Contributor".equals(codeString)) 10508 return FHIRTypes.CONTRIBUTOR; 10509 if ("DataRequirement".equals(codeString)) 10510 return FHIRTypes.DATAREQUIREMENT; 10511 if ("Expression".equals(codeString)) 10512 return FHIRTypes.EXPRESSION; 10513 if ("ExtendedContactDetail".equals(codeString)) 10514 return FHIRTypes.EXTENDEDCONTACTDETAIL; 10515 if ("Extension".equals(codeString)) 10516 return FHIRTypes.EXTENSION; 10517 if ("HumanName".equals(codeString)) 10518 return FHIRTypes.HUMANNAME; 10519 if ("Identifier".equals(codeString)) 10520 return FHIRTypes.IDENTIFIER; 10521 if ("Meta".equals(codeString)) 10522 return FHIRTypes.META; 10523 if ("MonetaryComponent".equals(codeString)) 10524 return FHIRTypes.MONETARYCOMPONENT; 10525 if ("Money".equals(codeString)) 10526 return FHIRTypes.MONEY; 10527 if ("Narrative".equals(codeString)) 10528 return FHIRTypes.NARRATIVE; 10529 if ("ParameterDefinition".equals(codeString)) 10530 return FHIRTypes.PARAMETERDEFINITION; 10531 if ("Period".equals(codeString)) 10532 return FHIRTypes.PERIOD; 10533 if ("PrimitiveType".equals(codeString)) 10534 return FHIRTypes.PRIMITIVETYPE; 10535 if ("base64Binary".equals(codeString)) 10536 return FHIRTypes.BASE64BINARY; 10537 if ("boolean".equals(codeString)) 10538 return FHIRTypes.BOOLEAN; 10539 if ("date".equals(codeString)) 10540 return FHIRTypes.DATE; 10541 if ("dateTime".equals(codeString)) 10542 return FHIRTypes.DATETIME; 10543 if ("decimal".equals(codeString)) 10544 return FHIRTypes.DECIMAL; 10545 if ("instant".equals(codeString)) 10546 return FHIRTypes.INSTANT; 10547 if ("integer".equals(codeString)) 10548 return FHIRTypes.INTEGER; 10549 if ("positiveInt".equals(codeString)) 10550 return FHIRTypes.POSITIVEINT; 10551 if ("unsignedInt".equals(codeString)) 10552 return FHIRTypes.UNSIGNEDINT; 10553 if ("integer64".equals(codeString)) 10554 return FHIRTypes.INTEGER64; 10555 if ("string".equals(codeString)) 10556 return FHIRTypes.STRING; 10557 if ("code".equals(codeString)) 10558 return FHIRTypes.CODE; 10559 if ("id".equals(codeString)) 10560 return FHIRTypes.ID; 10561 if ("markdown".equals(codeString)) 10562 return FHIRTypes.MARKDOWN; 10563 if ("time".equals(codeString)) 10564 return FHIRTypes.TIME; 10565 if ("uri".equals(codeString)) 10566 return FHIRTypes.URI; 10567 if ("canonical".equals(codeString)) 10568 return FHIRTypes.CANONICAL; 10569 if ("oid".equals(codeString)) 10570 return FHIRTypes.OID; 10571 if ("url".equals(codeString)) 10572 return FHIRTypes.URL; 10573 if ("uuid".equals(codeString)) 10574 return FHIRTypes.UUID; 10575 if ("Quantity".equals(codeString)) 10576 return FHIRTypes.QUANTITY; 10577 if ("Age".equals(codeString)) 10578 return FHIRTypes.AGE; 10579 if ("Count".equals(codeString)) 10580 return FHIRTypes.COUNT; 10581 if ("Distance".equals(codeString)) 10582 return FHIRTypes.DISTANCE; 10583 if ("Duration".equals(codeString)) 10584 return FHIRTypes.DURATION; 10585 if ("Range".equals(codeString)) 10586 return FHIRTypes.RANGE; 10587 if ("Ratio".equals(codeString)) 10588 return FHIRTypes.RATIO; 10589 if ("RatioRange".equals(codeString)) 10590 return FHIRTypes.RATIORANGE; 10591 if ("Reference".equals(codeString)) 10592 return FHIRTypes.REFERENCE; 10593 if ("RelatedArtifact".equals(codeString)) 10594 return FHIRTypes.RELATEDARTIFACT; 10595 if ("SampledData".equals(codeString)) 10596 return FHIRTypes.SAMPLEDDATA; 10597 if ("Signature".equals(codeString)) 10598 return FHIRTypes.SIGNATURE; 10599 if ("TriggerDefinition".equals(codeString)) 10600 return FHIRTypes.TRIGGERDEFINITION; 10601 if ("UsageContext".equals(codeString)) 10602 return FHIRTypes.USAGECONTEXT; 10603 if ("VirtualServiceDetail".equals(codeString)) 10604 return FHIRTypes.VIRTUALSERVICEDETAIL; 10605 if ("xhtml".equals(codeString)) 10606 return FHIRTypes.XHTML; 10607 if ("Resource".equals(codeString)) 10608 return FHIRTypes.RESOURCE; 10609 if ("Binary".equals(codeString)) 10610 return FHIRTypes.BINARY; 10611 if ("Bundle".equals(codeString)) 10612 return FHIRTypes.BUNDLE; 10613 if ("DomainResource".equals(codeString)) 10614 return FHIRTypes.DOMAINRESOURCE; 10615 if ("Account".equals(codeString)) 10616 return FHIRTypes.ACCOUNT; 10617 if ("ActivityDefinition".equals(codeString)) 10618 return FHIRTypes.ACTIVITYDEFINITION; 10619 if ("ActorDefinition".equals(codeString)) 10620 return FHIRTypes.ACTORDEFINITION; 10621 if ("AdministrableProductDefinition".equals(codeString)) 10622 return FHIRTypes.ADMINISTRABLEPRODUCTDEFINITION; 10623 if ("AdverseEvent".equals(codeString)) 10624 return FHIRTypes.ADVERSEEVENT; 10625 if ("AllergyIntolerance".equals(codeString)) 10626 return FHIRTypes.ALLERGYINTOLERANCE; 10627 if ("Appointment".equals(codeString)) 10628 return FHIRTypes.APPOINTMENT; 10629 if ("AppointmentResponse".equals(codeString)) 10630 return FHIRTypes.APPOINTMENTRESPONSE; 10631 if ("ArtifactAssessment".equals(codeString)) 10632 return FHIRTypes.ARTIFACTASSESSMENT; 10633 if ("AuditEvent".equals(codeString)) 10634 return FHIRTypes.AUDITEVENT; 10635 if ("Basic".equals(codeString)) 10636 return FHIRTypes.BASIC; 10637 if ("BiologicallyDerivedProduct".equals(codeString)) 10638 return FHIRTypes.BIOLOGICALLYDERIVEDPRODUCT; 10639 if ("BiologicallyDerivedProductDispense".equals(codeString)) 10640 return FHIRTypes.BIOLOGICALLYDERIVEDPRODUCTDISPENSE; 10641 if ("BodyStructure".equals(codeString)) 10642 return FHIRTypes.BODYSTRUCTURE; 10643 if ("CanonicalResource".equals(codeString)) 10644 return FHIRTypes.CANONICALRESOURCE; 10645 if ("CapabilityStatement".equals(codeString)) 10646 return FHIRTypes.CAPABILITYSTATEMENT; 10647 if ("CarePlan".equals(codeString)) 10648 return FHIRTypes.CAREPLAN; 10649 if ("CareTeam".equals(codeString)) 10650 return FHIRTypes.CARETEAM; 10651 if ("ChargeItem".equals(codeString)) 10652 return FHIRTypes.CHARGEITEM; 10653 if ("ChargeItemDefinition".equals(codeString)) 10654 return FHIRTypes.CHARGEITEMDEFINITION; 10655 if ("Citation".equals(codeString)) 10656 return FHIRTypes.CITATION; 10657 if ("Claim".equals(codeString)) 10658 return FHIRTypes.CLAIM; 10659 if ("ClaimResponse".equals(codeString)) 10660 return FHIRTypes.CLAIMRESPONSE; 10661 if ("ClinicalImpression".equals(codeString)) 10662 return FHIRTypes.CLINICALIMPRESSION; 10663 if ("ClinicalUseDefinition".equals(codeString)) 10664 return FHIRTypes.CLINICALUSEDEFINITION; 10665 if ("CodeSystem".equals(codeString)) 10666 return FHIRTypes.CODESYSTEM; 10667 if ("Communication".equals(codeString)) 10668 return FHIRTypes.COMMUNICATION; 10669 if ("CommunicationRequest".equals(codeString)) 10670 return FHIRTypes.COMMUNICATIONREQUEST; 10671 if ("CompartmentDefinition".equals(codeString)) 10672 return FHIRTypes.COMPARTMENTDEFINITION; 10673 if ("Composition".equals(codeString)) 10674 return FHIRTypes.COMPOSITION; 10675 if ("ConceptMap".equals(codeString)) 10676 return FHIRTypes.CONCEPTMAP; 10677 if ("Condition".equals(codeString)) 10678 return FHIRTypes.CONDITION; 10679 if ("ConditionDefinition".equals(codeString)) 10680 return FHIRTypes.CONDITIONDEFINITION; 10681 if ("Consent".equals(codeString)) 10682 return FHIRTypes.CONSENT; 10683 if ("Contract".equals(codeString)) 10684 return FHIRTypes.CONTRACT; 10685 if ("Coverage".equals(codeString)) 10686 return FHIRTypes.COVERAGE; 10687 if ("CoverageEligibilityRequest".equals(codeString)) 10688 return FHIRTypes.COVERAGEELIGIBILITYREQUEST; 10689 if ("CoverageEligibilityResponse".equals(codeString)) 10690 return FHIRTypes.COVERAGEELIGIBILITYRESPONSE; 10691 if ("DetectedIssue".equals(codeString)) 10692 return FHIRTypes.DETECTEDISSUE; 10693 if ("Device".equals(codeString)) 10694 return FHIRTypes.DEVICE; 10695 if ("DeviceAssociation".equals(codeString)) 10696 return FHIRTypes.DEVICEASSOCIATION; 10697 if ("DeviceDefinition".equals(codeString)) 10698 return FHIRTypes.DEVICEDEFINITION; 10699 if ("DeviceDispense".equals(codeString)) 10700 return FHIRTypes.DEVICEDISPENSE; 10701 if ("DeviceMetric".equals(codeString)) 10702 return FHIRTypes.DEVICEMETRIC; 10703 if ("DeviceRequest".equals(codeString)) 10704 return FHIRTypes.DEVICEREQUEST; 10705 if ("DeviceUsage".equals(codeString)) 10706 return FHIRTypes.DEVICEUSAGE; 10707 if ("DiagnosticReport".equals(codeString)) 10708 return FHIRTypes.DIAGNOSTICREPORT; 10709 if ("DocumentReference".equals(codeString)) 10710 return FHIRTypes.DOCUMENTREFERENCE; 10711 if ("Encounter".equals(codeString)) 10712 return FHIRTypes.ENCOUNTER; 10713 if ("EncounterHistory".equals(codeString)) 10714 return FHIRTypes.ENCOUNTERHISTORY; 10715 if ("Endpoint".equals(codeString)) 10716 return FHIRTypes.ENDPOINT; 10717 if ("EnrollmentRequest".equals(codeString)) 10718 return FHIRTypes.ENROLLMENTREQUEST; 10719 if ("EnrollmentResponse".equals(codeString)) 10720 return FHIRTypes.ENROLLMENTRESPONSE; 10721 if ("EpisodeOfCare".equals(codeString)) 10722 return FHIRTypes.EPISODEOFCARE; 10723 if ("EventDefinition".equals(codeString)) 10724 return FHIRTypes.EVENTDEFINITION; 10725 if ("Evidence".equals(codeString)) 10726 return FHIRTypes.EVIDENCE; 10727 if ("EvidenceReport".equals(codeString)) 10728 return FHIRTypes.EVIDENCEREPORT; 10729 if ("EvidenceVariable".equals(codeString)) 10730 return FHIRTypes.EVIDENCEVARIABLE; 10731 if ("ExampleScenario".equals(codeString)) 10732 return FHIRTypes.EXAMPLESCENARIO; 10733 if ("ExplanationOfBenefit".equals(codeString)) 10734 return FHIRTypes.EXPLANATIONOFBENEFIT; 10735 if ("FamilyMemberHistory".equals(codeString)) 10736 return FHIRTypes.FAMILYMEMBERHISTORY; 10737 if ("Flag".equals(codeString)) 10738 return FHIRTypes.FLAG; 10739 if ("FormularyItem".equals(codeString)) 10740 return FHIRTypes.FORMULARYITEM; 10741 if ("GenomicStudy".equals(codeString)) 10742 return FHIRTypes.GENOMICSTUDY; 10743 if ("Goal".equals(codeString)) 10744 return FHIRTypes.GOAL; 10745 if ("GraphDefinition".equals(codeString)) 10746 return FHIRTypes.GRAPHDEFINITION; 10747 if ("Group".equals(codeString)) 10748 return FHIRTypes.GROUP; 10749 if ("GuidanceResponse".equals(codeString)) 10750 return FHIRTypes.GUIDANCERESPONSE; 10751 if ("HealthcareService".equals(codeString)) 10752 return FHIRTypes.HEALTHCARESERVICE; 10753 if ("ImagingSelection".equals(codeString)) 10754 return FHIRTypes.IMAGINGSELECTION; 10755 if ("ImagingStudy".equals(codeString)) 10756 return FHIRTypes.IMAGINGSTUDY; 10757 if ("Immunization".equals(codeString)) 10758 return FHIRTypes.IMMUNIZATION; 10759 if ("ImmunizationEvaluation".equals(codeString)) 10760 return FHIRTypes.IMMUNIZATIONEVALUATION; 10761 if ("ImmunizationRecommendation".equals(codeString)) 10762 return FHIRTypes.IMMUNIZATIONRECOMMENDATION; 10763 if ("ImplementationGuide".equals(codeString)) 10764 return FHIRTypes.IMPLEMENTATIONGUIDE; 10765 if ("Ingredient".equals(codeString)) 10766 return FHIRTypes.INGREDIENT; 10767 if ("InsurancePlan".equals(codeString)) 10768 return FHIRTypes.INSURANCEPLAN; 10769 if ("InventoryItem".equals(codeString)) 10770 return FHIRTypes.INVENTORYITEM; 10771 if ("InventoryReport".equals(codeString)) 10772 return FHIRTypes.INVENTORYREPORT; 10773 if ("Invoice".equals(codeString)) 10774 return FHIRTypes.INVOICE; 10775 if ("Library".equals(codeString)) 10776 return FHIRTypes.LIBRARY; 10777 if ("Linkage".equals(codeString)) 10778 return FHIRTypes.LINKAGE; 10779 if ("List".equals(codeString)) 10780 return FHIRTypes.LIST; 10781 if ("Location".equals(codeString)) 10782 return FHIRTypes.LOCATION; 10783 if ("ManufacturedItemDefinition".equals(codeString)) 10784 return FHIRTypes.MANUFACTUREDITEMDEFINITION; 10785 if ("Measure".equals(codeString)) 10786 return FHIRTypes.MEASURE; 10787 if ("MeasureReport".equals(codeString)) 10788 return FHIRTypes.MEASUREREPORT; 10789 if ("Medication".equals(codeString)) 10790 return FHIRTypes.MEDICATION; 10791 if ("MedicationAdministration".equals(codeString)) 10792 return FHIRTypes.MEDICATIONADMINISTRATION; 10793 if ("MedicationDispense".equals(codeString)) 10794 return FHIRTypes.MEDICATIONDISPENSE; 10795 if ("MedicationKnowledge".equals(codeString)) 10796 return FHIRTypes.MEDICATIONKNOWLEDGE; 10797 if ("MedicationRequest".equals(codeString)) 10798 return FHIRTypes.MEDICATIONREQUEST; 10799 if ("MedicationStatement".equals(codeString)) 10800 return FHIRTypes.MEDICATIONSTATEMENT; 10801 if ("MedicinalProductDefinition".equals(codeString)) 10802 return FHIRTypes.MEDICINALPRODUCTDEFINITION; 10803 if ("MessageDefinition".equals(codeString)) 10804 return FHIRTypes.MESSAGEDEFINITION; 10805 if ("MessageHeader".equals(codeString)) 10806 return FHIRTypes.MESSAGEHEADER; 10807 if ("MetadataResource".equals(codeString)) 10808 return FHIRTypes.METADATARESOURCE; 10809 if ("MolecularSequence".equals(codeString)) 10810 return FHIRTypes.MOLECULARSEQUENCE; 10811 if ("NamingSystem".equals(codeString)) 10812 return FHIRTypes.NAMINGSYSTEM; 10813 if ("NutritionIntake".equals(codeString)) 10814 return FHIRTypes.NUTRITIONINTAKE; 10815 if ("NutritionOrder".equals(codeString)) 10816 return FHIRTypes.NUTRITIONORDER; 10817 if ("NutritionProduct".equals(codeString)) 10818 return FHIRTypes.NUTRITIONPRODUCT; 10819 if ("Observation".equals(codeString)) 10820 return FHIRTypes.OBSERVATION; 10821 if ("ObservationDefinition".equals(codeString)) 10822 return FHIRTypes.OBSERVATIONDEFINITION; 10823 if ("OperationDefinition".equals(codeString)) 10824 return FHIRTypes.OPERATIONDEFINITION; 10825 if ("OperationOutcome".equals(codeString)) 10826 return FHIRTypes.OPERATIONOUTCOME; 10827 if ("Organization".equals(codeString)) 10828 return FHIRTypes.ORGANIZATION; 10829 if ("OrganizationAffiliation".equals(codeString)) 10830 return FHIRTypes.ORGANIZATIONAFFILIATION; 10831 if ("PackagedProductDefinition".equals(codeString)) 10832 return FHIRTypes.PACKAGEDPRODUCTDEFINITION; 10833 if ("Patient".equals(codeString)) 10834 return FHIRTypes.PATIENT; 10835 if ("PaymentNotice".equals(codeString)) 10836 return FHIRTypes.PAYMENTNOTICE; 10837 if ("PaymentReconciliation".equals(codeString)) 10838 return FHIRTypes.PAYMENTRECONCILIATION; 10839 if ("Permission".equals(codeString)) 10840 return FHIRTypes.PERMISSION; 10841 if ("Person".equals(codeString)) 10842 return FHIRTypes.PERSON; 10843 if ("PlanDefinition".equals(codeString)) 10844 return FHIRTypes.PLANDEFINITION; 10845 if ("Practitioner".equals(codeString)) 10846 return FHIRTypes.PRACTITIONER; 10847 if ("PractitionerRole".equals(codeString)) 10848 return FHIRTypes.PRACTITIONERROLE; 10849 if ("Procedure".equals(codeString)) 10850 return FHIRTypes.PROCEDURE; 10851 if ("Provenance".equals(codeString)) 10852 return FHIRTypes.PROVENANCE; 10853 if ("Questionnaire".equals(codeString)) 10854 return FHIRTypes.QUESTIONNAIRE; 10855 if ("QuestionnaireResponse".equals(codeString)) 10856 return FHIRTypes.QUESTIONNAIRERESPONSE; 10857 if ("RegulatedAuthorization".equals(codeString)) 10858 return FHIRTypes.REGULATEDAUTHORIZATION; 10859 if ("RelatedPerson".equals(codeString)) 10860 return FHIRTypes.RELATEDPERSON; 10861 if ("RequestOrchestration".equals(codeString)) 10862 return FHIRTypes.REQUESTORCHESTRATION; 10863 if ("Requirements".equals(codeString)) 10864 return FHIRTypes.REQUIREMENTS; 10865 if ("ResearchStudy".equals(codeString)) 10866 return FHIRTypes.RESEARCHSTUDY; 10867 if ("ResearchSubject".equals(codeString)) 10868 return FHIRTypes.RESEARCHSUBJECT; 10869 if ("RiskAssessment".equals(codeString)) 10870 return FHIRTypes.RISKASSESSMENT; 10871 if ("Schedule".equals(codeString)) 10872 return FHIRTypes.SCHEDULE; 10873 if ("SearchParameter".equals(codeString)) 10874 return FHIRTypes.SEARCHPARAMETER; 10875 if ("ServiceRequest".equals(codeString)) 10876 return FHIRTypes.SERVICEREQUEST; 10877 if ("Slot".equals(codeString)) 10878 return FHIRTypes.SLOT; 10879 if ("Specimen".equals(codeString)) 10880 return FHIRTypes.SPECIMEN; 10881 if ("SpecimenDefinition".equals(codeString)) 10882 return FHIRTypes.SPECIMENDEFINITION; 10883 if ("StructureDefinition".equals(codeString)) 10884 return FHIRTypes.STRUCTUREDEFINITION; 10885 if ("StructureMap".equals(codeString)) 10886 return FHIRTypes.STRUCTUREMAP; 10887 if ("Subscription".equals(codeString)) 10888 return FHIRTypes.SUBSCRIPTION; 10889 if ("SubscriptionStatus".equals(codeString)) 10890 return FHIRTypes.SUBSCRIPTIONSTATUS; 10891 if ("SubscriptionTopic".equals(codeString)) 10892 return FHIRTypes.SUBSCRIPTIONTOPIC; 10893 if ("Substance".equals(codeString)) 10894 return FHIRTypes.SUBSTANCE; 10895 if ("SubstanceDefinition".equals(codeString)) 10896 return FHIRTypes.SUBSTANCEDEFINITION; 10897 if ("SubstanceNucleicAcid".equals(codeString)) 10898 return FHIRTypes.SUBSTANCENUCLEICACID; 10899 if ("SubstancePolymer".equals(codeString)) 10900 return FHIRTypes.SUBSTANCEPOLYMER; 10901 if ("SubstanceProtein".equals(codeString)) 10902 return FHIRTypes.SUBSTANCEPROTEIN; 10903 if ("SubstanceReferenceInformation".equals(codeString)) 10904 return FHIRTypes.SUBSTANCEREFERENCEINFORMATION; 10905 if ("SubstanceSourceMaterial".equals(codeString)) 10906 return FHIRTypes.SUBSTANCESOURCEMATERIAL; 10907 if ("SupplyDelivery".equals(codeString)) 10908 return FHIRTypes.SUPPLYDELIVERY; 10909 if ("SupplyRequest".equals(codeString)) 10910 return FHIRTypes.SUPPLYREQUEST; 10911 if ("Task".equals(codeString)) 10912 return FHIRTypes.TASK; 10913 if ("TerminologyCapabilities".equals(codeString)) 10914 return FHIRTypes.TERMINOLOGYCAPABILITIES; 10915 if ("TestPlan".equals(codeString)) 10916 return FHIRTypes.TESTPLAN; 10917 if ("TestReport".equals(codeString)) 10918 return FHIRTypes.TESTREPORT; 10919 if ("TestScript".equals(codeString)) 10920 return FHIRTypes.TESTSCRIPT; 10921 if ("Transport".equals(codeString)) 10922 return FHIRTypes.TRANSPORT; 10923 if ("ValueSet".equals(codeString)) 10924 return FHIRTypes.VALUESET; 10925 if ("VerificationResult".equals(codeString)) 10926 return FHIRTypes.VERIFICATIONRESULT; 10927 if ("VisionPrescription".equals(codeString)) 10928 return FHIRTypes.VISIONPRESCRIPTION; 10929 if ("Parameters".equals(codeString)) 10930 return FHIRTypes.PARAMETERS; 10931 throw new IllegalArgumentException("Unknown FHIRTypes code '"+codeString+"'"); 10932 } 10933 10934 public Enumeration<FHIRTypes> fromType(PrimitiveType<?> code) throws FHIRException { 10935 if (code == null) 10936 return null; 10937 if (code.isEmpty()) 10938 return new Enumeration<FHIRTypes>(this, FHIRTypes.NULL, code); 10939 String codeString = ((PrimitiveType) code).asStringValue(); 10940 if (codeString == null || "".equals(codeString)) 10941 return new Enumeration<FHIRTypes>(this, FHIRTypes.NULL, code); 10942 if ("Base".equals(codeString)) 10943 return new Enumeration<FHIRTypes>(this, FHIRTypes.BASE, code); 10944 if ("Element".equals(codeString)) 10945 return new Enumeration<FHIRTypes>(this, FHIRTypes.ELEMENT, code); 10946 if ("BackboneElement".equals(codeString)) 10947 return new Enumeration<FHIRTypes>(this, FHIRTypes.BACKBONEELEMENT, code); 10948 if ("DataType".equals(codeString)) 10949 return new Enumeration<FHIRTypes>(this, FHIRTypes.DATATYPE, code); 10950 if ("Address".equals(codeString)) 10951 return new Enumeration<FHIRTypes>(this, FHIRTypes.ADDRESS, code); 10952 if ("Annotation".equals(codeString)) 10953 return new Enumeration<FHIRTypes>(this, FHIRTypes.ANNOTATION, code); 10954 if ("Attachment".equals(codeString)) 10955 return new Enumeration<FHIRTypes>(this, FHIRTypes.ATTACHMENT, code); 10956 if ("Availability".equals(codeString)) 10957 return new Enumeration<FHIRTypes>(this, FHIRTypes.AVAILABILITY, code); 10958 if ("BackboneType".equals(codeString)) 10959 return new Enumeration<FHIRTypes>(this, FHIRTypes.BACKBONETYPE, code); 10960 if ("Dosage".equals(codeString)) 10961 return new Enumeration<FHIRTypes>(this, FHIRTypes.DOSAGE, code); 10962 if ("ElementDefinition".equals(codeString)) 10963 return new Enumeration<FHIRTypes>(this, FHIRTypes.ELEMENTDEFINITION, code); 10964 if ("MarketingStatus".equals(codeString)) 10965 return new Enumeration<FHIRTypes>(this, FHIRTypes.MARKETINGSTATUS, code); 10966 if ("ProductShelfLife".equals(codeString)) 10967 return new Enumeration<FHIRTypes>(this, FHIRTypes.PRODUCTSHELFLIFE, code); 10968 if ("Timing".equals(codeString)) 10969 return new Enumeration<FHIRTypes>(this, FHIRTypes.TIMING, code); 10970 if ("CodeableConcept".equals(codeString)) 10971 return new Enumeration<FHIRTypes>(this, FHIRTypes.CODEABLECONCEPT, code); 10972 if ("CodeableReference".equals(codeString)) 10973 return new Enumeration<FHIRTypes>(this, FHIRTypes.CODEABLEREFERENCE, code); 10974 if ("Coding".equals(codeString)) 10975 return new Enumeration<FHIRTypes>(this, FHIRTypes.CODING, code); 10976 if ("ContactDetail".equals(codeString)) 10977 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONTACTDETAIL, code); 10978 if ("ContactPoint".equals(codeString)) 10979 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONTACTPOINT, code); 10980 if ("Contributor".equals(codeString)) 10981 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONTRIBUTOR, code); 10982 if ("DataRequirement".equals(codeString)) 10983 return new Enumeration<FHIRTypes>(this, FHIRTypes.DATAREQUIREMENT, code); 10984 if ("Expression".equals(codeString)) 10985 return new Enumeration<FHIRTypes>(this, FHIRTypes.EXPRESSION, code); 10986 if ("ExtendedContactDetail".equals(codeString)) 10987 return new Enumeration<FHIRTypes>(this, FHIRTypes.EXTENDEDCONTACTDETAIL, code); 10988 if ("Extension".equals(codeString)) 10989 return new Enumeration<FHIRTypes>(this, FHIRTypes.EXTENSION, code); 10990 if ("HumanName".equals(codeString)) 10991 return new Enumeration<FHIRTypes>(this, FHIRTypes.HUMANNAME, code); 10992 if ("Identifier".equals(codeString)) 10993 return new Enumeration<FHIRTypes>(this, FHIRTypes.IDENTIFIER, code); 10994 if ("Meta".equals(codeString)) 10995 return new Enumeration<FHIRTypes>(this, FHIRTypes.META, code); 10996 if ("MonetaryComponent".equals(codeString)) 10997 return new Enumeration<FHIRTypes>(this, FHIRTypes.MONETARYCOMPONENT, code); 10998 if ("Money".equals(codeString)) 10999 return new Enumeration<FHIRTypes>(this, FHIRTypes.MONEY, code); 11000 if ("Narrative".equals(codeString)) 11001 return new Enumeration<FHIRTypes>(this, FHIRTypes.NARRATIVE, code); 11002 if ("ParameterDefinition".equals(codeString)) 11003 return new Enumeration<FHIRTypes>(this, FHIRTypes.PARAMETERDEFINITION, code); 11004 if ("Period".equals(codeString)) 11005 return new Enumeration<FHIRTypes>(this, FHIRTypes.PERIOD, code); 11006 if ("PrimitiveType".equals(codeString)) 11007 return new Enumeration<FHIRTypes>(this, FHIRTypes.PRIMITIVETYPE, code); 11008 if ("base64Binary".equals(codeString)) 11009 return new Enumeration<FHIRTypes>(this, FHIRTypes.BASE64BINARY, code); 11010 if ("boolean".equals(codeString)) 11011 return new Enumeration<FHIRTypes>(this, FHIRTypes.BOOLEAN, code); 11012 if ("date".equals(codeString)) 11013 return new Enumeration<FHIRTypes>(this, FHIRTypes.DATE, code); 11014 if ("dateTime".equals(codeString)) 11015 return new Enumeration<FHIRTypes>(this, FHIRTypes.DATETIME, code); 11016 if ("decimal".equals(codeString)) 11017 return new Enumeration<FHIRTypes>(this, FHIRTypes.DECIMAL, code); 11018 if ("instant".equals(codeString)) 11019 return new Enumeration<FHIRTypes>(this, FHIRTypes.INSTANT, code); 11020 if ("integer".equals(codeString)) 11021 return new Enumeration<FHIRTypes>(this, FHIRTypes.INTEGER, code); 11022 if ("positiveInt".equals(codeString)) 11023 return new Enumeration<FHIRTypes>(this, FHIRTypes.POSITIVEINT, code); 11024 if ("unsignedInt".equals(codeString)) 11025 return new Enumeration<FHIRTypes>(this, FHIRTypes.UNSIGNEDINT, code); 11026 if ("integer64".equals(codeString)) 11027 return new Enumeration<FHIRTypes>(this, FHIRTypes.INTEGER64, code); 11028 if ("string".equals(codeString)) 11029 return new Enumeration<FHIRTypes>(this, FHIRTypes.STRING, code); 11030 if ("code".equals(codeString)) 11031 return new Enumeration<FHIRTypes>(this, FHIRTypes.CODE, code); 11032 if ("id".equals(codeString)) 11033 return new Enumeration<FHIRTypes>(this, FHIRTypes.ID, code); 11034 if ("markdown".equals(codeString)) 11035 return new Enumeration<FHIRTypes>(this, FHIRTypes.MARKDOWN, code); 11036 if ("time".equals(codeString)) 11037 return new Enumeration<FHIRTypes>(this, FHIRTypes.TIME, code); 11038 if ("uri".equals(codeString)) 11039 return new Enumeration<FHIRTypes>(this, FHIRTypes.URI, code); 11040 if ("canonical".equals(codeString)) 11041 return new Enumeration<FHIRTypes>(this, FHIRTypes.CANONICAL, code); 11042 if ("oid".equals(codeString)) 11043 return new Enumeration<FHIRTypes>(this, FHIRTypes.OID, code); 11044 if ("url".equals(codeString)) 11045 return new Enumeration<FHIRTypes>(this, FHIRTypes.URL, code); 11046 if ("uuid".equals(codeString)) 11047 return new Enumeration<FHIRTypes>(this, FHIRTypes.UUID, code); 11048 if ("Quantity".equals(codeString)) 11049 return new Enumeration<FHIRTypes>(this, FHIRTypes.QUANTITY, code); 11050 if ("Age".equals(codeString)) 11051 return new Enumeration<FHIRTypes>(this, FHIRTypes.AGE, code); 11052 if ("Count".equals(codeString)) 11053 return new Enumeration<FHIRTypes>(this, FHIRTypes.COUNT, code); 11054 if ("Distance".equals(codeString)) 11055 return new Enumeration<FHIRTypes>(this, FHIRTypes.DISTANCE, code); 11056 if ("Duration".equals(codeString)) 11057 return new Enumeration<FHIRTypes>(this, FHIRTypes.DURATION, code); 11058 if ("Range".equals(codeString)) 11059 return new Enumeration<FHIRTypes>(this, FHIRTypes.RANGE, code); 11060 if ("Ratio".equals(codeString)) 11061 return new Enumeration<FHIRTypes>(this, FHIRTypes.RATIO, code); 11062 if ("RatioRange".equals(codeString)) 11063 return new Enumeration<FHIRTypes>(this, FHIRTypes.RATIORANGE, code); 11064 if ("Reference".equals(codeString)) 11065 return new Enumeration<FHIRTypes>(this, FHIRTypes.REFERENCE, code); 11066 if ("RelatedArtifact".equals(codeString)) 11067 return new Enumeration<FHIRTypes>(this, FHIRTypes.RELATEDARTIFACT, code); 11068 if ("SampledData".equals(codeString)) 11069 return new Enumeration<FHIRTypes>(this, FHIRTypes.SAMPLEDDATA, code); 11070 if ("Signature".equals(codeString)) 11071 return new Enumeration<FHIRTypes>(this, FHIRTypes.SIGNATURE, code); 11072 if ("TriggerDefinition".equals(codeString)) 11073 return new Enumeration<FHIRTypes>(this, FHIRTypes.TRIGGERDEFINITION, code); 11074 if ("UsageContext".equals(codeString)) 11075 return new Enumeration<FHIRTypes>(this, FHIRTypes.USAGECONTEXT, code); 11076 if ("VirtualServiceDetail".equals(codeString)) 11077 return new Enumeration<FHIRTypes>(this, FHIRTypes.VIRTUALSERVICEDETAIL, code); 11078 if ("xhtml".equals(codeString)) 11079 return new Enumeration<FHIRTypes>(this, FHIRTypes.XHTML, code); 11080 if ("Resource".equals(codeString)) 11081 return new Enumeration<FHIRTypes>(this, FHIRTypes.RESOURCE, code); 11082 if ("Binary".equals(codeString)) 11083 return new Enumeration<FHIRTypes>(this, FHIRTypes.BINARY, code); 11084 if ("Bundle".equals(codeString)) 11085 return new Enumeration<FHIRTypes>(this, FHIRTypes.BUNDLE, code); 11086 if ("DomainResource".equals(codeString)) 11087 return new Enumeration<FHIRTypes>(this, FHIRTypes.DOMAINRESOURCE, code); 11088 if ("Account".equals(codeString)) 11089 return new Enumeration<FHIRTypes>(this, FHIRTypes.ACCOUNT, code); 11090 if ("ActivityDefinition".equals(codeString)) 11091 return new Enumeration<FHIRTypes>(this, FHIRTypes.ACTIVITYDEFINITION, code); 11092 if ("ActorDefinition".equals(codeString)) 11093 return new Enumeration<FHIRTypes>(this, FHIRTypes.ACTORDEFINITION, code); 11094 if ("AdministrableProductDefinition".equals(codeString)) 11095 return new Enumeration<FHIRTypes>(this, FHIRTypes.ADMINISTRABLEPRODUCTDEFINITION, code); 11096 if ("AdverseEvent".equals(codeString)) 11097 return new Enumeration<FHIRTypes>(this, FHIRTypes.ADVERSEEVENT, code); 11098 if ("AllergyIntolerance".equals(codeString)) 11099 return new Enumeration<FHIRTypes>(this, FHIRTypes.ALLERGYINTOLERANCE, code); 11100 if ("Appointment".equals(codeString)) 11101 return new Enumeration<FHIRTypes>(this, FHIRTypes.APPOINTMENT, code); 11102 if ("AppointmentResponse".equals(codeString)) 11103 return new Enumeration<FHIRTypes>(this, FHIRTypes.APPOINTMENTRESPONSE, code); 11104 if ("ArtifactAssessment".equals(codeString)) 11105 return new Enumeration<FHIRTypes>(this, FHIRTypes.ARTIFACTASSESSMENT, code); 11106 if ("AuditEvent".equals(codeString)) 11107 return new Enumeration<FHIRTypes>(this, FHIRTypes.AUDITEVENT, code); 11108 if ("Basic".equals(codeString)) 11109 return new Enumeration<FHIRTypes>(this, FHIRTypes.BASIC, code); 11110 if ("BiologicallyDerivedProduct".equals(codeString)) 11111 return new Enumeration<FHIRTypes>(this, FHIRTypes.BIOLOGICALLYDERIVEDPRODUCT, code); 11112 if ("BiologicallyDerivedProductDispense".equals(codeString)) 11113 return new Enumeration<FHIRTypes>(this, FHIRTypes.BIOLOGICALLYDERIVEDPRODUCTDISPENSE, code); 11114 if ("BodyStructure".equals(codeString)) 11115 return new Enumeration<FHIRTypes>(this, FHIRTypes.BODYSTRUCTURE, code); 11116 if ("CanonicalResource".equals(codeString)) 11117 return new Enumeration<FHIRTypes>(this, FHIRTypes.CANONICALRESOURCE, code); 11118 if ("CapabilityStatement".equals(codeString)) 11119 return new Enumeration<FHIRTypes>(this, FHIRTypes.CAPABILITYSTATEMENT, code); 11120 if ("CarePlan".equals(codeString)) 11121 return new Enumeration<FHIRTypes>(this, FHIRTypes.CAREPLAN, code); 11122 if ("CareTeam".equals(codeString)) 11123 return new Enumeration<FHIRTypes>(this, FHIRTypes.CARETEAM, code); 11124 if ("ChargeItem".equals(codeString)) 11125 return new Enumeration<FHIRTypes>(this, FHIRTypes.CHARGEITEM, code); 11126 if ("ChargeItemDefinition".equals(codeString)) 11127 return new Enumeration<FHIRTypes>(this, FHIRTypes.CHARGEITEMDEFINITION, code); 11128 if ("Citation".equals(codeString)) 11129 return new Enumeration<FHIRTypes>(this, FHIRTypes.CITATION, code); 11130 if ("Claim".equals(codeString)) 11131 return new Enumeration<FHIRTypes>(this, FHIRTypes.CLAIM, code); 11132 if ("ClaimResponse".equals(codeString)) 11133 return new Enumeration<FHIRTypes>(this, FHIRTypes.CLAIMRESPONSE, code); 11134 if ("ClinicalImpression".equals(codeString)) 11135 return new Enumeration<FHIRTypes>(this, FHIRTypes.CLINICALIMPRESSION, code); 11136 if ("ClinicalUseDefinition".equals(codeString)) 11137 return new Enumeration<FHIRTypes>(this, FHIRTypes.CLINICALUSEDEFINITION, code); 11138 if ("CodeSystem".equals(codeString)) 11139 return new Enumeration<FHIRTypes>(this, FHIRTypes.CODESYSTEM, code); 11140 if ("Communication".equals(codeString)) 11141 return new Enumeration<FHIRTypes>(this, FHIRTypes.COMMUNICATION, code); 11142 if ("CommunicationRequest".equals(codeString)) 11143 return new Enumeration<FHIRTypes>(this, FHIRTypes.COMMUNICATIONREQUEST, code); 11144 if ("CompartmentDefinition".equals(codeString)) 11145 return new Enumeration<FHIRTypes>(this, FHIRTypes.COMPARTMENTDEFINITION, code); 11146 if ("Composition".equals(codeString)) 11147 return new Enumeration<FHIRTypes>(this, FHIRTypes.COMPOSITION, code); 11148 if ("ConceptMap".equals(codeString)) 11149 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONCEPTMAP, code); 11150 if ("Condition".equals(codeString)) 11151 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONDITION, code); 11152 if ("ConditionDefinition".equals(codeString)) 11153 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONDITIONDEFINITION, code); 11154 if ("Consent".equals(codeString)) 11155 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONSENT, code); 11156 if ("Contract".equals(codeString)) 11157 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONTRACT, code); 11158 if ("Coverage".equals(codeString)) 11159 return new Enumeration<FHIRTypes>(this, FHIRTypes.COVERAGE, code); 11160 if ("CoverageEligibilityRequest".equals(codeString)) 11161 return new Enumeration<FHIRTypes>(this, FHIRTypes.COVERAGEELIGIBILITYREQUEST, code); 11162 if ("CoverageEligibilityResponse".equals(codeString)) 11163 return new Enumeration<FHIRTypes>(this, FHIRTypes.COVERAGEELIGIBILITYRESPONSE, code); 11164 if ("DetectedIssue".equals(codeString)) 11165 return new Enumeration<FHIRTypes>(this, FHIRTypes.DETECTEDISSUE, code); 11166 if ("Device".equals(codeString)) 11167 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICE, code); 11168 if ("DeviceAssociation".equals(codeString)) 11169 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICEASSOCIATION, code); 11170 if ("DeviceDefinition".equals(codeString)) 11171 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICEDEFINITION, code); 11172 if ("DeviceDispense".equals(codeString)) 11173 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICEDISPENSE, code); 11174 if ("DeviceMetric".equals(codeString)) 11175 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICEMETRIC, code); 11176 if ("DeviceRequest".equals(codeString)) 11177 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICEREQUEST, code); 11178 if ("DeviceUsage".equals(codeString)) 11179 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICEUSAGE, code); 11180 if ("DiagnosticReport".equals(codeString)) 11181 return new Enumeration<FHIRTypes>(this, FHIRTypes.DIAGNOSTICREPORT, code); 11182 if ("DocumentReference".equals(codeString)) 11183 return new Enumeration<FHIRTypes>(this, FHIRTypes.DOCUMENTREFERENCE, code); 11184 if ("Encounter".equals(codeString)) 11185 return new Enumeration<FHIRTypes>(this, FHIRTypes.ENCOUNTER, code); 11186 if ("EncounterHistory".equals(codeString)) 11187 return new Enumeration<FHIRTypes>(this, FHIRTypes.ENCOUNTERHISTORY, code); 11188 if ("Endpoint".equals(codeString)) 11189 return new Enumeration<FHIRTypes>(this, FHIRTypes.ENDPOINT, code); 11190 if ("EnrollmentRequest".equals(codeString)) 11191 return new Enumeration<FHIRTypes>(this, FHIRTypes.ENROLLMENTREQUEST, code); 11192 if ("EnrollmentResponse".equals(codeString)) 11193 return new Enumeration<FHIRTypes>(this, FHIRTypes.ENROLLMENTRESPONSE, code); 11194 if ("EpisodeOfCare".equals(codeString)) 11195 return new Enumeration<FHIRTypes>(this, FHIRTypes.EPISODEOFCARE, code); 11196 if ("EventDefinition".equals(codeString)) 11197 return new Enumeration<FHIRTypes>(this, FHIRTypes.EVENTDEFINITION, code); 11198 if ("Evidence".equals(codeString)) 11199 return new Enumeration<FHIRTypes>(this, FHIRTypes.EVIDENCE, code); 11200 if ("EvidenceReport".equals(codeString)) 11201 return new Enumeration<FHIRTypes>(this, FHIRTypes.EVIDENCEREPORT, code); 11202 if ("EvidenceVariable".equals(codeString)) 11203 return new Enumeration<FHIRTypes>(this, FHIRTypes.EVIDENCEVARIABLE, code); 11204 if ("ExampleScenario".equals(codeString)) 11205 return new Enumeration<FHIRTypes>(this, FHIRTypes.EXAMPLESCENARIO, code); 11206 if ("ExplanationOfBenefit".equals(codeString)) 11207 return new Enumeration<FHIRTypes>(this, FHIRTypes.EXPLANATIONOFBENEFIT, code); 11208 if ("FamilyMemberHistory".equals(codeString)) 11209 return new Enumeration<FHIRTypes>(this, FHIRTypes.FAMILYMEMBERHISTORY, code); 11210 if ("Flag".equals(codeString)) 11211 return new Enumeration<FHIRTypes>(this, FHIRTypes.FLAG, code); 11212 if ("FormularyItem".equals(codeString)) 11213 return new Enumeration<FHIRTypes>(this, FHIRTypes.FORMULARYITEM, code); 11214 if ("GenomicStudy".equals(codeString)) 11215 return new Enumeration<FHIRTypes>(this, FHIRTypes.GENOMICSTUDY, code); 11216 if ("Goal".equals(codeString)) 11217 return new Enumeration<FHIRTypes>(this, FHIRTypes.GOAL, code); 11218 if ("GraphDefinition".equals(codeString)) 11219 return new Enumeration<FHIRTypes>(this, FHIRTypes.GRAPHDEFINITION, code); 11220 if ("Group".equals(codeString)) 11221 return new Enumeration<FHIRTypes>(this, FHIRTypes.GROUP, code); 11222 if ("GuidanceResponse".equals(codeString)) 11223 return new Enumeration<FHIRTypes>(this, FHIRTypes.GUIDANCERESPONSE, code); 11224 if ("HealthcareService".equals(codeString)) 11225 return new Enumeration<FHIRTypes>(this, FHIRTypes.HEALTHCARESERVICE, code); 11226 if ("ImagingSelection".equals(codeString)) 11227 return new Enumeration<FHIRTypes>(this, FHIRTypes.IMAGINGSELECTION, code); 11228 if ("ImagingStudy".equals(codeString)) 11229 return new Enumeration<FHIRTypes>(this, FHIRTypes.IMAGINGSTUDY, code); 11230 if ("Immunization".equals(codeString)) 11231 return new Enumeration<FHIRTypes>(this, FHIRTypes.IMMUNIZATION, code); 11232 if ("ImmunizationEvaluation".equals(codeString)) 11233 return new Enumeration<FHIRTypes>(this, FHIRTypes.IMMUNIZATIONEVALUATION, code); 11234 if ("ImmunizationRecommendation".equals(codeString)) 11235 return new Enumeration<FHIRTypes>(this, FHIRTypes.IMMUNIZATIONRECOMMENDATION, code); 11236 if ("ImplementationGuide".equals(codeString)) 11237 return new Enumeration<FHIRTypes>(this, FHIRTypes.IMPLEMENTATIONGUIDE, code); 11238 if ("Ingredient".equals(codeString)) 11239 return new Enumeration<FHIRTypes>(this, FHIRTypes.INGREDIENT, code); 11240 if ("InsurancePlan".equals(codeString)) 11241 return new Enumeration<FHIRTypes>(this, FHIRTypes.INSURANCEPLAN, code); 11242 if ("InventoryItem".equals(codeString)) 11243 return new Enumeration<FHIRTypes>(this, FHIRTypes.INVENTORYITEM, code); 11244 if ("InventoryReport".equals(codeString)) 11245 return new Enumeration<FHIRTypes>(this, FHIRTypes.INVENTORYREPORT, code); 11246 if ("Invoice".equals(codeString)) 11247 return new Enumeration<FHIRTypes>(this, FHIRTypes.INVOICE, code); 11248 if ("Library".equals(codeString)) 11249 return new Enumeration<FHIRTypes>(this, FHIRTypes.LIBRARY, code); 11250 if ("Linkage".equals(codeString)) 11251 return new Enumeration<FHIRTypes>(this, FHIRTypes.LINKAGE, code); 11252 if ("List".equals(codeString)) 11253 return new Enumeration<FHIRTypes>(this, FHIRTypes.LIST, code); 11254 if ("Location".equals(codeString)) 11255 return new Enumeration<FHIRTypes>(this, FHIRTypes.LOCATION, code); 11256 if ("ManufacturedItemDefinition".equals(codeString)) 11257 return new Enumeration<FHIRTypes>(this, FHIRTypes.MANUFACTUREDITEMDEFINITION, code); 11258 if ("Measure".equals(codeString)) 11259 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEASURE, code); 11260 if ("MeasureReport".equals(codeString)) 11261 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEASUREREPORT, code); 11262 if ("Medication".equals(codeString)) 11263 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICATION, code); 11264 if ("MedicationAdministration".equals(codeString)) 11265 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICATIONADMINISTRATION, code); 11266 if ("MedicationDispense".equals(codeString)) 11267 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICATIONDISPENSE, code); 11268 if ("MedicationKnowledge".equals(codeString)) 11269 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICATIONKNOWLEDGE, code); 11270 if ("MedicationRequest".equals(codeString)) 11271 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICATIONREQUEST, code); 11272 if ("MedicationStatement".equals(codeString)) 11273 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICATIONSTATEMENT, code); 11274 if ("MedicinalProductDefinition".equals(codeString)) 11275 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICINALPRODUCTDEFINITION, code); 11276 if ("MessageDefinition".equals(codeString)) 11277 return new Enumeration<FHIRTypes>(this, FHIRTypes.MESSAGEDEFINITION, code); 11278 if ("MessageHeader".equals(codeString)) 11279 return new Enumeration<FHIRTypes>(this, FHIRTypes.MESSAGEHEADER, code); 11280 if ("MetadataResource".equals(codeString)) 11281 return new Enumeration<FHIRTypes>(this, FHIRTypes.METADATARESOURCE, code); 11282 if ("MolecularSequence".equals(codeString)) 11283 return new Enumeration<FHIRTypes>(this, FHIRTypes.MOLECULARSEQUENCE, code); 11284 if ("NamingSystem".equals(codeString)) 11285 return new Enumeration<FHIRTypes>(this, FHIRTypes.NAMINGSYSTEM, code); 11286 if ("NutritionIntake".equals(codeString)) 11287 return new Enumeration<FHIRTypes>(this, FHIRTypes.NUTRITIONINTAKE, code); 11288 if ("NutritionOrder".equals(codeString)) 11289 return new Enumeration<FHIRTypes>(this, FHIRTypes.NUTRITIONORDER, code); 11290 if ("NutritionProduct".equals(codeString)) 11291 return new Enumeration<FHIRTypes>(this, FHIRTypes.NUTRITIONPRODUCT, code); 11292 if ("Observation".equals(codeString)) 11293 return new Enumeration<FHIRTypes>(this, FHIRTypes.OBSERVATION, code); 11294 if ("ObservationDefinition".equals(codeString)) 11295 return new Enumeration<FHIRTypes>(this, FHIRTypes.OBSERVATIONDEFINITION, code); 11296 if ("OperationDefinition".equals(codeString)) 11297 return new Enumeration<FHIRTypes>(this, FHIRTypes.OPERATIONDEFINITION, code); 11298 if ("OperationOutcome".equals(codeString)) 11299 return new Enumeration<FHIRTypes>(this, FHIRTypes.OPERATIONOUTCOME, code); 11300 if ("Organization".equals(codeString)) 11301 return new Enumeration<FHIRTypes>(this, FHIRTypes.ORGANIZATION, code); 11302 if ("OrganizationAffiliation".equals(codeString)) 11303 return new Enumeration<FHIRTypes>(this, FHIRTypes.ORGANIZATIONAFFILIATION, code); 11304 if ("PackagedProductDefinition".equals(codeString)) 11305 return new Enumeration<FHIRTypes>(this, FHIRTypes.PACKAGEDPRODUCTDEFINITION, code); 11306 if ("Patient".equals(codeString)) 11307 return new Enumeration<FHIRTypes>(this, FHIRTypes.PATIENT, code); 11308 if ("PaymentNotice".equals(codeString)) 11309 return new Enumeration<FHIRTypes>(this, FHIRTypes.PAYMENTNOTICE, code); 11310 if ("PaymentReconciliation".equals(codeString)) 11311 return new Enumeration<FHIRTypes>(this, FHIRTypes.PAYMENTRECONCILIATION, code); 11312 if ("Permission".equals(codeString)) 11313 return new Enumeration<FHIRTypes>(this, FHIRTypes.PERMISSION, code); 11314 if ("Person".equals(codeString)) 11315 return new Enumeration<FHIRTypes>(this, FHIRTypes.PERSON, code); 11316 if ("PlanDefinition".equals(codeString)) 11317 return new Enumeration<FHIRTypes>(this, FHIRTypes.PLANDEFINITION, code); 11318 if ("Practitioner".equals(codeString)) 11319 return new Enumeration<FHIRTypes>(this, FHIRTypes.PRACTITIONER, code); 11320 if ("PractitionerRole".equals(codeString)) 11321 return new Enumeration<FHIRTypes>(this, FHIRTypes.PRACTITIONERROLE, code); 11322 if ("Procedure".equals(codeString)) 11323 return new Enumeration<FHIRTypes>(this, FHIRTypes.PROCEDURE, code); 11324 if ("Provenance".equals(codeString)) 11325 return new Enumeration<FHIRTypes>(this, FHIRTypes.PROVENANCE, code); 11326 if ("Questionnaire".equals(codeString)) 11327 return new Enumeration<FHIRTypes>(this, FHIRTypes.QUESTIONNAIRE, code); 11328 if ("QuestionnaireResponse".equals(codeString)) 11329 return new Enumeration<FHIRTypes>(this, FHIRTypes.QUESTIONNAIRERESPONSE, code); 11330 if ("RegulatedAuthorization".equals(codeString)) 11331 return new Enumeration<FHIRTypes>(this, FHIRTypes.REGULATEDAUTHORIZATION, code); 11332 if ("RelatedPerson".equals(codeString)) 11333 return new Enumeration<FHIRTypes>(this, FHIRTypes.RELATEDPERSON, code); 11334 if ("RequestOrchestration".equals(codeString)) 11335 return new Enumeration<FHIRTypes>(this, FHIRTypes.REQUESTORCHESTRATION, code); 11336 if ("Requirements".equals(codeString)) 11337 return new Enumeration<FHIRTypes>(this, FHIRTypes.REQUIREMENTS, code); 11338 if ("ResearchStudy".equals(codeString)) 11339 return new Enumeration<FHIRTypes>(this, FHIRTypes.RESEARCHSTUDY, code); 11340 if ("ResearchSubject".equals(codeString)) 11341 return new Enumeration<FHIRTypes>(this, FHIRTypes.RESEARCHSUBJECT, code); 11342 if ("RiskAssessment".equals(codeString)) 11343 return new Enumeration<FHIRTypes>(this, FHIRTypes.RISKASSESSMENT, code); 11344 if ("Schedule".equals(codeString)) 11345 return new Enumeration<FHIRTypes>(this, FHIRTypes.SCHEDULE, code); 11346 if ("SearchParameter".equals(codeString)) 11347 return new Enumeration<FHIRTypes>(this, FHIRTypes.SEARCHPARAMETER, code); 11348 if ("ServiceRequest".equals(codeString)) 11349 return new Enumeration<FHIRTypes>(this, FHIRTypes.SERVICEREQUEST, code); 11350 if ("Slot".equals(codeString)) 11351 return new Enumeration<FHIRTypes>(this, FHIRTypes.SLOT, code); 11352 if ("Specimen".equals(codeString)) 11353 return new Enumeration<FHIRTypes>(this, FHIRTypes.SPECIMEN, code); 11354 if ("SpecimenDefinition".equals(codeString)) 11355 return new Enumeration<FHIRTypes>(this, FHIRTypes.SPECIMENDEFINITION, code); 11356 if ("StructureDefinition".equals(codeString)) 11357 return new Enumeration<FHIRTypes>(this, FHIRTypes.STRUCTUREDEFINITION, code); 11358 if ("StructureMap".equals(codeString)) 11359 return new Enumeration<FHIRTypes>(this, FHIRTypes.STRUCTUREMAP, code); 11360 if ("Subscription".equals(codeString)) 11361 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSCRIPTION, code); 11362 if ("SubscriptionStatus".equals(codeString)) 11363 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSCRIPTIONSTATUS, code); 11364 if ("SubscriptionTopic".equals(codeString)) 11365 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSCRIPTIONTOPIC, code); 11366 if ("Substance".equals(codeString)) 11367 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCE, code); 11368 if ("SubstanceDefinition".equals(codeString)) 11369 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCEDEFINITION, code); 11370 if ("SubstanceNucleicAcid".equals(codeString)) 11371 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCENUCLEICACID, code); 11372 if ("SubstancePolymer".equals(codeString)) 11373 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCEPOLYMER, code); 11374 if ("SubstanceProtein".equals(codeString)) 11375 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCEPROTEIN, code); 11376 if ("SubstanceReferenceInformation".equals(codeString)) 11377 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCEREFERENCEINFORMATION, code); 11378 if ("SubstanceSourceMaterial".equals(codeString)) 11379 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCESOURCEMATERIAL, code); 11380 if ("SupplyDelivery".equals(codeString)) 11381 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUPPLYDELIVERY, code); 11382 if ("SupplyRequest".equals(codeString)) 11383 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUPPLYREQUEST, code); 11384 if ("Task".equals(codeString)) 11385 return new Enumeration<FHIRTypes>(this, FHIRTypes.TASK, code); 11386 if ("TerminologyCapabilities".equals(codeString)) 11387 return new Enumeration<FHIRTypes>(this, FHIRTypes.TERMINOLOGYCAPABILITIES, code); 11388 if ("TestPlan".equals(codeString)) 11389 return new Enumeration<FHIRTypes>(this, FHIRTypes.TESTPLAN, code); 11390 if ("TestReport".equals(codeString)) 11391 return new Enumeration<FHIRTypes>(this, FHIRTypes.TESTREPORT, code); 11392 if ("TestScript".equals(codeString)) 11393 return new Enumeration<FHIRTypes>(this, FHIRTypes.TESTSCRIPT, code); 11394 if ("Transport".equals(codeString)) 11395 return new Enumeration<FHIRTypes>(this, FHIRTypes.TRANSPORT, code); 11396 if ("ValueSet".equals(codeString)) 11397 return new Enumeration<FHIRTypes>(this, FHIRTypes.VALUESET, code); 11398 if ("VerificationResult".equals(codeString)) 11399 return new Enumeration<FHIRTypes>(this, FHIRTypes.VERIFICATIONRESULT, code); 11400 if ("VisionPrescription".equals(codeString)) 11401 return new Enumeration<FHIRTypes>(this, FHIRTypes.VISIONPRESCRIPTION, code); 11402 if ("Parameters".equals(codeString)) 11403 return new Enumeration<FHIRTypes>(this, FHIRTypes.PARAMETERS, code); 11404 throw new FHIRException("Unknown FHIRTypes code '"+codeString+"'"); 11405 } 11406 public String toCode(FHIRTypes code) { 11407 if (code == FHIRTypes.NULL) 11408 return null; 11409 if (code == FHIRTypes.BASE) 11410 return "Base"; 11411 if (code == FHIRTypes.ELEMENT) 11412 return "Element"; 11413 if (code == FHIRTypes.BACKBONEELEMENT) 11414 return "BackboneElement"; 11415 if (code == FHIRTypes.DATATYPE) 11416 return "DataType"; 11417 if (code == FHIRTypes.ADDRESS) 11418 return "Address"; 11419 if (code == FHIRTypes.ANNOTATION) 11420 return "Annotation"; 11421 if (code == FHIRTypes.ATTACHMENT) 11422 return "Attachment"; 11423 if (code == FHIRTypes.AVAILABILITY) 11424 return "Availability"; 11425 if (code == FHIRTypes.BACKBONETYPE) 11426 return "BackboneType"; 11427 if (code == FHIRTypes.DOSAGE) 11428 return "Dosage"; 11429 if (code == FHIRTypes.ELEMENTDEFINITION) 11430 return "ElementDefinition"; 11431 if (code == FHIRTypes.MARKETINGSTATUS) 11432 return "MarketingStatus"; 11433 if (code == FHIRTypes.PRODUCTSHELFLIFE) 11434 return "ProductShelfLife"; 11435 if (code == FHIRTypes.TIMING) 11436 return "Timing"; 11437 if (code == FHIRTypes.CODEABLECONCEPT) 11438 return "CodeableConcept"; 11439 if (code == FHIRTypes.CODEABLEREFERENCE) 11440 return "CodeableReference"; 11441 if (code == FHIRTypes.CODING) 11442 return "Coding"; 11443 if (code == FHIRTypes.CONTACTDETAIL) 11444 return "ContactDetail"; 11445 if (code == FHIRTypes.CONTACTPOINT) 11446 return "ContactPoint"; 11447 if (code == FHIRTypes.CONTRIBUTOR) 11448 return "Contributor"; 11449 if (code == FHIRTypes.DATAREQUIREMENT) 11450 return "DataRequirement"; 11451 if (code == FHIRTypes.EXPRESSION) 11452 return "Expression"; 11453 if (code == FHIRTypes.EXTENDEDCONTACTDETAIL) 11454 return "ExtendedContactDetail"; 11455 if (code == FHIRTypes.EXTENSION) 11456 return "Extension"; 11457 if (code == FHIRTypes.HUMANNAME) 11458 return "HumanName"; 11459 if (code == FHIRTypes.IDENTIFIER) 11460 return "Identifier"; 11461 if (code == FHIRTypes.META) 11462 return "Meta"; 11463 if (code == FHIRTypes.MONETARYCOMPONENT) 11464 return "MonetaryComponent"; 11465 if (code == FHIRTypes.MONEY) 11466 return "Money"; 11467 if (code == FHIRTypes.NARRATIVE) 11468 return "Narrative"; 11469 if (code == FHIRTypes.PARAMETERDEFINITION) 11470 return "ParameterDefinition"; 11471 if (code == FHIRTypes.PERIOD) 11472 return "Period"; 11473 if (code == FHIRTypes.PRIMITIVETYPE) 11474 return "PrimitiveType"; 11475 if (code == FHIRTypes.BASE64BINARY) 11476 return "base64Binary"; 11477 if (code == FHIRTypes.BOOLEAN) 11478 return "boolean"; 11479 if (code == FHIRTypes.DATE) 11480 return "date"; 11481 if (code == FHIRTypes.DATETIME) 11482 return "dateTime"; 11483 if (code == FHIRTypes.DECIMAL) 11484 return "decimal"; 11485 if (code == FHIRTypes.INSTANT) 11486 return "instant"; 11487 if (code == FHIRTypes.INTEGER) 11488 return "integer"; 11489 if (code == FHIRTypes.POSITIVEINT) 11490 return "positiveInt"; 11491 if (code == FHIRTypes.UNSIGNEDINT) 11492 return "unsignedInt"; 11493 if (code == FHIRTypes.INTEGER64) 11494 return "integer64"; 11495 if (code == FHIRTypes.STRING) 11496 return "string"; 11497 if (code == FHIRTypes.CODE) 11498 return "code"; 11499 if (code == FHIRTypes.ID) 11500 return "id"; 11501 if (code == FHIRTypes.MARKDOWN) 11502 return "markdown"; 11503 if (code == FHIRTypes.TIME) 11504 return "time"; 11505 if (code == FHIRTypes.URI) 11506 return "uri"; 11507 if (code == FHIRTypes.CANONICAL) 11508 return "canonical"; 11509 if (code == FHIRTypes.OID) 11510 return "oid"; 11511 if (code == FHIRTypes.URL) 11512 return "url"; 11513 if (code == FHIRTypes.UUID) 11514 return "uuid"; 11515 if (code == FHIRTypes.QUANTITY) 11516 return "Quantity"; 11517 if (code == FHIRTypes.AGE) 11518 return "Age"; 11519 if (code == FHIRTypes.COUNT) 11520 return "Count"; 11521 if (code == FHIRTypes.DISTANCE) 11522 return "Distance"; 11523 if (code == FHIRTypes.DURATION) 11524 return "Duration"; 11525 if (code == FHIRTypes.RANGE) 11526 return "Range"; 11527 if (code == FHIRTypes.RATIO) 11528 return "Ratio"; 11529 if (code == FHIRTypes.RATIORANGE) 11530 return "RatioRange"; 11531 if (code == FHIRTypes.REFERENCE) 11532 return "Reference"; 11533 if (code == FHIRTypes.RELATEDARTIFACT) 11534 return "RelatedArtifact"; 11535 if (code == FHIRTypes.SAMPLEDDATA) 11536 return "SampledData"; 11537 if (code == FHIRTypes.SIGNATURE) 11538 return "Signature"; 11539 if (code == FHIRTypes.TRIGGERDEFINITION) 11540 return "TriggerDefinition"; 11541 if (code == FHIRTypes.USAGECONTEXT) 11542 return "UsageContext"; 11543 if (code == FHIRTypes.VIRTUALSERVICEDETAIL) 11544 return "VirtualServiceDetail"; 11545 if (code == FHIRTypes.XHTML) 11546 return "xhtml"; 11547 if (code == FHIRTypes.RESOURCE) 11548 return "Resource"; 11549 if (code == FHIRTypes.BINARY) 11550 return "Binary"; 11551 if (code == FHIRTypes.BUNDLE) 11552 return "Bundle"; 11553 if (code == FHIRTypes.DOMAINRESOURCE) 11554 return "DomainResource"; 11555 if (code == FHIRTypes.ACCOUNT) 11556 return "Account"; 11557 if (code == FHIRTypes.ACTIVITYDEFINITION) 11558 return "ActivityDefinition"; 11559 if (code == FHIRTypes.ACTORDEFINITION) 11560 return "ActorDefinition"; 11561 if (code == FHIRTypes.ADMINISTRABLEPRODUCTDEFINITION) 11562 return "AdministrableProductDefinition"; 11563 if (code == FHIRTypes.ADVERSEEVENT) 11564 return "AdverseEvent"; 11565 if (code == FHIRTypes.ALLERGYINTOLERANCE) 11566 return "AllergyIntolerance"; 11567 if (code == FHIRTypes.APPOINTMENT) 11568 return "Appointment"; 11569 if (code == FHIRTypes.APPOINTMENTRESPONSE) 11570 return "AppointmentResponse"; 11571 if (code == FHIRTypes.ARTIFACTASSESSMENT) 11572 return "ArtifactAssessment"; 11573 if (code == FHIRTypes.AUDITEVENT) 11574 return "AuditEvent"; 11575 if (code == FHIRTypes.BASIC) 11576 return "Basic"; 11577 if (code == FHIRTypes.BIOLOGICALLYDERIVEDPRODUCT) 11578 return "BiologicallyDerivedProduct"; 11579 if (code == FHIRTypes.BIOLOGICALLYDERIVEDPRODUCTDISPENSE) 11580 return "BiologicallyDerivedProductDispense"; 11581 if (code == FHIRTypes.BODYSTRUCTURE) 11582 return "BodyStructure"; 11583 if (code == FHIRTypes.CANONICALRESOURCE) 11584 return "CanonicalResource"; 11585 if (code == FHIRTypes.CAPABILITYSTATEMENT) 11586 return "CapabilityStatement"; 11587 if (code == FHIRTypes.CAREPLAN) 11588 return "CarePlan"; 11589 if (code == FHIRTypes.CARETEAM) 11590 return "CareTeam"; 11591 if (code == FHIRTypes.CHARGEITEM) 11592 return "ChargeItem"; 11593 if (code == FHIRTypes.CHARGEITEMDEFINITION) 11594 return "ChargeItemDefinition"; 11595 if (code == FHIRTypes.CITATION) 11596 return "Citation"; 11597 if (code == FHIRTypes.CLAIM) 11598 return "Claim"; 11599 if (code == FHIRTypes.CLAIMRESPONSE) 11600 return "ClaimResponse"; 11601 if (code == FHIRTypes.CLINICALIMPRESSION) 11602 return "ClinicalImpression"; 11603 if (code == FHIRTypes.CLINICALUSEDEFINITION) 11604 return "ClinicalUseDefinition"; 11605 if (code == FHIRTypes.CODESYSTEM) 11606 return "CodeSystem"; 11607 if (code == FHIRTypes.COMMUNICATION) 11608 return "Communication"; 11609 if (code == FHIRTypes.COMMUNICATIONREQUEST) 11610 return "CommunicationRequest"; 11611 if (code == FHIRTypes.COMPARTMENTDEFINITION) 11612 return "CompartmentDefinition"; 11613 if (code == FHIRTypes.COMPOSITION) 11614 return "Composition"; 11615 if (code == FHIRTypes.CONCEPTMAP) 11616 return "ConceptMap"; 11617 if (code == FHIRTypes.CONDITION) 11618 return "Condition"; 11619 if (code == FHIRTypes.CONDITIONDEFINITION) 11620 return "ConditionDefinition"; 11621 if (code == FHIRTypes.CONSENT) 11622 return "Consent"; 11623 if (code == FHIRTypes.CONTRACT) 11624 return "Contract"; 11625 if (code == FHIRTypes.COVERAGE) 11626 return "Coverage"; 11627 if (code == FHIRTypes.COVERAGEELIGIBILITYREQUEST) 11628 return "CoverageEligibilityRequest"; 11629 if (code == FHIRTypes.COVERAGEELIGIBILITYRESPONSE) 11630 return "CoverageEligibilityResponse"; 11631 if (code == FHIRTypes.DETECTEDISSUE) 11632 return "DetectedIssue"; 11633 if (code == FHIRTypes.DEVICE) 11634 return "Device"; 11635 if (code == FHIRTypes.DEVICEASSOCIATION) 11636 return "DeviceAssociation"; 11637 if (code == FHIRTypes.DEVICEDEFINITION) 11638 return "DeviceDefinition"; 11639 if (code == FHIRTypes.DEVICEDISPENSE) 11640 return "DeviceDispense"; 11641 if (code == FHIRTypes.DEVICEMETRIC) 11642 return "DeviceMetric"; 11643 if (code == FHIRTypes.DEVICEREQUEST) 11644 return "DeviceRequest"; 11645 if (code == FHIRTypes.DEVICEUSAGE) 11646 return "DeviceUsage"; 11647 if (code == FHIRTypes.DIAGNOSTICREPORT) 11648 return "DiagnosticReport"; 11649 if (code == FHIRTypes.DOCUMENTREFERENCE) 11650 return "DocumentReference"; 11651 if (code == FHIRTypes.ENCOUNTER) 11652 return "Encounter"; 11653 if (code == FHIRTypes.ENCOUNTERHISTORY) 11654 return "EncounterHistory"; 11655 if (code == FHIRTypes.ENDPOINT) 11656 return "Endpoint"; 11657 if (code == FHIRTypes.ENROLLMENTREQUEST) 11658 return "EnrollmentRequest"; 11659 if (code == FHIRTypes.ENROLLMENTRESPONSE) 11660 return "EnrollmentResponse"; 11661 if (code == FHIRTypes.EPISODEOFCARE) 11662 return "EpisodeOfCare"; 11663 if (code == FHIRTypes.EVENTDEFINITION) 11664 return "EventDefinition"; 11665 if (code == FHIRTypes.EVIDENCE) 11666 return "Evidence"; 11667 if (code == FHIRTypes.EVIDENCEREPORT) 11668 return "EvidenceReport"; 11669 if (code == FHIRTypes.EVIDENCEVARIABLE) 11670 return "EvidenceVariable"; 11671 if (code == FHIRTypes.EXAMPLESCENARIO) 11672 return "ExampleScenario"; 11673 if (code == FHIRTypes.EXPLANATIONOFBENEFIT) 11674 return "ExplanationOfBenefit"; 11675 if (code == FHIRTypes.FAMILYMEMBERHISTORY) 11676 return "FamilyMemberHistory"; 11677 if (code == FHIRTypes.FLAG) 11678 return "Flag"; 11679 if (code == FHIRTypes.FORMULARYITEM) 11680 return "FormularyItem"; 11681 if (code == FHIRTypes.GENOMICSTUDY) 11682 return "GenomicStudy"; 11683 if (code == FHIRTypes.GOAL) 11684 return "Goal"; 11685 if (code == FHIRTypes.GRAPHDEFINITION) 11686 return "GraphDefinition"; 11687 if (code == FHIRTypes.GROUP) 11688 return "Group"; 11689 if (code == FHIRTypes.GUIDANCERESPONSE) 11690 return "GuidanceResponse"; 11691 if (code == FHIRTypes.HEALTHCARESERVICE) 11692 return "HealthcareService"; 11693 if (code == FHIRTypes.IMAGINGSELECTION) 11694 return "ImagingSelection"; 11695 if (code == FHIRTypes.IMAGINGSTUDY) 11696 return "ImagingStudy"; 11697 if (code == FHIRTypes.IMMUNIZATION) 11698 return "Immunization"; 11699 if (code == FHIRTypes.IMMUNIZATIONEVALUATION) 11700 return "ImmunizationEvaluation"; 11701 if (code == FHIRTypes.IMMUNIZATIONRECOMMENDATION) 11702 return "ImmunizationRecommendation"; 11703 if (code == FHIRTypes.IMPLEMENTATIONGUIDE) 11704 return "ImplementationGuide"; 11705 if (code == FHIRTypes.INGREDIENT) 11706 return "Ingredient"; 11707 if (code == FHIRTypes.INSURANCEPLAN) 11708 return "InsurancePlan"; 11709 if (code == FHIRTypes.INVENTORYITEM) 11710 return "InventoryItem"; 11711 if (code == FHIRTypes.INVENTORYREPORT) 11712 return "InventoryReport"; 11713 if (code == FHIRTypes.INVOICE) 11714 return "Invoice"; 11715 if (code == FHIRTypes.LIBRARY) 11716 return "Library"; 11717 if (code == FHIRTypes.LINKAGE) 11718 return "Linkage"; 11719 if (code == FHIRTypes.LIST) 11720 return "List"; 11721 if (code == FHIRTypes.LOCATION) 11722 return "Location"; 11723 if (code == FHIRTypes.MANUFACTUREDITEMDEFINITION) 11724 return "ManufacturedItemDefinition"; 11725 if (code == FHIRTypes.MEASURE) 11726 return "Measure"; 11727 if (code == FHIRTypes.MEASUREREPORT) 11728 return "MeasureReport"; 11729 if (code == FHIRTypes.MEDICATION) 11730 return "Medication"; 11731 if (code == FHIRTypes.MEDICATIONADMINISTRATION) 11732 return "MedicationAdministration"; 11733 if (code == FHIRTypes.MEDICATIONDISPENSE) 11734 return "MedicationDispense"; 11735 if (code == FHIRTypes.MEDICATIONKNOWLEDGE) 11736 return "MedicationKnowledge"; 11737 if (code == FHIRTypes.MEDICATIONREQUEST) 11738 return "MedicationRequest"; 11739 if (code == FHIRTypes.MEDICATIONSTATEMENT) 11740 return "MedicationStatement"; 11741 if (code == FHIRTypes.MEDICINALPRODUCTDEFINITION) 11742 return "MedicinalProductDefinition"; 11743 if (code == FHIRTypes.MESSAGEDEFINITION) 11744 return "MessageDefinition"; 11745 if (code == FHIRTypes.MESSAGEHEADER) 11746 return "MessageHeader"; 11747 if (code == FHIRTypes.METADATARESOURCE) 11748 return "MetadataResource"; 11749 if (code == FHIRTypes.MOLECULARSEQUENCE) 11750 return "MolecularSequence"; 11751 if (code == FHIRTypes.NAMINGSYSTEM) 11752 return "NamingSystem"; 11753 if (code == FHIRTypes.NUTRITIONINTAKE) 11754 return "NutritionIntake"; 11755 if (code == FHIRTypes.NUTRITIONORDER) 11756 return "NutritionOrder"; 11757 if (code == FHIRTypes.NUTRITIONPRODUCT) 11758 return "NutritionProduct"; 11759 if (code == FHIRTypes.OBSERVATION) 11760 return "Observation"; 11761 if (code == FHIRTypes.OBSERVATIONDEFINITION) 11762 return "ObservationDefinition"; 11763 if (code == FHIRTypes.OPERATIONDEFINITION) 11764 return "OperationDefinition"; 11765 if (code == FHIRTypes.OPERATIONOUTCOME) 11766 return "OperationOutcome"; 11767 if (code == FHIRTypes.ORGANIZATION) 11768 return "Organization"; 11769 if (code == FHIRTypes.ORGANIZATIONAFFILIATION) 11770 return "OrganizationAffiliation"; 11771 if (code == FHIRTypes.PACKAGEDPRODUCTDEFINITION) 11772 return "PackagedProductDefinition"; 11773 if (code == FHIRTypes.PATIENT) 11774 return "Patient"; 11775 if (code == FHIRTypes.PAYMENTNOTICE) 11776 return "PaymentNotice"; 11777 if (code == FHIRTypes.PAYMENTRECONCILIATION) 11778 return "PaymentReconciliation"; 11779 if (code == FHIRTypes.PERMISSION) 11780 return "Permission"; 11781 if (code == FHIRTypes.PERSON) 11782 return "Person"; 11783 if (code == FHIRTypes.PLANDEFINITION) 11784 return "PlanDefinition"; 11785 if (code == FHIRTypes.PRACTITIONER) 11786 return "Practitioner"; 11787 if (code == FHIRTypes.PRACTITIONERROLE) 11788 return "PractitionerRole"; 11789 if (code == FHIRTypes.PROCEDURE) 11790 return "Procedure"; 11791 if (code == FHIRTypes.PROVENANCE) 11792 return "Provenance"; 11793 if (code == FHIRTypes.QUESTIONNAIRE) 11794 return "Questionnaire"; 11795 if (code == FHIRTypes.QUESTIONNAIRERESPONSE) 11796 return "QuestionnaireResponse"; 11797 if (code == FHIRTypes.REGULATEDAUTHORIZATION) 11798 return "RegulatedAuthorization"; 11799 if (code == FHIRTypes.RELATEDPERSON) 11800 return "RelatedPerson"; 11801 if (code == FHIRTypes.REQUESTORCHESTRATION) 11802 return "RequestOrchestration"; 11803 if (code == FHIRTypes.REQUIREMENTS) 11804 return "Requirements"; 11805 if (code == FHIRTypes.RESEARCHSTUDY) 11806 return "ResearchStudy"; 11807 if (code == FHIRTypes.RESEARCHSUBJECT) 11808 return "ResearchSubject"; 11809 if (code == FHIRTypes.RISKASSESSMENT) 11810 return "RiskAssessment"; 11811 if (code == FHIRTypes.SCHEDULE) 11812 return "Schedule"; 11813 if (code == FHIRTypes.SEARCHPARAMETER) 11814 return "SearchParameter"; 11815 if (code == FHIRTypes.SERVICEREQUEST) 11816 return "ServiceRequest"; 11817 if (code == FHIRTypes.SLOT) 11818 return "Slot"; 11819 if (code == FHIRTypes.SPECIMEN) 11820 return "Specimen"; 11821 if (code == FHIRTypes.SPECIMENDEFINITION) 11822 return "SpecimenDefinition"; 11823 if (code == FHIRTypes.STRUCTUREDEFINITION) 11824 return "StructureDefinition"; 11825 if (code == FHIRTypes.STRUCTUREMAP) 11826 return "StructureMap"; 11827 if (code == FHIRTypes.SUBSCRIPTION) 11828 return "Subscription"; 11829 if (code == FHIRTypes.SUBSCRIPTIONSTATUS) 11830 return "SubscriptionStatus"; 11831 if (code == FHIRTypes.SUBSCRIPTIONTOPIC) 11832 return "SubscriptionTopic"; 11833 if (code == FHIRTypes.SUBSTANCE) 11834 return "Substance"; 11835 if (code == FHIRTypes.SUBSTANCEDEFINITION) 11836 return "SubstanceDefinition"; 11837 if (code == FHIRTypes.SUBSTANCENUCLEICACID) 11838 return "SubstanceNucleicAcid"; 11839 if (code == FHIRTypes.SUBSTANCEPOLYMER) 11840 return "SubstancePolymer"; 11841 if (code == FHIRTypes.SUBSTANCEPROTEIN) 11842 return "SubstanceProtein"; 11843 if (code == FHIRTypes.SUBSTANCEREFERENCEINFORMATION) 11844 return "SubstanceReferenceInformation"; 11845 if (code == FHIRTypes.SUBSTANCESOURCEMATERIAL) 11846 return "SubstanceSourceMaterial"; 11847 if (code == FHIRTypes.SUPPLYDELIVERY) 11848 return "SupplyDelivery"; 11849 if (code == FHIRTypes.SUPPLYREQUEST) 11850 return "SupplyRequest"; 11851 if (code == FHIRTypes.TASK) 11852 return "Task"; 11853 if (code == FHIRTypes.TERMINOLOGYCAPABILITIES) 11854 return "TerminologyCapabilities"; 11855 if (code == FHIRTypes.TESTPLAN) 11856 return "TestPlan"; 11857 if (code == FHIRTypes.TESTREPORT) 11858 return "TestReport"; 11859 if (code == FHIRTypes.TESTSCRIPT) 11860 return "TestScript"; 11861 if (code == FHIRTypes.TRANSPORT) 11862 return "Transport"; 11863 if (code == FHIRTypes.VALUESET) 11864 return "ValueSet"; 11865 if (code == FHIRTypes.VERIFICATIONRESULT) 11866 return "VerificationResult"; 11867 if (code == FHIRTypes.VISIONPRESCRIPTION) 11868 return "VisionPrescription"; 11869 if (code == FHIRTypes.PARAMETERS) 11870 return "Parameters"; 11871 return "?"; 11872 } 11873 public String toSystem(FHIRTypes code) { 11874 return code.getSystem(); 11875 } 11876 } 11877 11878 public enum FHIRVersion { 11879 /** 11880 * Oldest archived version of FHIR. 11881 */ 11882 _0_01, 11883 /** 11884 * 1st Draft for Comment (Sept 2012 Ballot). 11885 */ 11886 _0_05, 11887 /** 11888 * 2nd Draft for Comment (January 2013 Ballot). 11889 */ 11890 _0_06, 11891 /** 11892 * DSTU 1 Ballot version. 11893 */ 11894 _0_11, 11895 /** 11896 * DSTU 1 version. 11897 */ 11898 _0_0, 11899 /** 11900 * DSTU 1 Official version. 11901 */ 11902 _0_0_80, 11903 /** 11904 * DSTU 1 Official version Technical Errata #1. 11905 */ 11906 _0_0_81, 11907 /** 11908 * DSTU 1 Official version Technical Errata #2. 11909 */ 11910 _0_0_82, 11911 /** 11912 * January 2015 Ballot. 11913 */ 11914 _0_4, 11915 /** 11916 * Draft For Comment (January 2015 Ballot). 11917 */ 11918 _0_4_0, 11919 /** 11920 * May 2015 Ballot. 11921 */ 11922 _0_5, 11923 /** 11924 * DSTU 2 Ballot version (May 2015 Ballot). 11925 */ 11926 _0_5_0, 11927 /** 11928 * DSTU 2 version. 11929 */ 11930 _1_0, 11931 /** 11932 * DSTU 2 QA Preview + CQIF Ballot (Sep 2015). 11933 */ 11934 _1_0_0, 11935 /** 11936 * DSTU 2 (Official version). 11937 */ 11938 _1_0_1, 11939 /** 11940 * DSTU 2 (Official version) with 1 technical errata. 11941 */ 11942 _1_0_2, 11943 /** 11944 * GAO Ballot version. 11945 */ 11946 _1_1, 11947 /** 11948 * GAO Ballot + draft changes to main FHIR standard. 11949 */ 11950 _1_1_0, 11951 /** 11952 * Connectathon 12 (Montreal) version. 11953 */ 11954 _1_4, 11955 /** 11956 * CQF on FHIR Ballot + Connectathon 12 (Montreal). 11957 */ 11958 _1_4_0, 11959 /** 11960 * Connectathon 13 (Baltimore) version. 11961 */ 11962 _1_6, 11963 /** 11964 * FHIR STU3 Ballot + Connectathon 13 (Baltimore). 11965 */ 11966 _1_6_0, 11967 /** 11968 * Connectathon 14 (San Antonio) version. 11969 */ 11970 _1_8, 11971 /** 11972 * FHIR STU3 Candidate + Connectathon 14 (San Antonio). 11973 */ 11974 _1_8_0, 11975 /** 11976 * STU3 version. 11977 */ 11978 _3_0, 11979 /** 11980 * FHIR Release 3 (STU). 11981 */ 11982 _3_0_0, 11983 /** 11984 * FHIR Release 3 (STU) with 1 technical errata. 11985 */ 11986 _3_0_1, 11987 /** 11988 * FHIR Release 3 (STU) with 2 technical errata. 11989 */ 11990 _3_0_2, 11991 /** 11992 * R4 Ballot #1 version. 11993 */ 11994 _3_3, 11995 /** 11996 * R4 Ballot #1 + Connectaton 18 (Cologne). 11997 */ 11998 _3_3_0, 11999 /** 12000 * R4 Ballot #2 version. 12001 */ 12002 _3_5, 12003 /** 12004 * R4 Ballot #2 + Connectathon 19 (Baltimore). 12005 */ 12006 _3_5_0, 12007 /** 12008 * R4 version. 12009 */ 12010 _4_0, 12011 /** 12012 * FHIR Release 4 (Normative + STU). 12013 */ 12014 _4_0_0, 12015 /** 12016 * FHIR Release 4 (Normative + STU) with 1 technical errata. 12017 */ 12018 _4_0_1, 12019 /** 12020 * R4B Ballot #1 version. 12021 */ 12022 _4_1, 12023 /** 12024 * R4B Ballot #1 + Connectathon 27 (Virtual). 12025 */ 12026 _4_1_0, 12027 /** 12028 * R5 Preview #1 version. 12029 */ 12030 _4_2, 12031 /** 12032 * R5 Preview #1 + Connectathon 23 (Sydney). 12033 */ 12034 _4_2_0, 12035 /** 12036 * R4B version. 12037 */ 12038 _4_3, 12039 /** 12040 * FHIR Release 4B (Normative + STU). 12041 */ 12042 _4_3_0, 12043 /** 12044 * FHIR Release 4B CI-Builld. 12045 */ 12046 _4_3_0CIBUILD, 12047 /** 12048 * FHIR Release 4B Snapshot #1. 12049 */ 12050 _4_3_0SNAPSHOT1, 12051 /** 12052 * R5 Preview #2 version. 12053 */ 12054 _4_4, 12055 /** 12056 * R5 Preview #2 + Connectathon 24 (Virtual). 12057 */ 12058 _4_4_0, 12059 /** 12060 * R5 Preview #3 version. 12061 */ 12062 _4_5, 12063 /** 12064 * R5 Preview #3 + Connectathon 25 (Virtual). 12065 */ 12066 _4_5_0, 12067 /** 12068 * R5 Draft Ballot version. 12069 */ 12070 _4_6, 12071 /** 12072 * R5 Draft Ballot + Connectathon 27 (Virtual). 12073 */ 12074 _4_6_0, 12075 /** 12076 * R5 Versions. 12077 */ 12078 _5_0, 12079 /** 12080 * R5 Final Version. 12081 */ 12082 _5_0_0, 12083 /** 12084 * R5 Rolling ci-build. 12085 */ 12086 _5_0_0CIBUILD, 12087 /** 12088 * R5 Preview #2. 12089 */ 12090 _5_0_0SNAPSHOT1, 12091 /** 12092 * R5 Interim tooling stage. 12093 */ 12094 _5_0_0SNAPSHOT2, 12095 /** 12096 * R5 Ballot. 12097 */ 12098 _5_0_0BALLOT, 12099 /** 12100 * R5 January 2023 Staging Release + Connectathon 32. 12101 */ 12102 _5_0_0SNAPSHOT3, 12103 /** 12104 * R5 Final QA. 12105 */ 12106 _5_0_0DRAFTFINAL, 12107 /** 12108 * R6 Rolling ci-build. 12109 */ 12110 _6_0_0CIBUILD, 12111 /** 12112 * R6 Formal version (does not exist yet) 12113 */ 12114 _6_0_0, 12115 _6_0_0_BALLOT1, 12116 _6_0_0_BALLOT2, 12117 _6_0_0_BALLOT3, 12118 /** 12119 * added to help the parsers 12120 */ 12121 NULL; 12122 public static FHIRVersion fromCode(String codeString) throws FHIRException { 12123 if (codeString == null || "".equals(codeString)) 12124 return null; 12125 if ("0.01".equals(codeString)) 12126 return _0_01; 12127 if ("0.05".equals(codeString)) 12128 return _0_05; 12129 if ("0.06".equals(codeString)) 12130 return _0_06; 12131 if ("0.11".equals(codeString)) 12132 return _0_11; 12133 if ("0.0".equals(codeString)) 12134 return _0_0; 12135 if ("0.0.80".equals(codeString)) 12136 return _0_0_80; 12137 if ("0.0.81".equals(codeString)) 12138 return _0_0_81; 12139 if ("0.0.82".equals(codeString)) 12140 return _0_0_82; 12141 if ("0.4".equals(codeString)) 12142 return _0_4; 12143 if ("0.4.0".equals(codeString)) 12144 return _0_4_0; 12145 if ("0.5".equals(codeString)) 12146 return _0_5; 12147 if ("0.5.0".equals(codeString)) 12148 return _0_5_0; 12149 if ("1.0".equals(codeString)) 12150 return _1_0; 12151 if ("1.0.0".equals(codeString)) 12152 return _1_0_0; 12153 if ("1.0.1".equals(codeString)) 12154 return _1_0_1; 12155 if ("1.0.2".equals(codeString)) 12156 return _1_0_2; 12157 if ("1.1".equals(codeString)) 12158 return _1_1; 12159 if ("1.1.0".equals(codeString)) 12160 return _1_1_0; 12161 if ("1.4".equals(codeString)) 12162 return _1_4; 12163 if ("1.4.0".equals(codeString)) 12164 return _1_4_0; 12165 if ("1.6".equals(codeString)) 12166 return _1_6; 12167 if ("1.6.0".equals(codeString)) 12168 return _1_6_0; 12169 if ("1.8".equals(codeString)) 12170 return _1_8; 12171 if ("1.8.0".equals(codeString)) 12172 return _1_8_0; 12173 if ("3.0".equals(codeString)) 12174 return _3_0; 12175 if ("3.0.0".equals(codeString)) 12176 return _3_0_0; 12177 if ("3.0.1".equals(codeString)) 12178 return _3_0_1; 12179 if ("3.0.2".equals(codeString)) 12180 return _3_0_2; 12181 if ("3.3".equals(codeString)) 12182 return _3_3; 12183 if ("3.3.0".equals(codeString)) 12184 return _3_3_0; 12185 if ("3.5".equals(codeString)) 12186 return _3_5; 12187 if ("3.5.0".equals(codeString)) 12188 return _3_5_0; 12189 if ("4.0".equals(codeString)) 12190 return _4_0; 12191 if ("4.0.0".equals(codeString)) 12192 return _4_0_0; 12193 if ("4.0.1".equals(codeString)) 12194 return _4_0_1; 12195 if ("4.1".equals(codeString)) 12196 return _4_1; 12197 if ("4.1.0".equals(codeString)) 12198 return _4_1_0; 12199 if ("4.2".equals(codeString)) 12200 return _4_2; 12201 if ("4.2.0".equals(codeString)) 12202 return _4_2_0; 12203 if ("4.3".equals(codeString)) 12204 return _4_3; 12205 if ("4.3.0".equals(codeString)) 12206 return _4_3_0; 12207 if ("4.3.0-cibuild".equals(codeString)) 12208 return _4_3_0CIBUILD; 12209 if ("4.3.0-snapshot1".equals(codeString)) 12210 return _4_3_0SNAPSHOT1; 12211 if ("4.4".equals(codeString)) 12212 return _4_4; 12213 if ("4.4.0".equals(codeString)) 12214 return _4_4_0; 12215 if ("4.5".equals(codeString)) 12216 return _4_5; 12217 if ("4.5.0".equals(codeString)) 12218 return _4_5_0; 12219 if ("4.6".equals(codeString)) 12220 return _4_6; 12221 if ("4.6.0".equals(codeString)) 12222 return _4_6_0; 12223 if ("5.0".equals(codeString)) 12224 return _5_0; 12225 if ("5.0.0".equals(codeString)) 12226 return _5_0_0; 12227 if ("5.0.0-cibuild".equals(codeString)) 12228 return _5_0_0CIBUILD; 12229 if ("5.0.0-snapshot1".equals(codeString)) 12230 return _5_0_0SNAPSHOT1; 12231 if ("5.0.0-snapshot2".equals(codeString)) 12232 return _5_0_0SNAPSHOT2; 12233 if ("5.0.0-ballot".equals(codeString)) 12234 return _5_0_0BALLOT; 12235 if ("5.0.0-snapshot3".equals(codeString)) 12236 return _5_0_0SNAPSHOT3; 12237 if ("5.0.0-draft-final".equals(codeString)) 12238 return _5_0_0DRAFTFINAL; 12239 if ("6.0.0-cibuild".equals(codeString)) 12240 return _6_0_0CIBUILD; 12241 if ("6.0.0".equals(codeString)) 12242 return _6_0_0; 12243 if ("6.0.0-ballot1".equals(codeString)) 12244 return _6_0_0_BALLOT1; 12245 if ("6.0.0-ballot2".equals(codeString)) 12246 return _6_0_0_BALLOT2; 12247 if ("6.0.0-ballot3".equals(codeString)) 12248 return _6_0_0_BALLOT3; 12249 throw new FHIRException("Unknown FHIRVersion code '"+codeString+"'"); 12250 } 12251 public static boolean isValidCode(String codeString) { 12252 if (codeString == null || "".equals(codeString)) 12253 return false; 12254 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"); 12255 } 12256 public String toCode() { 12257 switch (this) { 12258 case _0_01: return "0.01"; 12259 case _0_05: return "0.05"; 12260 case _0_06: return "0.06"; 12261 case _0_11: return "0.11"; 12262 case _0_0: return "0.0"; 12263 case _0_0_80: return "0.0.80"; 12264 case _0_0_81: return "0.0.81"; 12265 case _0_0_82: return "0.0.82"; 12266 case _0_4: return "0.4"; 12267 case _0_4_0: return "0.4.0"; 12268 case _0_5: return "0.5"; 12269 case _0_5_0: return "0.5.0"; 12270 case _1_0: return "1.0"; 12271 case _1_0_0: return "1.0.0"; 12272 case _1_0_1: return "1.0.1"; 12273 case _1_0_2: return "1.0.2"; 12274 case _1_1: return "1.1"; 12275 case _1_1_0: return "1.1.0"; 12276 case _1_4: return "1.4"; 12277 case _1_4_0: return "1.4.0"; 12278 case _1_6: return "1.6"; 12279 case _1_6_0: return "1.6.0"; 12280 case _1_8: return "1.8"; 12281 case _1_8_0: return "1.8.0"; 12282 case _3_0: return "3.0"; 12283 case _3_0_0: return "3.0.0"; 12284 case _3_0_1: return "3.0.1"; 12285 case _3_0_2: return "3.0.2"; 12286 case _3_3: return "3.3"; 12287 case _3_3_0: return "3.3.0"; 12288 case _3_5: return "3.5"; 12289 case _3_5_0: return "3.5.0"; 12290 case _4_0: return "4.0"; 12291 case _4_0_0: return "4.0.0"; 12292 case _4_0_1: return "4.0.1"; 12293 case _4_1: return "4.1"; 12294 case _4_1_0: return "4.1.0"; 12295 case _4_2: return "4.2"; 12296 case _4_2_0: return "4.2.0"; 12297 case _4_3: return "4.3"; 12298 case _4_3_0: return "4.3.0"; 12299 case _4_3_0CIBUILD: return "4.3.0-cibuild"; 12300 case _4_3_0SNAPSHOT1: return "4.3.0-snapshot1"; 12301 case _4_4: return "4.4"; 12302 case _4_4_0: return "4.4.0"; 12303 case _4_5: return "4.5"; 12304 case _4_5_0: return "4.5.0"; 12305 case _4_6: return "4.6"; 12306 case _4_6_0: return "4.6.0"; 12307 case _5_0: return "5.0"; 12308 case _5_0_0: return "5.0.0"; 12309 case _5_0_0CIBUILD: return "5.0.0-cibuild"; 12310 case _5_0_0SNAPSHOT1: return "5.0.0-snapshot1"; 12311 case _5_0_0SNAPSHOT2: return "5.0.0-snapshot2"; 12312 case _5_0_0BALLOT: return "5.0.0-ballot"; 12313 case _5_0_0SNAPSHOT3: return "5.0.0-snapshot3"; 12314 case _5_0_0DRAFTFINAL: return "5.0.0-draft-final"; 12315 case _6_0_0CIBUILD: return "6.0.0-cibuild"; 12316 case _6_0_0: return "6.0.0"; 12317 case _6_0_0_BALLOT1: return "6.0.0-ballot1"; 12318 case _6_0_0_BALLOT2: return "6.0.0-ballot2"; 12319 case _6_0_0_BALLOT3: return "6.0.0-ballot3"; 12320 case NULL: return null; 12321 default: return "?"; 12322 } 12323 } 12324 public String getSystem() { 12325 switch (this) { 12326 case _0_01: return "http://hl7.org/fhir/FHIR-version"; 12327 case _0_05: return "http://hl7.org/fhir/FHIR-version"; 12328 case _0_06: return "http://hl7.org/fhir/FHIR-version"; 12329 case _0_11: return "http://hl7.org/fhir/FHIR-version"; 12330 case _0_0: return "http://hl7.org/fhir/FHIR-version"; 12331 case _0_0_80: return "http://hl7.org/fhir/FHIR-version"; 12332 case _0_0_81: return "http://hl7.org/fhir/FHIR-version"; 12333 case _0_0_82: return "http://hl7.org/fhir/FHIR-version"; 12334 case _0_4: return "http://hl7.org/fhir/FHIR-version"; 12335 case _0_4_0: return "http://hl7.org/fhir/FHIR-version"; 12336 case _0_5: return "http://hl7.org/fhir/FHIR-version"; 12337 case _0_5_0: return "http://hl7.org/fhir/FHIR-version"; 12338 case _1_0: return "http://hl7.org/fhir/FHIR-version"; 12339 case _1_0_0: return "http://hl7.org/fhir/FHIR-version"; 12340 case _1_0_1: return "http://hl7.org/fhir/FHIR-version"; 12341 case _1_0_2: return "http://hl7.org/fhir/FHIR-version"; 12342 case _1_1: return "http://hl7.org/fhir/FHIR-version"; 12343 case _1_1_0: return "http://hl7.org/fhir/FHIR-version"; 12344 case _1_4: return "http://hl7.org/fhir/FHIR-version"; 12345 case _1_4_0: return "http://hl7.org/fhir/FHIR-version"; 12346 case _1_6: return "http://hl7.org/fhir/FHIR-version"; 12347 case _1_6_0: return "http://hl7.org/fhir/FHIR-version"; 12348 case _1_8: return "http://hl7.org/fhir/FHIR-version"; 12349 case _1_8_0: return "http://hl7.org/fhir/FHIR-version"; 12350 case _3_0: return "http://hl7.org/fhir/FHIR-version"; 12351 case _3_0_0: return "http://hl7.org/fhir/FHIR-version"; 12352 case _3_0_1: return "http://hl7.org/fhir/FHIR-version"; 12353 case _3_0_2: return "http://hl7.org/fhir/FHIR-version"; 12354 case _3_3: return "http://hl7.org/fhir/FHIR-version"; 12355 case _3_3_0: return "http://hl7.org/fhir/FHIR-version"; 12356 case _3_5: return "http://hl7.org/fhir/FHIR-version"; 12357 case _3_5_0: return "http://hl7.org/fhir/FHIR-version"; 12358 case _4_0: return "http://hl7.org/fhir/FHIR-version"; 12359 case _4_0_0: return "http://hl7.org/fhir/FHIR-version"; 12360 case _4_0_1: return "http://hl7.org/fhir/FHIR-version"; 12361 case _4_1: return "http://hl7.org/fhir/FHIR-version"; 12362 case _4_1_0: return "http://hl7.org/fhir/FHIR-version"; 12363 case _4_2: return "http://hl7.org/fhir/FHIR-version"; 12364 case _4_2_0: return "http://hl7.org/fhir/FHIR-version"; 12365 case _4_3: return "http://hl7.org/fhir/FHIR-version"; 12366 case _4_3_0: return "http://hl7.org/fhir/FHIR-version"; 12367 case _4_3_0CIBUILD: return "http://hl7.org/fhir/FHIR-version"; 12368 case _4_3_0SNAPSHOT1: return "http://hl7.org/fhir/FHIR-version"; 12369 case _4_4: return "http://hl7.org/fhir/FHIR-version"; 12370 case _4_4_0: return "http://hl7.org/fhir/FHIR-version"; 12371 case _4_5: return "http://hl7.org/fhir/FHIR-version"; 12372 case _4_5_0: return "http://hl7.org/fhir/FHIR-version"; 12373 case _4_6: return "http://hl7.org/fhir/FHIR-version"; 12374 case _4_6_0: return "http://hl7.org/fhir/FHIR-version"; 12375 case _5_0: return "http://hl7.org/fhir/FHIR-version"; 12376 case _5_0_0: return "http://hl7.org/fhir/FHIR-version"; 12377 case _5_0_0CIBUILD: return "http://hl7.org/fhir/FHIR-version"; 12378 case _5_0_0SNAPSHOT1: return "http://hl7.org/fhir/FHIR-version"; 12379 case _5_0_0SNAPSHOT2: return "http://hl7.org/fhir/FHIR-version"; 12380 case _5_0_0BALLOT: return "http://hl7.org/fhir/FHIR-version"; 12381 case _5_0_0SNAPSHOT3: return "http://hl7.org/fhir/FHIR-version"; 12382 case _5_0_0DRAFTFINAL: return "http://hl7.org/fhir/FHIR-version"; 12383 case _6_0_0CIBUILD: return "http://hl7.org/fhir/FHIR-version"; 12384 case _6_0_0: return "http://hl7.org/fhir/FHIR-version"; 12385 case _6_0_0_BALLOT1: return "http://hl7.org/fhir/FHIR-version"; 12386 case NULL: return null; 12387 default: return "?"; 12388 } 12389 } 12390 public String getDefinition() { 12391 switch (this) { 12392 case _0_01: return "Oldest archived version of FHIR."; 12393 case _0_05: return "1st Draft for Comment (Sept 2012 Ballot)."; 12394 case _0_06: return "2nd Draft for Comment (January 2013 Ballot)."; 12395 case _0_11: return "DSTU 1 Ballot version."; 12396 case _0_0: return "DSTU 1 version."; 12397 case _0_0_80: return "DSTU 1 Official version."; 12398 case _0_0_81: return "DSTU 1 Official version Technical Errata #1."; 12399 case _0_0_82: return "DSTU 1 Official version Technical Errata #2."; 12400 case _0_4: return "January 2015 Ballot."; 12401 case _0_4_0: return "Draft For Comment (January 2015 Ballot)."; 12402 case _0_5: return "May 2015 Ballot."; 12403 case _0_5_0: return "DSTU 2 Ballot version (May 2015 Ballot)."; 12404 case _1_0: return "DSTU 2 version."; 12405 case _1_0_0: return "DSTU 2 QA Preview + CQIF Ballot (Sep 2015)."; 12406 case _1_0_1: return "DSTU 2 (Official version)."; 12407 case _1_0_2: return "DSTU 2 (Official version) with 1 technical errata."; 12408 case _1_1: return "GAO Ballot version."; 12409 case _1_1_0: return "GAO Ballot + draft changes to main FHIR standard."; 12410 case _1_4: return "Connectathon 12 (Montreal) version."; 12411 case _1_4_0: return "CQF on FHIR Ballot + Connectathon 12 (Montreal)."; 12412 case _1_6: return "Connectathon 13 (Baltimore) version."; 12413 case _1_6_0: return "FHIR STU3 Ballot + Connectathon 13 (Baltimore)."; 12414 case _1_8: return "Connectathon 14 (San Antonio) version."; 12415 case _1_8_0: return "FHIR STU3 Candidate + Connectathon 14 (San Antonio)."; 12416 case _3_0: return "STU3 version."; 12417 case _3_0_0: return "FHIR Release 3 (STU)."; 12418 case _3_0_1: return "FHIR Release 3 (STU) with 1 technical errata."; 12419 case _3_0_2: return "FHIR Release 3 (STU) with 2 technical errata."; 12420 case _3_3: return "R4 Ballot #1 version."; 12421 case _3_3_0: return "R4 Ballot #1 + Connectaton 18 (Cologne)."; 12422 case _3_5: return "R4 Ballot #2 version."; 12423 case _3_5_0: return "R4 Ballot #2 + Connectathon 19 (Baltimore)."; 12424 case _4_0: return "R4 version."; 12425 case _4_0_0: return "FHIR Release 4 (Normative + STU)."; 12426 case _4_0_1: return "FHIR Release 4 (Normative + STU) with 1 technical errata."; 12427 case _4_1: return "R4B Ballot #1 version."; 12428 case _4_1_0: return "R4B Ballot #1 + Connectathon 27 (Virtual)."; 12429 case _4_2: return "R5 Preview #1 version."; 12430 case _4_2_0: return "R5 Preview #1 + Connectathon 23 (Sydney)."; 12431 case _4_3: return "R4B version."; 12432 case _4_3_0: return "FHIR Release 4B (Normative + STU)."; 12433 case _4_3_0CIBUILD: return "FHIR Release 4B CI-Builld."; 12434 case _4_3_0SNAPSHOT1: return "FHIR Release 4B Snapshot #1."; 12435 case _4_4: return "R5 Preview #2 version."; 12436 case _4_4_0: return "R5 Preview #2 + Connectathon 24 (Virtual)."; 12437 case _4_5: return "R5 Preview #3 version."; 12438 case _4_5_0: return "R5 Preview #3 + Connectathon 25 (Virtual)."; 12439 case _4_6: return "R5 Draft Ballot version."; 12440 case _4_6_0: return "R5 Draft Ballot + Connectathon 27 (Virtual)."; 12441 case _5_0: return "R5 Versions."; 12442 case _5_0_0: return "R5 Final Version."; 12443 case _5_0_0CIBUILD: return "R5 Rolling ci-build."; 12444 case _5_0_0SNAPSHOT1: return "R5 Preview #2."; 12445 case _5_0_0SNAPSHOT2: return "R5 Interim tooling stage."; 12446 case _5_0_0BALLOT: return "R5 Ballot."; 12447 case _5_0_0SNAPSHOT3: return "R5 January 2023 Staging Release + Connectathon 32."; 12448 case _5_0_0DRAFTFINAL: return "R5 Final QA."; 12449 case _6_0_0CIBUILD: return "R6 Rolling ci-build."; 12450 case _6_0_0: return "R6 Final Version."; 12451 case _6_0_0_BALLOT1: return "R6 Ballot #1."; 12452 case NULL: return null; 12453 default: return "?"; 12454 } 12455 } 12456 public String getDisplay() { 12457 switch (this) { 12458 case _0_01: return "0.01"; 12459 case _0_05: return "0.05"; 12460 case _0_06: return "0.06"; 12461 case _0_11: return "0.11"; 12462 case _0_0: return "0.0"; 12463 case _0_0_80: return "0.0.80"; 12464 case _0_0_81: return "0.0.81"; 12465 case _0_0_82: return "0.0.82"; 12466 case _0_4: return "0.4"; 12467 case _0_4_0: return "0.4.0"; 12468 case _0_5: return "0.5"; 12469 case _0_5_0: return "0.5.0"; 12470 case _1_0: return "1.0"; 12471 case _1_0_0: return "1.0.0"; 12472 case _1_0_1: return "1.0.1"; 12473 case _1_0_2: return "1.0.2"; 12474 case _1_1: return "1.1"; 12475 case _1_1_0: return "1.1.0"; 12476 case _1_4: return "1.4"; 12477 case _1_4_0: return "1.4.0"; 12478 case _1_6: return "1.6"; 12479 case _1_6_0: return "1.6.0"; 12480 case _1_8: return "1.8"; 12481 case _1_8_0: return "1.8.0"; 12482 case _3_0: return "3.0"; 12483 case _3_0_0: return "3.0.0"; 12484 case _3_0_1: return "3.0.1"; 12485 case _3_0_2: return "3.0.2"; 12486 case _3_3: return "3.3"; 12487 case _3_3_0: return "3.3.0"; 12488 case _3_5: return "3.5"; 12489 case _3_5_0: return "3.5.0"; 12490 case _4_0: return "4.0"; 12491 case _4_0_0: return "4.0.0"; 12492 case _4_0_1: return "4.0.1"; 12493 case _4_1: return "4.1"; 12494 case _4_1_0: return "4.1.0"; 12495 case _4_2: return "4.2"; 12496 case _4_2_0: return "4.2.0"; 12497 case _4_3: return "4.3"; 12498 case _4_3_0: return "4.3.0"; 12499 case _4_3_0CIBUILD: return "4.3.0-cibuild"; 12500 case _4_3_0SNAPSHOT1: return "4.3.0-snapshot1"; 12501 case _4_4: return "4.4"; 12502 case _4_4_0: return "4.4.0"; 12503 case _4_5: return "4.5"; 12504 case _4_5_0: return "4.5.0"; 12505 case _4_6: return "4.6"; 12506 case _4_6_0: return "4.6.0"; 12507 case _5_0: return "5.0"; 12508 case _5_0_0: return "5.0.0"; 12509 case _5_0_0CIBUILD: return "5.0.0-cibuild"; 12510 case _5_0_0SNAPSHOT1: return "5.0.0-snapshot1"; 12511 case _5_0_0SNAPSHOT2: return "5.0.0-snapshot2"; 12512 case _5_0_0BALLOT: return "5.0.0-ballot"; 12513 case _5_0_0SNAPSHOT3: return "5.0.0-snapshot3"; 12514 case _5_0_0DRAFTFINAL: return "5.0.0-draft-final"; 12515 case _6_0_0CIBUILD: return "6.0.0-cibuild"; 12516 case _6_0_0: return "6.0.0"; 12517 case _6_0_0_BALLOT1: return "6.0.0-ballot1"; 12518 case _6_0_0_BALLOT2: return "6.0.0-ballot2"; 12519 case _6_0_0_BALLOT3: return "6.0.0-ballot3"; 12520 case NULL: return null; 12521 default: return "?"; 12522 } 12523 } 12524// manual code from configuration.txt: 12525//public String toCode(int len) { 12526// return toCode().substring(0, len); 12527// } 12528// 12529// 12530// @Override 12531// public String toString() { 12532// return toCode(); 12533// } 12534// 12535// 12536// public boolean isR4B() { 12537// return toCode().startsWith("4.1"); 12538// } 12539// 12540// end addition 12541 } 12542 12543 public static class FHIRVersionEnumFactory implements EnumFactory<FHIRVersion> { 12544 public FHIRVersion fromCode(String codeString) throws IllegalArgumentException { 12545 if (codeString == null || "".equals(codeString)) 12546 if (codeString == null || "".equals(codeString)) 12547 return null; 12548 if ("0.01".equals(codeString)) 12549 return FHIRVersion._0_01; 12550 if ("0.05".equals(codeString)) 12551 return FHIRVersion._0_05; 12552 if ("0.06".equals(codeString)) 12553 return FHIRVersion._0_06; 12554 if ("0.11".equals(codeString)) 12555 return FHIRVersion._0_11; 12556 if ("0.0".equals(codeString)) 12557 return FHIRVersion._0_0; 12558 if ("0.0.80".equals(codeString)) 12559 return FHIRVersion._0_0_80; 12560 if ("0.0.81".equals(codeString)) 12561 return FHIRVersion._0_0_81; 12562 if ("0.0.82".equals(codeString)) 12563 return FHIRVersion._0_0_82; 12564 if ("0.4".equals(codeString)) 12565 return FHIRVersion._0_4; 12566 if ("0.4.0".equals(codeString)) 12567 return FHIRVersion._0_4_0; 12568 if ("0.5".equals(codeString)) 12569 return FHIRVersion._0_5; 12570 if ("0.5.0".equals(codeString)) 12571 return FHIRVersion._0_5_0; 12572 if ("1.0".equals(codeString)) 12573 return FHIRVersion._1_0; 12574 if ("1.0.0".equals(codeString)) 12575 return FHIRVersion._1_0_0; 12576 if ("1.0.1".equals(codeString)) 12577 return FHIRVersion._1_0_1; 12578 if ("1.0.2".equals(codeString)) 12579 return FHIRVersion._1_0_2; 12580 if ("1.1".equals(codeString)) 12581 return FHIRVersion._1_1; 12582 if ("1.1.0".equals(codeString)) 12583 return FHIRVersion._1_1_0; 12584 if ("1.4".equals(codeString)) 12585 return FHIRVersion._1_4; 12586 if ("1.4.0".equals(codeString)) 12587 return FHIRVersion._1_4_0; 12588 if ("1.6".equals(codeString)) 12589 return FHIRVersion._1_6; 12590 if ("1.6.0".equals(codeString)) 12591 return FHIRVersion._1_6_0; 12592 if ("1.8".equals(codeString)) 12593 return FHIRVersion._1_8; 12594 if ("1.8.0".equals(codeString)) 12595 return FHIRVersion._1_8_0; 12596 if ("3.0".equals(codeString)) 12597 return FHIRVersion._3_0; 12598 if ("3.0.0".equals(codeString)) 12599 return FHIRVersion._3_0_0; 12600 if ("3.0.1".equals(codeString)) 12601 return FHIRVersion._3_0_1; 12602 if ("3.0.2".equals(codeString)) 12603 return FHIRVersion._3_0_2; 12604 if ("3.3".equals(codeString)) 12605 return FHIRVersion._3_3; 12606 if ("3.3.0".equals(codeString)) 12607 return FHIRVersion._3_3_0; 12608 if ("3.5".equals(codeString)) 12609 return FHIRVersion._3_5; 12610 if ("3.5.0".equals(codeString)) 12611 return FHIRVersion._3_5_0; 12612 if ("4.0".equals(codeString)) 12613 return FHIRVersion._4_0; 12614 if ("4.0.0".equals(codeString)) 12615 return FHIRVersion._4_0_0; 12616 if ("4.0.1".equals(codeString)) 12617 return FHIRVersion._4_0_1; 12618 if ("4.1".equals(codeString)) 12619 return FHIRVersion._4_1; 12620 if ("4.1.0".equals(codeString)) 12621 return FHIRVersion._4_1_0; 12622 if ("4.2".equals(codeString)) 12623 return FHIRVersion._4_2; 12624 if ("4.2.0".equals(codeString)) 12625 return FHIRVersion._4_2_0; 12626 if ("4.3".equals(codeString)) 12627 return FHIRVersion._4_3; 12628 if ("4.3.0".equals(codeString)) 12629 return FHIRVersion._4_3_0; 12630 if ("4.3.0-cibuild".equals(codeString)) 12631 return FHIRVersion._4_3_0CIBUILD; 12632 if ("4.3.0-snapshot1".equals(codeString)) 12633 return FHIRVersion._4_3_0SNAPSHOT1; 12634 if ("4.4".equals(codeString)) 12635 return FHIRVersion._4_4; 12636 if ("4.4.0".equals(codeString)) 12637 return FHIRVersion._4_4_0; 12638 if ("4.5".equals(codeString)) 12639 return FHIRVersion._4_5; 12640 if ("4.5.0".equals(codeString)) 12641 return FHIRVersion._4_5_0; 12642 if ("4.6".equals(codeString)) 12643 return FHIRVersion._4_6; 12644 if ("4.6.0".equals(codeString)) 12645 return FHIRVersion._4_6_0; 12646 if ("5.0".equals(codeString)) 12647 return FHIRVersion._5_0; 12648 if ("5.0.0".equals(codeString)) 12649 return FHIRVersion._5_0_0; 12650 if ("5.0.0-cibuild".equals(codeString)) 12651 return FHIRVersion._5_0_0CIBUILD; 12652 if ("5.0.0-snapshot1".equals(codeString)) 12653 return FHIRVersion._5_0_0SNAPSHOT1; 12654 if ("5.0.0-snapshot2".equals(codeString)) 12655 return FHIRVersion._5_0_0SNAPSHOT2; 12656 if ("5.0.0-ballot".equals(codeString)) 12657 return FHIRVersion._5_0_0BALLOT; 12658 if ("5.0.0-snapshot3".equals(codeString)) 12659 return FHIRVersion._5_0_0SNAPSHOT3; 12660 if ("5.0.0-draft-final".equals(codeString)) 12661 return FHIRVersion._5_0_0DRAFTFINAL; 12662 if ("6.0.0-cibuild".equals(codeString)) 12663 return FHIRVersion._6_0_0CIBUILD; 12664 if ("6.0.0".equals(codeString)) 12665 return FHIRVersion._6_0_0; 12666 if ("6.0.0-ballot1".equals(codeString)) 12667 return FHIRVersion._6_0_0_BALLOT1; 12668 if ("6.0.0-ballot2".equals(codeString)) 12669 return FHIRVersion._6_0_0_BALLOT2; 12670 if ("6.0.0-ballot3".equals(codeString)) 12671 return FHIRVersion._6_0_0_BALLOT3; 12672 throw new IllegalArgumentException("Unknown FHIRVersion code '"+codeString+"'"); 12673 } 12674 12675 public Enumeration<FHIRVersion> fromType(PrimitiveType<?> code) throws FHIRException { 12676 if (code == null) 12677 return null; 12678 if (code.isEmpty()) 12679 return new Enumeration<FHIRVersion>(this, FHIRVersion.NULL, code); 12680 String codeString = ((PrimitiveType) code).asStringValue(); 12681 if (codeString == null || "".equals(codeString)) 12682 return new Enumeration<FHIRVersion>(this, FHIRVersion.NULL, code); 12683 if ("0.01".equals(codeString)) 12684 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_01, code); 12685 if ("0.05".equals(codeString)) 12686 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_05, code); 12687 if ("0.06".equals(codeString)) 12688 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_06, code); 12689 if ("0.11".equals(codeString)) 12690 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_11, code); 12691 if ("0.0".equals(codeString)) 12692 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_0, code); 12693 if ("0.0.80".equals(codeString)) 12694 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_0_80, code); 12695 if ("0.0.81".equals(codeString)) 12696 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_0_81, code); 12697 if ("0.0.82".equals(codeString)) 12698 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_0_82, code); 12699 if ("0.4".equals(codeString)) 12700 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_4, code); 12701 if ("0.4.0".equals(codeString)) 12702 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_4_0, code); 12703 if ("0.5".equals(codeString)) 12704 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_5, code); 12705 if ("0.5.0".equals(codeString)) 12706 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_5_0, code); 12707 if ("1.0".equals(codeString)) 12708 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_0, code); 12709 if ("1.0.0".equals(codeString)) 12710 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_0_0, code); 12711 if ("1.0.1".equals(codeString)) 12712 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_0_1, code); 12713 if ("1.0.2".equals(codeString)) 12714 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_0_2, code); 12715 if ("1.1".equals(codeString)) 12716 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_1, code); 12717 if ("1.1.0".equals(codeString)) 12718 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_1_0, code); 12719 if ("1.4".equals(codeString)) 12720 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_4, code); 12721 if ("1.4.0".equals(codeString)) 12722 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_4_0, code); 12723 if ("1.6".equals(codeString)) 12724 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_6, code); 12725 if ("1.6.0".equals(codeString)) 12726 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_6_0, code); 12727 if ("1.8".equals(codeString)) 12728 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_8, code); 12729 if ("1.8.0".equals(codeString)) 12730 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_8_0, code); 12731 if ("3.0".equals(codeString)) 12732 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_0, code); 12733 if ("3.0.0".equals(codeString)) 12734 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_0_0, code); 12735 if ("3.0.1".equals(codeString)) 12736 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_0_1, code); 12737 if ("3.0.2".equals(codeString)) 12738 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_0_2, code); 12739 if ("3.3".equals(codeString)) 12740 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_3, code); 12741 if ("3.3.0".equals(codeString)) 12742 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_3_0, code); 12743 if ("3.5".equals(codeString)) 12744 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_5, code); 12745 if ("3.5.0".equals(codeString)) 12746 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_5_0, code); 12747 if ("4.0".equals(codeString)) 12748 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_0, code); 12749 if ("4.0.0".equals(codeString)) 12750 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_0_0, code); 12751 if ("4.0.1".equals(codeString)) 12752 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_0_1, code); 12753 if ("4.1".equals(codeString)) 12754 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_1, code); 12755 if ("4.1.0".equals(codeString)) 12756 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_1_0, code); 12757 if ("4.2".equals(codeString)) 12758 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_2, code); 12759 if ("4.2.0".equals(codeString)) 12760 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_2_0, code); 12761 if ("4.3".equals(codeString)) 12762 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_3, code); 12763 if ("4.3.0".equals(codeString)) 12764 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_3_0, code); 12765 if ("4.3.0-cibuild".equals(codeString)) 12766 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_3_0CIBUILD, code); 12767 if ("4.3.0-snapshot1".equals(codeString)) 12768 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_3_0SNAPSHOT1, code); 12769 if ("4.4".equals(codeString)) 12770 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_4, code); 12771 if ("4.4.0".equals(codeString)) 12772 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_4_0, code); 12773 if ("4.5".equals(codeString)) 12774 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_5, code); 12775 if ("4.5.0".equals(codeString)) 12776 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_5_0, code); 12777 if ("4.6".equals(codeString)) 12778 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_6, code); 12779 if ("4.6.0".equals(codeString)) 12780 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_6_0, code); 12781 if ("5.0".equals(codeString)) 12782 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0, code); 12783 if ("5.0.0".equals(codeString)) 12784 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0, code); 12785 if ("5.0.0-cibuild".equals(codeString)) 12786 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0CIBUILD, code); 12787 if ("5.0.0-snapshot1".equals(codeString)) 12788 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0SNAPSHOT1, code); 12789 if ("5.0.0-snapshot2".equals(codeString)) 12790 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0SNAPSHOT2, code); 12791 if ("5.0.0-ballot".equals(codeString)) 12792 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0BALLOT, code); 12793 if ("5.0.0-snapshot3".equals(codeString)) 12794 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0SNAPSHOT3, code); 12795 if ("5.0.0-draft-final".equals(codeString)) 12796 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0DRAFTFINAL, code); 12797 if ("6.0.0-cibuild".equals(codeString)) 12798 return new Enumeration<FHIRVersion>(this, FHIRVersion._6_0_0CIBUILD, code); 12799 if ("6.0.0".equals(codeString)) 12800 return new Enumeration<FHIRVersion>(this, FHIRVersion._6_0_0, code); 12801 if ("6.0.0-ballot1".equals(codeString)) 12802 return new Enumeration<FHIRVersion>(this, FHIRVersion._6_0_0_BALLOT1, code); 12803 if ("6.0.0-ballot2".equals(codeString)) 12804 return new Enumeration<FHIRVersion>(this, FHIRVersion._6_0_0_BALLOT2, code); 12805 if ("6.0.0-ballot3".equals(codeString)) 12806 return new Enumeration<FHIRVersion>(this, FHIRVersion._6_0_0_BALLOT3, code); 12807 throw new FHIRException("Unknown FHIRVersion code '"+codeString+"'"); 12808 } 12809 public String toCode(FHIRVersion code) { 12810 if (code == FHIRVersion.NULL) 12811 return null; 12812 if (code == FHIRVersion._0_01) 12813 return "0.01"; 12814 if (code == FHIRVersion._0_05) 12815 return "0.05"; 12816 if (code == FHIRVersion._0_06) 12817 return "0.06"; 12818 if (code == FHIRVersion._0_11) 12819 return "0.11"; 12820 if (code == FHIRVersion._0_0) 12821 return "0.0"; 12822 if (code == FHIRVersion._0_0_80) 12823 return "0.0.80"; 12824 if (code == FHIRVersion._0_0_81) 12825 return "0.0.81"; 12826 if (code == FHIRVersion._0_0_82) 12827 return "0.0.82"; 12828 if (code == FHIRVersion._0_4) 12829 return "0.4"; 12830 if (code == FHIRVersion._0_4_0) 12831 return "0.4.0"; 12832 if (code == FHIRVersion._0_5) 12833 return "0.5"; 12834 if (code == FHIRVersion._0_5_0) 12835 return "0.5.0"; 12836 if (code == FHIRVersion._1_0) 12837 return "1.0"; 12838 if (code == FHIRVersion._1_0_0) 12839 return "1.0.0"; 12840 if (code == FHIRVersion._1_0_1) 12841 return "1.0.1"; 12842 if (code == FHIRVersion._1_0_2) 12843 return "1.0.2"; 12844 if (code == FHIRVersion._1_1) 12845 return "1.1"; 12846 if (code == FHIRVersion._1_1_0) 12847 return "1.1.0"; 12848 if (code == FHIRVersion._1_4) 12849 return "1.4"; 12850 if (code == FHIRVersion._1_4_0) 12851 return "1.4.0"; 12852 if (code == FHIRVersion._1_6) 12853 return "1.6"; 12854 if (code == FHIRVersion._1_6_0) 12855 return "1.6.0"; 12856 if (code == FHIRVersion._1_8) 12857 return "1.8"; 12858 if (code == FHIRVersion._1_8_0) 12859 return "1.8.0"; 12860 if (code == FHIRVersion._3_0) 12861 return "3.0"; 12862 if (code == FHIRVersion._3_0_0) 12863 return "3.0.0"; 12864 if (code == FHIRVersion._3_0_1) 12865 return "3.0.1"; 12866 if (code == FHIRVersion._3_0_2) 12867 return "3.0.2"; 12868 if (code == FHIRVersion._3_3) 12869 return "3.3"; 12870 if (code == FHIRVersion._3_3_0) 12871 return "3.3.0"; 12872 if (code == FHIRVersion._3_5) 12873 return "3.5"; 12874 if (code == FHIRVersion._3_5_0) 12875 return "3.5.0"; 12876 if (code == FHIRVersion._4_0) 12877 return "4.0"; 12878 if (code == FHIRVersion._4_0_0) 12879 return "4.0.0"; 12880 if (code == FHIRVersion._4_0_1) 12881 return "4.0.1"; 12882 if (code == FHIRVersion._4_1) 12883 return "4.1"; 12884 if (code == FHIRVersion._4_1_0) 12885 return "4.1.0"; 12886 if (code == FHIRVersion._4_2) 12887 return "4.2"; 12888 if (code == FHIRVersion._4_2_0) 12889 return "4.2.0"; 12890 if (code == FHIRVersion._4_3) 12891 return "4.3"; 12892 if (code == FHIRVersion._4_3_0) 12893 return "4.3.0"; 12894 if (code == FHIRVersion._4_3_0CIBUILD) 12895 return "4.3.0-cibuild"; 12896 if (code == FHIRVersion._4_3_0SNAPSHOT1) 12897 return "4.3.0-snapshot1"; 12898 if (code == FHIRVersion._4_4) 12899 return "4.4"; 12900 if (code == FHIRVersion._4_4_0) 12901 return "4.4.0"; 12902 if (code == FHIRVersion._4_5) 12903 return "4.5"; 12904 if (code == FHIRVersion._4_5_0) 12905 return "4.5.0"; 12906 if (code == FHIRVersion._4_6) 12907 return "4.6"; 12908 if (code == FHIRVersion._4_6_0) 12909 return "4.6.0"; 12910 if (code == FHIRVersion._5_0) 12911 return "5.0"; 12912 if (code == FHIRVersion._5_0_0) 12913 return "5.0.0"; 12914 if (code == FHIRVersion._5_0_0CIBUILD) 12915 return "5.0.0-cibuild"; 12916 if (code == FHIRVersion._5_0_0SNAPSHOT1) 12917 return "5.0.0-snapshot1"; 12918 if (code == FHIRVersion._5_0_0SNAPSHOT2) 12919 return "5.0.0-snapshot2"; 12920 if (code == FHIRVersion._5_0_0BALLOT) 12921 return "5.0.0-ballot"; 12922 if (code == FHIRVersion._5_0_0SNAPSHOT3) 12923 return "5.0.0-snapshot3"; 12924 if (code == FHIRVersion._5_0_0DRAFTFINAL) 12925 return "5.0.0-draft-final"; 12926 if (code == FHIRVersion._6_0_0CIBUILD) 12927 return "6.0.0-cibuild"; 12928 if (code == FHIRVersion._6_0_0) 12929 return "6.0.0"; 12930 if (code == FHIRVersion._6_0_0_BALLOT1) { 12931 return "6.0.0-ballot1"; 12932 } 12933 if (code == FHIRVersion._6_0_0_BALLOT2) { 12934 return "6.0.0-ballot2"; 12935 } 12936 if (code == FHIRVersion._6_0_0_BALLOT3) { 12937 return "6.0.0-ballot3"; 12938 } 12939 return "?"; 12940 } 12941 public String toSystem(FHIRVersion code) { 12942 return code.getSystem(); 12943 } 12944 } 12945 12946 public enum FilterOperator { 12947 /** 12948 * The specified property of the code equals the provided value. 12949 */ 12950 EQUAL, 12951 /** 12952 * 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). 12953 */ 12954 ISA, 12955 /** 12956 * 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). 12957 */ 12958 DESCENDENTOF, 12959 /** 12960 * The specified property of the code does not have an is-a relationship with the provided value. 12961 */ 12962 ISNOTA, 12963 /** 12964 * The specified property of the code matches the regex specified in the provided value. 12965 */ 12966 REGEX, 12967 /** 12968 * The specified property of the code is in the set of codes or concepts specified in the provided value (comma-separated list). 12969 */ 12970 IN, 12971 /** 12972 * The specified property of the code is not in the set of codes or concepts specified in the provided value (comma-separated list). 12973 */ 12974 NOTIN, 12975 /** 12976 * 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). 12977 */ 12978 GENERALIZES, 12979 /** 12980 * 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. 12981 */ 12982 CHILDOF, 12983 /** 12984 * 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. 12985 */ 12986 DESCENDENTLEAF, 12987 /** 12988 * 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). 12989 */ 12990 EXISTS, 12991 /** 12992 * added to help the parsers 12993 */ 12994 NULL; 12995 public static FilterOperator fromCode(String codeString) throws FHIRException { 12996 if (codeString == null || "".equals(codeString)) 12997 return null; 12998 if ("=".equals(codeString)) 12999 return EQUAL; 13000 if ("is-a".equals(codeString)) 13001 return ISA; 13002 if ("descendent-of".equals(codeString)) 13003 return DESCENDENTOF; 13004 if ("is-not-a".equals(codeString)) 13005 return ISNOTA; 13006 if ("regex".equals(codeString)) 13007 return REGEX; 13008 if ("in".equals(codeString)) 13009 return IN; 13010 if ("not-in".equals(codeString)) 13011 return NOTIN; 13012 if ("generalizes".equals(codeString)) 13013 return GENERALIZES; 13014 if ("child-of".equals(codeString)) 13015 return CHILDOF; 13016 if ("descendent-leaf".equals(codeString)) 13017 return DESCENDENTLEAF; 13018 if ("exists".equals(codeString)) 13019 return EXISTS; 13020 throw new FHIRException("Unknown FilterOperator code '"+codeString+"'"); 13021 } 13022 public static boolean isValidCode(String codeString) { 13023 if (codeString == null || "".equals(codeString)) 13024 return false; 13025 return Utilities.existsInList(codeString, "=", "is-a", "descendent-of", "is-not-a", "regex", "in", "not-in", "generalizes", "child-of", "descendent-leaf", "exists"); 13026 } 13027 public String toCode() { 13028 switch (this) { 13029 case EQUAL: return "="; 13030 case ISA: return "is-a"; 13031 case DESCENDENTOF: return "descendent-of"; 13032 case ISNOTA: return "is-not-a"; 13033 case REGEX: return "regex"; 13034 case IN: return "in"; 13035 case NOTIN: return "not-in"; 13036 case GENERALIZES: return "generalizes"; 13037 case CHILDOF: return "child-of"; 13038 case DESCENDENTLEAF: return "descendent-leaf"; 13039 case EXISTS: return "exists"; 13040 case NULL: return null; 13041 default: return "?"; 13042 } 13043 } 13044 public String getSystem() { 13045 switch (this) { 13046 case EQUAL: return "http://hl7.org/fhir/filter-operator"; 13047 case ISA: return "http://hl7.org/fhir/filter-operator"; 13048 case DESCENDENTOF: return "http://hl7.org/fhir/filter-operator"; 13049 case ISNOTA: return "http://hl7.org/fhir/filter-operator"; 13050 case REGEX: return "http://hl7.org/fhir/filter-operator"; 13051 case IN: return "http://hl7.org/fhir/filter-operator"; 13052 case NOTIN: return "http://hl7.org/fhir/filter-operator"; 13053 case GENERALIZES: return "http://hl7.org/fhir/filter-operator"; 13054 case CHILDOF: return "http://hl7.org/fhir/filter-operator"; 13055 case DESCENDENTLEAF: return "http://hl7.org/fhir/filter-operator"; 13056 case EXISTS: return "http://hl7.org/fhir/filter-operator"; 13057 case NULL: return null; 13058 default: return "?"; 13059 } 13060 } 13061 public String getDefinition() { 13062 switch (this) { 13063 case EQUAL: return "The specified property of the code equals the provided value."; 13064 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)."; 13065 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)."; 13066 case ISNOTA: return "The specified property of the code does not have an is-a relationship with the provided value."; 13067 case REGEX: return "The specified property of the code matches the regex specified in the provided value."; 13068 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)."; 13069 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)."; 13070 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)."; 13071 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."; 13072 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."; 13073 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)."; 13074 case NULL: return null; 13075 default: return "?"; 13076 } 13077 } 13078 public String getDisplay() { 13079 switch (this) { 13080 case EQUAL: return "Equals"; 13081 case ISA: return "Is A (by subsumption)"; 13082 case DESCENDENTOF: return "Descendent Of (by subsumption)"; 13083 case ISNOTA: return "Not (Is A) (by subsumption)"; 13084 case REGEX: return "Regular Expression"; 13085 case IN: return "In Set"; 13086 case NOTIN: return "Not in Set"; 13087 case GENERALIZES: return "Generalizes (by Subsumption)"; 13088 case CHILDOF: return "Child Of"; 13089 case DESCENDENTLEAF: return "Descendent Leaf"; 13090 case EXISTS: return "Exists"; 13091 case NULL: return null; 13092 default: return "?"; 13093 } 13094 } 13095 } 13096 13097 public static class FilterOperatorEnumFactory implements EnumFactory<FilterOperator> { 13098 public FilterOperator fromCode(String codeString) throws IllegalArgumentException { 13099 if (codeString == null || "".equals(codeString)) 13100 if (codeString == null || "".equals(codeString)) 13101 return null; 13102 if ("=".equals(codeString)) 13103 return FilterOperator.EQUAL; 13104 if ("is-a".equals(codeString)) 13105 return FilterOperator.ISA; 13106 if ("descendent-of".equals(codeString)) 13107 return FilterOperator.DESCENDENTOF; 13108 if ("is-not-a".equals(codeString)) 13109 return FilterOperator.ISNOTA; 13110 if ("regex".equals(codeString)) 13111 return FilterOperator.REGEX; 13112 if ("in".equals(codeString)) 13113 return FilterOperator.IN; 13114 if ("not-in".equals(codeString)) 13115 return FilterOperator.NOTIN; 13116 if ("generalizes".equals(codeString)) 13117 return FilterOperator.GENERALIZES; 13118 if ("child-of".equals(codeString)) 13119 return FilterOperator.CHILDOF; 13120 if ("descendent-leaf".equals(codeString)) 13121 return FilterOperator.DESCENDENTLEAF; 13122 if ("exists".equals(codeString)) 13123 return FilterOperator.EXISTS; 13124 throw new IllegalArgumentException("Unknown FilterOperator code '"+codeString+"'"); 13125 } 13126 13127 public Enumeration<FilterOperator> fromType(PrimitiveType<?> code) throws FHIRException { 13128 if (code == null) 13129 return null; 13130 if (code.isEmpty()) 13131 return new Enumeration<FilterOperator>(this, FilterOperator.NULL, code); 13132 String codeString = ((PrimitiveType) code).asStringValue(); 13133 if (codeString == null || "".equals(codeString)) 13134 return new Enumeration<FilterOperator>(this, FilterOperator.NULL, code); 13135 if ("=".equals(codeString)) 13136 return new Enumeration<FilterOperator>(this, FilterOperator.EQUAL, code); 13137 if ("is-a".equals(codeString)) 13138 return new Enumeration<FilterOperator>(this, FilterOperator.ISA, code); 13139 if ("descendent-of".equals(codeString)) 13140 return new Enumeration<FilterOperator>(this, FilterOperator.DESCENDENTOF, code); 13141 if ("is-not-a".equals(codeString)) 13142 return new Enumeration<FilterOperator>(this, FilterOperator.ISNOTA, code); 13143 if ("regex".equals(codeString)) 13144 return new Enumeration<FilterOperator>(this, FilterOperator.REGEX, code); 13145 if ("in".equals(codeString)) 13146 return new Enumeration<FilterOperator>(this, FilterOperator.IN, code); 13147 if ("not-in".equals(codeString)) 13148 return new Enumeration<FilterOperator>(this, FilterOperator.NOTIN, code); 13149 if ("generalizes".equals(codeString)) 13150 return new Enumeration<FilterOperator>(this, FilterOperator.GENERALIZES, code); 13151 if ("child-of".equals(codeString)) 13152 return new Enumeration<FilterOperator>(this, FilterOperator.CHILDOF, code); 13153 if ("descendent-leaf".equals(codeString)) 13154 return new Enumeration<FilterOperator>(this, FilterOperator.DESCENDENTLEAF, code); 13155 if ("exists".equals(codeString)) 13156 return new Enumeration<FilterOperator>(this, FilterOperator.EXISTS, code); 13157 throw new FHIRException("Unknown FilterOperator code '"+codeString+"'"); 13158 } 13159 public String toCode(FilterOperator code) { 13160 if (code == FilterOperator.NULL) 13161 return null; 13162 if (code == FilterOperator.EQUAL) 13163 return "="; 13164 if (code == FilterOperator.ISA) 13165 return "is-a"; 13166 if (code == FilterOperator.DESCENDENTOF) 13167 return "descendent-of"; 13168 if (code == FilterOperator.ISNOTA) 13169 return "is-not-a"; 13170 if (code == FilterOperator.REGEX) 13171 return "regex"; 13172 if (code == FilterOperator.IN) 13173 return "in"; 13174 if (code == FilterOperator.NOTIN) 13175 return "not-in"; 13176 if (code == FilterOperator.GENERALIZES) 13177 return "generalizes"; 13178 if (code == FilterOperator.CHILDOF) 13179 return "child-of"; 13180 if (code == FilterOperator.DESCENDENTLEAF) 13181 return "descendent-leaf"; 13182 if (code == FilterOperator.EXISTS) 13183 return "exists"; 13184 return "?"; 13185 } 13186 public String toSystem(FilterOperator code) { 13187 return code.getSystem(); 13188 } 13189 } 13190 13191 public enum FinancialResourceStatusCodes { 13192 /** 13193 * The instance is currently in-force. 13194 */ 13195 ACTIVE, 13196 /** 13197 * The instance is withdrawn, rescinded or reversed. 13198 */ 13199 CANCELLED, 13200 /** 13201 * A new instance the contents of which is not complete. 13202 */ 13203 DRAFT, 13204 /** 13205 * The instance was entered in error. 13206 */ 13207 ENTEREDINERROR, 13208 /** 13209 * added to help the parsers 13210 */ 13211 NULL; 13212 public static FinancialResourceStatusCodes fromCode(String codeString) throws FHIRException { 13213 if (codeString == null || "".equals(codeString)) 13214 return null; 13215 if ("active".equals(codeString)) 13216 return ACTIVE; 13217 if ("cancelled".equals(codeString)) 13218 return CANCELLED; 13219 if ("draft".equals(codeString)) 13220 return DRAFT; 13221 if ("entered-in-error".equals(codeString)) 13222 return ENTEREDINERROR; 13223 throw new FHIRException("Unknown FinancialResourceStatusCodes code '"+codeString+"'"); 13224 } 13225 public static boolean isValidCode(String codeString) { 13226 if (codeString == null || "".equals(codeString)) 13227 return false; 13228 return Utilities.existsInList(codeString, "active", "cancelled", "draft", "entered-in-error"); 13229 } 13230 public String toCode() { 13231 switch (this) { 13232 case ACTIVE: return "active"; 13233 case CANCELLED: return "cancelled"; 13234 case DRAFT: return "draft"; 13235 case ENTEREDINERROR: return "entered-in-error"; 13236 case NULL: return null; 13237 default: return "?"; 13238 } 13239 } 13240 public String getSystem() { 13241 switch (this) { 13242 case ACTIVE: return "http://hl7.org/fhir/fm-status"; 13243 case CANCELLED: return "http://hl7.org/fhir/fm-status"; 13244 case DRAFT: return "http://hl7.org/fhir/fm-status"; 13245 case ENTEREDINERROR: return "http://hl7.org/fhir/fm-status"; 13246 case NULL: return null; 13247 default: return "?"; 13248 } 13249 } 13250 public String getDefinition() { 13251 switch (this) { 13252 case ACTIVE: return "The instance is currently in-force."; 13253 case CANCELLED: return "The instance is withdrawn, rescinded or reversed."; 13254 case DRAFT: return "A new instance the contents of which is not complete."; 13255 case ENTEREDINERROR: return "The instance was entered in error."; 13256 case NULL: return null; 13257 default: return "?"; 13258 } 13259 } 13260 public String getDisplay() { 13261 switch (this) { 13262 case ACTIVE: return "Active"; 13263 case CANCELLED: return "Cancelled"; 13264 case DRAFT: return "Draft"; 13265 case ENTEREDINERROR: return "Entered in Error"; 13266 case NULL: return null; 13267 default: return "?"; 13268 } 13269 } 13270 } 13271 13272 public static class FinancialResourceStatusCodesEnumFactory implements EnumFactory<FinancialResourceStatusCodes> { 13273 public FinancialResourceStatusCodes fromCode(String codeString) throws IllegalArgumentException { 13274 if (codeString == null || "".equals(codeString)) 13275 if (codeString == null || "".equals(codeString)) 13276 return null; 13277 if ("active".equals(codeString)) 13278 return FinancialResourceStatusCodes.ACTIVE; 13279 if ("cancelled".equals(codeString)) 13280 return FinancialResourceStatusCodes.CANCELLED; 13281 if ("draft".equals(codeString)) 13282 return FinancialResourceStatusCodes.DRAFT; 13283 if ("entered-in-error".equals(codeString)) 13284 return FinancialResourceStatusCodes.ENTEREDINERROR; 13285 throw new IllegalArgumentException("Unknown FinancialResourceStatusCodes code '"+codeString+"'"); 13286 } 13287 13288 public Enumeration<FinancialResourceStatusCodes> fromType(PrimitiveType<?> code) throws FHIRException { 13289 if (code == null) 13290 return null; 13291 if (code.isEmpty()) 13292 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.NULL, code); 13293 String codeString = ((PrimitiveType) code).asStringValue(); 13294 if (codeString == null || "".equals(codeString)) 13295 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.NULL, code); 13296 if ("active".equals(codeString)) 13297 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.ACTIVE, code); 13298 if ("cancelled".equals(codeString)) 13299 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.CANCELLED, code); 13300 if ("draft".equals(codeString)) 13301 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.DRAFT, code); 13302 if ("entered-in-error".equals(codeString)) 13303 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.ENTEREDINERROR, code); 13304 throw new FHIRException("Unknown FinancialResourceStatusCodes code '"+codeString+"'"); 13305 } 13306 public String toCode(FinancialResourceStatusCodes code) { 13307 if (code == FinancialResourceStatusCodes.NULL) 13308 return null; 13309 if (code == FinancialResourceStatusCodes.ACTIVE) 13310 return "active"; 13311 if (code == FinancialResourceStatusCodes.CANCELLED) 13312 return "cancelled"; 13313 if (code == FinancialResourceStatusCodes.DRAFT) 13314 return "draft"; 13315 if (code == FinancialResourceStatusCodes.ENTEREDINERROR) 13316 return "entered-in-error"; 13317 return "?"; 13318 } 13319 public String toSystem(FinancialResourceStatusCodes code) { 13320 return code.getSystem(); 13321 } 13322 } 13323 13324 public enum ListMode { 13325 /** 13326 * This list is the master list, maintained in an ongoing fashion with regular updates as the real-world list it is tracking changes. 13327 */ 13328 WORKING, 13329 /** 13330 * This list was prepared as a snapshot. It should not be assumed to be current. 13331 */ 13332 SNAPSHOT, 13333 /** 13334 * 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. 13335 */ 13336 CHANGES, 13337 /** 13338 * added to help the parsers 13339 */ 13340 NULL; 13341 public static ListMode fromCode(String codeString) throws FHIRException { 13342 if (codeString == null || "".equals(codeString)) 13343 return null; 13344 if ("working".equals(codeString)) 13345 return WORKING; 13346 if ("snapshot".equals(codeString)) 13347 return SNAPSHOT; 13348 if ("changes".equals(codeString)) 13349 return CHANGES; 13350 throw new FHIRException("Unknown ListMode code '"+codeString+"'"); 13351 } 13352 public static boolean isValidCode(String codeString) { 13353 if (codeString == null || "".equals(codeString)) 13354 return false; 13355 return Utilities.existsInList(codeString, "working", "snapshot", "changes"); 13356 } 13357 public String toCode() { 13358 switch (this) { 13359 case WORKING: return "working"; 13360 case SNAPSHOT: return "snapshot"; 13361 case CHANGES: return "changes"; 13362 case NULL: return null; 13363 default: return "?"; 13364 } 13365 } 13366 public String getSystem() { 13367 switch (this) { 13368 case WORKING: return "http://hl7.org/fhir/list-mode"; 13369 case SNAPSHOT: return "http://hl7.org/fhir/list-mode"; 13370 case CHANGES: return "http://hl7.org/fhir/list-mode"; 13371 case NULL: return null; 13372 default: return "?"; 13373 } 13374 } 13375 public String getDefinition() { 13376 switch (this) { 13377 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."; 13378 case SNAPSHOT: return "This list was prepared as a snapshot. It should not be assumed to be current."; 13379 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."; 13380 case NULL: return null; 13381 default: return "?"; 13382 } 13383 } 13384 public String getDisplay() { 13385 switch (this) { 13386 case WORKING: return "Working List"; 13387 case SNAPSHOT: return "Snapshot List"; 13388 case CHANGES: return "Change List"; 13389 case NULL: return null; 13390 default: return "?"; 13391 } 13392 } 13393 } 13394 13395 public static class ListModeEnumFactory implements EnumFactory<ListMode> { 13396 public ListMode fromCode(String codeString) throws IllegalArgumentException { 13397 if (codeString == null || "".equals(codeString)) 13398 if (codeString == null || "".equals(codeString)) 13399 return null; 13400 if ("working".equals(codeString)) 13401 return ListMode.WORKING; 13402 if ("snapshot".equals(codeString)) 13403 return ListMode.SNAPSHOT; 13404 if ("changes".equals(codeString)) 13405 return ListMode.CHANGES; 13406 throw new IllegalArgumentException("Unknown ListMode code '"+codeString+"'"); 13407 } 13408 13409 public Enumeration<ListMode> fromType(PrimitiveType<?> code) throws FHIRException { 13410 if (code == null) 13411 return null; 13412 if (code.isEmpty()) 13413 return new Enumeration<ListMode>(this, ListMode.NULL, code); 13414 String codeString = ((PrimitiveType) code).asStringValue(); 13415 if (codeString == null || "".equals(codeString)) 13416 return new Enumeration<ListMode>(this, ListMode.NULL, code); 13417 if ("working".equals(codeString)) 13418 return new Enumeration<ListMode>(this, ListMode.WORKING, code); 13419 if ("snapshot".equals(codeString)) 13420 return new Enumeration<ListMode>(this, ListMode.SNAPSHOT, code); 13421 if ("changes".equals(codeString)) 13422 return new Enumeration<ListMode>(this, ListMode.CHANGES, code); 13423 throw new FHIRException("Unknown ListMode code '"+codeString+"'"); 13424 } 13425 public String toCode(ListMode code) { 13426 if (code == ListMode.NULL) 13427 return null; 13428 if (code == ListMode.WORKING) 13429 return "working"; 13430 if (code == ListMode.SNAPSHOT) 13431 return "snapshot"; 13432 if (code == ListMode.CHANGES) 13433 return "changes"; 13434 return "?"; 13435 } 13436 public String toSystem(ListMode code) { 13437 return code.getSystem(); 13438 } 13439 } 13440 13441 public enum MeasureImprovementNotation { 13442 /** 13443 * null 13444 */ 13445 INCREASE, 13446 /** 13447 * null 13448 */ 13449 DECREASE, 13450 /** 13451 * added to help the parsers 13452 */ 13453 NULL; 13454 public static MeasureImprovementNotation fromCode(String codeString) throws FHIRException { 13455 if (codeString == null || "".equals(codeString)) 13456 return null; 13457 if ("increase".equals(codeString)) 13458 return INCREASE; 13459 if ("decrease".equals(codeString)) 13460 return DECREASE; 13461 throw new FHIRException("Unknown MeasureImprovementNotation code '"+codeString+"'"); 13462 } 13463 public static boolean isValidCode(String codeString) { 13464 if (codeString == null || "".equals(codeString)) 13465 return false; 13466 return Utilities.existsInList(codeString, "increase", "decrease"); 13467 } 13468 public String toCode() { 13469 switch (this) { 13470 case INCREASE: return "increase"; 13471 case DECREASE: return "decrease"; 13472 case NULL: return null; 13473 default: return "?"; 13474 } 13475 } 13476 public String getSystem() { 13477 switch (this) { 13478 case INCREASE: return "http://terminology.hl7.org/CodeSystem/measure-improvement-notation"; 13479 case DECREASE: return "http://terminology.hl7.org/CodeSystem/measure-improvement-notation"; 13480 case NULL: return null; 13481 default: return "?"; 13482 } 13483 } 13484 public String getDefinition() { 13485 switch (this) { 13486 case INCREASE: return ""; 13487 case DECREASE: return ""; 13488 case NULL: return null; 13489 default: return "?"; 13490 } 13491 } 13492 public String getDisplay() { 13493 switch (this) { 13494 case INCREASE: return "Increased score indicates improvement"; 13495 case DECREASE: return "Decreased score indicates improvement"; 13496 case NULL: return null; 13497 default: return "?"; 13498 } 13499 } 13500 } 13501 13502 public static class MeasureImprovementNotationEnumFactory implements EnumFactory<MeasureImprovementNotation> { 13503 public MeasureImprovementNotation fromCode(String codeString) throws IllegalArgumentException { 13504 if (codeString == null || "".equals(codeString)) 13505 if (codeString == null || "".equals(codeString)) 13506 return null; 13507 if ("increase".equals(codeString)) 13508 return MeasureImprovementNotation.INCREASE; 13509 if ("decrease".equals(codeString)) 13510 return MeasureImprovementNotation.DECREASE; 13511 throw new IllegalArgumentException("Unknown MeasureImprovementNotation code '"+codeString+"'"); 13512 } 13513 13514 public Enumeration<MeasureImprovementNotation> fromType(PrimitiveType<?> code) throws FHIRException { 13515 if (code == null) 13516 return null; 13517 if (code.isEmpty()) 13518 return new Enumeration<MeasureImprovementNotation>(this, MeasureImprovementNotation.NULL, code); 13519 String codeString = ((PrimitiveType) code).asStringValue(); 13520 if (codeString == null || "".equals(codeString)) 13521 return new Enumeration<MeasureImprovementNotation>(this, MeasureImprovementNotation.NULL, code); 13522 if ("increase".equals(codeString)) 13523 return new Enumeration<MeasureImprovementNotation>(this, MeasureImprovementNotation.INCREASE, code); 13524 if ("decrease".equals(codeString)) 13525 return new Enumeration<MeasureImprovementNotation>(this, MeasureImprovementNotation.DECREASE, code); 13526 throw new FHIRException("Unknown MeasureImprovementNotation code '"+codeString+"'"); 13527 } 13528 public String toCode(MeasureImprovementNotation code) { 13529 if (code == MeasureImprovementNotation.NULL) 13530 return null; 13531 if (code == MeasureImprovementNotation.INCREASE) 13532 return "increase"; 13533 if (code == MeasureImprovementNotation.DECREASE) 13534 return "decrease"; 13535 return "?"; 13536 } 13537 public String toSystem(MeasureImprovementNotation code) { 13538 return code.getSystem(); 13539 } 13540 } 13541 13542 public enum MimeTypes { 13543 /** 13544 * added to help the parsers 13545 */ 13546 NULL; 13547 public static MimeTypes fromCode(String codeString) throws FHIRException { 13548 if (codeString == null || "".equals(codeString)) 13549 return null; 13550 throw new FHIRException("Unknown MimeTypes code '"+codeString+"'"); 13551 } 13552 public static boolean isValidCode(String codeString) { 13553 if (codeString == null || "".equals(codeString)) 13554 return false; 13555 return Utilities.existsInList(codeString); 13556 } 13557 public String toCode() { 13558 switch (this) { 13559 case NULL: return null; 13560 default: return "?"; 13561 } 13562 } 13563 public String getSystem() { 13564 switch (this) { 13565 case NULL: return null; 13566 default: return "?"; 13567 } 13568 } 13569 public String getDefinition() { 13570 switch (this) { 13571 case NULL: return null; 13572 default: return "?"; 13573 } 13574 } 13575 public String getDisplay() { 13576 switch (this) { 13577 case NULL: return null; 13578 default: return "?"; 13579 } 13580 } 13581 } 13582 13583 public static class MimeTypesEnumFactory implements EnumFactory<MimeTypes> { 13584 public MimeTypes fromCode(String codeString) throws IllegalArgumentException { 13585 if (codeString == null || "".equals(codeString)) 13586 if (codeString == null || "".equals(codeString)) 13587 return null; 13588 throw new IllegalArgumentException("Unknown MimeTypes code '"+codeString+"'"); 13589 } 13590 13591 public Enumeration<MimeTypes> fromType(PrimitiveType<?> code) throws FHIRException { 13592 if (code == null) 13593 return null; 13594 if (code.isEmpty()) 13595 return new Enumeration<MimeTypes>(this, MimeTypes.NULL, code); 13596 String codeString = ((PrimitiveType) code).asStringValue(); 13597 if (codeString == null || "".equals(codeString)) 13598 return new Enumeration<MimeTypes>(this, MimeTypes.NULL, code); 13599 throw new FHIRException("Unknown MimeTypes code '"+codeString+"'"); 13600 } 13601 public String toCode(MimeTypes code) { 13602 if (code == MimeTypes.NULL) 13603 return null; 13604 return "?"; 13605 } 13606 public String toSystem(MimeTypes code) { 13607 return code.getSystem(); 13608 } 13609 } 13610 13611 public enum ObservationStatus { 13612 /** 13613 * The existence of the observation is registered, but there is no result yet available. 13614 */ 13615 REGISTERED, 13616 /** 13617 * This is an initial or interim observation: data may be incomplete or unverified. 13618 */ 13619 PRELIMINARY, 13620 /** 13621 * 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. 13622 */ 13623 FINAL, 13624 /** 13625 * Subsequent to being Final, the observation has been modified subsequent. This includes updates/new information and corrections. 13626 */ 13627 AMENDED, 13628 /** 13629 * Subsequent to being Final, the observation has been modified to correct an error in the test result. 13630 */ 13631 CORRECTED, 13632 /** 13633 * The observation is unavailable because the measurement was not started or not completed (also sometimes called "aborted"). 13634 */ 13635 CANCELLED, 13636 /** 13637 * 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".). 13638 */ 13639 ENTEREDINERROR, 13640 /** 13641 * 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. 13642 */ 13643 UNKNOWN, 13644 /** 13645 * added to help the parsers 13646 */ 13647 NULL; 13648 public static ObservationStatus fromCode(String codeString) throws FHIRException { 13649 if (codeString == null || "".equals(codeString)) 13650 return null; 13651 if ("registered".equals(codeString)) 13652 return REGISTERED; 13653 if ("preliminary".equals(codeString)) 13654 return PRELIMINARY; 13655 if ("final".equals(codeString)) 13656 return FINAL; 13657 if ("amended".equals(codeString)) 13658 return AMENDED; 13659 if ("corrected".equals(codeString)) 13660 return CORRECTED; 13661 if ("cancelled".equals(codeString)) 13662 return CANCELLED; 13663 if ("entered-in-error".equals(codeString)) 13664 return ENTEREDINERROR; 13665 if ("unknown".equals(codeString)) 13666 return UNKNOWN; 13667 throw new FHIRException("Unknown ObservationStatus code '"+codeString+"'"); 13668 } 13669 public static boolean isValidCode(String codeString) { 13670 if (codeString == null || "".equals(codeString)) 13671 return false; 13672 return Utilities.existsInList(codeString, "registered", "preliminary", "final", "amended", "corrected", "cancelled", "entered-in-error", "unknown"); 13673 } 13674 public String toCode() { 13675 switch (this) { 13676 case REGISTERED: return "registered"; 13677 case PRELIMINARY: return "preliminary"; 13678 case FINAL: return "final"; 13679 case AMENDED: return "amended"; 13680 case CORRECTED: return "corrected"; 13681 case CANCELLED: return "cancelled"; 13682 case ENTEREDINERROR: return "entered-in-error"; 13683 case UNKNOWN: return "unknown"; 13684 case NULL: return null; 13685 default: return "?"; 13686 } 13687 } 13688 public String getSystem() { 13689 switch (this) { 13690 case REGISTERED: return "http://hl7.org/fhir/observation-status"; 13691 case PRELIMINARY: return "http://hl7.org/fhir/observation-status"; 13692 case FINAL: return "http://hl7.org/fhir/observation-status"; 13693 case AMENDED: return "http://hl7.org/fhir/observation-status"; 13694 case CORRECTED: return "http://hl7.org/fhir/observation-status"; 13695 case CANCELLED: return "http://hl7.org/fhir/observation-status"; 13696 case ENTEREDINERROR: return "http://hl7.org/fhir/observation-status"; 13697 case UNKNOWN: return "http://hl7.org/fhir/observation-status"; 13698 case NULL: return null; 13699 default: return "?"; 13700 } 13701 } 13702 public String getDefinition() { 13703 switch (this) { 13704 case REGISTERED: return "The existence of the observation is registered, but there is no result yet available."; 13705 case PRELIMINARY: return "This is an initial or interim observation: data may be incomplete or unverified."; 13706 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."; 13707 case AMENDED: return "Subsequent to being Final, the observation has been modified subsequent. This includes updates/new information and corrections."; 13708 case CORRECTED: return "Subsequent to being Final, the observation has been modified to correct an error in the test result."; 13709 case CANCELLED: return "The observation is unavailable because the measurement was not started or not completed (also sometimes called \"aborted\")."; 13710 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\".)."; 13711 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."; 13712 case NULL: return null; 13713 default: return "?"; 13714 } 13715 } 13716 public String getDisplay() { 13717 switch (this) { 13718 case REGISTERED: return "Registered"; 13719 case PRELIMINARY: return "Preliminary"; 13720 case FINAL: return "Final"; 13721 case AMENDED: return "Amended"; 13722 case CORRECTED: return "Corrected"; 13723 case CANCELLED: return "Cancelled"; 13724 case ENTEREDINERROR: return "Entered in Error"; 13725 case UNKNOWN: return "Unknown"; 13726 case NULL: return null; 13727 default: return "?"; 13728 } 13729 } 13730 } 13731 13732 public static class ObservationStatusEnumFactory implements EnumFactory<ObservationStatus> { 13733 public ObservationStatus fromCode(String codeString) throws IllegalArgumentException { 13734 if (codeString == null || "".equals(codeString)) 13735 if (codeString == null || "".equals(codeString)) 13736 return null; 13737 if ("registered".equals(codeString)) 13738 return ObservationStatus.REGISTERED; 13739 if ("preliminary".equals(codeString)) 13740 return ObservationStatus.PRELIMINARY; 13741 if ("final".equals(codeString)) 13742 return ObservationStatus.FINAL; 13743 if ("amended".equals(codeString)) 13744 return ObservationStatus.AMENDED; 13745 if ("corrected".equals(codeString)) 13746 return ObservationStatus.CORRECTED; 13747 if ("cancelled".equals(codeString)) 13748 return ObservationStatus.CANCELLED; 13749 if ("entered-in-error".equals(codeString)) 13750 return ObservationStatus.ENTEREDINERROR; 13751 if ("unknown".equals(codeString)) 13752 return ObservationStatus.UNKNOWN; 13753 throw new IllegalArgumentException("Unknown ObservationStatus code '"+codeString+"'"); 13754 } 13755 13756 public Enumeration<ObservationStatus> fromType(PrimitiveType<?> code) throws FHIRException { 13757 if (code == null) 13758 return null; 13759 if (code.isEmpty()) 13760 return new Enumeration<ObservationStatus>(this, ObservationStatus.NULL, code); 13761 String codeString = ((PrimitiveType) code).asStringValue(); 13762 if (codeString == null || "".equals(codeString)) 13763 return new Enumeration<ObservationStatus>(this, ObservationStatus.NULL, code); 13764 if ("registered".equals(codeString)) 13765 return new Enumeration<ObservationStatus>(this, ObservationStatus.REGISTERED, code); 13766 if ("preliminary".equals(codeString)) 13767 return new Enumeration<ObservationStatus>(this, ObservationStatus.PRELIMINARY, code); 13768 if ("final".equals(codeString)) 13769 return new Enumeration<ObservationStatus>(this, ObservationStatus.FINAL, code); 13770 if ("amended".equals(codeString)) 13771 return new Enumeration<ObservationStatus>(this, ObservationStatus.AMENDED, code); 13772 if ("corrected".equals(codeString)) 13773 return new Enumeration<ObservationStatus>(this, ObservationStatus.CORRECTED, code); 13774 if ("cancelled".equals(codeString)) 13775 return new Enumeration<ObservationStatus>(this, ObservationStatus.CANCELLED, code); 13776 if ("entered-in-error".equals(codeString)) 13777 return new Enumeration<ObservationStatus>(this, ObservationStatus.ENTEREDINERROR, code); 13778 if ("unknown".equals(codeString)) 13779 return new Enumeration<ObservationStatus>(this, ObservationStatus.UNKNOWN, code); 13780 throw new FHIRException("Unknown ObservationStatus code '"+codeString+"'"); 13781 } 13782 public String toCode(ObservationStatus code) { 13783 if (code == ObservationStatus.NULL) 13784 return null; 13785 if (code == ObservationStatus.REGISTERED) 13786 return "registered"; 13787 if (code == ObservationStatus.PRELIMINARY) 13788 return "preliminary"; 13789 if (code == ObservationStatus.FINAL) 13790 return "final"; 13791 if (code == ObservationStatus.AMENDED) 13792 return "amended"; 13793 if (code == ObservationStatus.CORRECTED) 13794 return "corrected"; 13795 if (code == ObservationStatus.CANCELLED) 13796 return "cancelled"; 13797 if (code == ObservationStatus.ENTEREDINERROR) 13798 return "entered-in-error"; 13799 if (code == ObservationStatus.UNKNOWN) 13800 return "unknown"; 13801 return "?"; 13802 } 13803 public String toSystem(ObservationStatus code) { 13804 return code.getSystem(); 13805 } 13806 } 13807 13808 public enum OperationParameterUse { 13809 /** 13810 * This is an input parameter. 13811 */ 13812 IN, 13813 /** 13814 * This is an output parameter. 13815 */ 13816 OUT, 13817 /** 13818 * added to help the parsers 13819 */ 13820 NULL; 13821 public static OperationParameterUse fromCode(String codeString) throws FHIRException { 13822 if (codeString == null || "".equals(codeString)) 13823 return null; 13824 if ("in".equals(codeString)) 13825 return IN; 13826 if ("out".equals(codeString)) 13827 return OUT; 13828 throw new FHIRException("Unknown OperationParameterUse code '"+codeString+"'"); 13829 } 13830 public static boolean isValidCode(String codeString) { 13831 if (codeString == null || "".equals(codeString)) 13832 return false; 13833 return Utilities.existsInList(codeString, "in", "out"); 13834 } 13835 public String toCode() { 13836 switch (this) { 13837 case IN: return "in"; 13838 case OUT: return "out"; 13839 case NULL: return null; 13840 default: return "?"; 13841 } 13842 } 13843 public String getSystem() { 13844 switch (this) { 13845 case IN: return "http://hl7.org/fhir/operation-parameter-use"; 13846 case OUT: return "http://hl7.org/fhir/operation-parameter-use"; 13847 case NULL: return null; 13848 default: return "?"; 13849 } 13850 } 13851 public String getDefinition() { 13852 switch (this) { 13853 case IN: return "This is an input parameter."; 13854 case OUT: return "This is an output parameter."; 13855 case NULL: return null; 13856 default: return "?"; 13857 } 13858 } 13859 public String getDisplay() { 13860 switch (this) { 13861 case IN: return "In"; 13862 case OUT: return "Out"; 13863 case NULL: return null; 13864 default: return "?"; 13865 } 13866 } 13867 } 13868 13869 public static class OperationParameterUseEnumFactory implements EnumFactory<OperationParameterUse> { 13870 public OperationParameterUse fromCode(String codeString) throws IllegalArgumentException { 13871 if (codeString == null || "".equals(codeString)) 13872 if (codeString == null || "".equals(codeString)) 13873 return null; 13874 if ("in".equals(codeString)) 13875 return OperationParameterUse.IN; 13876 if ("out".equals(codeString)) 13877 return OperationParameterUse.OUT; 13878 throw new IllegalArgumentException("Unknown OperationParameterUse code '"+codeString+"'"); 13879 } 13880 13881 public Enumeration<OperationParameterUse> fromType(PrimitiveType<?> code) throws FHIRException { 13882 if (code == null) 13883 return null; 13884 if (code.isEmpty()) 13885 return new Enumeration<OperationParameterUse>(this, OperationParameterUse.NULL, code); 13886 String codeString = ((PrimitiveType) code).asStringValue(); 13887 if (codeString == null || "".equals(codeString)) 13888 return new Enumeration<OperationParameterUse>(this, OperationParameterUse.NULL, code); 13889 if ("in".equals(codeString)) 13890 return new Enumeration<OperationParameterUse>(this, OperationParameterUse.IN, code); 13891 if ("out".equals(codeString)) 13892 return new Enumeration<OperationParameterUse>(this, OperationParameterUse.OUT, code); 13893 throw new FHIRException("Unknown OperationParameterUse code '"+codeString+"'"); 13894 } 13895 public String toCode(OperationParameterUse code) { 13896 if (code == OperationParameterUse.NULL) 13897 return null; 13898 if (code == OperationParameterUse.IN) 13899 return "in"; 13900 if (code == OperationParameterUse.OUT) 13901 return "out"; 13902 return "?"; 13903 } 13904 public String toSystem(OperationParameterUse code) { 13905 return code.getSystem(); 13906 } 13907 } 13908 13909 public enum PublicationStatus { 13910 /** 13911 * This resource is still under development and is not yet considered to be ready for normal use. 13912 */ 13913 DRAFT, 13914 /** 13915 * This resource is ready for normal use. 13916 */ 13917 ACTIVE, 13918 /** 13919 * This resource has been withdrawn or superseded and should no longer be used. 13920 */ 13921 RETIRED, 13922 /** 13923 * 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. 13924 */ 13925 UNKNOWN, 13926 /** 13927 * added to help the parsers 13928 */ 13929 NULL; 13930 public static PublicationStatus fromCode(String codeString) throws FHIRException { 13931 if (codeString == null || "".equals(codeString)) 13932 return null; 13933 if ("draft".equals(codeString)) 13934 return DRAFT; 13935 if ("active".equals(codeString)) 13936 return ACTIVE; 13937 if ("retired".equals(codeString)) 13938 return RETIRED; 13939 if ("unknown".equals(codeString)) 13940 return UNKNOWN; 13941 throw new FHIRException("Unknown PublicationStatus code '"+codeString+"'"); 13942 } 13943 public static boolean isValidCode(String codeString) { 13944 if (codeString == null || "".equals(codeString)) 13945 return false; 13946 return Utilities.existsInList(codeString, "draft", "active", "retired", "unknown"); 13947 } 13948 public String toCode() { 13949 switch (this) { 13950 case DRAFT: return "draft"; 13951 case ACTIVE: return "active"; 13952 case RETIRED: return "retired"; 13953 case UNKNOWN: return "unknown"; 13954 case NULL: return null; 13955 default: return "?"; 13956 } 13957 } 13958 public String getSystem() { 13959 switch (this) { 13960 case DRAFT: return "http://hl7.org/fhir/publication-status"; 13961 case ACTIVE: return "http://hl7.org/fhir/publication-status"; 13962 case RETIRED: return "http://hl7.org/fhir/publication-status"; 13963 case UNKNOWN: return "http://hl7.org/fhir/publication-status"; 13964 case NULL: return null; 13965 default: return "?"; 13966 } 13967 } 13968 public String getDefinition() { 13969 switch (this) { 13970 case DRAFT: return "This resource is still under development and is not yet considered to be ready for normal use."; 13971 case ACTIVE: return "This resource is ready for normal use."; 13972 case RETIRED: return "This resource has been withdrawn or superseded and should no longer be used."; 13973 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."; 13974 case NULL: return null; 13975 default: return "?"; 13976 } 13977 } 13978 public String getDisplay() { 13979 switch (this) { 13980 case DRAFT: return "Draft"; 13981 case ACTIVE: return "Active"; 13982 case RETIRED: return "Retired"; 13983 case UNKNOWN: return "Unknown"; 13984 case NULL: return null; 13985 default: return "?"; 13986 } 13987 } 13988 } 13989 13990 public static class PublicationStatusEnumFactory implements EnumFactory<PublicationStatus> { 13991 public PublicationStatus fromCode(String codeString) throws IllegalArgumentException { 13992 if (codeString == null || "".equals(codeString)) 13993 if (codeString == null || "".equals(codeString)) 13994 return null; 13995 if ("draft".equals(codeString)) 13996 return PublicationStatus.DRAFT; 13997 if ("active".equals(codeString)) 13998 return PublicationStatus.ACTIVE; 13999 if ("retired".equals(codeString)) 14000 return PublicationStatus.RETIRED; 14001 if ("unknown".equals(codeString)) 14002 return PublicationStatus.UNKNOWN; 14003 throw new IllegalArgumentException("Unknown PublicationStatus code '"+codeString+"'"); 14004 } 14005 14006 public Enumeration<PublicationStatus> fromType(PrimitiveType<?> code) throws FHIRException { 14007 if (code == null) 14008 return null; 14009 if (code.isEmpty()) 14010 return new Enumeration<PublicationStatus>(this, PublicationStatus.NULL, code); 14011 String codeString = ((PrimitiveType) code).asStringValue(); 14012 if (codeString == null || "".equals(codeString)) 14013 return new Enumeration<PublicationStatus>(this, PublicationStatus.NULL, code); 14014 if ("draft".equals(codeString)) 14015 return new Enumeration<PublicationStatus>(this, PublicationStatus.DRAFT, code); 14016 if ("active".equals(codeString)) 14017 return new Enumeration<PublicationStatus>(this, PublicationStatus.ACTIVE, code); 14018 if ("retired".equals(codeString)) 14019 return new Enumeration<PublicationStatus>(this, PublicationStatus.RETIRED, code); 14020 if ("unknown".equals(codeString)) 14021 return new Enumeration<PublicationStatus>(this, PublicationStatus.UNKNOWN, code); 14022 throw new FHIRException("Unknown PublicationStatus code '"+codeString+"'"); 14023 } 14024 public String toCode(PublicationStatus code) { 14025 if (code == PublicationStatus.NULL) 14026 return null; 14027 if (code == PublicationStatus.DRAFT) 14028 return "draft"; 14029 if (code == PublicationStatus.ACTIVE) 14030 return "active"; 14031 if (code == PublicationStatus.RETIRED) 14032 return "retired"; 14033 if (code == PublicationStatus.UNKNOWN) 14034 return "unknown"; 14035 return "?"; 14036 } 14037 public String toSystem(PublicationStatus code) { 14038 return code.getSystem(); 14039 } 14040 } 14041 14042 public enum QuantityComparator { 14043 /** 14044 * The actual value is less than the given value. 14045 */ 14046 LESS_THAN, 14047 /** 14048 * The actual value is less than or equal to the given value. 14049 */ 14050 LESS_OR_EQUAL, 14051 /** 14052 * The actual value is greater than or equal to the given value. 14053 */ 14054 GREATER_OR_EQUAL, 14055 /** 14056 * The actual value is greater than the given value. 14057 */ 14058 GREATER_THAN, 14059 /** 14060 * The actual value is sufficient for the total quantity to equal the given value. 14061 */ 14062 AD, 14063 /** 14064 * added to help the parsers 14065 */ 14066 NULL; 14067 public static QuantityComparator fromCode(String codeString) throws FHIRException { 14068 if (codeString == null || "".equals(codeString)) 14069 return null; 14070 if ("<".equals(codeString)) 14071 return LESS_THAN; 14072 if ("<=".equals(codeString)) 14073 return LESS_OR_EQUAL; 14074 if (">=".equals(codeString)) 14075 return GREATER_OR_EQUAL; 14076 if (">".equals(codeString)) 14077 return GREATER_THAN; 14078 if ("ad".equals(codeString)) 14079 return AD; 14080 throw new FHIRException("Unknown QuantityComparator code '"+codeString+"'"); 14081 } 14082 public static boolean isValidCode(String codeString) { 14083 if (codeString == null || "".equals(codeString)) 14084 return false; 14085 return Utilities.existsInList(codeString, "<", "<=", ">=", ">", "ad"); 14086 } 14087 public String toCode() { 14088 switch (this) { 14089 case LESS_THAN: return "<"; 14090 case LESS_OR_EQUAL: return "<="; 14091 case GREATER_OR_EQUAL: return ">="; 14092 case GREATER_THAN: return ">"; 14093 case AD: return "ad"; 14094 case NULL: return null; 14095 default: return "?"; 14096 } 14097 } 14098 public String getSystem() { 14099 switch (this) { 14100 case LESS_THAN: return "http://hl7.org/fhir/quantity-comparator"; 14101 case LESS_OR_EQUAL: return "http://hl7.org/fhir/quantity-comparator"; 14102 case GREATER_OR_EQUAL: return "http://hl7.org/fhir/quantity-comparator"; 14103 case GREATER_THAN: return "http://hl7.org/fhir/quantity-comparator"; 14104 case AD: return "http://hl7.org/fhir/quantity-comparator"; 14105 case NULL: return null; 14106 default: return "?"; 14107 } 14108 } 14109 public String getDefinition() { 14110 switch (this) { 14111 case LESS_THAN: return "The actual value is less than the given value."; 14112 case LESS_OR_EQUAL: return "The actual value is less than or equal to the given value."; 14113 case GREATER_OR_EQUAL: return "The actual value is greater than or equal to the given value."; 14114 case GREATER_THAN: return "The actual value is greater than the given value."; 14115 case AD: return "The actual value is sufficient for the total quantity to equal the given value."; 14116 case NULL: return null; 14117 default: return "?"; 14118 } 14119 } 14120 public String getDisplay() { 14121 switch (this) { 14122 case LESS_THAN: return "Less than"; 14123 case LESS_OR_EQUAL: return "Less or Equal to"; 14124 case GREATER_OR_EQUAL: return "Greater or Equal to"; 14125 case GREATER_THAN: return "Greater than"; 14126 case AD: return "Sufficient to achieve this total quantity"; 14127 case NULL: return null; 14128 default: return "?"; 14129 } 14130 } 14131 } 14132 14133 public static class QuantityComparatorEnumFactory implements EnumFactory<QuantityComparator> { 14134 public QuantityComparator fromCode(String codeString) throws IllegalArgumentException { 14135 if (codeString == null || "".equals(codeString)) 14136 if (codeString == null || "".equals(codeString)) 14137 return null; 14138 if ("<".equals(codeString)) 14139 return QuantityComparator.LESS_THAN; 14140 if ("<=".equals(codeString)) 14141 return QuantityComparator.LESS_OR_EQUAL; 14142 if (">=".equals(codeString)) 14143 return QuantityComparator.GREATER_OR_EQUAL; 14144 if (">".equals(codeString)) 14145 return QuantityComparator.GREATER_THAN; 14146 if ("ad".equals(codeString)) 14147 return QuantityComparator.AD; 14148 throw new IllegalArgumentException("Unknown QuantityComparator code '"+codeString+"'"); 14149 } 14150 14151 public Enumeration<QuantityComparator> fromType(PrimitiveType<?> code) throws FHIRException { 14152 if (code == null) 14153 return null; 14154 if (code.isEmpty()) 14155 return new Enumeration<QuantityComparator>(this, QuantityComparator.NULL, code); 14156 String codeString = ((PrimitiveType) code).asStringValue(); 14157 if (codeString == null || "".equals(codeString)) 14158 return new Enumeration<QuantityComparator>(this, QuantityComparator.NULL, code); 14159 if ("<".equals(codeString)) 14160 return new Enumeration<QuantityComparator>(this, QuantityComparator.LESS_THAN, code); 14161 if ("<=".equals(codeString)) 14162 return new Enumeration<QuantityComparator>(this, QuantityComparator.LESS_OR_EQUAL, code); 14163 if (">=".equals(codeString)) 14164 return new Enumeration<QuantityComparator>(this, QuantityComparator.GREATER_OR_EQUAL, code); 14165 if (">".equals(codeString)) 14166 return new Enumeration<QuantityComparator>(this, QuantityComparator.GREATER_THAN, code); 14167 if ("ad".equals(codeString)) 14168 return new Enumeration<QuantityComparator>(this, QuantityComparator.AD, code); 14169 throw new FHIRException("Unknown QuantityComparator code '"+codeString+"'"); 14170 } 14171 public String toCode(QuantityComparator code) { 14172 if (code == QuantityComparator.NULL) 14173 return null; 14174 if (code == QuantityComparator.LESS_THAN) 14175 return "<"; 14176 if (code == QuantityComparator.LESS_OR_EQUAL) 14177 return "<="; 14178 if (code == QuantityComparator.GREATER_OR_EQUAL) 14179 return ">="; 14180 if (code == QuantityComparator.GREATER_THAN) 14181 return ">"; 14182 if (code == QuantityComparator.AD) 14183 return "ad"; 14184 return "?"; 14185 } 14186 public String toSystem(QuantityComparator code) { 14187 return code.getSystem(); 14188 } 14189 } 14190 14191 public enum RequestIntent { 14192 /** 14193 * 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. 14194 */ 14195 PROPOSAL, 14196 /** 14197 * The request represents an intention to ensure something occurs without providing an authorization for others to act. 14198 */ 14199 PLAN, 14200 /** 14201 * The request represents a legally binding instruction authored by a Patient or RelatedPerson. 14202 */ 14203 DIRECTIVE, 14204 /** 14205 * The request represents a request/demand and authorization for action by the requestor. 14206 */ 14207 ORDER, 14208 /** 14209 * The request represents an original authorization for action. 14210 */ 14211 ORIGINALORDER, 14212 /** 14213 * 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. 14214 */ 14215 REFLEXORDER, 14216 /** 14217 * 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. 14218 */ 14219 FILLERORDER, 14220 /** 14221 * 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. 14222 */ 14223 INSTANCEORDER, 14224 /** 14225 * 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. 14226 */ 14227 OPTION, 14228 /** 14229 * added to help the parsers 14230 */ 14231 NULL; 14232 public static RequestIntent fromCode(String codeString) throws FHIRException { 14233 if (codeString == null || "".equals(codeString)) 14234 return null; 14235 if ("proposal".equals(codeString)) 14236 return PROPOSAL; 14237 if ("plan".equals(codeString)) 14238 return PLAN; 14239 if ("directive".equals(codeString)) 14240 return DIRECTIVE; 14241 if ("order".equals(codeString)) 14242 return ORDER; 14243 if ("original-order".equals(codeString)) 14244 return ORIGINALORDER; 14245 if ("reflex-order".equals(codeString)) 14246 return REFLEXORDER; 14247 if ("filler-order".equals(codeString)) 14248 return FILLERORDER; 14249 if ("instance-order".equals(codeString)) 14250 return INSTANCEORDER; 14251 if ("option".equals(codeString)) 14252 return OPTION; 14253 throw new FHIRException("Unknown RequestIntent code '"+codeString+"'"); 14254 } 14255 public static boolean isValidCode(String codeString) { 14256 if (codeString == null || "".equals(codeString)) 14257 return false; 14258 return Utilities.existsInList(codeString, "proposal", "plan", "directive", "order", "original-order", "reflex-order", "filler-order", "instance-order", "option"); 14259 } 14260 public String toCode() { 14261 switch (this) { 14262 case PROPOSAL: return "proposal"; 14263 case PLAN: return "plan"; 14264 case DIRECTIVE: return "directive"; 14265 case ORDER: return "order"; 14266 case ORIGINALORDER: return "original-order"; 14267 case REFLEXORDER: return "reflex-order"; 14268 case FILLERORDER: return "filler-order"; 14269 case INSTANCEORDER: return "instance-order"; 14270 case OPTION: return "option"; 14271 case NULL: return null; 14272 default: return "?"; 14273 } 14274 } 14275 public String getSystem() { 14276 switch (this) { 14277 case PROPOSAL: return "http://hl7.org/fhir/request-intent"; 14278 case PLAN: return "http://hl7.org/fhir/request-intent"; 14279 case DIRECTIVE: return "http://hl7.org/fhir/request-intent"; 14280 case ORDER: return "http://hl7.org/fhir/request-intent"; 14281 case ORIGINALORDER: return "http://hl7.org/fhir/request-intent"; 14282 case REFLEXORDER: return "http://hl7.org/fhir/request-intent"; 14283 case FILLERORDER: return "http://hl7.org/fhir/request-intent"; 14284 case INSTANCEORDER: return "http://hl7.org/fhir/request-intent"; 14285 case OPTION: return "http://hl7.org/fhir/request-intent"; 14286 case NULL: return null; 14287 default: return "?"; 14288 } 14289 } 14290 public String getDefinition() { 14291 switch (this) { 14292 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."; 14293 case PLAN: return "The request represents an intention to ensure something occurs without providing an authorization for others to act."; 14294 case DIRECTIVE: return "The request represents a legally binding instruction authored by a Patient or RelatedPerson."; 14295 case ORDER: return "The request represents a request/demand and authorization for action by the requestor."; 14296 case ORIGINALORDER: return "The request represents an original authorization for action."; 14297 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."; 14298 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."; 14299 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."; 14300 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."; 14301 case NULL: return null; 14302 default: return "?"; 14303 } 14304 } 14305 public String getDisplay() { 14306 switch (this) { 14307 case PROPOSAL: return "Proposal"; 14308 case PLAN: return "Plan"; 14309 case DIRECTIVE: return "Directive"; 14310 case ORDER: return "Order"; 14311 case ORIGINALORDER: return "Original Order"; 14312 case REFLEXORDER: return "Reflex Order"; 14313 case FILLERORDER: return "Filler Order"; 14314 case INSTANCEORDER: return "Instance Order"; 14315 case OPTION: return "Option"; 14316 case NULL: return null; 14317 default: return "?"; 14318 } 14319 } 14320 } 14321 14322 public static class RequestIntentEnumFactory implements EnumFactory<RequestIntent> { 14323 public RequestIntent fromCode(String codeString) throws IllegalArgumentException { 14324 if (codeString == null || "".equals(codeString)) 14325 if (codeString == null || "".equals(codeString)) 14326 return null; 14327 if ("proposal".equals(codeString)) 14328 return RequestIntent.PROPOSAL; 14329 if ("plan".equals(codeString)) 14330 return RequestIntent.PLAN; 14331 if ("directive".equals(codeString)) 14332 return RequestIntent.DIRECTIVE; 14333 if ("order".equals(codeString)) 14334 return RequestIntent.ORDER; 14335 if ("original-order".equals(codeString)) 14336 return RequestIntent.ORIGINALORDER; 14337 if ("reflex-order".equals(codeString)) 14338 return RequestIntent.REFLEXORDER; 14339 if ("filler-order".equals(codeString)) 14340 return RequestIntent.FILLERORDER; 14341 if ("instance-order".equals(codeString)) 14342 return RequestIntent.INSTANCEORDER; 14343 if ("option".equals(codeString)) 14344 return RequestIntent.OPTION; 14345 throw new IllegalArgumentException("Unknown RequestIntent code '"+codeString+"'"); 14346 } 14347 14348 public Enumeration<RequestIntent> fromType(PrimitiveType<?> code) throws FHIRException { 14349 if (code == null) 14350 return null; 14351 if (code.isEmpty()) 14352 return new Enumeration<RequestIntent>(this, RequestIntent.NULL, code); 14353 String codeString = ((PrimitiveType) code).asStringValue(); 14354 if (codeString == null || "".equals(codeString)) 14355 return new Enumeration<RequestIntent>(this, RequestIntent.NULL, code); 14356 if ("proposal".equals(codeString)) 14357 return new Enumeration<RequestIntent>(this, RequestIntent.PROPOSAL, code); 14358 if ("plan".equals(codeString)) 14359 return new Enumeration<RequestIntent>(this, RequestIntent.PLAN, code); 14360 if ("directive".equals(codeString)) 14361 return new Enumeration<RequestIntent>(this, RequestIntent.DIRECTIVE, code); 14362 if ("order".equals(codeString)) 14363 return new Enumeration<RequestIntent>(this, RequestIntent.ORDER, code); 14364 if ("original-order".equals(codeString)) 14365 return new Enumeration<RequestIntent>(this, RequestIntent.ORIGINALORDER, code); 14366 if ("reflex-order".equals(codeString)) 14367 return new Enumeration<RequestIntent>(this, RequestIntent.REFLEXORDER, code); 14368 if ("filler-order".equals(codeString)) 14369 return new Enumeration<RequestIntent>(this, RequestIntent.FILLERORDER, code); 14370 if ("instance-order".equals(codeString)) 14371 return new Enumeration<RequestIntent>(this, RequestIntent.INSTANCEORDER, code); 14372 if ("option".equals(codeString)) 14373 return new Enumeration<RequestIntent>(this, RequestIntent.OPTION, code); 14374 throw new FHIRException("Unknown RequestIntent code '"+codeString+"'"); 14375 } 14376 public String toCode(RequestIntent code) { 14377 if (code == RequestIntent.NULL) 14378 return null; 14379 if (code == RequestIntent.PROPOSAL) 14380 return "proposal"; 14381 if (code == RequestIntent.PLAN) 14382 return "plan"; 14383 if (code == RequestIntent.DIRECTIVE) 14384 return "directive"; 14385 if (code == RequestIntent.ORDER) 14386 return "order"; 14387 if (code == RequestIntent.ORIGINALORDER) 14388 return "original-order"; 14389 if (code == RequestIntent.REFLEXORDER) 14390 return "reflex-order"; 14391 if (code == RequestIntent.FILLERORDER) 14392 return "filler-order"; 14393 if (code == RequestIntent.INSTANCEORDER) 14394 return "instance-order"; 14395 if (code == RequestIntent.OPTION) 14396 return "option"; 14397 return "?"; 14398 } 14399 public String toSystem(RequestIntent code) { 14400 return code.getSystem(); 14401 } 14402 } 14403 14404 public enum RequestPriority { 14405 /** 14406 * The request has normal priority. 14407 */ 14408 ROUTINE, 14409 /** 14410 * The request should be actioned promptly - higher priority than routine. 14411 */ 14412 URGENT, 14413 /** 14414 * The request should be actioned as soon as possible - higher priority than urgent. 14415 */ 14416 ASAP, 14417 /** 14418 * The request should be actioned immediately - highest possible priority. E.g. an emergency. 14419 */ 14420 STAT, 14421 /** 14422 * added to help the parsers 14423 */ 14424 NULL; 14425 public static RequestPriority fromCode(String codeString) throws FHIRException { 14426 if (codeString == null || "".equals(codeString)) 14427 return null; 14428 if ("routine".equals(codeString)) 14429 return ROUTINE; 14430 if ("urgent".equals(codeString)) 14431 return URGENT; 14432 if ("asap".equals(codeString)) 14433 return ASAP; 14434 if ("stat".equals(codeString)) 14435 return STAT; 14436 throw new FHIRException("Unknown RequestPriority code '"+codeString+"'"); 14437 } 14438 public static boolean isValidCode(String codeString) { 14439 if (codeString == null || "".equals(codeString)) 14440 return false; 14441 return Utilities.existsInList(codeString, "routine", "urgent", "asap", "stat"); 14442 } 14443 public String toCode() { 14444 switch (this) { 14445 case ROUTINE: return "routine"; 14446 case URGENT: return "urgent"; 14447 case ASAP: return "asap"; 14448 case STAT: return "stat"; 14449 case NULL: return null; 14450 default: return "?"; 14451 } 14452 } 14453 public String getSystem() { 14454 switch (this) { 14455 case ROUTINE: return "http://hl7.org/fhir/request-priority"; 14456 case URGENT: return "http://hl7.org/fhir/request-priority"; 14457 case ASAP: return "http://hl7.org/fhir/request-priority"; 14458 case STAT: return "http://hl7.org/fhir/request-priority"; 14459 case NULL: return null; 14460 default: return "?"; 14461 } 14462 } 14463 public String getDefinition() { 14464 switch (this) { 14465 case ROUTINE: return "The request has normal priority."; 14466 case URGENT: return "The request should be actioned promptly - higher priority than routine."; 14467 case ASAP: return "The request should be actioned as soon as possible - higher priority than urgent."; 14468 case STAT: return "The request should be actioned immediately - highest possible priority. E.g. an emergency."; 14469 case NULL: return null; 14470 default: return "?"; 14471 } 14472 } 14473 public String getDisplay() { 14474 switch (this) { 14475 case ROUTINE: return "Routine"; 14476 case URGENT: return "Urgent"; 14477 case ASAP: return "ASAP"; 14478 case STAT: return "STAT"; 14479 case NULL: return null; 14480 default: return "?"; 14481 } 14482 } 14483 } 14484 14485 public static class RequestPriorityEnumFactory implements EnumFactory<RequestPriority> { 14486 public RequestPriority fromCode(String codeString) throws IllegalArgumentException { 14487 if (codeString == null || "".equals(codeString)) 14488 if (codeString == null || "".equals(codeString)) 14489 return null; 14490 if ("routine".equals(codeString)) 14491 return RequestPriority.ROUTINE; 14492 if ("urgent".equals(codeString)) 14493 return RequestPriority.URGENT; 14494 if ("asap".equals(codeString)) 14495 return RequestPriority.ASAP; 14496 if ("stat".equals(codeString)) 14497 return RequestPriority.STAT; 14498 throw new IllegalArgumentException("Unknown RequestPriority code '"+codeString+"'"); 14499 } 14500 14501 public Enumeration<RequestPriority> fromType(PrimitiveType<?> code) throws FHIRException { 14502 if (code == null) 14503 return null; 14504 if (code.isEmpty()) 14505 return new Enumeration<RequestPriority>(this, RequestPriority.NULL, code); 14506 String codeString = ((PrimitiveType) code).asStringValue(); 14507 if (codeString == null || "".equals(codeString)) 14508 return new Enumeration<RequestPriority>(this, RequestPriority.NULL, code); 14509 if ("routine".equals(codeString)) 14510 return new Enumeration<RequestPriority>(this, RequestPriority.ROUTINE, code); 14511 if ("urgent".equals(codeString)) 14512 return new Enumeration<RequestPriority>(this, RequestPriority.URGENT, code); 14513 if ("asap".equals(codeString)) 14514 return new Enumeration<RequestPriority>(this, RequestPriority.ASAP, code); 14515 if ("stat".equals(codeString)) 14516 return new Enumeration<RequestPriority>(this, RequestPriority.STAT, code); 14517 throw new FHIRException("Unknown RequestPriority code '"+codeString+"'"); 14518 } 14519 public String toCode(RequestPriority code) { 14520 if (code == RequestPriority.NULL) 14521 return null; 14522 if (code == RequestPriority.ROUTINE) 14523 return "routine"; 14524 if (code == RequestPriority.URGENT) 14525 return "urgent"; 14526 if (code == RequestPriority.ASAP) 14527 return "asap"; 14528 if (code == RequestPriority.STAT) 14529 return "stat"; 14530 return "?"; 14531 } 14532 public String toSystem(RequestPriority code) { 14533 return code.getSystem(); 14534 } 14535 } 14536 14537 public enum RequestStatus { 14538 /** 14539 * The request has been created but is not yet complete or ready for action. 14540 */ 14541 DRAFT, 14542 /** 14543 * The request is in force and ready to be acted upon. 14544 */ 14545 ACTIVE, 14546 /** 14547 * The request (and any implicit authorization to act) has been temporarily withdrawn but is expected to resume in the future. 14548 */ 14549 ONHOLD, 14550 /** 14551 * 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. 14552 */ 14553 REVOKED, 14554 /** 14555 * The activity described by the request has been fully performed. No further activity will occur. 14556 */ 14557 COMPLETED, 14558 /** 14559 * 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".). 14560 */ 14561 ENTEREDINERROR, 14562 /** 14563 * 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. 14564 */ 14565 UNKNOWN, 14566 /** 14567 * added to help the parsers 14568 */ 14569 NULL; 14570 public static RequestStatus fromCode(String codeString) throws FHIRException { 14571 if (codeString == null || "".equals(codeString)) 14572 return null; 14573 if ("draft".equals(codeString)) 14574 return DRAFT; 14575 if ("active".equals(codeString)) 14576 return ACTIVE; 14577 if ("on-hold".equals(codeString)) 14578 return ONHOLD; 14579 if ("revoked".equals(codeString)) 14580 return REVOKED; 14581 if ("completed".equals(codeString)) 14582 return COMPLETED; 14583 if ("entered-in-error".equals(codeString)) 14584 return ENTEREDINERROR; 14585 if ("unknown".equals(codeString)) 14586 return UNKNOWN; 14587 throw new FHIRException("Unknown RequestStatus code '"+codeString+"'"); 14588 } 14589 public static boolean isValidCode(String codeString) { 14590 if (codeString == null || "".equals(codeString)) 14591 return false; 14592 return Utilities.existsInList(codeString, "draft", "active", "on-hold", "revoked", "completed", "entered-in-error", "unknown"); 14593 } 14594 public String toCode() { 14595 switch (this) { 14596 case DRAFT: return "draft"; 14597 case ACTIVE: return "active"; 14598 case ONHOLD: return "on-hold"; 14599 case REVOKED: return "revoked"; 14600 case COMPLETED: return "completed"; 14601 case ENTEREDINERROR: return "entered-in-error"; 14602 case UNKNOWN: return "unknown"; 14603 case NULL: return null; 14604 default: return "?"; 14605 } 14606 } 14607 public String getSystem() { 14608 switch (this) { 14609 case DRAFT: return "http://hl7.org/fhir/request-status"; 14610 case ACTIVE: return "http://hl7.org/fhir/request-status"; 14611 case ONHOLD: return "http://hl7.org/fhir/request-status"; 14612 case REVOKED: return "http://hl7.org/fhir/request-status"; 14613 case COMPLETED: return "http://hl7.org/fhir/request-status"; 14614 case ENTEREDINERROR: return "http://hl7.org/fhir/request-status"; 14615 case UNKNOWN: return "http://hl7.org/fhir/request-status"; 14616 case NULL: return null; 14617 default: return "?"; 14618 } 14619 } 14620 public String getDefinition() { 14621 switch (this) { 14622 case DRAFT: return "The request has been created but is not yet complete or ready for action."; 14623 case ACTIVE: return "The request is in force and ready to be acted upon."; 14624 case ONHOLD: return "The request (and any implicit authorization to act) has been temporarily withdrawn but is expected to resume in the future."; 14625 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."; 14626 case COMPLETED: return "The activity described by the request has been fully performed. No further activity will occur."; 14627 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\".)."; 14628 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."; 14629 case NULL: return null; 14630 default: return "?"; 14631 } 14632 } 14633 public String getDisplay() { 14634 switch (this) { 14635 case DRAFT: return "Draft"; 14636 case ACTIVE: return "Active"; 14637 case ONHOLD: return "On Hold"; 14638 case REVOKED: return "Revoked"; 14639 case COMPLETED: return "Completed"; 14640 case ENTEREDINERROR: return "Entered in Error"; 14641 case UNKNOWN: return "Unknown"; 14642 case NULL: return null; 14643 default: return "?"; 14644 } 14645 } 14646 } 14647 14648 public static class RequestStatusEnumFactory implements EnumFactory<RequestStatus> { 14649 public RequestStatus fromCode(String codeString) throws IllegalArgumentException { 14650 if (codeString == null || "".equals(codeString)) 14651 if (codeString == null || "".equals(codeString)) 14652 return null; 14653 if ("draft".equals(codeString)) 14654 return RequestStatus.DRAFT; 14655 if ("active".equals(codeString)) 14656 return RequestStatus.ACTIVE; 14657 if ("on-hold".equals(codeString)) 14658 return RequestStatus.ONHOLD; 14659 if ("revoked".equals(codeString)) 14660 return RequestStatus.REVOKED; 14661 if ("completed".equals(codeString)) 14662 return RequestStatus.COMPLETED; 14663 if ("entered-in-error".equals(codeString)) 14664 return RequestStatus.ENTEREDINERROR; 14665 if ("unknown".equals(codeString)) 14666 return RequestStatus.UNKNOWN; 14667 throw new IllegalArgumentException("Unknown RequestStatus code '"+codeString+"'"); 14668 } 14669 14670 public Enumeration<RequestStatus> fromType(PrimitiveType<?> code) throws FHIRException { 14671 if (code == null) 14672 return null; 14673 if (code.isEmpty()) 14674 return new Enumeration<RequestStatus>(this, RequestStatus.NULL, code); 14675 String codeString = ((PrimitiveType) code).asStringValue(); 14676 if (codeString == null || "".equals(codeString)) 14677 return new Enumeration<RequestStatus>(this, RequestStatus.NULL, code); 14678 if ("draft".equals(codeString)) 14679 return new Enumeration<RequestStatus>(this, RequestStatus.DRAFT, code); 14680 if ("active".equals(codeString)) 14681 return new Enumeration<RequestStatus>(this, RequestStatus.ACTIVE, code); 14682 if ("on-hold".equals(codeString)) 14683 return new Enumeration<RequestStatus>(this, RequestStatus.ONHOLD, code); 14684 if ("revoked".equals(codeString)) 14685 return new Enumeration<RequestStatus>(this, RequestStatus.REVOKED, code); 14686 if ("completed".equals(codeString)) 14687 return new Enumeration<RequestStatus>(this, RequestStatus.COMPLETED, code); 14688 if ("entered-in-error".equals(codeString)) 14689 return new Enumeration<RequestStatus>(this, RequestStatus.ENTEREDINERROR, code); 14690 if ("unknown".equals(codeString)) 14691 return new Enumeration<RequestStatus>(this, RequestStatus.UNKNOWN, code); 14692 throw new FHIRException("Unknown RequestStatus code '"+codeString+"'"); 14693 } 14694 public String toCode(RequestStatus code) { 14695 if (code == RequestStatus.NULL) 14696 return null; 14697 if (code == RequestStatus.DRAFT) 14698 return "draft"; 14699 if (code == RequestStatus.ACTIVE) 14700 return "active"; 14701 if (code == RequestStatus.ONHOLD) 14702 return "on-hold"; 14703 if (code == RequestStatus.REVOKED) 14704 return "revoked"; 14705 if (code == RequestStatus.COMPLETED) 14706 return "completed"; 14707 if (code == RequestStatus.ENTEREDINERROR) 14708 return "entered-in-error"; 14709 if (code == RequestStatus.UNKNOWN) 14710 return "unknown"; 14711 return "?"; 14712 } 14713 public String toSystem(RequestStatus code) { 14714 return code.getSystem(); 14715 } 14716 } 14717 14718 public enum ResourceTypeEnum { 14719 /** 14720 * 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. 14721 */ 14722 ACCOUNT, 14723 /** 14724 * This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context. 14725 */ 14726 ACTIVITYDEFINITION, 14727 /** 14728 * 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. 14729 */ 14730 ACTORDEFINITION, 14731 /** 14732 * 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). 14733 */ 14734 ADMINISTRABLEPRODUCTDEFINITION, 14735 /** 14736 * 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. 14737 */ 14738 ADVERSEEVENT, 14739 /** 14740 * Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance. 14741 */ 14742 ALLERGYINTOLERANCE, 14743 /** 14744 * 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). 14745 */ 14746 APPOINTMENT, 14747 /** 14748 * A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection. 14749 */ 14750 APPOINTMENTRESPONSE, 14751 /** 14752 * This Resource provides one or more comments, classifiers or ratings about a Resource and supports attribution and rights management metadata for the added content. 14753 */ 14754 ARTIFACTASSESSMENT, 14755 /** 14756 * A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis. 14757 */ 14758 AUDITEVENT, 14759 /** 14760 * 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. 14761 */ 14762 BASIC, 14763 /** 14764 * 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. 14765 */ 14766 BINARY, 14767 /** 14768 * A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity. 14769 */ 14770 BIOLOGICALLYDERIVEDPRODUCT, 14771 /** 14772 * A record of dispensation of a biologically derived product. 14773 */ 14774 BIOLOGICALLYDERIVEDPRODUCTDISPENSE, 14775 /** 14776 * 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. 14777 */ 14778 BODYSTRUCTURE, 14779 /** 14780 * A container for a collection of resources. 14781 */ 14782 BUNDLE, 14783 /** 14784 * 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. 14785 */ 14786 CAPABILITYSTATEMENT, 14787 /** 14788 * 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. 14789 */ 14790 CAREPLAN, 14791 /** 14792 * The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care. 14793 */ 14794 CARETEAM, 14795 /** 14796 * 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. 14797 */ 14798 CHARGEITEM, 14799 /** 14800 * 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. 14801 */ 14802 CHARGEITEMDEFINITION, 14803 /** 14804 * 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. 14805 */ 14806 CITATION, 14807 /** 14808 * 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. 14809 */ 14810 CLAIM, 14811 /** 14812 * This resource provides the adjudication details from the processing of a Claim resource. 14813 */ 14814 CLAIMRESPONSE, 14815 /** 14816 * 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. 14817 */ 14818 CLINICALIMPRESSION, 14819 /** 14820 * A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure. 14821 */ 14822 CLINICALUSEDEFINITION, 14823 /** 14824 * 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. 14825 */ 14826 CODESYSTEM, 14827 /** 14828 * 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. 14829 */ 14830 COMMUNICATION, 14831 /** 14832 * 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. 14833 */ 14834 COMMUNICATIONREQUEST, 14835 /** 14836 * A compartment definition that defines how resources are accessed on a server. 14837 */ 14838 COMPARTMENTDEFINITION, 14839 /** 14840 * 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.). 14841 */ 14842 COMPOSITION, 14843 /** 14844 * 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. 14845 */ 14846 CONCEPTMAP, 14847 /** 14848 * A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern. 14849 */ 14850 CONDITION, 14851 /** 14852 * A definition of a condition and information relevant to managing it. 14853 */ 14854 CONDITIONDEFINITION, 14855 /** 14856 * 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. 14857 */ 14858 CONSENT, 14859 /** 14860 * Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement. 14861 */ 14862 CONTRACT, 14863 /** 14864 * Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment. 14865 */ 14866 COVERAGE, 14867 /** 14868 * 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. 14869 */ 14870 COVERAGEELIGIBILITYREQUEST, 14871 /** 14872 * This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource. 14873 */ 14874 COVERAGEELIGIBILITYRESPONSE, 14875 /** 14876 * 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. 14877 */ 14878 DETECTEDISSUE, 14879 /** 14880 * 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. 14881 */ 14882 DEVICE, 14883 /** 14884 * A record of association of a device. 14885 */ 14886 DEVICEASSOCIATION, 14887 /** 14888 * This is a specialized resource that defines the characteristics and capabilities of a device. 14889 */ 14890 DEVICEDEFINITION, 14891 /** 14892 * 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. 14893 */ 14894 DEVICEDISPENSE, 14895 /** 14896 * 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. 14897 */ 14898 DEVICEMETRIC, 14899 /** 14900 * 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. 14901 */ 14902 DEVICEREQUEST, 14903 /** 14904 * 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. 14905 */ 14906 DEVICEUSAGE, 14907 /** 14908 * 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. 14909 */ 14910 DIAGNOSTICREPORT, 14911 /** 14912 * 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. 14913 */ 14914 DOCUMENTREFERENCE, 14915 /** 14916 * 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). 14917 */ 14918 ENCOUNTER, 14919 /** 14920 * A record of significant events/milestones key data throughout the history of an Encounter 14921 */ 14922 ENCOUNTERHISTORY, 14923 /** 14924 * 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. 14925 */ 14926 ENDPOINT, 14927 /** 14928 * This resource provides the insurance enrollment details to the insurer regarding a specified coverage. 14929 */ 14930 ENROLLMENTREQUEST, 14931 /** 14932 * This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource. 14933 */ 14934 ENROLLMENTRESPONSE, 14935 /** 14936 * 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. 14937 */ 14938 EPISODEOFCARE, 14939 /** 14940 * The EventDefinition resource provides a reusable description of when a particular event can occur. 14941 */ 14942 EVENTDEFINITION, 14943 /** 14944 * 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. 14945 */ 14946 EVIDENCE, 14947 /** 14948 * 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. 14949 */ 14950 EVIDENCEREPORT, 14951 /** 14952 * The EvidenceVariable resource describes an element that knowledge (Evidence) is about. 14953 */ 14954 EVIDENCEVARIABLE, 14955 /** 14956 * A walkthrough of a workflow showing the interaction between systems and the instances shared, possibly including the evolution of instances over time. 14957 */ 14958 EXAMPLESCENARIO, 14959 /** 14960 * 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. 14961 */ 14962 EXPLANATIONOFBENEFIT, 14963 /** 14964 * Significant health conditions for a person related to the patient relevant in the context of care for the patient. 14965 */ 14966 FAMILYMEMBERHISTORY, 14967 /** 14968 * Prospective warnings of potential issues when providing care to the patient. 14969 */ 14970 FLAG, 14971 /** 14972 * 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. 14973 */ 14974 FORMULARYITEM, 14975 /** 14976 * A set of analyses performed to analyze and generate genomic data. 14977 */ 14978 GENOMICSTUDY, 14979 /** 14980 * 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. 14981 */ 14982 GOAL, 14983 /** 14984 * 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. 14985 */ 14986 GRAPHDEFINITION, 14987 /** 14988 * 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. 14989 */ 14990 GROUP, 14991 /** 14992 * 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. 14993 */ 14994 GUIDANCERESPONSE, 14995 /** 14996 * 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. 14997 */ 14998 HEALTHCARESERVICE, 14999 /** 15000 * 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. 15001 */ 15002 IMAGINGSELECTION, 15003 /** 15004 * 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. 15005 */ 15006 IMAGINGSTUDY, 15007 /** 15008 * 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. 15009 */ 15010 IMMUNIZATION, 15011 /** 15012 * Describes a comparison of an immunization event against published recommendations to determine if the administration is "valid" in relation to those recommendations. 15013 */ 15014 IMMUNIZATIONEVALUATION, 15015 /** 15016 * A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification. 15017 */ 15018 IMMUNIZATIONRECOMMENDATION, 15019 /** 15020 * 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. 15021 */ 15022 IMPLEMENTATIONGUIDE, 15023 /** 15024 * An ingredient of a manufactured item or pharmaceutical product. 15025 */ 15026 INGREDIENT, 15027 /** 15028 * Details of a Health Insurance product/plan provided by an organization. 15029 */ 15030 INSURANCEPLAN, 15031 /** 15032 * functional description of an inventory item used in inventory and supply-related workflows. 15033 */ 15034 INVENTORYITEM, 15035 /** 15036 * A report of inventory or stock items. 15037 */ 15038 INVENTORYREPORT, 15039 /** 15040 * Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose. 15041 */ 15042 INVOICE, 15043 /** 15044 * 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. 15045 */ 15046 LIBRARY, 15047 /** 15048 * Identifies two or more records (resource instances) that refer to the same real-world "occurrence". 15049 */ 15050 LINKAGE, 15051 /** 15052 * A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc. 15053 */ 15054 LIST, 15055 /** 15056 * Details and position information for a place where services are provided and resources and participants may be stored, found, contained, or accommodated. 15057 */ 15058 LOCATION, 15059 /** 15060 * The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product. 15061 */ 15062 MANUFACTUREDITEMDEFINITION, 15063 /** 15064 * The Measure resource provides the definition of a quality measure. 15065 */ 15066 MEASURE, 15067 /** 15068 * The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation. 15069 */ 15070 MEASUREREPORT, 15071 /** 15072 * 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. 15073 */ 15074 MEDICATION, 15075 /** 15076 * 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. 15077 */ 15078 MEDICATIONADMINISTRATION, 15079 /** 15080 * 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. 15081 */ 15082 MEDICATIONDISPENSE, 15083 /** 15084 * Information about a medication that is used to support knowledge. 15085 */ 15086 MEDICATIONKNOWLEDGE, 15087 /** 15088 * 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. 15089 */ 15090 MEDICATIONREQUEST, 15091 /** 15092 * 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. 15093 15094The 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. 15095 */ 15096 MEDICATIONSTATEMENT, 15097 /** 15098 * 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.). 15099 */ 15100 MEDICINALPRODUCTDEFINITION, 15101 /** 15102 * 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. 15103 */ 15104 MESSAGEDEFINITION, 15105 /** 15106 * 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. 15107 */ 15108 MESSAGEHEADER, 15109 /** 15110 * Representation of a molecular sequence. 15111 */ 15112 MOLECULARSEQUENCE, 15113 /** 15114 * 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. 15115 */ 15116 NAMINGSYSTEM, 15117 /** 15118 * 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. 15119 */ 15120 NUTRITIONINTAKE, 15121 /** 15122 * A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident. 15123 */ 15124 NUTRITIONORDER, 15125 /** 15126 * A food or supplement that is consumed by patients. 15127 */ 15128 NUTRITIONPRODUCT, 15129 /** 15130 * Measurements and simple assertions made about a patient, device or other subject. 15131 */ 15132 OBSERVATION, 15133 /** 15134 * Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service. 15135 */ 15136 OBSERVATIONDEFINITION, 15137 /** 15138 * A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction). 15139 */ 15140 OPERATIONDEFINITION, 15141 /** 15142 * A collection of error, warning, or information messages that result from a system action. 15143 */ 15144 OPERATIONOUTCOME, 15145 /** 15146 * 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. 15147 */ 15148 ORGANIZATION, 15149 /** 15150 * Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship. 15151 */ 15152 ORGANIZATIONAFFILIATION, 15153 /** 15154 * A medically related item or items, in a container or package. 15155 */ 15156 PACKAGEDPRODUCTDEFINITION, 15157 /** 15158 * 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. 15159 */ 15160 PARAMETERS, 15161 /** 15162 * Demographics and other administrative information about an individual or animal receiving care or other health-related services. 15163 */ 15164 PATIENT, 15165 /** 15166 * This resource provides the status of the payment for goods and services rendered, and the request and response resource references. 15167 */ 15168 PAYMENTNOTICE, 15169 /** 15170 * This resource provides the details including amount of a payment and allocates the payment items being paid. 15171 */ 15172 PAYMENTRECONCILIATION, 15173 /** 15174 * Permission resource holds access rules for a given data and context. 15175 */ 15176 PERMISSION, 15177 /** 15178 * Demographics and administrative information about a person independent of a specific health-related context. 15179 */ 15180 PERSON, 15181 /** 15182 * 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. 15183 */ 15184 PLANDEFINITION, 15185 /** 15186 * A person who is directly or indirectly involved in the provisioning of healthcare or related services. 15187 */ 15188 PRACTITIONER, 15189 /** 15190 * A specific set of Roles/Locations/specialties/services that a practitioner may perform, or has performed at an organization during a period of time. 15191 */ 15192 PRACTITIONERROLE, 15193 /** 15194 * 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. 15195 */ 15196 PROCEDURE, 15197 /** 15198 * 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. 15199 */ 15200 PROVENANCE, 15201 /** 15202 * 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. 15203 */ 15204 QUESTIONNAIRE, 15205 /** 15206 * 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. 15207 */ 15208 QUESTIONNAIRERESPONSE, 15209 /** 15210 * 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. 15211 */ 15212 REGULATEDAUTHORIZATION, 15213 /** 15214 * 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. 15215 */ 15216 RELATEDPERSON, 15217 /** 15218 * 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". 15219 */ 15220 REQUESTORCHESTRATION, 15221 /** 15222 * 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. 15223 */ 15224 REQUIREMENTS, 15225 /** 15226 * 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. 15227 */ 15228 RESEARCHSTUDY, 15229 /** 15230 * A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study. 15231 */ 15232 RESEARCHSUBJECT, 15233 /** 15234 * An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome. 15235 */ 15236 RISKASSESSMENT, 15237 /** 15238 * A container for slots of time that may be available for booking appointments. 15239 */ 15240 SCHEDULE, 15241 /** 15242 * A search parameter that defines a named search item that can be used to search/filter on a resource. 15243 */ 15244 SEARCHPARAMETER, 15245 /** 15246 * A record of a request for service such as diagnostic investigations, treatments, or operations to be performed. 15247 */ 15248 SERVICEREQUEST, 15249 /** 15250 * A slot of time on a schedule that may be available for booking appointments. 15251 */ 15252 SLOT, 15253 /** 15254 * A sample to be used for analysis. 15255 */ 15256 SPECIMEN, 15257 /** 15258 * A kind of specimen with associated set of requirements. 15259 */ 15260 SPECIMENDEFINITION, 15261 /** 15262 * 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. 15263 */ 15264 STRUCTUREDEFINITION, 15265 /** 15266 * A Map of relationships between 2 structures that can be used to transform data. 15267 */ 15268 STRUCTUREMAP, 15269 /** 15270 * The subscription resource describes a particular client's request to be notified about a SubscriptionTopic. 15271 */ 15272 SUBSCRIPTION, 15273 /** 15274 * The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted. 15275 */ 15276 SUBSCRIPTIONSTATUS, 15277 /** 15278 * Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic. 15279 */ 15280 SUBSCRIPTIONTOPIC, 15281 /** 15282 * A homogeneous material with a definite composition. 15283 */ 15284 SUBSTANCE, 15285 /** 15286 * The detailed description of a substance, typically at a level beyond what is used for prescribing. 15287 */ 15288 SUBSTANCEDEFINITION, 15289 /** 15290 * 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. 15291 */ 15292 SUBSTANCENUCLEICACID, 15293 /** 15294 * Properties of a substance specific to it being a polymer. 15295 */ 15296 SUBSTANCEPOLYMER, 15297 /** 15298 * 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. 15299 */ 15300 SUBSTANCEPROTEIN, 15301 /** 15302 * Todo. 15303 */ 15304 SUBSTANCEREFERENCEINFORMATION, 15305 /** 15306 * 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. 15307 */ 15308 SUBSTANCESOURCEMATERIAL, 15309 /** 15310 * Record of delivery of what is supplied. 15311 */ 15312 SUPPLYDELIVERY, 15313 /** 15314 * 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. 15315 */ 15316 SUPPLYREQUEST, 15317 /** 15318 * A task to be performed. 15319 */ 15320 TASK, 15321 /** 15322 * 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. 15323 */ 15324 TERMINOLOGYCAPABILITIES, 15325 /** 15326 * A plan for executing testing on an artifact or specifications 15327 */ 15328 TESTPLAN, 15329 /** 15330 * A summary of information based on the results of executing a TestScript. 15331 */ 15332 TESTREPORT, 15333 /** 15334 * A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification. 15335 */ 15336 TESTSCRIPT, 15337 /** 15338 * Record of transport. 15339 */ 15340 TRANSPORT, 15341 /** 15342 * 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). 15343 */ 15344 VALUESET, 15345 /** 15346 * Describes validation requirements, source(s), status and dates for one or more elements. 15347 */ 15348 VERIFICATIONRESULT, 15349 /** 15350 * An authorization for the provision of glasses and/or contact lenses to a patient. 15351 */ 15352 VISIONPRESCRIPTION, 15353 /** 15354 * added to help the parsers 15355 */ 15356 NULL; 15357 public static ResourceTypeEnum fromCode(String codeString) throws FHIRException { 15358 if (codeString == null || "".equals(codeString)) 15359 return null; 15360 if ("Account".equals(codeString)) 15361 return ACCOUNT; 15362 if ("ActivityDefinition".equals(codeString)) 15363 return ACTIVITYDEFINITION; 15364 if ("ActorDefinition".equals(codeString)) 15365 return ACTORDEFINITION; 15366 if ("AdministrableProductDefinition".equals(codeString)) 15367 return ADMINISTRABLEPRODUCTDEFINITION; 15368 if ("AdverseEvent".equals(codeString)) 15369 return ADVERSEEVENT; 15370 if ("AllergyIntolerance".equals(codeString)) 15371 return ALLERGYINTOLERANCE; 15372 if ("Appointment".equals(codeString)) 15373 return APPOINTMENT; 15374 if ("AppointmentResponse".equals(codeString)) 15375 return APPOINTMENTRESPONSE; 15376 if ("ArtifactAssessment".equals(codeString)) 15377 return ARTIFACTASSESSMENT; 15378 if ("AuditEvent".equals(codeString)) 15379 return AUDITEVENT; 15380 if ("Basic".equals(codeString)) 15381 return BASIC; 15382 if ("Binary".equals(codeString)) 15383 return BINARY; 15384 if ("BiologicallyDerivedProduct".equals(codeString)) 15385 return BIOLOGICALLYDERIVEDPRODUCT; 15386 if ("BiologicallyDerivedProductDispense".equals(codeString)) 15387 return BIOLOGICALLYDERIVEDPRODUCTDISPENSE; 15388 if ("BodyStructure".equals(codeString)) 15389 return BODYSTRUCTURE; 15390 if ("Bundle".equals(codeString)) 15391 return BUNDLE; 15392 if ("CapabilityStatement".equals(codeString)) 15393 return CAPABILITYSTATEMENT; 15394 if ("CarePlan".equals(codeString)) 15395 return CAREPLAN; 15396 if ("CareTeam".equals(codeString)) 15397 return CARETEAM; 15398 if ("ChargeItem".equals(codeString)) 15399 return CHARGEITEM; 15400 if ("ChargeItemDefinition".equals(codeString)) 15401 return CHARGEITEMDEFINITION; 15402 if ("Citation".equals(codeString)) 15403 return CITATION; 15404 if ("Claim".equals(codeString)) 15405 return CLAIM; 15406 if ("ClaimResponse".equals(codeString)) 15407 return CLAIMRESPONSE; 15408 if ("ClinicalImpression".equals(codeString)) 15409 return CLINICALIMPRESSION; 15410 if ("ClinicalUseDefinition".equals(codeString)) 15411 return CLINICALUSEDEFINITION; 15412 if ("CodeSystem".equals(codeString)) 15413 return CODESYSTEM; 15414 if ("Communication".equals(codeString)) 15415 return COMMUNICATION; 15416 if ("CommunicationRequest".equals(codeString)) 15417 return COMMUNICATIONREQUEST; 15418 if ("CompartmentDefinition".equals(codeString)) 15419 return COMPARTMENTDEFINITION; 15420 if ("Composition".equals(codeString)) 15421 return COMPOSITION; 15422 if ("ConceptMap".equals(codeString)) 15423 return CONCEPTMAP; 15424 if ("Condition".equals(codeString)) 15425 return CONDITION; 15426 if ("ConditionDefinition".equals(codeString)) 15427 return CONDITIONDEFINITION; 15428 if ("Consent".equals(codeString)) 15429 return CONSENT; 15430 if ("Contract".equals(codeString)) 15431 return CONTRACT; 15432 if ("Coverage".equals(codeString)) 15433 return COVERAGE; 15434 if ("CoverageEligibilityRequest".equals(codeString)) 15435 return COVERAGEELIGIBILITYREQUEST; 15436 if ("CoverageEligibilityResponse".equals(codeString)) 15437 return COVERAGEELIGIBILITYRESPONSE; 15438 if ("DetectedIssue".equals(codeString)) 15439 return DETECTEDISSUE; 15440 if ("Device".equals(codeString)) 15441 return DEVICE; 15442 if ("DeviceAssociation".equals(codeString)) 15443 return DEVICEASSOCIATION; 15444 if ("DeviceDefinition".equals(codeString)) 15445 return DEVICEDEFINITION; 15446 if ("DeviceDispense".equals(codeString)) 15447 return DEVICEDISPENSE; 15448 if ("DeviceMetric".equals(codeString)) 15449 return DEVICEMETRIC; 15450 if ("DeviceRequest".equals(codeString)) 15451 return DEVICEREQUEST; 15452 if ("DeviceUsage".equals(codeString)) 15453 return DEVICEUSAGE; 15454 if ("DiagnosticReport".equals(codeString)) 15455 return DIAGNOSTICREPORT; 15456 if ("DocumentReference".equals(codeString)) 15457 return DOCUMENTREFERENCE; 15458 if ("Encounter".equals(codeString)) 15459 return ENCOUNTER; 15460 if ("EncounterHistory".equals(codeString)) 15461 return ENCOUNTERHISTORY; 15462 if ("Endpoint".equals(codeString)) 15463 return ENDPOINT; 15464 if ("EnrollmentRequest".equals(codeString)) 15465 return ENROLLMENTREQUEST; 15466 if ("EnrollmentResponse".equals(codeString)) 15467 return ENROLLMENTRESPONSE; 15468 if ("EpisodeOfCare".equals(codeString)) 15469 return EPISODEOFCARE; 15470 if ("EventDefinition".equals(codeString)) 15471 return EVENTDEFINITION; 15472 if ("Evidence".equals(codeString)) 15473 return EVIDENCE; 15474 if ("EvidenceReport".equals(codeString)) 15475 return EVIDENCEREPORT; 15476 if ("EvidenceVariable".equals(codeString)) 15477 return EVIDENCEVARIABLE; 15478 if ("ExampleScenario".equals(codeString)) 15479 return EXAMPLESCENARIO; 15480 if ("ExplanationOfBenefit".equals(codeString)) 15481 return EXPLANATIONOFBENEFIT; 15482 if ("FamilyMemberHistory".equals(codeString)) 15483 return FAMILYMEMBERHISTORY; 15484 if ("Flag".equals(codeString)) 15485 return FLAG; 15486 if ("FormularyItem".equals(codeString)) 15487 return FORMULARYITEM; 15488 if ("GenomicStudy".equals(codeString)) 15489 return GENOMICSTUDY; 15490 if ("Goal".equals(codeString)) 15491 return GOAL; 15492 if ("GraphDefinition".equals(codeString)) 15493 return GRAPHDEFINITION; 15494 if ("Group".equals(codeString)) 15495 return GROUP; 15496 if ("GuidanceResponse".equals(codeString)) 15497 return GUIDANCERESPONSE; 15498 if ("HealthcareService".equals(codeString)) 15499 return HEALTHCARESERVICE; 15500 if ("ImagingSelection".equals(codeString)) 15501 return IMAGINGSELECTION; 15502 if ("ImagingStudy".equals(codeString)) 15503 return IMAGINGSTUDY; 15504 if ("Immunization".equals(codeString)) 15505 return IMMUNIZATION; 15506 if ("ImmunizationEvaluation".equals(codeString)) 15507 return IMMUNIZATIONEVALUATION; 15508 if ("ImmunizationRecommendation".equals(codeString)) 15509 return IMMUNIZATIONRECOMMENDATION; 15510 if ("ImplementationGuide".equals(codeString)) 15511 return IMPLEMENTATIONGUIDE; 15512 if ("Ingredient".equals(codeString)) 15513 return INGREDIENT; 15514 if ("InsurancePlan".equals(codeString)) 15515 return INSURANCEPLAN; 15516 if ("InventoryItem".equals(codeString)) 15517 return INVENTORYITEM; 15518 if ("InventoryReport".equals(codeString)) 15519 return INVENTORYREPORT; 15520 if ("Invoice".equals(codeString)) 15521 return INVOICE; 15522 if ("Library".equals(codeString)) 15523 return LIBRARY; 15524 if ("Linkage".equals(codeString)) 15525 return LINKAGE; 15526 if ("List".equals(codeString)) 15527 return LIST; 15528 if ("Location".equals(codeString)) 15529 return LOCATION; 15530 if ("ManufacturedItemDefinition".equals(codeString)) 15531 return MANUFACTUREDITEMDEFINITION; 15532 if ("Measure".equals(codeString)) 15533 return MEASURE; 15534 if ("MeasureReport".equals(codeString)) 15535 return MEASUREREPORT; 15536 if ("Medication".equals(codeString)) 15537 return MEDICATION; 15538 if ("MedicationAdministration".equals(codeString)) 15539 return MEDICATIONADMINISTRATION; 15540 if ("MedicationDispense".equals(codeString)) 15541 return MEDICATIONDISPENSE; 15542 if ("MedicationKnowledge".equals(codeString)) 15543 return MEDICATIONKNOWLEDGE; 15544 if ("MedicationRequest".equals(codeString)) 15545 return MEDICATIONREQUEST; 15546 if ("MedicationStatement".equals(codeString)) 15547 return MEDICATIONSTATEMENT; 15548 if ("MedicinalProductDefinition".equals(codeString)) 15549 return MEDICINALPRODUCTDEFINITION; 15550 if ("MessageDefinition".equals(codeString)) 15551 return MESSAGEDEFINITION; 15552 if ("MessageHeader".equals(codeString)) 15553 return MESSAGEHEADER; 15554 if ("MolecularSequence".equals(codeString)) 15555 return MOLECULARSEQUENCE; 15556 if ("NamingSystem".equals(codeString)) 15557 return NAMINGSYSTEM; 15558 if ("NutritionIntake".equals(codeString)) 15559 return NUTRITIONINTAKE; 15560 if ("NutritionOrder".equals(codeString)) 15561 return NUTRITIONORDER; 15562 if ("NutritionProduct".equals(codeString)) 15563 return NUTRITIONPRODUCT; 15564 if ("Observation".equals(codeString)) 15565 return OBSERVATION; 15566 if ("ObservationDefinition".equals(codeString)) 15567 return OBSERVATIONDEFINITION; 15568 if ("OperationDefinition".equals(codeString)) 15569 return OPERATIONDEFINITION; 15570 if ("OperationOutcome".equals(codeString)) 15571 return OPERATIONOUTCOME; 15572 if ("Organization".equals(codeString)) 15573 return ORGANIZATION; 15574 if ("OrganizationAffiliation".equals(codeString)) 15575 return ORGANIZATIONAFFILIATION; 15576 if ("PackagedProductDefinition".equals(codeString)) 15577 return PACKAGEDPRODUCTDEFINITION; 15578 if ("Parameters".equals(codeString)) 15579 return PARAMETERS; 15580 if ("Patient".equals(codeString)) 15581 return PATIENT; 15582 if ("PaymentNotice".equals(codeString)) 15583 return PAYMENTNOTICE; 15584 if ("PaymentReconciliation".equals(codeString)) 15585 return PAYMENTRECONCILIATION; 15586 if ("Permission".equals(codeString)) 15587 return PERMISSION; 15588 if ("Person".equals(codeString)) 15589 return PERSON; 15590 if ("PlanDefinition".equals(codeString)) 15591 return PLANDEFINITION; 15592 if ("Practitioner".equals(codeString)) 15593 return PRACTITIONER; 15594 if ("PractitionerRole".equals(codeString)) 15595 return PRACTITIONERROLE; 15596 if ("Procedure".equals(codeString)) 15597 return PROCEDURE; 15598 if ("Provenance".equals(codeString)) 15599 return PROVENANCE; 15600 if ("Questionnaire".equals(codeString)) 15601 return QUESTIONNAIRE; 15602 if ("QuestionnaireResponse".equals(codeString)) 15603 return QUESTIONNAIRERESPONSE; 15604 if ("RegulatedAuthorization".equals(codeString)) 15605 return REGULATEDAUTHORIZATION; 15606 if ("RelatedPerson".equals(codeString)) 15607 return RELATEDPERSON; 15608 if ("RequestOrchestration".equals(codeString)) 15609 return REQUESTORCHESTRATION; 15610 if ("Requirements".equals(codeString)) 15611 return REQUIREMENTS; 15612 if ("ResearchStudy".equals(codeString)) 15613 return RESEARCHSTUDY; 15614 if ("ResearchSubject".equals(codeString)) 15615 return RESEARCHSUBJECT; 15616 if ("RiskAssessment".equals(codeString)) 15617 return RISKASSESSMENT; 15618 if ("Schedule".equals(codeString)) 15619 return SCHEDULE; 15620 if ("SearchParameter".equals(codeString)) 15621 return SEARCHPARAMETER; 15622 if ("ServiceRequest".equals(codeString)) 15623 return SERVICEREQUEST; 15624 if ("Slot".equals(codeString)) 15625 return SLOT; 15626 if ("Specimen".equals(codeString)) 15627 return SPECIMEN; 15628 if ("SpecimenDefinition".equals(codeString)) 15629 return SPECIMENDEFINITION; 15630 if ("StructureDefinition".equals(codeString)) 15631 return STRUCTUREDEFINITION; 15632 if ("StructureMap".equals(codeString)) 15633 return STRUCTUREMAP; 15634 if ("Subscription".equals(codeString)) 15635 return SUBSCRIPTION; 15636 if ("SubscriptionStatus".equals(codeString)) 15637 return SUBSCRIPTIONSTATUS; 15638 if ("SubscriptionTopic".equals(codeString)) 15639 return SUBSCRIPTIONTOPIC; 15640 if ("Substance".equals(codeString)) 15641 return SUBSTANCE; 15642 if ("SubstanceDefinition".equals(codeString)) 15643 return SUBSTANCEDEFINITION; 15644 if ("SubstanceNucleicAcid".equals(codeString)) 15645 return SUBSTANCENUCLEICACID; 15646 if ("SubstancePolymer".equals(codeString)) 15647 return SUBSTANCEPOLYMER; 15648 if ("SubstanceProtein".equals(codeString)) 15649 return SUBSTANCEPROTEIN; 15650 if ("SubstanceReferenceInformation".equals(codeString)) 15651 return SUBSTANCEREFERENCEINFORMATION; 15652 if ("SubstanceSourceMaterial".equals(codeString)) 15653 return SUBSTANCESOURCEMATERIAL; 15654 if ("SupplyDelivery".equals(codeString)) 15655 return SUPPLYDELIVERY; 15656 if ("SupplyRequest".equals(codeString)) 15657 return SUPPLYREQUEST; 15658 if ("Task".equals(codeString)) 15659 return TASK; 15660 if ("TerminologyCapabilities".equals(codeString)) 15661 return TERMINOLOGYCAPABILITIES; 15662 if ("TestPlan".equals(codeString)) 15663 return TESTPLAN; 15664 if ("TestReport".equals(codeString)) 15665 return TESTREPORT; 15666 if ("TestScript".equals(codeString)) 15667 return TESTSCRIPT; 15668 if ("Transport".equals(codeString)) 15669 return TRANSPORT; 15670 if ("ValueSet".equals(codeString)) 15671 return VALUESET; 15672 if ("VerificationResult".equals(codeString)) 15673 return VERIFICATIONRESULT; 15674 if ("VisionPrescription".equals(codeString)) 15675 return VISIONPRESCRIPTION; 15676 throw new FHIRException("Unknown ResourceTypeEnum code '"+codeString+"'"); 15677 } 15678 public static boolean isValidCode(String codeString) { 15679 if (codeString == null || "".equals(codeString)) 15680 return false; 15681 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"); 15682 } 15683 public String toCode() { 15684 switch (this) { 15685 case ACCOUNT: return "Account"; 15686 case ACTIVITYDEFINITION: return "ActivityDefinition"; 15687 case ACTORDEFINITION: return "ActorDefinition"; 15688 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 15689 case ADVERSEEVENT: return "AdverseEvent"; 15690 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 15691 case APPOINTMENT: return "Appointment"; 15692 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 15693 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 15694 case AUDITEVENT: return "AuditEvent"; 15695 case BASIC: return "Basic"; 15696 case BINARY: return "Binary"; 15697 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 15698 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "BiologicallyDerivedProductDispense"; 15699 case BODYSTRUCTURE: return "BodyStructure"; 15700 case BUNDLE: return "Bundle"; 15701 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 15702 case CAREPLAN: return "CarePlan"; 15703 case CARETEAM: return "CareTeam"; 15704 case CHARGEITEM: return "ChargeItem"; 15705 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 15706 case CITATION: return "Citation"; 15707 case CLAIM: return "Claim"; 15708 case CLAIMRESPONSE: return "ClaimResponse"; 15709 case CLINICALIMPRESSION: return "ClinicalImpression"; 15710 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 15711 case CODESYSTEM: return "CodeSystem"; 15712 case COMMUNICATION: return "Communication"; 15713 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 15714 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 15715 case COMPOSITION: return "Composition"; 15716 case CONCEPTMAP: return "ConceptMap"; 15717 case CONDITION: return "Condition"; 15718 case CONDITIONDEFINITION: return "ConditionDefinition"; 15719 case CONSENT: return "Consent"; 15720 case CONTRACT: return "Contract"; 15721 case COVERAGE: return "Coverage"; 15722 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 15723 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 15724 case DETECTEDISSUE: return "DetectedIssue"; 15725 case DEVICE: return "Device"; 15726 case DEVICEASSOCIATION: return "DeviceAssociation"; 15727 case DEVICEDEFINITION: return "DeviceDefinition"; 15728 case DEVICEDISPENSE: return "DeviceDispense"; 15729 case DEVICEMETRIC: return "DeviceMetric"; 15730 case DEVICEREQUEST: return "DeviceRequest"; 15731 case DEVICEUSAGE: return "DeviceUsage"; 15732 case DIAGNOSTICREPORT: return "DiagnosticReport"; 15733 case DOCUMENTREFERENCE: return "DocumentReference"; 15734 case ENCOUNTER: return "Encounter"; 15735 case ENCOUNTERHISTORY: return "EncounterHistory"; 15736 case ENDPOINT: return "Endpoint"; 15737 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 15738 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 15739 case EPISODEOFCARE: return "EpisodeOfCare"; 15740 case EVENTDEFINITION: return "EventDefinition"; 15741 case EVIDENCE: return "Evidence"; 15742 case EVIDENCEREPORT: return "EvidenceReport"; 15743 case EVIDENCEVARIABLE: return "EvidenceVariable"; 15744 case EXAMPLESCENARIO: return "ExampleScenario"; 15745 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 15746 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 15747 case FLAG: return "Flag"; 15748 case FORMULARYITEM: return "FormularyItem"; 15749 case GENOMICSTUDY: return "GenomicStudy"; 15750 case GOAL: return "Goal"; 15751 case GRAPHDEFINITION: return "GraphDefinition"; 15752 case GROUP: return "Group"; 15753 case GUIDANCERESPONSE: return "GuidanceResponse"; 15754 case HEALTHCARESERVICE: return "HealthcareService"; 15755 case IMAGINGSELECTION: return "ImagingSelection"; 15756 case IMAGINGSTUDY: return "ImagingStudy"; 15757 case IMMUNIZATION: return "Immunization"; 15758 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 15759 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 15760 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 15761 case INGREDIENT: return "Ingredient"; 15762 case INSURANCEPLAN: return "InsurancePlan"; 15763 case INVENTORYITEM: return "InventoryItem"; 15764 case INVENTORYREPORT: return "InventoryReport"; 15765 case INVOICE: return "Invoice"; 15766 case LIBRARY: return "Library"; 15767 case LINKAGE: return "Linkage"; 15768 case LIST: return "List"; 15769 case LOCATION: return "Location"; 15770 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 15771 case MEASURE: return "Measure"; 15772 case MEASUREREPORT: return "MeasureReport"; 15773 case MEDICATION: return "Medication"; 15774 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 15775 case MEDICATIONDISPENSE: return "MedicationDispense"; 15776 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 15777 case MEDICATIONREQUEST: return "MedicationRequest"; 15778 case MEDICATIONSTATEMENT: return "MedicationStatement"; 15779 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 15780 case MESSAGEDEFINITION: return "MessageDefinition"; 15781 case MESSAGEHEADER: return "MessageHeader"; 15782 case MOLECULARSEQUENCE: return "MolecularSequence"; 15783 case NAMINGSYSTEM: return "NamingSystem"; 15784 case NUTRITIONINTAKE: return "NutritionIntake"; 15785 case NUTRITIONORDER: return "NutritionOrder"; 15786 case NUTRITIONPRODUCT: return "NutritionProduct"; 15787 case OBSERVATION: return "Observation"; 15788 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 15789 case OPERATIONDEFINITION: return "OperationDefinition"; 15790 case OPERATIONOUTCOME: return "OperationOutcome"; 15791 case ORGANIZATION: return "Organization"; 15792 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 15793 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 15794 case PARAMETERS: return "Parameters"; 15795 case PATIENT: return "Patient"; 15796 case PAYMENTNOTICE: return "PaymentNotice"; 15797 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 15798 case PERMISSION: return "Permission"; 15799 case PERSON: return "Person"; 15800 case PLANDEFINITION: return "PlanDefinition"; 15801 case PRACTITIONER: return "Practitioner"; 15802 case PRACTITIONERROLE: return "PractitionerRole"; 15803 case PROCEDURE: return "Procedure"; 15804 case PROVENANCE: return "Provenance"; 15805 case QUESTIONNAIRE: return "Questionnaire"; 15806 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 15807 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 15808 case RELATEDPERSON: return "RelatedPerson"; 15809 case REQUESTORCHESTRATION: return "RequestOrchestration"; 15810 case REQUIREMENTS: return "Requirements"; 15811 case RESEARCHSTUDY: return "ResearchStudy"; 15812 case RESEARCHSUBJECT: return "ResearchSubject"; 15813 case RISKASSESSMENT: return "RiskAssessment"; 15814 case SCHEDULE: return "Schedule"; 15815 case SEARCHPARAMETER: return "SearchParameter"; 15816 case SERVICEREQUEST: return "ServiceRequest"; 15817 case SLOT: return "Slot"; 15818 case SPECIMEN: return "Specimen"; 15819 case SPECIMENDEFINITION: return "SpecimenDefinition"; 15820 case STRUCTUREDEFINITION: return "StructureDefinition"; 15821 case STRUCTUREMAP: return "StructureMap"; 15822 case SUBSCRIPTION: return "Subscription"; 15823 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 15824 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 15825 case SUBSTANCE: return "Substance"; 15826 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 15827 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 15828 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 15829 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 15830 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 15831 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 15832 case SUPPLYDELIVERY: return "SupplyDelivery"; 15833 case SUPPLYREQUEST: return "SupplyRequest"; 15834 case TASK: return "Task"; 15835 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 15836 case TESTPLAN: return "TestPlan"; 15837 case TESTREPORT: return "TestReport"; 15838 case TESTSCRIPT: return "TestScript"; 15839 case TRANSPORT: return "Transport"; 15840 case VALUESET: return "ValueSet"; 15841 case VERIFICATIONRESULT: return "VerificationResult"; 15842 case VISIONPRESCRIPTION: return "VisionPrescription"; 15843 case NULL: return null; 15844 default: return "?"; 15845 } 15846 } 15847 public String getSystem() { 15848 switch (this) { 15849 case ACCOUNT: return "http://hl7.org/fhir/fhir-types"; 15850 case ACTIVITYDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15851 case ACTORDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15852 case ADMINISTRABLEPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15853 case ADVERSEEVENT: return "http://hl7.org/fhir/fhir-types"; 15854 case ALLERGYINTOLERANCE: return "http://hl7.org/fhir/fhir-types"; 15855 case APPOINTMENT: return "http://hl7.org/fhir/fhir-types"; 15856 case APPOINTMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 15857 case ARTIFACTASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 15858 case AUDITEVENT: return "http://hl7.org/fhir/fhir-types"; 15859 case BASIC: return "http://hl7.org/fhir/fhir-types"; 15860 case BINARY: return "http://hl7.org/fhir/fhir-types"; 15861 case BIOLOGICALLYDERIVEDPRODUCT: return "http://hl7.org/fhir/fhir-types"; 15862 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "http://hl7.org/fhir/fhir-types"; 15863 case BODYSTRUCTURE: return "http://hl7.org/fhir/fhir-types"; 15864 case BUNDLE: return "http://hl7.org/fhir/fhir-types"; 15865 case CAPABILITYSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 15866 case CAREPLAN: return "http://hl7.org/fhir/fhir-types"; 15867 case CARETEAM: return "http://hl7.org/fhir/fhir-types"; 15868 case CHARGEITEM: return "http://hl7.org/fhir/fhir-types"; 15869 case CHARGEITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15870 case CITATION: return "http://hl7.org/fhir/fhir-types"; 15871 case CLAIM: return "http://hl7.org/fhir/fhir-types"; 15872 case CLAIMRESPONSE: return "http://hl7.org/fhir/fhir-types"; 15873 case CLINICALIMPRESSION: return "http://hl7.org/fhir/fhir-types"; 15874 case CLINICALUSEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15875 case CODESYSTEM: return "http://hl7.org/fhir/fhir-types"; 15876 case COMMUNICATION: return "http://hl7.org/fhir/fhir-types"; 15877 case COMMUNICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 15878 case COMPARTMENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15879 case COMPOSITION: return "http://hl7.org/fhir/fhir-types"; 15880 case CONCEPTMAP: return "http://hl7.org/fhir/fhir-types"; 15881 case CONDITION: return "http://hl7.org/fhir/fhir-types"; 15882 case CONDITIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15883 case CONSENT: return "http://hl7.org/fhir/fhir-types"; 15884 case CONTRACT: return "http://hl7.org/fhir/fhir-types"; 15885 case COVERAGE: return "http://hl7.org/fhir/fhir-types"; 15886 case COVERAGEELIGIBILITYREQUEST: return "http://hl7.org/fhir/fhir-types"; 15887 case COVERAGEELIGIBILITYRESPONSE: return "http://hl7.org/fhir/fhir-types"; 15888 case DETECTEDISSUE: return "http://hl7.org/fhir/fhir-types"; 15889 case DEVICE: return "http://hl7.org/fhir/fhir-types"; 15890 case DEVICEASSOCIATION: return "http://hl7.org/fhir/fhir-types"; 15891 case DEVICEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15892 case DEVICEDISPENSE: return "http://hl7.org/fhir/fhir-types"; 15893 case DEVICEMETRIC: return "http://hl7.org/fhir/fhir-types"; 15894 case DEVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 15895 case DEVICEUSAGE: return "http://hl7.org/fhir/fhir-types"; 15896 case DIAGNOSTICREPORT: return "http://hl7.org/fhir/fhir-types"; 15897 case DOCUMENTREFERENCE: return "http://hl7.org/fhir/fhir-types"; 15898 case ENCOUNTER: return "http://hl7.org/fhir/fhir-types"; 15899 case ENCOUNTERHISTORY: return "http://hl7.org/fhir/fhir-types"; 15900 case ENDPOINT: return "http://hl7.org/fhir/fhir-types"; 15901 case ENROLLMENTREQUEST: return "http://hl7.org/fhir/fhir-types"; 15902 case ENROLLMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 15903 case EPISODEOFCARE: return "http://hl7.org/fhir/fhir-types"; 15904 case EVENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15905 case EVIDENCE: return "http://hl7.org/fhir/fhir-types"; 15906 case EVIDENCEREPORT: return "http://hl7.org/fhir/fhir-types"; 15907 case EVIDENCEVARIABLE: return "http://hl7.org/fhir/fhir-types"; 15908 case EXAMPLESCENARIO: return "http://hl7.org/fhir/fhir-types"; 15909 case EXPLANATIONOFBENEFIT: return "http://hl7.org/fhir/fhir-types"; 15910 case FAMILYMEMBERHISTORY: return "http://hl7.org/fhir/fhir-types"; 15911 case FLAG: return "http://hl7.org/fhir/fhir-types"; 15912 case FORMULARYITEM: return "http://hl7.org/fhir/fhir-types"; 15913 case GENOMICSTUDY: return "http://hl7.org/fhir/fhir-types"; 15914 case GOAL: return "http://hl7.org/fhir/fhir-types"; 15915 case GRAPHDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15916 case GROUP: return "http://hl7.org/fhir/fhir-types"; 15917 case GUIDANCERESPONSE: return "http://hl7.org/fhir/fhir-types"; 15918 case HEALTHCARESERVICE: return "http://hl7.org/fhir/fhir-types"; 15919 case IMAGINGSELECTION: return "http://hl7.org/fhir/fhir-types"; 15920 case IMAGINGSTUDY: return "http://hl7.org/fhir/fhir-types"; 15921 case IMMUNIZATION: return "http://hl7.org/fhir/fhir-types"; 15922 case IMMUNIZATIONEVALUATION: return "http://hl7.org/fhir/fhir-types"; 15923 case IMMUNIZATIONRECOMMENDATION: return "http://hl7.org/fhir/fhir-types"; 15924 case IMPLEMENTATIONGUIDE: return "http://hl7.org/fhir/fhir-types"; 15925 case INGREDIENT: return "http://hl7.org/fhir/fhir-types"; 15926 case INSURANCEPLAN: return "http://hl7.org/fhir/fhir-types"; 15927 case INVENTORYITEM: return "http://hl7.org/fhir/fhir-types"; 15928 case INVENTORYREPORT: return "http://hl7.org/fhir/fhir-types"; 15929 case INVOICE: return "http://hl7.org/fhir/fhir-types"; 15930 case LIBRARY: return "http://hl7.org/fhir/fhir-types"; 15931 case LINKAGE: return "http://hl7.org/fhir/fhir-types"; 15932 case LIST: return "http://hl7.org/fhir/fhir-types"; 15933 case LOCATION: return "http://hl7.org/fhir/fhir-types"; 15934 case MANUFACTUREDITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15935 case MEASURE: return "http://hl7.org/fhir/fhir-types"; 15936 case MEASUREREPORT: return "http://hl7.org/fhir/fhir-types"; 15937 case MEDICATION: return "http://hl7.org/fhir/fhir-types"; 15938 case MEDICATIONADMINISTRATION: return "http://hl7.org/fhir/fhir-types"; 15939 case MEDICATIONDISPENSE: return "http://hl7.org/fhir/fhir-types"; 15940 case MEDICATIONKNOWLEDGE: return "http://hl7.org/fhir/fhir-types"; 15941 case MEDICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 15942 case MEDICATIONSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 15943 case MEDICINALPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15944 case MESSAGEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15945 case MESSAGEHEADER: return "http://hl7.org/fhir/fhir-types"; 15946 case MOLECULARSEQUENCE: return "http://hl7.org/fhir/fhir-types"; 15947 case NAMINGSYSTEM: return "http://hl7.org/fhir/fhir-types"; 15948 case NUTRITIONINTAKE: return "http://hl7.org/fhir/fhir-types"; 15949 case NUTRITIONORDER: return "http://hl7.org/fhir/fhir-types"; 15950 case NUTRITIONPRODUCT: return "http://hl7.org/fhir/fhir-types"; 15951 case OBSERVATION: return "http://hl7.org/fhir/fhir-types"; 15952 case OBSERVATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15953 case OPERATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15954 case OPERATIONOUTCOME: return "http://hl7.org/fhir/fhir-types"; 15955 case ORGANIZATION: return "http://hl7.org/fhir/fhir-types"; 15956 case ORGANIZATIONAFFILIATION: return "http://hl7.org/fhir/fhir-types"; 15957 case PACKAGEDPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15958 case PARAMETERS: return "http://hl7.org/fhir/fhir-types"; 15959 case PATIENT: return "http://hl7.org/fhir/fhir-types"; 15960 case PAYMENTNOTICE: return "http://hl7.org/fhir/fhir-types"; 15961 case PAYMENTRECONCILIATION: return "http://hl7.org/fhir/fhir-types"; 15962 case PERMISSION: return "http://hl7.org/fhir/fhir-types"; 15963 case PERSON: return "http://hl7.org/fhir/fhir-types"; 15964 case PLANDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15965 case PRACTITIONER: return "http://hl7.org/fhir/fhir-types"; 15966 case PRACTITIONERROLE: return "http://hl7.org/fhir/fhir-types"; 15967 case PROCEDURE: return "http://hl7.org/fhir/fhir-types"; 15968 case PROVENANCE: return "http://hl7.org/fhir/fhir-types"; 15969 case QUESTIONNAIRE: return "http://hl7.org/fhir/fhir-types"; 15970 case QUESTIONNAIRERESPONSE: return "http://hl7.org/fhir/fhir-types"; 15971 case REGULATEDAUTHORIZATION: return "http://hl7.org/fhir/fhir-types"; 15972 case RELATEDPERSON: return "http://hl7.org/fhir/fhir-types"; 15973 case REQUESTORCHESTRATION: return "http://hl7.org/fhir/fhir-types"; 15974 case REQUIREMENTS: return "http://hl7.org/fhir/fhir-types"; 15975 case RESEARCHSTUDY: return "http://hl7.org/fhir/fhir-types"; 15976 case RESEARCHSUBJECT: return "http://hl7.org/fhir/fhir-types"; 15977 case RISKASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 15978 case SCHEDULE: return "http://hl7.org/fhir/fhir-types"; 15979 case SEARCHPARAMETER: return "http://hl7.org/fhir/fhir-types"; 15980 case SERVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 15981 case SLOT: return "http://hl7.org/fhir/fhir-types"; 15982 case SPECIMEN: return "http://hl7.org/fhir/fhir-types"; 15983 case SPECIMENDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15984 case STRUCTUREDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15985 case STRUCTUREMAP: return "http://hl7.org/fhir/fhir-types"; 15986 case SUBSCRIPTION: return "http://hl7.org/fhir/fhir-types"; 15987 case SUBSCRIPTIONSTATUS: return "http://hl7.org/fhir/fhir-types"; 15988 case SUBSCRIPTIONTOPIC: return "http://hl7.org/fhir/fhir-types"; 15989 case SUBSTANCE: return "http://hl7.org/fhir/fhir-types"; 15990 case SUBSTANCEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15991 case SUBSTANCENUCLEICACID: return "http://hl7.org/fhir/fhir-types"; 15992 case SUBSTANCEPOLYMER: return "http://hl7.org/fhir/fhir-types"; 15993 case SUBSTANCEPROTEIN: return "http://hl7.org/fhir/fhir-types"; 15994 case SUBSTANCEREFERENCEINFORMATION: return "http://hl7.org/fhir/fhir-types"; 15995 case SUBSTANCESOURCEMATERIAL: return "http://hl7.org/fhir/fhir-types"; 15996 case SUPPLYDELIVERY: return "http://hl7.org/fhir/fhir-types"; 15997 case SUPPLYREQUEST: return "http://hl7.org/fhir/fhir-types"; 15998 case TASK: return "http://hl7.org/fhir/fhir-types"; 15999 case TERMINOLOGYCAPABILITIES: return "http://hl7.org/fhir/fhir-types"; 16000 case TESTPLAN: return "http://hl7.org/fhir/fhir-types"; 16001 case TESTREPORT: return "http://hl7.org/fhir/fhir-types"; 16002 case TESTSCRIPT: return "http://hl7.org/fhir/fhir-types"; 16003 case TRANSPORT: return "http://hl7.org/fhir/fhir-types"; 16004 case VALUESET: return "http://hl7.org/fhir/fhir-types"; 16005 case VERIFICATIONRESULT: return "http://hl7.org/fhir/fhir-types"; 16006 case VISIONPRESCRIPTION: return "http://hl7.org/fhir/fhir-types"; 16007 case NULL: return null; 16008 default: return "?"; 16009 } 16010 } 16011 public String getDefinition() { 16012 switch (this) { 16013 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."; 16014 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."; 16015 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."; 16016 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)."; 16017 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."; 16018 case ALLERGYINTOLERANCE: return "Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance."; 16019 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)."; 16020 case APPOINTMENTRESPONSE: return "A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection."; 16021 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."; 16022 case AUDITEVENT: return "A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis."; 16023 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."; 16024 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."; 16025 case BIOLOGICALLYDERIVEDPRODUCT: return "A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity."; 16026 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "A record of dispensation of a biologically derived product."; 16027 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."; 16028 case BUNDLE: return "A container for a collection of resources."; 16029 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."; 16030 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."; 16031 case CARETEAM: return "The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care."; 16032 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."; 16033 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."; 16034 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."; 16035 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."; 16036 case CLAIMRESPONSE: return "This resource provides the adjudication details from the processing of a Claim resource."; 16037 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."; 16038 case CLINICALUSEDEFINITION: return "A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure."; 16039 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."; 16040 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."; 16041 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."; 16042 case COMPARTMENTDEFINITION: return "A compartment definition that defines how resources are accessed on a server."; 16043 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.)."; 16044 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."; 16045 case CONDITION: return "A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern."; 16046 case CONDITIONDEFINITION: return "A definition of a condition and information relevant to managing it."; 16047 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."; 16048 case CONTRACT: return "Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement."; 16049 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."; 16050 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."; 16051 case COVERAGEELIGIBILITYRESPONSE: return "This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource."; 16052 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."; 16053 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."; 16054 case DEVICEASSOCIATION: return "A record of association of a device."; 16055 case DEVICEDEFINITION: return "This is a specialized resource that defines the characteristics and capabilities of a device."; 16056 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."; 16057 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. "; 16058 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."; 16059 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."; 16060 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."; 16061 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."; 16062 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)."; 16063 case ENCOUNTERHISTORY: return "A record of significant events/milestones key data throughout the history of an Encounter"; 16064 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."; 16065 case ENROLLMENTREQUEST: return "This resource provides the insurance enrollment details to the insurer regarding a specified coverage."; 16066 case ENROLLMENTRESPONSE: return "This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource."; 16067 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."; 16068 case EVENTDEFINITION: return "The EventDefinition resource provides a reusable description of when a particular event can occur."; 16069 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."; 16070 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."; 16071 case EVIDENCEVARIABLE: return "The EvidenceVariable resource describes an element that knowledge (Evidence) is about."; 16072 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."; 16073 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."; 16074 case FAMILYMEMBERHISTORY: return "Significant health conditions for a person related to the patient relevant in the context of care for the patient."; 16075 case FLAG: return "Prospective warnings of potential issues when providing care to the patient."; 16076 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."; 16077 case GENOMICSTUDY: return "A set of analyses performed to analyze and generate genomic data."; 16078 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."; 16079 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."; 16080 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."; 16081 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."; 16082 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."; 16083 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."; 16084 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."; 16085 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."; 16086 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."; 16087 case IMMUNIZATIONRECOMMENDATION: return "A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification."; 16088 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."; 16089 case INGREDIENT: return "An ingredient of a manufactured item or pharmaceutical product."; 16090 case INSURANCEPLAN: return "Details of a Health Insurance product/plan provided by an organization."; 16091 case INVENTORYITEM: return "functional description of an inventory item used in inventory and supply-related workflows."; 16092 case INVENTORYREPORT: return "A report of inventory or stock items."; 16093 case INVOICE: return "Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose."; 16094 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."; 16095 case LINKAGE: return "Identifies two or more records (resource instances) that refer to the same real-world \"occurrence\"."; 16096 case LIST: return "A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc."; 16097 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."; 16098 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."; 16099 case MEASURE: return "The Measure resource provides the definition of a quality measure."; 16100 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."; 16101 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."; 16102 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."; 16103 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."; 16104 case MEDICATIONKNOWLEDGE: return "Information about a medication that is used to support knowledge."; 16105 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."; 16106 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."; 16107 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.)."; 16108 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."; 16109 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."; 16110 case MOLECULARSEQUENCE: return "Representation of a molecular sequence."; 16111 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."; 16112 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."; 16113 case NUTRITIONORDER: return "A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident."; 16114 case NUTRITIONPRODUCT: return "A food or supplement that is consumed by patients."; 16115 case OBSERVATION: return "Measurements and simple assertions made about a patient, device or other subject."; 16116 case OBSERVATIONDEFINITION: return "Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service."; 16117 case OPERATIONDEFINITION: return "A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction)."; 16118 case OPERATIONOUTCOME: return "A collection of error, warning, or information messages that result from a system action."; 16119 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."; 16120 case ORGANIZATIONAFFILIATION: return "Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship."; 16121 case PACKAGEDPRODUCTDEFINITION: return "A medically related item or items, in a container or package."; 16122 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."; 16123 case PATIENT: return "Demographics and other administrative information about an individual or animal receiving care or other health-related services."; 16124 case PAYMENTNOTICE: return "This resource provides the status of the payment for goods and services rendered, and the request and response resource references."; 16125 case PAYMENTRECONCILIATION: return "This resource provides the details including amount of a payment and allocates the payment items being paid."; 16126 case PERMISSION: return "Permission resource holds access rules for a given data and context."; 16127 case PERSON: return "Demographics and administrative information about a person independent of a specific health-related context."; 16128 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."; 16129 case PRACTITIONER: return "A person who is directly or indirectly involved in the provisioning of healthcare or related services."; 16130 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."; 16131 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."; 16132 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."; 16133 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."; 16134 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."; 16135 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."; 16136 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."; 16137 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\"."; 16138 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."; 16139 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."; 16140 case RESEARCHSUBJECT: return "A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study."; 16141 case RISKASSESSMENT: return "An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome."; 16142 case SCHEDULE: return "A container for slots of time that may be available for booking appointments."; 16143 case SEARCHPARAMETER: return "A search parameter that defines a named search item that can be used to search/filter on a resource."; 16144 case SERVICEREQUEST: return "A record of a request for service such as diagnostic investigations, treatments, or operations to be performed."; 16145 case SLOT: return "A slot of time on a schedule that may be available for booking appointments."; 16146 case SPECIMEN: return "A sample to be used for analysis."; 16147 case SPECIMENDEFINITION: return "A kind of specimen with associated set of requirements."; 16148 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."; 16149 case STRUCTUREMAP: return "A Map of relationships between 2 structures that can be used to transform data."; 16150 case SUBSCRIPTION: return "The subscription resource describes a particular client's request to be notified about a SubscriptionTopic."; 16151 case SUBSCRIPTIONSTATUS: return "The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted."; 16152 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."; 16153 case SUBSTANCE: return "A homogeneous material with a definite composition."; 16154 case SUBSTANCEDEFINITION: return "The detailed description of a substance, typically at a level beyond what is used for prescribing."; 16155 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."; 16156 case SUBSTANCEPOLYMER: return "Properties of a substance specific to it being a polymer."; 16157 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."; 16158 case SUBSTANCEREFERENCEINFORMATION: return "Todo."; 16159 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."; 16160 case SUPPLYDELIVERY: return "Record of delivery of what is supplied."; 16161 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."; 16162 case TASK: return "A task to be performed."; 16163 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."; 16164 case TESTPLAN: return "A plan for executing testing on an artifact or specifications"; 16165 case TESTREPORT: return "A summary of information based on the results of executing a TestScript."; 16166 case TESTSCRIPT: return "A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification."; 16167 case TRANSPORT: return "Record of transport."; 16168 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)."; 16169 case VERIFICATIONRESULT: return "Describes validation requirements, source(s), status and dates for one or more elements."; 16170 case VISIONPRESCRIPTION: return "An authorization for the provision of glasses and/or contact lenses to a patient."; 16171 case NULL: return null; 16172 default: return "?"; 16173 } 16174 } 16175 public String getDisplay() { 16176 switch (this) { 16177 case ACCOUNT: return "Account"; 16178 case ACTIVITYDEFINITION: return "ActivityDefinition"; 16179 case ACTORDEFINITION: return "ActorDefinition"; 16180 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 16181 case ADVERSEEVENT: return "AdverseEvent"; 16182 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 16183 case APPOINTMENT: return "Appointment"; 16184 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 16185 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 16186 case AUDITEVENT: return "AuditEvent"; 16187 case BASIC: return "Basic"; 16188 case BINARY: return "Binary"; 16189 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 16190 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "BiologicallyDerivedProductDispense"; 16191 case BODYSTRUCTURE: return "BodyStructure"; 16192 case BUNDLE: return "Bundle"; 16193 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 16194 case CAREPLAN: return "CarePlan"; 16195 case CARETEAM: return "CareTeam"; 16196 case CHARGEITEM: return "ChargeItem"; 16197 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 16198 case CITATION: return "Citation"; 16199 case CLAIM: return "Claim"; 16200 case CLAIMRESPONSE: return "ClaimResponse"; 16201 case CLINICALIMPRESSION: return "ClinicalImpression"; 16202 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 16203 case CODESYSTEM: return "CodeSystem"; 16204 case COMMUNICATION: return "Communication"; 16205 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 16206 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 16207 case COMPOSITION: return "Composition"; 16208 case CONCEPTMAP: return "ConceptMap"; 16209 case CONDITION: return "Condition"; 16210 case CONDITIONDEFINITION: return "ConditionDefinition"; 16211 case CONSENT: return "Consent"; 16212 case CONTRACT: return "Contract"; 16213 case COVERAGE: return "Coverage"; 16214 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 16215 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 16216 case DETECTEDISSUE: return "DetectedIssue"; 16217 case DEVICE: return "Device"; 16218 case DEVICEASSOCIATION: return "DeviceAssociation"; 16219 case DEVICEDEFINITION: return "DeviceDefinition"; 16220 case DEVICEDISPENSE: return "DeviceDispense"; 16221 case DEVICEMETRIC: return "DeviceMetric"; 16222 case DEVICEREQUEST: return "DeviceRequest"; 16223 case DEVICEUSAGE: return "DeviceUsage"; 16224 case DIAGNOSTICREPORT: return "DiagnosticReport"; 16225 case DOCUMENTREFERENCE: return "DocumentReference"; 16226 case ENCOUNTER: return "Encounter"; 16227 case ENCOUNTERHISTORY: return "EncounterHistory"; 16228 case ENDPOINT: return "Endpoint"; 16229 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 16230 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 16231 case EPISODEOFCARE: return "EpisodeOfCare"; 16232 case EVENTDEFINITION: return "EventDefinition"; 16233 case EVIDENCE: return "Evidence"; 16234 case EVIDENCEREPORT: return "EvidenceReport"; 16235 case EVIDENCEVARIABLE: return "EvidenceVariable"; 16236 case EXAMPLESCENARIO: return "ExampleScenario"; 16237 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 16238 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 16239 case FLAG: return "Flag"; 16240 case FORMULARYITEM: return "FormularyItem"; 16241 case GENOMICSTUDY: return "GenomicStudy"; 16242 case GOAL: return "Goal"; 16243 case GRAPHDEFINITION: return "GraphDefinition"; 16244 case GROUP: return "Group"; 16245 case GUIDANCERESPONSE: return "GuidanceResponse"; 16246 case HEALTHCARESERVICE: return "HealthcareService"; 16247 case IMAGINGSELECTION: return "ImagingSelection"; 16248 case IMAGINGSTUDY: return "ImagingStudy"; 16249 case IMMUNIZATION: return "Immunization"; 16250 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 16251 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 16252 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 16253 case INGREDIENT: return "Ingredient"; 16254 case INSURANCEPLAN: return "InsurancePlan"; 16255 case INVENTORYITEM: return "InventoryItem"; 16256 case INVENTORYREPORT: return "InventoryReport"; 16257 case INVOICE: return "Invoice"; 16258 case LIBRARY: return "Library"; 16259 case LINKAGE: return "Linkage"; 16260 case LIST: return "List"; 16261 case LOCATION: return "Location"; 16262 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 16263 case MEASURE: return "Measure"; 16264 case MEASUREREPORT: return "MeasureReport"; 16265 case MEDICATION: return "Medication"; 16266 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 16267 case MEDICATIONDISPENSE: return "MedicationDispense"; 16268 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 16269 case MEDICATIONREQUEST: return "MedicationRequest"; 16270 case MEDICATIONSTATEMENT: return "MedicationStatement"; 16271 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 16272 case MESSAGEDEFINITION: return "MessageDefinition"; 16273 case MESSAGEHEADER: return "MessageHeader"; 16274 case MOLECULARSEQUENCE: return "MolecularSequence"; 16275 case NAMINGSYSTEM: return "NamingSystem"; 16276 case NUTRITIONINTAKE: return "NutritionIntake"; 16277 case NUTRITIONORDER: return "NutritionOrder"; 16278 case NUTRITIONPRODUCT: return "NutritionProduct"; 16279 case OBSERVATION: return "Observation"; 16280 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 16281 case OPERATIONDEFINITION: return "OperationDefinition"; 16282 case OPERATIONOUTCOME: return "OperationOutcome"; 16283 case ORGANIZATION: return "Organization"; 16284 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 16285 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 16286 case PARAMETERS: return "Parameters"; 16287 case PATIENT: return "Patient"; 16288 case PAYMENTNOTICE: return "PaymentNotice"; 16289 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 16290 case PERMISSION: return "Permission"; 16291 case PERSON: return "Person"; 16292 case PLANDEFINITION: return "PlanDefinition"; 16293 case PRACTITIONER: return "Practitioner"; 16294 case PRACTITIONERROLE: return "PractitionerRole"; 16295 case PROCEDURE: return "Procedure"; 16296 case PROVENANCE: return "Provenance"; 16297 case QUESTIONNAIRE: return "Questionnaire"; 16298 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 16299 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 16300 case RELATEDPERSON: return "RelatedPerson"; 16301 case REQUESTORCHESTRATION: return "RequestOrchestration"; 16302 case REQUIREMENTS: return "Requirements"; 16303 case RESEARCHSTUDY: return "ResearchStudy"; 16304 case RESEARCHSUBJECT: return "ResearchSubject"; 16305 case RISKASSESSMENT: return "RiskAssessment"; 16306 case SCHEDULE: return "Schedule"; 16307 case SEARCHPARAMETER: return "SearchParameter"; 16308 case SERVICEREQUEST: return "ServiceRequest"; 16309 case SLOT: return "Slot"; 16310 case SPECIMEN: return "Specimen"; 16311 case SPECIMENDEFINITION: return "SpecimenDefinition"; 16312 case STRUCTUREDEFINITION: return "StructureDefinition"; 16313 case STRUCTUREMAP: return "StructureMap"; 16314 case SUBSCRIPTION: return "Subscription"; 16315 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 16316 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 16317 case SUBSTANCE: return "Substance"; 16318 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 16319 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 16320 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 16321 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 16322 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 16323 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 16324 case SUPPLYDELIVERY: return "SupplyDelivery"; 16325 case SUPPLYREQUEST: return "SupplyRequest"; 16326 case TASK: return "Task"; 16327 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 16328 case TESTPLAN: return "TestPlan"; 16329 case TESTREPORT: return "TestReport"; 16330 case TESTSCRIPT: return "TestScript"; 16331 case TRANSPORT: return "Transport"; 16332 case VALUESET: return "ValueSet"; 16333 case VERIFICATIONRESULT: return "VerificationResult"; 16334 case VISIONPRESCRIPTION: return "VisionPrescription"; 16335 case NULL: return null; 16336 default: return "?"; 16337 } 16338 } 16339 } 16340 16341 public static class ResourceTypeEnumEnumFactory implements EnumFactory<ResourceTypeEnum> { 16342 public ResourceTypeEnum fromCode(String codeString) throws IllegalArgumentException { 16343 if (codeString == null || "".equals(codeString)) 16344 if (codeString == null || "".equals(codeString)) 16345 return null; 16346 if ("Account".equals(codeString)) 16347 return ResourceTypeEnum.ACCOUNT; 16348 if ("ActivityDefinition".equals(codeString)) 16349 return ResourceTypeEnum.ACTIVITYDEFINITION; 16350 if ("ActorDefinition".equals(codeString)) 16351 return ResourceTypeEnum.ACTORDEFINITION; 16352 if ("AdministrableProductDefinition".equals(codeString)) 16353 return ResourceTypeEnum.ADMINISTRABLEPRODUCTDEFINITION; 16354 if ("AdverseEvent".equals(codeString)) 16355 return ResourceTypeEnum.ADVERSEEVENT; 16356 if ("AllergyIntolerance".equals(codeString)) 16357 return ResourceTypeEnum.ALLERGYINTOLERANCE; 16358 if ("Appointment".equals(codeString)) 16359 return ResourceTypeEnum.APPOINTMENT; 16360 if ("AppointmentResponse".equals(codeString)) 16361 return ResourceTypeEnum.APPOINTMENTRESPONSE; 16362 if ("ArtifactAssessment".equals(codeString)) 16363 return ResourceTypeEnum.ARTIFACTASSESSMENT; 16364 if ("AuditEvent".equals(codeString)) 16365 return ResourceTypeEnum.AUDITEVENT; 16366 if ("Basic".equals(codeString)) 16367 return ResourceTypeEnum.BASIC; 16368 if ("Binary".equals(codeString)) 16369 return ResourceTypeEnum.BINARY; 16370 if ("BiologicallyDerivedProduct".equals(codeString)) 16371 return ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCT; 16372 if ("BiologicallyDerivedProductDispense".equals(codeString)) 16373 return ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCTDISPENSE; 16374 if ("BodyStructure".equals(codeString)) 16375 return ResourceTypeEnum.BODYSTRUCTURE; 16376 if ("Bundle".equals(codeString)) 16377 return ResourceTypeEnum.BUNDLE; 16378 if ("CapabilityStatement".equals(codeString)) 16379 return ResourceTypeEnum.CAPABILITYSTATEMENT; 16380 if ("CarePlan".equals(codeString)) 16381 return ResourceTypeEnum.CAREPLAN; 16382 if ("CareTeam".equals(codeString)) 16383 return ResourceTypeEnum.CARETEAM; 16384 if ("ChargeItem".equals(codeString)) 16385 return ResourceTypeEnum.CHARGEITEM; 16386 if ("ChargeItemDefinition".equals(codeString)) 16387 return ResourceTypeEnum.CHARGEITEMDEFINITION; 16388 if ("Citation".equals(codeString)) 16389 return ResourceTypeEnum.CITATION; 16390 if ("Claim".equals(codeString)) 16391 return ResourceTypeEnum.CLAIM; 16392 if ("ClaimResponse".equals(codeString)) 16393 return ResourceTypeEnum.CLAIMRESPONSE; 16394 if ("ClinicalImpression".equals(codeString)) 16395 return ResourceTypeEnum.CLINICALIMPRESSION; 16396 if ("ClinicalUseDefinition".equals(codeString)) 16397 return ResourceTypeEnum.CLINICALUSEDEFINITION; 16398 if ("CodeSystem".equals(codeString)) 16399 return ResourceTypeEnum.CODESYSTEM; 16400 if ("Communication".equals(codeString)) 16401 return ResourceTypeEnum.COMMUNICATION; 16402 if ("CommunicationRequest".equals(codeString)) 16403 return ResourceTypeEnum.COMMUNICATIONREQUEST; 16404 if ("CompartmentDefinition".equals(codeString)) 16405 return ResourceTypeEnum.COMPARTMENTDEFINITION; 16406 if ("Composition".equals(codeString)) 16407 return ResourceTypeEnum.COMPOSITION; 16408 if ("ConceptMap".equals(codeString)) 16409 return ResourceTypeEnum.CONCEPTMAP; 16410 if ("Condition".equals(codeString)) 16411 return ResourceTypeEnum.CONDITION; 16412 if ("ConditionDefinition".equals(codeString)) 16413 return ResourceTypeEnum.CONDITIONDEFINITION; 16414 if ("Consent".equals(codeString)) 16415 return ResourceTypeEnum.CONSENT; 16416 if ("Contract".equals(codeString)) 16417 return ResourceTypeEnum.CONTRACT; 16418 if ("Coverage".equals(codeString)) 16419 return ResourceTypeEnum.COVERAGE; 16420 if ("CoverageEligibilityRequest".equals(codeString)) 16421 return ResourceTypeEnum.COVERAGEELIGIBILITYREQUEST; 16422 if ("CoverageEligibilityResponse".equals(codeString)) 16423 return ResourceTypeEnum.COVERAGEELIGIBILITYRESPONSE; 16424 if ("DetectedIssue".equals(codeString)) 16425 return ResourceTypeEnum.DETECTEDISSUE; 16426 if ("Device".equals(codeString)) 16427 return ResourceTypeEnum.DEVICE; 16428 if ("DeviceAssociation".equals(codeString)) 16429 return ResourceTypeEnum.DEVICEASSOCIATION; 16430 if ("DeviceDefinition".equals(codeString)) 16431 return ResourceTypeEnum.DEVICEDEFINITION; 16432 if ("DeviceDispense".equals(codeString)) 16433 return ResourceTypeEnum.DEVICEDISPENSE; 16434 if ("DeviceMetric".equals(codeString)) 16435 return ResourceTypeEnum.DEVICEMETRIC; 16436 if ("DeviceRequest".equals(codeString)) 16437 return ResourceTypeEnum.DEVICEREQUEST; 16438 if ("DeviceUsage".equals(codeString)) 16439 return ResourceTypeEnum.DEVICEUSAGE; 16440 if ("DiagnosticReport".equals(codeString)) 16441 return ResourceTypeEnum.DIAGNOSTICREPORT; 16442 if ("DocumentReference".equals(codeString)) 16443 return ResourceTypeEnum.DOCUMENTREFERENCE; 16444 if ("Encounter".equals(codeString)) 16445 return ResourceTypeEnum.ENCOUNTER; 16446 if ("EncounterHistory".equals(codeString)) 16447 return ResourceTypeEnum.ENCOUNTERHISTORY; 16448 if ("Endpoint".equals(codeString)) 16449 return ResourceTypeEnum.ENDPOINT; 16450 if ("EnrollmentRequest".equals(codeString)) 16451 return ResourceTypeEnum.ENROLLMENTREQUEST; 16452 if ("EnrollmentResponse".equals(codeString)) 16453 return ResourceTypeEnum.ENROLLMENTRESPONSE; 16454 if ("EpisodeOfCare".equals(codeString)) 16455 return ResourceTypeEnum.EPISODEOFCARE; 16456 if ("EventDefinition".equals(codeString)) 16457 return ResourceTypeEnum.EVENTDEFINITION; 16458 if ("Evidence".equals(codeString)) 16459 return ResourceTypeEnum.EVIDENCE; 16460 if ("EvidenceReport".equals(codeString)) 16461 return ResourceTypeEnum.EVIDENCEREPORT; 16462 if ("EvidenceVariable".equals(codeString)) 16463 return ResourceTypeEnum.EVIDENCEVARIABLE; 16464 if ("ExampleScenario".equals(codeString)) 16465 return ResourceTypeEnum.EXAMPLESCENARIO; 16466 if ("ExplanationOfBenefit".equals(codeString)) 16467 return ResourceTypeEnum.EXPLANATIONOFBENEFIT; 16468 if ("FamilyMemberHistory".equals(codeString)) 16469 return ResourceTypeEnum.FAMILYMEMBERHISTORY; 16470 if ("Flag".equals(codeString)) 16471 return ResourceTypeEnum.FLAG; 16472 if ("FormularyItem".equals(codeString)) 16473 return ResourceTypeEnum.FORMULARYITEM; 16474 if ("GenomicStudy".equals(codeString)) 16475 return ResourceTypeEnum.GENOMICSTUDY; 16476 if ("Goal".equals(codeString)) 16477 return ResourceTypeEnum.GOAL; 16478 if ("GraphDefinition".equals(codeString)) 16479 return ResourceTypeEnum.GRAPHDEFINITION; 16480 if ("Group".equals(codeString)) 16481 return ResourceTypeEnum.GROUP; 16482 if ("GuidanceResponse".equals(codeString)) 16483 return ResourceTypeEnum.GUIDANCERESPONSE; 16484 if ("HealthcareService".equals(codeString)) 16485 return ResourceTypeEnum.HEALTHCARESERVICE; 16486 if ("ImagingSelection".equals(codeString)) 16487 return ResourceTypeEnum.IMAGINGSELECTION; 16488 if ("ImagingStudy".equals(codeString)) 16489 return ResourceTypeEnum.IMAGINGSTUDY; 16490 if ("Immunization".equals(codeString)) 16491 return ResourceTypeEnum.IMMUNIZATION; 16492 if ("ImmunizationEvaluation".equals(codeString)) 16493 return ResourceTypeEnum.IMMUNIZATIONEVALUATION; 16494 if ("ImmunizationRecommendation".equals(codeString)) 16495 return ResourceTypeEnum.IMMUNIZATIONRECOMMENDATION; 16496 if ("ImplementationGuide".equals(codeString)) 16497 return ResourceTypeEnum.IMPLEMENTATIONGUIDE; 16498 if ("Ingredient".equals(codeString)) 16499 return ResourceTypeEnum.INGREDIENT; 16500 if ("InsurancePlan".equals(codeString)) 16501 return ResourceTypeEnum.INSURANCEPLAN; 16502 if ("InventoryItem".equals(codeString)) 16503 return ResourceTypeEnum.INVENTORYITEM; 16504 if ("InventoryReport".equals(codeString)) 16505 return ResourceTypeEnum.INVENTORYREPORT; 16506 if ("Invoice".equals(codeString)) 16507 return ResourceTypeEnum.INVOICE; 16508 if ("Library".equals(codeString)) 16509 return ResourceTypeEnum.LIBRARY; 16510 if ("Linkage".equals(codeString)) 16511 return ResourceTypeEnum.LINKAGE; 16512 if ("List".equals(codeString)) 16513 return ResourceTypeEnum.LIST; 16514 if ("Location".equals(codeString)) 16515 return ResourceTypeEnum.LOCATION; 16516 if ("ManufacturedItemDefinition".equals(codeString)) 16517 return ResourceTypeEnum.MANUFACTUREDITEMDEFINITION; 16518 if ("Measure".equals(codeString)) 16519 return ResourceTypeEnum.MEASURE; 16520 if ("MeasureReport".equals(codeString)) 16521 return ResourceTypeEnum.MEASUREREPORT; 16522 if ("Medication".equals(codeString)) 16523 return ResourceTypeEnum.MEDICATION; 16524 if ("MedicationAdministration".equals(codeString)) 16525 return ResourceTypeEnum.MEDICATIONADMINISTRATION; 16526 if ("MedicationDispense".equals(codeString)) 16527 return ResourceTypeEnum.MEDICATIONDISPENSE; 16528 if ("MedicationKnowledge".equals(codeString)) 16529 return ResourceTypeEnum.MEDICATIONKNOWLEDGE; 16530 if ("MedicationRequest".equals(codeString)) 16531 return ResourceTypeEnum.MEDICATIONREQUEST; 16532 if ("MedicationStatement".equals(codeString)) 16533 return ResourceTypeEnum.MEDICATIONSTATEMENT; 16534 if ("MedicinalProductDefinition".equals(codeString)) 16535 return ResourceTypeEnum.MEDICINALPRODUCTDEFINITION; 16536 if ("MessageDefinition".equals(codeString)) 16537 return ResourceTypeEnum.MESSAGEDEFINITION; 16538 if ("MessageHeader".equals(codeString)) 16539 return ResourceTypeEnum.MESSAGEHEADER; 16540 if ("MolecularSequence".equals(codeString)) 16541 return ResourceTypeEnum.MOLECULARSEQUENCE; 16542 if ("NamingSystem".equals(codeString)) 16543 return ResourceTypeEnum.NAMINGSYSTEM; 16544 if ("NutritionIntake".equals(codeString)) 16545 return ResourceTypeEnum.NUTRITIONINTAKE; 16546 if ("NutritionOrder".equals(codeString)) 16547 return ResourceTypeEnum.NUTRITIONORDER; 16548 if ("NutritionProduct".equals(codeString)) 16549 return ResourceTypeEnum.NUTRITIONPRODUCT; 16550 if ("Observation".equals(codeString)) 16551 return ResourceTypeEnum.OBSERVATION; 16552 if ("ObservationDefinition".equals(codeString)) 16553 return ResourceTypeEnum.OBSERVATIONDEFINITION; 16554 if ("OperationDefinition".equals(codeString)) 16555 return ResourceTypeEnum.OPERATIONDEFINITION; 16556 if ("OperationOutcome".equals(codeString)) 16557 return ResourceTypeEnum.OPERATIONOUTCOME; 16558 if ("Organization".equals(codeString)) 16559 return ResourceTypeEnum.ORGANIZATION; 16560 if ("OrganizationAffiliation".equals(codeString)) 16561 return ResourceTypeEnum.ORGANIZATIONAFFILIATION; 16562 if ("PackagedProductDefinition".equals(codeString)) 16563 return ResourceTypeEnum.PACKAGEDPRODUCTDEFINITION; 16564 if ("Parameters".equals(codeString)) 16565 return ResourceTypeEnum.PARAMETERS; 16566 if ("Patient".equals(codeString)) 16567 return ResourceTypeEnum.PATIENT; 16568 if ("PaymentNotice".equals(codeString)) 16569 return ResourceTypeEnum.PAYMENTNOTICE; 16570 if ("PaymentReconciliation".equals(codeString)) 16571 return ResourceTypeEnum.PAYMENTRECONCILIATION; 16572 if ("Permission".equals(codeString)) 16573 return ResourceTypeEnum.PERMISSION; 16574 if ("Person".equals(codeString)) 16575 return ResourceTypeEnum.PERSON; 16576 if ("PlanDefinition".equals(codeString)) 16577 return ResourceTypeEnum.PLANDEFINITION; 16578 if ("Practitioner".equals(codeString)) 16579 return ResourceTypeEnum.PRACTITIONER; 16580 if ("PractitionerRole".equals(codeString)) 16581 return ResourceTypeEnum.PRACTITIONERROLE; 16582 if ("Procedure".equals(codeString)) 16583 return ResourceTypeEnum.PROCEDURE; 16584 if ("Provenance".equals(codeString)) 16585 return ResourceTypeEnum.PROVENANCE; 16586 if ("Questionnaire".equals(codeString)) 16587 return ResourceTypeEnum.QUESTIONNAIRE; 16588 if ("QuestionnaireResponse".equals(codeString)) 16589 return ResourceTypeEnum.QUESTIONNAIRERESPONSE; 16590 if ("RegulatedAuthorization".equals(codeString)) 16591 return ResourceTypeEnum.REGULATEDAUTHORIZATION; 16592 if ("RelatedPerson".equals(codeString)) 16593 return ResourceTypeEnum.RELATEDPERSON; 16594 if ("RequestOrchestration".equals(codeString)) 16595 return ResourceTypeEnum.REQUESTORCHESTRATION; 16596 if ("Requirements".equals(codeString)) 16597 return ResourceTypeEnum.REQUIREMENTS; 16598 if ("ResearchStudy".equals(codeString)) 16599 return ResourceTypeEnum.RESEARCHSTUDY; 16600 if ("ResearchSubject".equals(codeString)) 16601 return ResourceTypeEnum.RESEARCHSUBJECT; 16602 if ("RiskAssessment".equals(codeString)) 16603 return ResourceTypeEnum.RISKASSESSMENT; 16604 if ("Schedule".equals(codeString)) 16605 return ResourceTypeEnum.SCHEDULE; 16606 if ("SearchParameter".equals(codeString)) 16607 return ResourceTypeEnum.SEARCHPARAMETER; 16608 if ("ServiceRequest".equals(codeString)) 16609 return ResourceTypeEnum.SERVICEREQUEST; 16610 if ("Slot".equals(codeString)) 16611 return ResourceTypeEnum.SLOT; 16612 if ("Specimen".equals(codeString)) 16613 return ResourceTypeEnum.SPECIMEN; 16614 if ("SpecimenDefinition".equals(codeString)) 16615 return ResourceTypeEnum.SPECIMENDEFINITION; 16616 if ("StructureDefinition".equals(codeString)) 16617 return ResourceTypeEnum.STRUCTUREDEFINITION; 16618 if ("StructureMap".equals(codeString)) 16619 return ResourceTypeEnum.STRUCTUREMAP; 16620 if ("Subscription".equals(codeString)) 16621 return ResourceTypeEnum.SUBSCRIPTION; 16622 if ("SubscriptionStatus".equals(codeString)) 16623 return ResourceTypeEnum.SUBSCRIPTIONSTATUS; 16624 if ("SubscriptionTopic".equals(codeString)) 16625 return ResourceTypeEnum.SUBSCRIPTIONTOPIC; 16626 if ("Substance".equals(codeString)) 16627 return ResourceTypeEnum.SUBSTANCE; 16628 if ("SubstanceDefinition".equals(codeString)) 16629 return ResourceTypeEnum.SUBSTANCEDEFINITION; 16630 if ("SubstanceNucleicAcid".equals(codeString)) 16631 return ResourceTypeEnum.SUBSTANCENUCLEICACID; 16632 if ("SubstancePolymer".equals(codeString)) 16633 return ResourceTypeEnum.SUBSTANCEPOLYMER; 16634 if ("SubstanceProtein".equals(codeString)) 16635 return ResourceTypeEnum.SUBSTANCEPROTEIN; 16636 if ("SubstanceReferenceInformation".equals(codeString)) 16637 return ResourceTypeEnum.SUBSTANCEREFERENCEINFORMATION; 16638 if ("SubstanceSourceMaterial".equals(codeString)) 16639 return ResourceTypeEnum.SUBSTANCESOURCEMATERIAL; 16640 if ("SupplyDelivery".equals(codeString)) 16641 return ResourceTypeEnum.SUPPLYDELIVERY; 16642 if ("SupplyRequest".equals(codeString)) 16643 return ResourceTypeEnum.SUPPLYREQUEST; 16644 if ("Task".equals(codeString)) 16645 return ResourceTypeEnum.TASK; 16646 if ("TerminologyCapabilities".equals(codeString)) 16647 return ResourceTypeEnum.TERMINOLOGYCAPABILITIES; 16648 if ("TestPlan".equals(codeString)) 16649 return ResourceTypeEnum.TESTPLAN; 16650 if ("TestReport".equals(codeString)) 16651 return ResourceTypeEnum.TESTREPORT; 16652 if ("TestScript".equals(codeString)) 16653 return ResourceTypeEnum.TESTSCRIPT; 16654 if ("Transport".equals(codeString)) 16655 return ResourceTypeEnum.TRANSPORT; 16656 if ("ValueSet".equals(codeString)) 16657 return ResourceTypeEnum.VALUESET; 16658 if ("VerificationResult".equals(codeString)) 16659 return ResourceTypeEnum.VERIFICATIONRESULT; 16660 if ("VisionPrescription".equals(codeString)) 16661 return ResourceTypeEnum.VISIONPRESCRIPTION; 16662 throw new IllegalArgumentException("Unknown ResourceTypeEnum code '"+codeString+"'"); 16663 } 16664 16665 public Enumeration<ResourceTypeEnum> fromType(PrimitiveType<?> code) throws FHIRException { 16666 if (code == null) 16667 return null; 16668 if (code.isEmpty()) 16669 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NULL, code); 16670 String codeString = ((PrimitiveType) code).asStringValue(); 16671 if (codeString == null || "".equals(codeString)) 16672 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NULL, code); 16673 if ("Account".equals(codeString)) 16674 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ACCOUNT, code); 16675 if ("ActivityDefinition".equals(codeString)) 16676 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ACTIVITYDEFINITION, code); 16677 if ("ActorDefinition".equals(codeString)) 16678 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ACTORDEFINITION, code); 16679 if ("AdministrableProductDefinition".equals(codeString)) 16680 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ADMINISTRABLEPRODUCTDEFINITION, code); 16681 if ("AdverseEvent".equals(codeString)) 16682 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ADVERSEEVENT, code); 16683 if ("AllergyIntolerance".equals(codeString)) 16684 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ALLERGYINTOLERANCE, code); 16685 if ("Appointment".equals(codeString)) 16686 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.APPOINTMENT, code); 16687 if ("AppointmentResponse".equals(codeString)) 16688 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.APPOINTMENTRESPONSE, code); 16689 if ("ArtifactAssessment".equals(codeString)) 16690 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ARTIFACTASSESSMENT, code); 16691 if ("AuditEvent".equals(codeString)) 16692 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.AUDITEVENT, code); 16693 if ("Basic".equals(codeString)) 16694 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BASIC, code); 16695 if ("Binary".equals(codeString)) 16696 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BINARY, code); 16697 if ("BiologicallyDerivedProduct".equals(codeString)) 16698 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCT, code); 16699 if ("BiologicallyDerivedProductDispense".equals(codeString)) 16700 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCTDISPENSE, code); 16701 if ("BodyStructure".equals(codeString)) 16702 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BODYSTRUCTURE, code); 16703 if ("Bundle".equals(codeString)) 16704 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BUNDLE, code); 16705 if ("CapabilityStatement".equals(codeString)) 16706 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CAPABILITYSTATEMENT, code); 16707 if ("CarePlan".equals(codeString)) 16708 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CAREPLAN, code); 16709 if ("CareTeam".equals(codeString)) 16710 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CARETEAM, code); 16711 if ("ChargeItem".equals(codeString)) 16712 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CHARGEITEM, code); 16713 if ("ChargeItemDefinition".equals(codeString)) 16714 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CHARGEITEMDEFINITION, code); 16715 if ("Citation".equals(codeString)) 16716 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CITATION, code); 16717 if ("Claim".equals(codeString)) 16718 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLAIM, code); 16719 if ("ClaimResponse".equals(codeString)) 16720 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLAIMRESPONSE, code); 16721 if ("ClinicalImpression".equals(codeString)) 16722 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLINICALIMPRESSION, code); 16723 if ("ClinicalUseDefinition".equals(codeString)) 16724 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLINICALUSEDEFINITION, code); 16725 if ("CodeSystem".equals(codeString)) 16726 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CODESYSTEM, code); 16727 if ("Communication".equals(codeString)) 16728 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMMUNICATION, code); 16729 if ("CommunicationRequest".equals(codeString)) 16730 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMMUNICATIONREQUEST, code); 16731 if ("CompartmentDefinition".equals(codeString)) 16732 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMPARTMENTDEFINITION, code); 16733 if ("Composition".equals(codeString)) 16734 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMPOSITION, code); 16735 if ("ConceptMap".equals(codeString)) 16736 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONCEPTMAP, code); 16737 if ("Condition".equals(codeString)) 16738 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONDITION, code); 16739 if ("ConditionDefinition".equals(codeString)) 16740 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONDITIONDEFINITION, code); 16741 if ("Consent".equals(codeString)) 16742 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONSENT, code); 16743 if ("Contract".equals(codeString)) 16744 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONTRACT, code); 16745 if ("Coverage".equals(codeString)) 16746 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COVERAGE, code); 16747 if ("CoverageEligibilityRequest".equals(codeString)) 16748 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COVERAGEELIGIBILITYREQUEST, code); 16749 if ("CoverageEligibilityResponse".equals(codeString)) 16750 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COVERAGEELIGIBILITYRESPONSE, code); 16751 if ("DetectedIssue".equals(codeString)) 16752 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DETECTEDISSUE, code); 16753 if ("Device".equals(codeString)) 16754 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICE, code); 16755 if ("DeviceAssociation".equals(codeString)) 16756 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEASSOCIATION, code); 16757 if ("DeviceDefinition".equals(codeString)) 16758 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEDEFINITION, code); 16759 if ("DeviceDispense".equals(codeString)) 16760 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEDISPENSE, code); 16761 if ("DeviceMetric".equals(codeString)) 16762 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEMETRIC, code); 16763 if ("DeviceRequest".equals(codeString)) 16764 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEREQUEST, code); 16765 if ("DeviceUsage".equals(codeString)) 16766 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEUSAGE, code); 16767 if ("DiagnosticReport".equals(codeString)) 16768 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DIAGNOSTICREPORT, code); 16769 if ("DocumentReference".equals(codeString)) 16770 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DOCUMENTREFERENCE, code); 16771 if ("Encounter".equals(codeString)) 16772 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENCOUNTER, code); 16773 if ("EncounterHistory".equals(codeString)) 16774 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENCOUNTERHISTORY, code); 16775 if ("Endpoint".equals(codeString)) 16776 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENDPOINT, code); 16777 if ("EnrollmentRequest".equals(codeString)) 16778 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENROLLMENTREQUEST, code); 16779 if ("EnrollmentResponse".equals(codeString)) 16780 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENROLLMENTRESPONSE, code); 16781 if ("EpisodeOfCare".equals(codeString)) 16782 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EPISODEOFCARE, code); 16783 if ("EventDefinition".equals(codeString)) 16784 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EVENTDEFINITION, code); 16785 if ("Evidence".equals(codeString)) 16786 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EVIDENCE, code); 16787 if ("EvidenceReport".equals(codeString)) 16788 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EVIDENCEREPORT, code); 16789 if ("EvidenceVariable".equals(codeString)) 16790 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EVIDENCEVARIABLE, code); 16791 if ("ExampleScenario".equals(codeString)) 16792 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EXAMPLESCENARIO, code); 16793 if ("ExplanationOfBenefit".equals(codeString)) 16794 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EXPLANATIONOFBENEFIT, code); 16795 if ("FamilyMemberHistory".equals(codeString)) 16796 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.FAMILYMEMBERHISTORY, code); 16797 if ("Flag".equals(codeString)) 16798 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.FLAG, code); 16799 if ("FormularyItem".equals(codeString)) 16800 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.FORMULARYITEM, code); 16801 if ("GenomicStudy".equals(codeString)) 16802 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GENOMICSTUDY, code); 16803 if ("Goal".equals(codeString)) 16804 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GOAL, code); 16805 if ("GraphDefinition".equals(codeString)) 16806 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GRAPHDEFINITION, code); 16807 if ("Group".equals(codeString)) 16808 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GROUP, code); 16809 if ("GuidanceResponse".equals(codeString)) 16810 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GUIDANCERESPONSE, code); 16811 if ("HealthcareService".equals(codeString)) 16812 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.HEALTHCARESERVICE, code); 16813 if ("ImagingSelection".equals(codeString)) 16814 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMAGINGSELECTION, code); 16815 if ("ImagingStudy".equals(codeString)) 16816 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMAGINGSTUDY, code); 16817 if ("Immunization".equals(codeString)) 16818 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMMUNIZATION, code); 16819 if ("ImmunizationEvaluation".equals(codeString)) 16820 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMMUNIZATIONEVALUATION, code); 16821 if ("ImmunizationRecommendation".equals(codeString)) 16822 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMMUNIZATIONRECOMMENDATION, code); 16823 if ("ImplementationGuide".equals(codeString)) 16824 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMPLEMENTATIONGUIDE, code); 16825 if ("Ingredient".equals(codeString)) 16826 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INGREDIENT, code); 16827 if ("InsurancePlan".equals(codeString)) 16828 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INSURANCEPLAN, code); 16829 if ("InventoryItem".equals(codeString)) 16830 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INVENTORYITEM, code); 16831 if ("InventoryReport".equals(codeString)) 16832 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INVENTORYREPORT, code); 16833 if ("Invoice".equals(codeString)) 16834 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INVOICE, code); 16835 if ("Library".equals(codeString)) 16836 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LIBRARY, code); 16837 if ("Linkage".equals(codeString)) 16838 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LINKAGE, code); 16839 if ("List".equals(codeString)) 16840 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LIST, code); 16841 if ("Location".equals(codeString)) 16842 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LOCATION, code); 16843 if ("ManufacturedItemDefinition".equals(codeString)) 16844 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MANUFACTUREDITEMDEFINITION, code); 16845 if ("Measure".equals(codeString)) 16846 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEASURE, code); 16847 if ("MeasureReport".equals(codeString)) 16848 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEASUREREPORT, code); 16849 if ("Medication".equals(codeString)) 16850 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATION, code); 16851 if ("MedicationAdministration".equals(codeString)) 16852 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONADMINISTRATION, code); 16853 if ("MedicationDispense".equals(codeString)) 16854 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONDISPENSE, code); 16855 if ("MedicationKnowledge".equals(codeString)) 16856 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONKNOWLEDGE, code); 16857 if ("MedicationRequest".equals(codeString)) 16858 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONREQUEST, code); 16859 if ("MedicationStatement".equals(codeString)) 16860 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONSTATEMENT, code); 16861 if ("MedicinalProductDefinition".equals(codeString)) 16862 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICINALPRODUCTDEFINITION, code); 16863 if ("MessageDefinition".equals(codeString)) 16864 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MESSAGEDEFINITION, code); 16865 if ("MessageHeader".equals(codeString)) 16866 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MESSAGEHEADER, code); 16867 if ("MolecularSequence".equals(codeString)) 16868 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MOLECULARSEQUENCE, code); 16869 if ("NamingSystem".equals(codeString)) 16870 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NAMINGSYSTEM, code); 16871 if ("NutritionIntake".equals(codeString)) 16872 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NUTRITIONINTAKE, code); 16873 if ("NutritionOrder".equals(codeString)) 16874 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NUTRITIONORDER, code); 16875 if ("NutritionProduct".equals(codeString)) 16876 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NUTRITIONPRODUCT, code); 16877 if ("Observation".equals(codeString)) 16878 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OBSERVATION, code); 16879 if ("ObservationDefinition".equals(codeString)) 16880 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OBSERVATIONDEFINITION, code); 16881 if ("OperationDefinition".equals(codeString)) 16882 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OPERATIONDEFINITION, code); 16883 if ("OperationOutcome".equals(codeString)) 16884 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OPERATIONOUTCOME, code); 16885 if ("Organization".equals(codeString)) 16886 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ORGANIZATION, code); 16887 if ("OrganizationAffiliation".equals(codeString)) 16888 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ORGANIZATIONAFFILIATION, code); 16889 if ("PackagedProductDefinition".equals(codeString)) 16890 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PACKAGEDPRODUCTDEFINITION, code); 16891 if ("Parameters".equals(codeString)) 16892 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PARAMETERS, code); 16893 if ("Patient".equals(codeString)) 16894 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PATIENT, code); 16895 if ("PaymentNotice".equals(codeString)) 16896 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PAYMENTNOTICE, code); 16897 if ("PaymentReconciliation".equals(codeString)) 16898 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PAYMENTRECONCILIATION, code); 16899 if ("Permission".equals(codeString)) 16900 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PERMISSION, code); 16901 if ("Person".equals(codeString)) 16902 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PERSON, code); 16903 if ("PlanDefinition".equals(codeString)) 16904 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PLANDEFINITION, code); 16905 if ("Practitioner".equals(codeString)) 16906 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PRACTITIONER, code); 16907 if ("PractitionerRole".equals(codeString)) 16908 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PRACTITIONERROLE, code); 16909 if ("Procedure".equals(codeString)) 16910 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PROCEDURE, code); 16911 if ("Provenance".equals(codeString)) 16912 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PROVENANCE, code); 16913 if ("Questionnaire".equals(codeString)) 16914 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.QUESTIONNAIRE, code); 16915 if ("QuestionnaireResponse".equals(codeString)) 16916 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.QUESTIONNAIRERESPONSE, code); 16917 if ("RegulatedAuthorization".equals(codeString)) 16918 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.REGULATEDAUTHORIZATION, code); 16919 if ("RelatedPerson".equals(codeString)) 16920 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RELATEDPERSON, code); 16921 if ("RequestOrchestration".equals(codeString)) 16922 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.REQUESTORCHESTRATION, code); 16923 if ("Requirements".equals(codeString)) 16924 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.REQUIREMENTS, code); 16925 if ("ResearchStudy".equals(codeString)) 16926 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RESEARCHSTUDY, code); 16927 if ("ResearchSubject".equals(codeString)) 16928 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RESEARCHSUBJECT, code); 16929 if ("RiskAssessment".equals(codeString)) 16930 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RISKASSESSMENT, code); 16931 if ("Schedule".equals(codeString)) 16932 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SCHEDULE, code); 16933 if ("SearchParameter".equals(codeString)) 16934 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SEARCHPARAMETER, code); 16935 if ("ServiceRequest".equals(codeString)) 16936 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SERVICEREQUEST, code); 16937 if ("Slot".equals(codeString)) 16938 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SLOT, code); 16939 if ("Specimen".equals(codeString)) 16940 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SPECIMEN, code); 16941 if ("SpecimenDefinition".equals(codeString)) 16942 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SPECIMENDEFINITION, code); 16943 if ("StructureDefinition".equals(codeString)) 16944 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.STRUCTUREDEFINITION, code); 16945 if ("StructureMap".equals(codeString)) 16946 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.STRUCTUREMAP, code); 16947 if ("Subscription".equals(codeString)) 16948 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSCRIPTION, code); 16949 if ("SubscriptionStatus".equals(codeString)) 16950 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSCRIPTIONSTATUS, code); 16951 if ("SubscriptionTopic".equals(codeString)) 16952 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSCRIPTIONTOPIC, code); 16953 if ("Substance".equals(codeString)) 16954 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCE, code); 16955 if ("SubstanceDefinition".equals(codeString)) 16956 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEDEFINITION, code); 16957 if ("SubstanceNucleicAcid".equals(codeString)) 16958 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCENUCLEICACID, code); 16959 if ("SubstancePolymer".equals(codeString)) 16960 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEPOLYMER, code); 16961 if ("SubstanceProtein".equals(codeString)) 16962 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEPROTEIN, code); 16963 if ("SubstanceReferenceInformation".equals(codeString)) 16964 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEREFERENCEINFORMATION, code); 16965 if ("SubstanceSourceMaterial".equals(codeString)) 16966 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCESOURCEMATERIAL, code); 16967 if ("SupplyDelivery".equals(codeString)) 16968 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUPPLYDELIVERY, code); 16969 if ("SupplyRequest".equals(codeString)) 16970 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUPPLYREQUEST, code); 16971 if ("Task".equals(codeString)) 16972 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TASK, code); 16973 if ("TerminologyCapabilities".equals(codeString)) 16974 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TERMINOLOGYCAPABILITIES, code); 16975 if ("TestPlan".equals(codeString)) 16976 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TESTPLAN, code); 16977 if ("TestReport".equals(codeString)) 16978 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TESTREPORT, code); 16979 if ("TestScript".equals(codeString)) 16980 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TESTSCRIPT, code); 16981 if ("Transport".equals(codeString)) 16982 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TRANSPORT, code); 16983 if ("ValueSet".equals(codeString)) 16984 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.VALUESET, code); 16985 if ("VerificationResult".equals(codeString)) 16986 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.VERIFICATIONRESULT, code); 16987 if ("VisionPrescription".equals(codeString)) 16988 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.VISIONPRESCRIPTION, code); 16989 throw new FHIRException("Unknown ResourceTypeEnum code '"+codeString+"'"); 16990 } 16991 public String toCode(ResourceTypeEnum code) { 16992 if (code == ResourceTypeEnum.NULL) 16993 return null; 16994 if (code == ResourceTypeEnum.ACCOUNT) 16995 return "Account"; 16996 if (code == ResourceTypeEnum.ACTIVITYDEFINITION) 16997 return "ActivityDefinition"; 16998 if (code == ResourceTypeEnum.ACTORDEFINITION) 16999 return "ActorDefinition"; 17000 if (code == ResourceTypeEnum.ADMINISTRABLEPRODUCTDEFINITION) 17001 return "AdministrableProductDefinition"; 17002 if (code == ResourceTypeEnum.ADVERSEEVENT) 17003 return "AdverseEvent"; 17004 if (code == ResourceTypeEnum.ALLERGYINTOLERANCE) 17005 return "AllergyIntolerance"; 17006 if (code == ResourceTypeEnum.APPOINTMENT) 17007 return "Appointment"; 17008 if (code == ResourceTypeEnum.APPOINTMENTRESPONSE) 17009 return "AppointmentResponse"; 17010 if (code == ResourceTypeEnum.ARTIFACTASSESSMENT) 17011 return "ArtifactAssessment"; 17012 if (code == ResourceTypeEnum.AUDITEVENT) 17013 return "AuditEvent"; 17014 if (code == ResourceTypeEnum.BASIC) 17015 return "Basic"; 17016 if (code == ResourceTypeEnum.BINARY) 17017 return "Binary"; 17018 if (code == ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCT) 17019 return "BiologicallyDerivedProduct"; 17020 if (code == ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCTDISPENSE) 17021 return "BiologicallyDerivedProductDispense"; 17022 if (code == ResourceTypeEnum.BODYSTRUCTURE) 17023 return "BodyStructure"; 17024 if (code == ResourceTypeEnum.BUNDLE) 17025 return "Bundle"; 17026 if (code == ResourceTypeEnum.CAPABILITYSTATEMENT) 17027 return "CapabilityStatement"; 17028 if (code == ResourceTypeEnum.CAREPLAN) 17029 return "CarePlan"; 17030 if (code == ResourceTypeEnum.CARETEAM) 17031 return "CareTeam"; 17032 if (code == ResourceTypeEnum.CHARGEITEM) 17033 return "ChargeItem"; 17034 if (code == ResourceTypeEnum.CHARGEITEMDEFINITION) 17035 return "ChargeItemDefinition"; 17036 if (code == ResourceTypeEnum.CITATION) 17037 return "Citation"; 17038 if (code == ResourceTypeEnum.CLAIM) 17039 return "Claim"; 17040 if (code == ResourceTypeEnum.CLAIMRESPONSE) 17041 return "ClaimResponse"; 17042 if (code == ResourceTypeEnum.CLINICALIMPRESSION) 17043 return "ClinicalImpression"; 17044 if (code == ResourceTypeEnum.CLINICALUSEDEFINITION) 17045 return "ClinicalUseDefinition"; 17046 if (code == ResourceTypeEnum.CODESYSTEM) 17047 return "CodeSystem"; 17048 if (code == ResourceTypeEnum.COMMUNICATION) 17049 return "Communication"; 17050 if (code == ResourceTypeEnum.COMMUNICATIONREQUEST) 17051 return "CommunicationRequest"; 17052 if (code == ResourceTypeEnum.COMPARTMENTDEFINITION) 17053 return "CompartmentDefinition"; 17054 if (code == ResourceTypeEnum.COMPOSITION) 17055 return "Composition"; 17056 if (code == ResourceTypeEnum.CONCEPTMAP) 17057 return "ConceptMap"; 17058 if (code == ResourceTypeEnum.CONDITION) 17059 return "Condition"; 17060 if (code == ResourceTypeEnum.CONDITIONDEFINITION) 17061 return "ConditionDefinition"; 17062 if (code == ResourceTypeEnum.CONSENT) 17063 return "Consent"; 17064 if (code == ResourceTypeEnum.CONTRACT) 17065 return "Contract"; 17066 if (code == ResourceTypeEnum.COVERAGE) 17067 return "Coverage"; 17068 if (code == ResourceTypeEnum.COVERAGEELIGIBILITYREQUEST) 17069 return "CoverageEligibilityRequest"; 17070 if (code == ResourceTypeEnum.COVERAGEELIGIBILITYRESPONSE) 17071 return "CoverageEligibilityResponse"; 17072 if (code == ResourceTypeEnum.DETECTEDISSUE) 17073 return "DetectedIssue"; 17074 if (code == ResourceTypeEnum.DEVICE) 17075 return "Device"; 17076 if (code == ResourceTypeEnum.DEVICEASSOCIATION) 17077 return "DeviceAssociation"; 17078 if (code == ResourceTypeEnum.DEVICEDEFINITION) 17079 return "DeviceDefinition"; 17080 if (code == ResourceTypeEnum.DEVICEDISPENSE) 17081 return "DeviceDispense"; 17082 if (code == ResourceTypeEnum.DEVICEMETRIC) 17083 return "DeviceMetric"; 17084 if (code == ResourceTypeEnum.DEVICEREQUEST) 17085 return "DeviceRequest"; 17086 if (code == ResourceTypeEnum.DEVICEUSAGE) 17087 return "DeviceUsage"; 17088 if (code == ResourceTypeEnum.DIAGNOSTICREPORT) 17089 return "DiagnosticReport"; 17090 if (code == ResourceTypeEnum.DOCUMENTREFERENCE) 17091 return "DocumentReference"; 17092 if (code == ResourceTypeEnum.ENCOUNTER) 17093 return "Encounter"; 17094 if (code == ResourceTypeEnum.ENCOUNTERHISTORY) 17095 return "EncounterHistory"; 17096 if (code == ResourceTypeEnum.ENDPOINT) 17097 return "Endpoint"; 17098 if (code == ResourceTypeEnum.ENROLLMENTREQUEST) 17099 return "EnrollmentRequest"; 17100 if (code == ResourceTypeEnum.ENROLLMENTRESPONSE) 17101 return "EnrollmentResponse"; 17102 if (code == ResourceTypeEnum.EPISODEOFCARE) 17103 return "EpisodeOfCare"; 17104 if (code == ResourceTypeEnum.EVENTDEFINITION) 17105 return "EventDefinition"; 17106 if (code == ResourceTypeEnum.EVIDENCE) 17107 return "Evidence"; 17108 if (code == ResourceTypeEnum.EVIDENCEREPORT) 17109 return "EvidenceReport"; 17110 if (code == ResourceTypeEnum.EVIDENCEVARIABLE) 17111 return "EvidenceVariable"; 17112 if (code == ResourceTypeEnum.EXAMPLESCENARIO) 17113 return "ExampleScenario"; 17114 if (code == ResourceTypeEnum.EXPLANATIONOFBENEFIT) 17115 return "ExplanationOfBenefit"; 17116 if (code == ResourceTypeEnum.FAMILYMEMBERHISTORY) 17117 return "FamilyMemberHistory"; 17118 if (code == ResourceTypeEnum.FLAG) 17119 return "Flag"; 17120 if (code == ResourceTypeEnum.FORMULARYITEM) 17121 return "FormularyItem"; 17122 if (code == ResourceTypeEnum.GENOMICSTUDY) 17123 return "GenomicStudy"; 17124 if (code == ResourceTypeEnum.GOAL) 17125 return "Goal"; 17126 if (code == ResourceTypeEnum.GRAPHDEFINITION) 17127 return "GraphDefinition"; 17128 if (code == ResourceTypeEnum.GROUP) 17129 return "Group"; 17130 if (code == ResourceTypeEnum.GUIDANCERESPONSE) 17131 return "GuidanceResponse"; 17132 if (code == ResourceTypeEnum.HEALTHCARESERVICE) 17133 return "HealthcareService"; 17134 if (code == ResourceTypeEnum.IMAGINGSELECTION) 17135 return "ImagingSelection"; 17136 if (code == ResourceTypeEnum.IMAGINGSTUDY) 17137 return "ImagingStudy"; 17138 if (code == ResourceTypeEnum.IMMUNIZATION) 17139 return "Immunization"; 17140 if (code == ResourceTypeEnum.IMMUNIZATIONEVALUATION) 17141 return "ImmunizationEvaluation"; 17142 if (code == ResourceTypeEnum.IMMUNIZATIONRECOMMENDATION) 17143 return "ImmunizationRecommendation"; 17144 if (code == ResourceTypeEnum.IMPLEMENTATIONGUIDE) 17145 return "ImplementationGuide"; 17146 if (code == ResourceTypeEnum.INGREDIENT) 17147 return "Ingredient"; 17148 if (code == ResourceTypeEnum.INSURANCEPLAN) 17149 return "InsurancePlan"; 17150 if (code == ResourceTypeEnum.INVENTORYITEM) 17151 return "InventoryItem"; 17152 if (code == ResourceTypeEnum.INVENTORYREPORT) 17153 return "InventoryReport"; 17154 if (code == ResourceTypeEnum.INVOICE) 17155 return "Invoice"; 17156 if (code == ResourceTypeEnum.LIBRARY) 17157 return "Library"; 17158 if (code == ResourceTypeEnum.LINKAGE) 17159 return "Linkage"; 17160 if (code == ResourceTypeEnum.LIST) 17161 return "List"; 17162 if (code == ResourceTypeEnum.LOCATION) 17163 return "Location"; 17164 if (code == ResourceTypeEnum.MANUFACTUREDITEMDEFINITION) 17165 return "ManufacturedItemDefinition"; 17166 if (code == ResourceTypeEnum.MEASURE) 17167 return "Measure"; 17168 if (code == ResourceTypeEnum.MEASUREREPORT) 17169 return "MeasureReport"; 17170 if (code == ResourceTypeEnum.MEDICATION) 17171 return "Medication"; 17172 if (code == ResourceTypeEnum.MEDICATIONADMINISTRATION) 17173 return "MedicationAdministration"; 17174 if (code == ResourceTypeEnum.MEDICATIONDISPENSE) 17175 return "MedicationDispense"; 17176 if (code == ResourceTypeEnum.MEDICATIONKNOWLEDGE) 17177 return "MedicationKnowledge"; 17178 if (code == ResourceTypeEnum.MEDICATIONREQUEST) 17179 return "MedicationRequest"; 17180 if (code == ResourceTypeEnum.MEDICATIONSTATEMENT) 17181 return "MedicationStatement"; 17182 if (code == ResourceTypeEnum.MEDICINALPRODUCTDEFINITION) 17183 return "MedicinalProductDefinition"; 17184 if (code == ResourceTypeEnum.MESSAGEDEFINITION) 17185 return "MessageDefinition"; 17186 if (code == ResourceTypeEnum.MESSAGEHEADER) 17187 return "MessageHeader"; 17188 if (code == ResourceTypeEnum.MOLECULARSEQUENCE) 17189 return "MolecularSequence"; 17190 if (code == ResourceTypeEnum.NAMINGSYSTEM) 17191 return "NamingSystem"; 17192 if (code == ResourceTypeEnum.NUTRITIONINTAKE) 17193 return "NutritionIntake"; 17194 if (code == ResourceTypeEnum.NUTRITIONORDER) 17195 return "NutritionOrder"; 17196 if (code == ResourceTypeEnum.NUTRITIONPRODUCT) 17197 return "NutritionProduct"; 17198 if (code == ResourceTypeEnum.OBSERVATION) 17199 return "Observation"; 17200 if (code == ResourceTypeEnum.OBSERVATIONDEFINITION) 17201 return "ObservationDefinition"; 17202 if (code == ResourceTypeEnum.OPERATIONDEFINITION) 17203 return "OperationDefinition"; 17204 if (code == ResourceTypeEnum.OPERATIONOUTCOME) 17205 return "OperationOutcome"; 17206 if (code == ResourceTypeEnum.ORGANIZATION) 17207 return "Organization"; 17208 if (code == ResourceTypeEnum.ORGANIZATIONAFFILIATION) 17209 return "OrganizationAffiliation"; 17210 if (code == ResourceTypeEnum.PACKAGEDPRODUCTDEFINITION) 17211 return "PackagedProductDefinition"; 17212 if (code == ResourceTypeEnum.PARAMETERS) 17213 return "Parameters"; 17214 if (code == ResourceTypeEnum.PATIENT) 17215 return "Patient"; 17216 if (code == ResourceTypeEnum.PAYMENTNOTICE) 17217 return "PaymentNotice"; 17218 if (code == ResourceTypeEnum.PAYMENTRECONCILIATION) 17219 return "PaymentReconciliation"; 17220 if (code == ResourceTypeEnum.PERMISSION) 17221 return "Permission"; 17222 if (code == ResourceTypeEnum.PERSON) 17223 return "Person"; 17224 if (code == ResourceTypeEnum.PLANDEFINITION) 17225 return "PlanDefinition"; 17226 if (code == ResourceTypeEnum.PRACTITIONER) 17227 return "Practitioner"; 17228 if (code == ResourceTypeEnum.PRACTITIONERROLE) 17229 return "PractitionerRole"; 17230 if (code == ResourceTypeEnum.PROCEDURE) 17231 return "Procedure"; 17232 if (code == ResourceTypeEnum.PROVENANCE) 17233 return "Provenance"; 17234 if (code == ResourceTypeEnum.QUESTIONNAIRE) 17235 return "Questionnaire"; 17236 if (code == ResourceTypeEnum.QUESTIONNAIRERESPONSE) 17237 return "QuestionnaireResponse"; 17238 if (code == ResourceTypeEnum.REGULATEDAUTHORIZATION) 17239 return "RegulatedAuthorization"; 17240 if (code == ResourceTypeEnum.RELATEDPERSON) 17241 return "RelatedPerson"; 17242 if (code == ResourceTypeEnum.REQUESTORCHESTRATION) 17243 return "RequestOrchestration"; 17244 if (code == ResourceTypeEnum.REQUIREMENTS) 17245 return "Requirements"; 17246 if (code == ResourceTypeEnum.RESEARCHSTUDY) 17247 return "ResearchStudy"; 17248 if (code == ResourceTypeEnum.RESEARCHSUBJECT) 17249 return "ResearchSubject"; 17250 if (code == ResourceTypeEnum.RISKASSESSMENT) 17251 return "RiskAssessment"; 17252 if (code == ResourceTypeEnum.SCHEDULE) 17253 return "Schedule"; 17254 if (code == ResourceTypeEnum.SEARCHPARAMETER) 17255 return "SearchParameter"; 17256 if (code == ResourceTypeEnum.SERVICEREQUEST) 17257 return "ServiceRequest"; 17258 if (code == ResourceTypeEnum.SLOT) 17259 return "Slot"; 17260 if (code == ResourceTypeEnum.SPECIMEN) 17261 return "Specimen"; 17262 if (code == ResourceTypeEnum.SPECIMENDEFINITION) 17263 return "SpecimenDefinition"; 17264 if (code == ResourceTypeEnum.STRUCTUREDEFINITION) 17265 return "StructureDefinition"; 17266 if (code == ResourceTypeEnum.STRUCTUREMAP) 17267 return "StructureMap"; 17268 if (code == ResourceTypeEnum.SUBSCRIPTION) 17269 return "Subscription"; 17270 if (code == ResourceTypeEnum.SUBSCRIPTIONSTATUS) 17271 return "SubscriptionStatus"; 17272 if (code == ResourceTypeEnum.SUBSCRIPTIONTOPIC) 17273 return "SubscriptionTopic"; 17274 if (code == ResourceTypeEnum.SUBSTANCE) 17275 return "Substance"; 17276 if (code == ResourceTypeEnum.SUBSTANCEDEFINITION) 17277 return "SubstanceDefinition"; 17278 if (code == ResourceTypeEnum.SUBSTANCENUCLEICACID) 17279 return "SubstanceNucleicAcid"; 17280 if (code == ResourceTypeEnum.SUBSTANCEPOLYMER) 17281 return "SubstancePolymer"; 17282 if (code == ResourceTypeEnum.SUBSTANCEPROTEIN) 17283 return "SubstanceProtein"; 17284 if (code == ResourceTypeEnum.SUBSTANCEREFERENCEINFORMATION) 17285 return "SubstanceReferenceInformation"; 17286 if (code == ResourceTypeEnum.SUBSTANCESOURCEMATERIAL) 17287 return "SubstanceSourceMaterial"; 17288 if (code == ResourceTypeEnum.SUPPLYDELIVERY) 17289 return "SupplyDelivery"; 17290 if (code == ResourceTypeEnum.SUPPLYREQUEST) 17291 return "SupplyRequest"; 17292 if (code == ResourceTypeEnum.TASK) 17293 return "Task"; 17294 if (code == ResourceTypeEnum.TERMINOLOGYCAPABILITIES) 17295 return "TerminologyCapabilities"; 17296 if (code == ResourceTypeEnum.TESTPLAN) 17297 return "TestPlan"; 17298 if (code == ResourceTypeEnum.TESTREPORT) 17299 return "TestReport"; 17300 if (code == ResourceTypeEnum.TESTSCRIPT) 17301 return "TestScript"; 17302 if (code == ResourceTypeEnum.TRANSPORT) 17303 return "Transport"; 17304 if (code == ResourceTypeEnum.VALUESET) 17305 return "ValueSet"; 17306 if (code == ResourceTypeEnum.VERIFICATIONRESULT) 17307 return "VerificationResult"; 17308 if (code == ResourceTypeEnum.VISIONPRESCRIPTION) 17309 return "VisionPrescription"; 17310 return "?"; 17311 } 17312 public String toSystem(ResourceTypeEnum code) { 17313 return code.getSystem(); 17314 } 17315 } 17316 17317 public enum SearchComparator { 17318 /** 17319 * the value for the parameter in the resource is equal to the provided value. 17320 */ 17321 EQ, 17322 /** 17323 * the value for the parameter in the resource is not equal to the provided value. 17324 */ 17325 NE, 17326 /** 17327 * the value for the parameter in the resource is greater than the provided value. 17328 */ 17329 GT, 17330 /** 17331 * the value for the parameter in the resource is less than the provided value. 17332 */ 17333 LT, 17334 /** 17335 * the value for the parameter in the resource is greater or equal to the provided value. 17336 */ 17337 GE, 17338 /** 17339 * the value for the parameter in the resource is less or equal to the provided value. 17340 */ 17341 LE, 17342 /** 17343 * the value for the parameter in the resource starts after the provided value. 17344 */ 17345 SA, 17346 /** 17347 * the value for the parameter in the resource ends before the provided value. 17348 */ 17349 EB, 17350 /** 17351 * the value for the parameter in the resource is approximately the same to the provided value. 17352 */ 17353 AP, 17354 /** 17355 * added to help the parsers 17356 */ 17357 NULL; 17358 public static SearchComparator fromCode(String codeString) throws FHIRException { 17359 if (codeString == null || "".equals(codeString)) 17360 return null; 17361 if ("eq".equals(codeString)) 17362 return EQ; 17363 if ("ne".equals(codeString)) 17364 return NE; 17365 if ("gt".equals(codeString)) 17366 return GT; 17367 if ("lt".equals(codeString)) 17368 return LT; 17369 if ("ge".equals(codeString)) 17370 return GE; 17371 if ("le".equals(codeString)) 17372 return LE; 17373 if ("sa".equals(codeString)) 17374 return SA; 17375 if ("eb".equals(codeString)) 17376 return EB; 17377 if ("ap".equals(codeString)) 17378 return AP; 17379 throw new FHIRException("Unknown SearchComparator code '"+codeString+"'"); 17380 } 17381 public static boolean isValidCode(String codeString) { 17382 if (codeString == null || "".equals(codeString)) 17383 return false; 17384 return Utilities.existsInList(codeString, "eq", "ne", "gt", "lt", "ge", "le", "sa", "eb", "ap"); 17385 } 17386 public String toCode() { 17387 switch (this) { 17388 case EQ: return "eq"; 17389 case NE: return "ne"; 17390 case GT: return "gt"; 17391 case LT: return "lt"; 17392 case GE: return "ge"; 17393 case LE: return "le"; 17394 case SA: return "sa"; 17395 case EB: return "eb"; 17396 case AP: return "ap"; 17397 case NULL: return null; 17398 default: return "?"; 17399 } 17400 } 17401 public String getSystem() { 17402 switch (this) { 17403 case EQ: return "http://hl7.org/fhir/search-comparator"; 17404 case NE: return "http://hl7.org/fhir/search-comparator"; 17405 case GT: return "http://hl7.org/fhir/search-comparator"; 17406 case LT: return "http://hl7.org/fhir/search-comparator"; 17407 case GE: return "http://hl7.org/fhir/search-comparator"; 17408 case LE: return "http://hl7.org/fhir/search-comparator"; 17409 case SA: return "http://hl7.org/fhir/search-comparator"; 17410 case EB: return "http://hl7.org/fhir/search-comparator"; 17411 case AP: return "http://hl7.org/fhir/search-comparator"; 17412 case NULL: return null; 17413 default: return "?"; 17414 } 17415 } 17416 public String getDefinition() { 17417 switch (this) { 17418 case EQ: return "the value for the parameter in the resource is equal to the provided value."; 17419 case NE: return "the value for the parameter in the resource is not equal to the provided value."; 17420 case GT: return "the value for the parameter in the resource is greater than the provided value."; 17421 case LT: return "the value for the parameter in the resource is less than the provided value."; 17422 case GE: return "the value for the parameter in the resource is greater or equal to the provided value."; 17423 case LE: return "the value for the parameter in the resource is less or equal to the provided value."; 17424 case SA: return "the value for the parameter in the resource starts after the provided value."; 17425 case EB: return "the value for the parameter in the resource ends before the provided value."; 17426 case AP: return "the value for the parameter in the resource is approximately the same to the provided value."; 17427 case NULL: return null; 17428 default: return "?"; 17429 } 17430 } 17431 public String getDisplay() { 17432 switch (this) { 17433 case EQ: return "Equals"; 17434 case NE: return "Not Equals"; 17435 case GT: return "Greater Than"; 17436 case LT: return "Less Than"; 17437 case GE: return "Greater or Equals"; 17438 case LE: return "Less of Equal"; 17439 case SA: return "Starts After"; 17440 case EB: return "Ends Before"; 17441 case AP: return "Approximately"; 17442 case NULL: return null; 17443 default: return "?"; 17444 } 17445 } 17446 } 17447 17448 public static class SearchComparatorEnumFactory implements EnumFactory<SearchComparator> { 17449 public SearchComparator fromCode(String codeString) throws IllegalArgumentException { 17450 if (codeString == null || "".equals(codeString)) 17451 if (codeString == null || "".equals(codeString)) 17452 return null; 17453 if ("eq".equals(codeString)) 17454 return SearchComparator.EQ; 17455 if ("ne".equals(codeString)) 17456 return SearchComparator.NE; 17457 if ("gt".equals(codeString)) 17458 return SearchComparator.GT; 17459 if ("lt".equals(codeString)) 17460 return SearchComparator.LT; 17461 if ("ge".equals(codeString)) 17462 return SearchComparator.GE; 17463 if ("le".equals(codeString)) 17464 return SearchComparator.LE; 17465 if ("sa".equals(codeString)) 17466 return SearchComparator.SA; 17467 if ("eb".equals(codeString)) 17468 return SearchComparator.EB; 17469 if ("ap".equals(codeString)) 17470 return SearchComparator.AP; 17471 throw new IllegalArgumentException("Unknown SearchComparator code '"+codeString+"'"); 17472 } 17473 17474 public Enumeration<SearchComparator> fromType(PrimitiveType<?> code) throws FHIRException { 17475 if (code == null) 17476 return null; 17477 if (code.isEmpty()) 17478 return new Enumeration<SearchComparator>(this, SearchComparator.NULL, code); 17479 String codeString = ((PrimitiveType) code).asStringValue(); 17480 if (codeString == null || "".equals(codeString)) 17481 return new Enumeration<SearchComparator>(this, SearchComparator.NULL, code); 17482 if ("eq".equals(codeString)) 17483 return new Enumeration<SearchComparator>(this, SearchComparator.EQ, code); 17484 if ("ne".equals(codeString)) 17485 return new Enumeration<SearchComparator>(this, SearchComparator.NE, code); 17486 if ("gt".equals(codeString)) 17487 return new Enumeration<SearchComparator>(this, SearchComparator.GT, code); 17488 if ("lt".equals(codeString)) 17489 return new Enumeration<SearchComparator>(this, SearchComparator.LT, code); 17490 if ("ge".equals(codeString)) 17491 return new Enumeration<SearchComparator>(this, SearchComparator.GE, code); 17492 if ("le".equals(codeString)) 17493 return new Enumeration<SearchComparator>(this, SearchComparator.LE, code); 17494 if ("sa".equals(codeString)) 17495 return new Enumeration<SearchComparator>(this, SearchComparator.SA, code); 17496 if ("eb".equals(codeString)) 17497 return new Enumeration<SearchComparator>(this, SearchComparator.EB, code); 17498 if ("ap".equals(codeString)) 17499 return new Enumeration<SearchComparator>(this, SearchComparator.AP, code); 17500 throw new FHIRException("Unknown SearchComparator code '"+codeString+"'"); 17501 } 17502 public String toCode(SearchComparator code) { 17503 if (code == SearchComparator.NULL) 17504 return null; 17505 if (code == SearchComparator.EQ) 17506 return "eq"; 17507 if (code == SearchComparator.NE) 17508 return "ne"; 17509 if (code == SearchComparator.GT) 17510 return "gt"; 17511 if (code == SearchComparator.LT) 17512 return "lt"; 17513 if (code == SearchComparator.GE) 17514 return "ge"; 17515 if (code == SearchComparator.LE) 17516 return "le"; 17517 if (code == SearchComparator.SA) 17518 return "sa"; 17519 if (code == SearchComparator.EB) 17520 return "eb"; 17521 if (code == SearchComparator.AP) 17522 return "ap"; 17523 return "?"; 17524 } 17525 public String toSystem(SearchComparator code) { 17526 return code.getSystem(); 17527 } 17528 } 17529 17530 public enum SearchModifierCode { 17531 /** 17532 * The search parameter returns resources that have a value or not. 17533 */ 17534 MISSING, 17535 /** 17536 * The search parameter returns resources that have a value that exactly matches the supplied parameter (the whole string, including casing and accents). 17537 */ 17538 EXACT, 17539 /** 17540 * The search parameter returns resources that include the supplied parameter value anywhere within the field being searched. 17541 */ 17542 CONTAINS, 17543 /** 17544 * The search parameter returns resources that do not contain a match. 17545 */ 17546 NOT, 17547 /** 17548 * 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. 17549 */ 17550 TEXT, 17551 /** 17552 * 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. 17553 */ 17554 IN, 17555 /** 17556 * 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. 17557 */ 17558 NOTIN, 17559 /** 17560 * The search parameter tests whether the value in a resource is subsumed by the specified value (is-a, or hierarchical relationships). 17561 */ 17562 BELOW, 17563 /** 17564 * The search parameter tests whether the value in a resource subsumes the specified value (is-a, or hierarchical relationships). 17565 */ 17566 ABOVE, 17567 /** 17568 * The search parameter only applies to the Resource Type specified as a modifier (e.g. the modifier is not actually :type, but :Patient etc.). 17569 */ 17570 TYPE, 17571 /** 17572 * The search parameter applies to the identifier on the resource, not the reference. 17573 */ 17574 IDENTIFIER, 17575 /** 17576 * 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. 17577 */ 17578 OFTYPE, 17579 /** 17580 * Tests whether the textual display value in a resource (e.g., CodeableConcept.text, Coding.display, or Reference.display) matches the supplied parameter value. 17581 */ 17582 CODETEXT, 17583 /** 17584 * 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. 17585 */ 17586 TEXTADVANCED, 17587 /** 17588 * The search parameter indicates an inclusion directive (_include, _revinclude) that is applied to an included resource instead of the matching resource. 17589 */ 17590 ITERATE, 17591 /** 17592 * added to help the parsers 17593 */ 17594 NULL; 17595 public static SearchModifierCode fromCode(String codeString) throws FHIRException { 17596 if (codeString == null || "".equals(codeString)) 17597 return null; 17598 if ("missing".equals(codeString)) 17599 return MISSING; 17600 if ("exact".equals(codeString)) 17601 return EXACT; 17602 if ("contains".equals(codeString)) 17603 return CONTAINS; 17604 if ("not".equals(codeString)) 17605 return NOT; 17606 if ("text".equals(codeString)) 17607 return TEXT; 17608 if ("in".equals(codeString)) 17609 return IN; 17610 if ("not-in".equals(codeString)) 17611 return NOTIN; 17612 if ("below".equals(codeString)) 17613 return BELOW; 17614 if ("above".equals(codeString)) 17615 return ABOVE; 17616 if ("type".equals(codeString)) 17617 return TYPE; 17618 if ("identifier".equals(codeString)) 17619 return IDENTIFIER; 17620 if ("of-type".equals(codeString)) 17621 return OFTYPE; 17622 if ("code-text".equals(codeString)) 17623 return CODETEXT; 17624 if ("text-advanced".equals(codeString)) 17625 return TEXTADVANCED; 17626 if ("iterate".equals(codeString)) 17627 return ITERATE; 17628 throw new FHIRException("Unknown SearchModifierCode code '"+codeString+"'"); 17629 } 17630 public static boolean isValidCode(String codeString) { 17631 if (codeString == null || "".equals(codeString)) 17632 return false; 17633 return Utilities.existsInList(codeString, "missing", "exact", "contains", "not", "text", "in", "not-in", "below", "above", "type", "identifier", "of-type", "code-text", "text-advanced", "iterate"); 17634 } 17635 public String toCode() { 17636 switch (this) { 17637 case MISSING: return "missing"; 17638 case EXACT: return "exact"; 17639 case CONTAINS: return "contains"; 17640 case NOT: return "not"; 17641 case TEXT: return "text"; 17642 case IN: return "in"; 17643 case NOTIN: return "not-in"; 17644 case BELOW: return "below"; 17645 case ABOVE: return "above"; 17646 case TYPE: return "type"; 17647 case IDENTIFIER: return "identifier"; 17648 case OFTYPE: return "of-type"; 17649 case CODETEXT: return "code-text"; 17650 case TEXTADVANCED: return "text-advanced"; 17651 case ITERATE: return "iterate"; 17652 case NULL: return null; 17653 default: return "?"; 17654 } 17655 } 17656 public String getSystem() { 17657 switch (this) { 17658 case MISSING: return "http://hl7.org/fhir/search-modifier-code"; 17659 case EXACT: return "http://hl7.org/fhir/search-modifier-code"; 17660 case CONTAINS: return "http://hl7.org/fhir/search-modifier-code"; 17661 case NOT: return "http://hl7.org/fhir/search-modifier-code"; 17662 case TEXT: return "http://hl7.org/fhir/search-modifier-code"; 17663 case IN: return "http://hl7.org/fhir/search-modifier-code"; 17664 case NOTIN: return "http://hl7.org/fhir/search-modifier-code"; 17665 case BELOW: return "http://hl7.org/fhir/search-modifier-code"; 17666 case ABOVE: return "http://hl7.org/fhir/search-modifier-code"; 17667 case TYPE: return "http://hl7.org/fhir/search-modifier-code"; 17668 case IDENTIFIER: return "http://hl7.org/fhir/search-modifier-code"; 17669 case OFTYPE: return "http://hl7.org/fhir/search-modifier-code"; 17670 case CODETEXT: return "http://hl7.org/fhir/search-modifier-code"; 17671 case TEXTADVANCED: return "http://hl7.org/fhir/search-modifier-code"; 17672 case ITERATE: return "http://hl7.org/fhir/search-modifier-code"; 17673 case NULL: return null; 17674 default: return "?"; 17675 } 17676 } 17677 public String getDefinition() { 17678 switch (this) { 17679 case MISSING: return "The search parameter returns resources that have a value or not."; 17680 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)."; 17681 case CONTAINS: return "The search parameter returns resources that include the supplied parameter value anywhere within the field being searched."; 17682 case NOT: return "The search parameter returns resources that do not contain a match."; 17683 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."; 17684 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."; 17685 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."; 17686 case BELOW: return "The search parameter tests whether the value in a resource is subsumed by the specified value (is-a, or hierarchical relationships)."; 17687 case ABOVE: return "The search parameter tests whether the value in a resource subsumes the specified value (is-a, or hierarchical relationships)."; 17688 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.)."; 17689 case IDENTIFIER: return "The search parameter applies to the identifier on the resource, not the reference."; 17690 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."; 17691 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."; 17692 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."; 17693 case ITERATE: return "The search parameter indicates an inclusion directive (_include, _revinclude) that is applied to an included resource instead of the matching resource."; 17694 case NULL: return null; 17695 default: return "?"; 17696 } 17697 } 17698 public String getDisplay() { 17699 switch (this) { 17700 case MISSING: return "Missing"; 17701 case EXACT: return "Exact"; 17702 case CONTAINS: return "Contains"; 17703 case NOT: return "Not"; 17704 case TEXT: return "Text"; 17705 case IN: return "In"; 17706 case NOTIN: return "Not In"; 17707 case BELOW: return "Below"; 17708 case ABOVE: return "Above"; 17709 case TYPE: return "Type"; 17710 case IDENTIFIER: return "Identifier"; 17711 case OFTYPE: return "Of Type"; 17712 case CODETEXT: return "Code Text"; 17713 case TEXTADVANCED: return "Text Advanced"; 17714 case ITERATE: return "Iterate"; 17715 case NULL: return null; 17716 default: return "?"; 17717 } 17718 } 17719 } 17720 17721 public static class SearchModifierCodeEnumFactory implements EnumFactory<SearchModifierCode> { 17722 public SearchModifierCode fromCode(String codeString) throws IllegalArgumentException { 17723 if (codeString == null || "".equals(codeString)) 17724 if (codeString == null || "".equals(codeString)) 17725 return null; 17726 if ("missing".equals(codeString)) 17727 return SearchModifierCode.MISSING; 17728 if ("exact".equals(codeString)) 17729 return SearchModifierCode.EXACT; 17730 if ("contains".equals(codeString)) 17731 return SearchModifierCode.CONTAINS; 17732 if ("not".equals(codeString)) 17733 return SearchModifierCode.NOT; 17734 if ("text".equals(codeString)) 17735 return SearchModifierCode.TEXT; 17736 if ("in".equals(codeString)) 17737 return SearchModifierCode.IN; 17738 if ("not-in".equals(codeString)) 17739 return SearchModifierCode.NOTIN; 17740 if ("below".equals(codeString)) 17741 return SearchModifierCode.BELOW; 17742 if ("above".equals(codeString)) 17743 return SearchModifierCode.ABOVE; 17744 if ("type".equals(codeString)) 17745 return SearchModifierCode.TYPE; 17746 if ("identifier".equals(codeString)) 17747 return SearchModifierCode.IDENTIFIER; 17748 if ("of-type".equals(codeString)) 17749 return SearchModifierCode.OFTYPE; 17750 if ("code-text".equals(codeString)) 17751 return SearchModifierCode.CODETEXT; 17752 if ("text-advanced".equals(codeString)) 17753 return SearchModifierCode.TEXTADVANCED; 17754 if ("iterate".equals(codeString)) 17755 return SearchModifierCode.ITERATE; 17756 throw new IllegalArgumentException("Unknown SearchModifierCode code '"+codeString+"'"); 17757 } 17758 17759 public Enumeration<SearchModifierCode> fromType(PrimitiveType<?> code) throws FHIRException { 17760 if (code == null) 17761 return null; 17762 if (code.isEmpty()) 17763 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.NULL, code); 17764 String codeString = ((PrimitiveType) code).asStringValue(); 17765 if (codeString == null || "".equals(codeString)) 17766 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.NULL, code); 17767 if ("missing".equals(codeString)) 17768 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.MISSING, code); 17769 if ("exact".equals(codeString)) 17770 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.EXACT, code); 17771 if ("contains".equals(codeString)) 17772 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.CONTAINS, code); 17773 if ("not".equals(codeString)) 17774 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.NOT, code); 17775 if ("text".equals(codeString)) 17776 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.TEXT, code); 17777 if ("in".equals(codeString)) 17778 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.IN, code); 17779 if ("not-in".equals(codeString)) 17780 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.NOTIN, code); 17781 if ("below".equals(codeString)) 17782 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.BELOW, code); 17783 if ("above".equals(codeString)) 17784 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.ABOVE, code); 17785 if ("type".equals(codeString)) 17786 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.TYPE, code); 17787 if ("identifier".equals(codeString)) 17788 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.IDENTIFIER, code); 17789 if ("of-type".equals(codeString)) 17790 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.OFTYPE, code); 17791 if ("code-text".equals(codeString)) 17792 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.CODETEXT, code); 17793 if ("text-advanced".equals(codeString)) 17794 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.TEXTADVANCED, code); 17795 if ("iterate".equals(codeString)) 17796 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.ITERATE, code); 17797 throw new FHIRException("Unknown SearchModifierCode code '"+codeString+"'"); 17798 } 17799 public String toCode(SearchModifierCode code) { 17800 if (code == SearchModifierCode.NULL) 17801 return null; 17802 if (code == SearchModifierCode.MISSING) 17803 return "missing"; 17804 if (code == SearchModifierCode.EXACT) 17805 return "exact"; 17806 if (code == SearchModifierCode.CONTAINS) 17807 return "contains"; 17808 if (code == SearchModifierCode.NOT) 17809 return "not"; 17810 if (code == SearchModifierCode.TEXT) 17811 return "text"; 17812 if (code == SearchModifierCode.IN) 17813 return "in"; 17814 if (code == SearchModifierCode.NOTIN) 17815 return "not-in"; 17816 if (code == SearchModifierCode.BELOW) 17817 return "below"; 17818 if (code == SearchModifierCode.ABOVE) 17819 return "above"; 17820 if (code == SearchModifierCode.TYPE) 17821 return "type"; 17822 if (code == SearchModifierCode.IDENTIFIER) 17823 return "identifier"; 17824 if (code == SearchModifierCode.OFTYPE) 17825 return "of-type"; 17826 if (code == SearchModifierCode.CODETEXT) 17827 return "code-text"; 17828 if (code == SearchModifierCode.TEXTADVANCED) 17829 return "text-advanced"; 17830 if (code == SearchModifierCode.ITERATE) 17831 return "iterate"; 17832 return "?"; 17833 } 17834 public String toSystem(SearchModifierCode code) { 17835 return code.getSystem(); 17836 } 17837 } 17838 17839 public enum SearchParamType { 17840 /** 17841 * Search parameter SHALL be a number (a whole number, or a decimal). 17842 */ 17843 NUMBER, 17844 /** 17845 * Search parameter is on a date/time. The date format is the standard XML format, though other formats may be supported. 17846 */ 17847 DATE, 17848 /** 17849 * 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. 17850 */ 17851 STRING, 17852 /** 17853 * 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. 17854 */ 17855 TOKEN, 17856 /** 17857 * A reference to another resource (Reference or canonical). 17858 */ 17859 REFERENCE, 17860 /** 17861 * A composite search parameter that combines a search on two values together. 17862 */ 17863 COMPOSITE, 17864 /** 17865 * A search parameter that searches on a quantity. 17866 */ 17867 QUANTITY, 17868 /** 17869 * A search parameter that searches on a URI (RFC 3986). 17870 */ 17871 URI, 17872 /** 17873 * Special logic applies to this parameter per the description of the search parameter. 17874 */ 17875 SPECIAL, 17876 RESOURCE, // R6 hack 17877 /** 17878 * added to help the parsers 17879 */ 17880 NULL; 17881 public static SearchParamType fromCode(String codeString) throws FHIRException { 17882 if (codeString == null || "".equals(codeString)) 17883 return null; 17884 if ("number".equals(codeString)) 17885 return NUMBER; 17886 if ("date".equals(codeString)) 17887 return DATE; 17888 if ("string".equals(codeString)) 17889 return STRING; 17890 if ("token".equals(codeString)) 17891 return TOKEN; 17892 if ("reference".equals(codeString)) 17893 return REFERENCE; 17894 if ("composite".equals(codeString)) 17895 return COMPOSITE; 17896 if ("quantity".equals(codeString)) 17897 return QUANTITY; 17898 if ("uri".equals(codeString)) 17899 return URI; 17900 if ("special".equals(codeString)) 17901 return SPECIAL; 17902 if ("resource".equals(codeString)) 17903 return RESOURCE; 17904 throw new FHIRException("Unknown SearchParamType code '"+codeString+"'"); 17905 } 17906 public static boolean isValidCode(String codeString) { 17907 if (codeString == null || "".equals(codeString)) 17908 return false; 17909 return Utilities.existsInList(codeString, "number", "date", "string", "token", "reference", "composite", "quantity", "uri", "special", "resource"); 17910 } 17911 public String toCode() { 17912 switch (this) { 17913 case NUMBER: return "number"; 17914 case DATE: return "date"; 17915 case STRING: return "string"; 17916 case TOKEN: return "token"; 17917 case REFERENCE: return "reference"; 17918 case COMPOSITE: return "composite"; 17919 case QUANTITY: return "quantity"; 17920 case URI: return "uri"; 17921 case SPECIAL: return "special"; 17922 case RESOURCE: return "resource"; 17923 case NULL: return null; 17924 default: return "?"; 17925 } 17926 } 17927 public String getSystem() { 17928 switch (this) { 17929 case NUMBER: return "http://hl7.org/fhir/search-param-type"; 17930 case DATE: return "http://hl7.org/fhir/search-param-type"; 17931 case STRING: return "http://hl7.org/fhir/search-param-type"; 17932 case TOKEN: return "http://hl7.org/fhir/search-param-type"; 17933 case REFERENCE: return "http://hl7.org/fhir/search-param-type"; 17934 case COMPOSITE: return "http://hl7.org/fhir/search-param-type"; 17935 case QUANTITY: return "http://hl7.org/fhir/search-param-type"; 17936 case URI: return "http://hl7.org/fhir/search-param-type"; 17937 case SPECIAL: return "http://hl7.org/fhir/search-param-type"; 17938 case RESOURCE: return "http://hl7.org/fhir/search-param-type"; 17939 case NULL: return null; 17940 default: return "?"; 17941 } 17942 } 17943 public String getDefinition() { 17944 switch (this) { 17945 case NUMBER: return "Search parameter SHALL be a number (a whole number, or a decimal)."; 17946 case DATE: return "Search parameter is on a date/time. The date format is the standard XML format, though other formats may be supported."; 17947 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."; 17948 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."; 17949 case REFERENCE: return "A reference to another resource (Reference or canonical)."; 17950 case COMPOSITE: return "A composite search parameter that combines a search on two values together."; 17951 case QUANTITY: return "A search parameter that searches on a quantity."; 17952 case URI: return "A search parameter that searches on a URI (RFC 3986)."; 17953 case SPECIAL: return "Special logic applies to this parameter per the description of the search parameter."; 17954 case RESOURCE: return "Special logic applies to this parameter per the description of the search parameter."; 17955 case NULL: return null; 17956 default: return "?"; 17957 } 17958 } 17959 public String getDisplay() { 17960 switch (this) { 17961 case NUMBER: return "Number"; 17962 case DATE: return "Date/DateTime"; 17963 case STRING: return "String"; 17964 case TOKEN: return "Token"; 17965 case REFERENCE: return "Reference"; 17966 case COMPOSITE: return "Composite"; 17967 case QUANTITY: return "Quantity"; 17968 case URI: return "URI"; 17969 case SPECIAL: return "Special"; 17970 case RESOURCE: return "Resource"; 17971 case NULL: return null; 17972 default: return "?"; 17973 } 17974 } 17975 } 17976 17977 public static class SearchParamTypeEnumFactory implements EnumFactory<SearchParamType> { 17978 public SearchParamType fromCode(String codeString) throws IllegalArgumentException { 17979 if (codeString == null || "".equals(codeString)) 17980 if (codeString == null || "".equals(codeString)) 17981 return null; 17982 if ("number".equals(codeString)) 17983 return SearchParamType.NUMBER; 17984 if ("date".equals(codeString)) 17985 return SearchParamType.DATE; 17986 if ("string".equals(codeString)) 17987 return SearchParamType.STRING; 17988 if ("token".equals(codeString)) 17989 return SearchParamType.TOKEN; 17990 if ("reference".equals(codeString)) 17991 return SearchParamType.REFERENCE; 17992 if ("composite".equals(codeString)) 17993 return SearchParamType.COMPOSITE; 17994 if ("quantity".equals(codeString)) 17995 return SearchParamType.QUANTITY; 17996 if ("uri".equals(codeString)) 17997 return SearchParamType.URI; 17998 if ("special".equals(codeString)) 17999 return SearchParamType.SPECIAL; 18000 if ("resource".equals(codeString)) 18001 return SearchParamType.RESOURCE; 18002 throw new IllegalArgumentException("Unknown SearchParamType code '"+codeString+"'"); 18003 } 18004 18005 public Enumeration<SearchParamType> fromType(PrimitiveType<?> code) throws FHIRException { 18006 if (code == null) 18007 return null; 18008 if (code.isEmpty()) 18009 return new Enumeration<SearchParamType>(this, SearchParamType.NULL, code); 18010 String codeString = ((PrimitiveType) code).asStringValue(); 18011 if (codeString == null || "".equals(codeString)) 18012 return new Enumeration<SearchParamType>(this, SearchParamType.NULL, code); 18013 if ("number".equals(codeString)) 18014 return new Enumeration<SearchParamType>(this, SearchParamType.NUMBER, code); 18015 if ("date".equals(codeString)) 18016 return new Enumeration<SearchParamType>(this, SearchParamType.DATE, code); 18017 if ("string".equals(codeString)) 18018 return new Enumeration<SearchParamType>(this, SearchParamType.STRING, code); 18019 if ("token".equals(codeString)) 18020 return new Enumeration<SearchParamType>(this, SearchParamType.TOKEN, code); 18021 if ("reference".equals(codeString)) 18022 return new Enumeration<SearchParamType>(this, SearchParamType.REFERENCE, code); 18023 if ("composite".equals(codeString)) 18024 return new Enumeration<SearchParamType>(this, SearchParamType.COMPOSITE, code); 18025 if ("quantity".equals(codeString)) 18026 return new Enumeration<SearchParamType>(this, SearchParamType.QUANTITY, code); 18027 if ("uri".equals(codeString)) 18028 return new Enumeration<SearchParamType>(this, SearchParamType.URI, code); 18029 if ("special".equals(codeString)) 18030 return new Enumeration<SearchParamType>(this, SearchParamType.SPECIAL, code); 18031 if ("resource".equals(codeString)) 18032 return new Enumeration<SearchParamType>(this, SearchParamType.RESOURCE, code); 18033 throw new FHIRException("Unknown SearchParamType code '"+codeString+"'"); 18034 } 18035 public String toCode(SearchParamType code) { 18036 if (code == SearchParamType.NULL) 18037 return null; 18038 if (code == SearchParamType.NUMBER) 18039 return "number"; 18040 if (code == SearchParamType.DATE) 18041 return "date"; 18042 if (code == SearchParamType.STRING) 18043 return "string"; 18044 if (code == SearchParamType.TOKEN) 18045 return "token"; 18046 if (code == SearchParamType.REFERENCE) 18047 return "reference"; 18048 if (code == SearchParamType.COMPOSITE) 18049 return "composite"; 18050 if (code == SearchParamType.QUANTITY) 18051 return "quantity"; 18052 if (code == SearchParamType.URI) 18053 return "uri"; 18054 if (code == SearchParamType.SPECIAL) 18055 return "special"; 18056 if (code == SearchParamType.RESOURCE) 18057 return "resource"; 18058 return "?"; 18059 } 18060 public String toSystem(SearchParamType code) { 18061 return code.getSystem(); 18062 } 18063 } 18064 18065 public enum SubscriptionStatusCodes { 18066 /** 18067 * The client has requested the subscription, and the server has not yet set it up. 18068 */ 18069 REQUESTED, 18070 /** 18071 * The subscription is active. 18072 */ 18073 ACTIVE, 18074 /** 18075 * The server has an error executing the notification. 18076 */ 18077 ERROR, 18078 /** 18079 * Too many errors have occurred or the subscription has expired. 18080 */ 18081 OFF, 18082 /** 18083 * This subscription has been flagged as incorrect. 18084 */ 18085 ENTEREDINERROR, 18086 /** 18087 * added to help the parsers 18088 */ 18089 NULL; 18090 public static SubscriptionStatusCodes fromCode(String codeString) throws FHIRException { 18091 if (codeString == null || "".equals(codeString)) 18092 return null; 18093 if ("requested".equals(codeString)) 18094 return REQUESTED; 18095 if ("active".equals(codeString)) 18096 return ACTIVE; 18097 if ("error".equals(codeString)) 18098 return ERROR; 18099 if ("off".equals(codeString)) 18100 return OFF; 18101 if ("entered-in-error".equals(codeString)) 18102 return ENTEREDINERROR; 18103 throw new FHIRException("Unknown SubscriptionStatusCodes code '"+codeString+"'"); 18104 } 18105 public static boolean isValidCode(String codeString) { 18106 if (codeString == null || "".equals(codeString)) 18107 return false; 18108 return Utilities.existsInList(codeString, "requested", "active", "error", "off", "entered-in-error"); 18109 } 18110 public String toCode() { 18111 switch (this) { 18112 case REQUESTED: return "requested"; 18113 case ACTIVE: return "active"; 18114 case ERROR: return "error"; 18115 case OFF: return "off"; 18116 case ENTEREDINERROR: return "entered-in-error"; 18117 case NULL: return null; 18118 default: return "?"; 18119 } 18120 } 18121 public String getSystem() { 18122 switch (this) { 18123 case REQUESTED: return "http://hl7.org/fhir/subscription-status"; 18124 case ACTIVE: return "http://hl7.org/fhir/subscription-status"; 18125 case ERROR: return "http://hl7.org/fhir/subscription-status"; 18126 case OFF: return "http://hl7.org/fhir/subscription-status"; 18127 case ENTEREDINERROR: return "http://hl7.org/fhir/subscription-status"; 18128 case NULL: return null; 18129 default: return "?"; 18130 } 18131 } 18132 public String getDefinition() { 18133 switch (this) { 18134 case REQUESTED: return "The client has requested the subscription, and the server has not yet set it up."; 18135 case ACTIVE: return "The subscription is active."; 18136 case ERROR: return "The server has an error executing the notification."; 18137 case OFF: return "Too many errors have occurred or the subscription has expired."; 18138 case ENTEREDINERROR: return "This subscription has been flagged as incorrect."; 18139 case NULL: return null; 18140 default: return "?"; 18141 } 18142 } 18143 public String getDisplay() { 18144 switch (this) { 18145 case REQUESTED: return "Requested"; 18146 case ACTIVE: return "Active"; 18147 case ERROR: return "Error"; 18148 case OFF: return "Off"; 18149 case ENTEREDINERROR: return "Entered in Error"; 18150 case NULL: return null; 18151 default: return "?"; 18152 } 18153 } 18154 } 18155 18156 public static class SubscriptionStatusCodesEnumFactory implements EnumFactory<SubscriptionStatusCodes> { 18157 public SubscriptionStatusCodes fromCode(String codeString) throws IllegalArgumentException { 18158 if (codeString == null || "".equals(codeString)) 18159 if (codeString == null || "".equals(codeString)) 18160 return null; 18161 if ("requested".equals(codeString)) 18162 return SubscriptionStatusCodes.REQUESTED; 18163 if ("active".equals(codeString)) 18164 return SubscriptionStatusCodes.ACTIVE; 18165 if ("error".equals(codeString)) 18166 return SubscriptionStatusCodes.ERROR; 18167 if ("off".equals(codeString)) 18168 return SubscriptionStatusCodes.OFF; 18169 if ("entered-in-error".equals(codeString)) 18170 return SubscriptionStatusCodes.ENTEREDINERROR; 18171 throw new IllegalArgumentException("Unknown SubscriptionStatusCodes code '"+codeString+"'"); 18172 } 18173 18174 public Enumeration<SubscriptionStatusCodes> fromType(PrimitiveType<?> code) throws FHIRException { 18175 if (code == null) 18176 return null; 18177 if (code.isEmpty()) 18178 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.NULL, code); 18179 String codeString = ((PrimitiveType) code).asStringValue(); 18180 if (codeString == null || "".equals(codeString)) 18181 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.NULL, code); 18182 if ("requested".equals(codeString)) 18183 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.REQUESTED, code); 18184 if ("active".equals(codeString)) 18185 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.ACTIVE, code); 18186 if ("error".equals(codeString)) 18187 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.ERROR, code); 18188 if ("off".equals(codeString)) 18189 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.OFF, code); 18190 if ("entered-in-error".equals(codeString)) 18191 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.ENTEREDINERROR, code); 18192 throw new FHIRException("Unknown SubscriptionStatusCodes code '"+codeString+"'"); 18193 } 18194 public String toCode(SubscriptionStatusCodes code) { 18195 if (code == SubscriptionStatusCodes.NULL) 18196 return null; 18197 if (code == SubscriptionStatusCodes.REQUESTED) 18198 return "requested"; 18199 if (code == SubscriptionStatusCodes.ACTIVE) 18200 return "active"; 18201 if (code == SubscriptionStatusCodes.ERROR) 18202 return "error"; 18203 if (code == SubscriptionStatusCodes.OFF) 18204 return "off"; 18205 if (code == SubscriptionStatusCodes.ENTEREDINERROR) 18206 return "entered-in-error"; 18207 return "?"; 18208 } 18209 public String toSystem(SubscriptionStatusCodes code) { 18210 return code.getSystem(); 18211 } 18212 } 18213 18214 public enum Use { 18215 /** 18216 * The treatment is complete and this represents a Claim for the services. 18217 */ 18218 CLAIM, 18219 /** 18220 * The treatment is proposed and this represents a Pre-authorization for the services. 18221 */ 18222 PREAUTHORIZATION, 18223 /** 18224 * The treatment is proposed and this represents a Pre-determination for the services. 18225 */ 18226 PREDETERMINATION, 18227 /** 18228 * added to help the parsers 18229 */ 18230 NULL; 18231 public static Use fromCode(String codeString) throws FHIRException { 18232 if (codeString == null || "".equals(codeString)) 18233 return null; 18234 if ("claim".equals(codeString)) 18235 return CLAIM; 18236 if ("preauthorization".equals(codeString)) 18237 return PREAUTHORIZATION; 18238 if ("predetermination".equals(codeString)) 18239 return PREDETERMINATION; 18240 throw new FHIRException("Unknown Use code '"+codeString+"'"); 18241 } 18242 public static boolean isValidCode(String codeString) { 18243 if (codeString == null || "".equals(codeString)) 18244 return false; 18245 return Utilities.existsInList(codeString, "claim", "preauthorization", "predetermination"); 18246 } 18247 public String toCode() { 18248 switch (this) { 18249 case CLAIM: return "claim"; 18250 case PREAUTHORIZATION: return "preauthorization"; 18251 case PREDETERMINATION: return "predetermination"; 18252 case NULL: return null; 18253 default: return "?"; 18254 } 18255 } 18256 public String getSystem() { 18257 switch (this) { 18258 case CLAIM: return "http://hl7.org/fhir/claim-use"; 18259 case PREAUTHORIZATION: return "http://hl7.org/fhir/claim-use"; 18260 case PREDETERMINATION: return "http://hl7.org/fhir/claim-use"; 18261 case NULL: return null; 18262 default: return "?"; 18263 } 18264 } 18265 public String getDefinition() { 18266 switch (this) { 18267 case CLAIM: return "The treatment is complete and this represents a Claim for the services."; 18268 case PREAUTHORIZATION: return "The treatment is proposed and this represents a Pre-authorization for the services."; 18269 case PREDETERMINATION: return "The treatment is proposed and this represents a Pre-determination for the services."; 18270 case NULL: return null; 18271 default: return "?"; 18272 } 18273 } 18274 public String getDisplay() { 18275 switch (this) { 18276 case CLAIM: return "Claim"; 18277 case PREAUTHORIZATION: return "Preauthorization"; 18278 case PREDETERMINATION: return "Predetermination"; 18279 case NULL: return null; 18280 default: return "?"; 18281 } 18282 } 18283 } 18284 18285 public static class UseEnumFactory implements EnumFactory<Use> { 18286 public Use fromCode(String codeString) throws IllegalArgumentException { 18287 if (codeString == null || "".equals(codeString)) 18288 if (codeString == null || "".equals(codeString)) 18289 return null; 18290 if ("claim".equals(codeString)) 18291 return Use.CLAIM; 18292 if ("preauthorization".equals(codeString)) 18293 return Use.PREAUTHORIZATION; 18294 if ("predetermination".equals(codeString)) 18295 return Use.PREDETERMINATION; 18296 throw new IllegalArgumentException("Unknown Use code '"+codeString+"'"); 18297 } 18298 18299 public Enumeration<Use> fromType(PrimitiveType<?> code) throws FHIRException { 18300 if (code == null) 18301 return null; 18302 if (code.isEmpty()) 18303 return new Enumeration<Use>(this, Use.NULL, code); 18304 String codeString = ((PrimitiveType) code).asStringValue(); 18305 if (codeString == null || "".equals(codeString)) 18306 return new Enumeration<Use>(this, Use.NULL, code); 18307 if ("claim".equals(codeString)) 18308 return new Enumeration<Use>(this, Use.CLAIM, code); 18309 if ("preauthorization".equals(codeString)) 18310 return new Enumeration<Use>(this, Use.PREAUTHORIZATION, code); 18311 if ("predetermination".equals(codeString)) 18312 return new Enumeration<Use>(this, Use.PREDETERMINATION, code); 18313 throw new FHIRException("Unknown Use code '"+codeString+"'"); 18314 } 18315 public String toCode(Use code) { 18316 if (code == Use.NULL) 18317 return null; 18318 if (code == Use.CLAIM) 18319 return "claim"; 18320 if (code == Use.PREAUTHORIZATION) 18321 return "preauthorization"; 18322 if (code == Use.PREDETERMINATION) 18323 return "predetermination"; 18324 return "?"; 18325 } 18326 public String toSystem(Use code) { 18327 return code.getSystem(); 18328 } 18329 } 18330 18331 public enum VersionIndependentResourceTypesAll { 18332 /** 18333 * 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. 18334 */ 18335 ACCOUNT, 18336 /** 18337 * This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context. 18338 */ 18339 ACTIVITYDEFINITION, 18340 /** 18341 * 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. 18342 */ 18343 ACTORDEFINITION, 18344 /** 18345 * 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). 18346 */ 18347 ADMINISTRABLEPRODUCTDEFINITION, 18348 /** 18349 * 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. 18350 */ 18351 ADVERSEEVENT, 18352 /** 18353 * Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance. 18354 */ 18355 ALLERGYINTOLERANCE, 18356 /** 18357 * 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). 18358 */ 18359 APPOINTMENT, 18360 /** 18361 * A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection. 18362 */ 18363 APPOINTMENTRESPONSE, 18364 /** 18365 * This Resource provides one or more comments, classifiers or ratings about a Resource and supports attribution and rights management metadata for the added content. 18366 */ 18367 ARTIFACTASSESSMENT, 18368 /** 18369 * A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis. 18370 */ 18371 AUDITEVENT, 18372 /** 18373 * 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. 18374 */ 18375 BASIC, 18376 /** 18377 * 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. 18378 */ 18379 BINARY, 18380 /** 18381 * A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity. 18382 */ 18383 BIOLOGICALLYDERIVEDPRODUCT, 18384 /** 18385 * A record of dispensation of a biologically derived product. 18386 */ 18387 BIOLOGICALLYDERIVEDPRODUCTDISPENSE, 18388 /** 18389 * 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. 18390 */ 18391 BODYSTRUCTURE, 18392 /** 18393 * A container for a collection of resources. 18394 */ 18395 BUNDLE, 18396 /** 18397 * Common Interface declaration for conformance and knowledge artifact resources. 18398 */ 18399 CANONICALRESOURCE, 18400 /** 18401 * 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. 18402 */ 18403 CAPABILITYSTATEMENT, 18404 /** 18405 * 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. 18406 */ 18407 CAREPLAN, 18408 /** 18409 * The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care. 18410 */ 18411 CARETEAM, 18412 /** 18413 * 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. 18414 */ 18415 CHARGEITEM, 18416 /** 18417 * 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. 18418 */ 18419 CHARGEITEMDEFINITION, 18420 /** 18421 * 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. 18422 */ 18423 CITATION, 18424 /** 18425 * 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. 18426 */ 18427 CLAIM, 18428 /** 18429 * This resource provides the adjudication details from the processing of a Claim resource. 18430 */ 18431 CLAIMRESPONSE, 18432 /** 18433 * 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. 18434 */ 18435 CLINICALIMPRESSION, 18436 /** 18437 * A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure. 18438 */ 18439 CLINICALUSEDEFINITION, 18440 /** 18441 * 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. 18442 */ 18443 CODESYSTEM, 18444 /** 18445 * 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. 18446 */ 18447 COMMUNICATION, 18448 /** 18449 * 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. 18450 */ 18451 COMMUNICATIONREQUEST, 18452 /** 18453 * A compartment definition that defines how resources are accessed on a server. 18454 */ 18455 COMPARTMENTDEFINITION, 18456 /** 18457 * 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.). 18458 */ 18459 COMPOSITION, 18460 /** 18461 * 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. 18462 */ 18463 CONCEPTMAP, 18464 /** 18465 * A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern. 18466 */ 18467 CONDITION, 18468 /** 18469 * A definition of a condition and information relevant to managing it. 18470 */ 18471 CONDITIONDEFINITION, 18472 /** 18473 * 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. 18474 */ 18475 CONSENT, 18476 /** 18477 * Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement. 18478 */ 18479 CONTRACT, 18480 /** 18481 * Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment. 18482 */ 18483 COVERAGE, 18484 /** 18485 * 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. 18486 */ 18487 COVERAGEELIGIBILITYREQUEST, 18488 /** 18489 * This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource. 18490 */ 18491 COVERAGEELIGIBILITYRESPONSE, 18492 /** 18493 * 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. 18494 */ 18495 DETECTEDISSUE, 18496 /** 18497 * 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. 18498 */ 18499 DEVICE, 18500 /** 18501 * A record of association of a device. 18502 */ 18503 DEVICEASSOCIATION, 18504 /** 18505 * This is a specialized resource that defines the characteristics and capabilities of a device. 18506 */ 18507 DEVICEDEFINITION, 18508 /** 18509 * 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. 18510 */ 18511 DEVICEDISPENSE, 18512 /** 18513 * 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. 18514 */ 18515 DEVICEMETRIC, 18516 /** 18517 * 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. 18518 */ 18519 DEVICEREQUEST, 18520 /** 18521 * 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. 18522 */ 18523 DEVICEUSAGE, 18524 /** 18525 * 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. 18526 */ 18527 DIAGNOSTICREPORT, 18528 /** 18529 * 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. 18530 */ 18531 DOCUMENTREFERENCE, 18532 /** 18533 * A resource that includes narrative, extensions, and contained resources. 18534 */ 18535 DOMAINRESOURCE, 18536 /** 18537 * 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). 18538 */ 18539 ENCOUNTER, 18540 /** 18541 * A record of significant events/milestones key data throughout the history of an Encounter 18542 */ 18543 ENCOUNTERHISTORY, 18544 /** 18545 * 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. 18546 */ 18547 ENDPOINT, 18548 /** 18549 * This resource provides the insurance enrollment details to the insurer regarding a specified coverage. 18550 */ 18551 ENROLLMENTREQUEST, 18552 /** 18553 * This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource. 18554 */ 18555 ENROLLMENTRESPONSE, 18556 /** 18557 * 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. 18558 */ 18559 EPISODEOFCARE, 18560 /** 18561 * The EventDefinition resource provides a reusable description of when a particular event can occur. 18562 */ 18563 EVENTDEFINITION, 18564 /** 18565 * 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. 18566 */ 18567 EVIDENCE, 18568 /** 18569 * 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. 18570 */ 18571 EVIDENCEREPORT, 18572 /** 18573 * The EvidenceVariable resource describes an element that knowledge (Evidence) is about. 18574 */ 18575 EVIDENCEVARIABLE, 18576 /** 18577 * A walkthrough of a workflow showing the interaction between systems and the instances shared, possibly including the evolution of instances over time. 18578 */ 18579 EXAMPLESCENARIO, 18580 /** 18581 * 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. 18582 */ 18583 EXPLANATIONOFBENEFIT, 18584 /** 18585 * Significant health conditions for a person related to the patient relevant in the context of care for the patient. 18586 */ 18587 FAMILYMEMBERHISTORY, 18588 /** 18589 * Prospective warnings of potential issues when providing care to the patient. 18590 */ 18591 FLAG, 18592 /** 18593 * 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. 18594 */ 18595 FORMULARYITEM, 18596 /** 18597 * A set of analyses performed to analyze and generate genomic data. 18598 */ 18599 GENOMICSTUDY, 18600 /** 18601 * 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. 18602 */ 18603 GOAL, 18604 /** 18605 * 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. 18606 */ 18607 GRAPHDEFINITION, 18608 /** 18609 * 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. 18610 */ 18611 GROUP, 18612 /** 18613 * 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. 18614 */ 18615 GUIDANCERESPONSE, 18616 /** 18617 * 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. 18618 */ 18619 HEALTHCARESERVICE, 18620 /** 18621 * 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. 18622 */ 18623 IMAGINGSELECTION, 18624 /** 18625 * 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. 18626 */ 18627 IMAGINGSTUDY, 18628 /** 18629 * 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. 18630 */ 18631 IMMUNIZATION, 18632 /** 18633 * Describes a comparison of an immunization event against published recommendations to determine if the administration is "valid" in relation to those recommendations. 18634 */ 18635 IMMUNIZATIONEVALUATION, 18636 /** 18637 * A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification. 18638 */ 18639 IMMUNIZATIONRECOMMENDATION, 18640 /** 18641 * 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. 18642 */ 18643 IMPLEMENTATIONGUIDE, 18644 /** 18645 * An ingredient of a manufactured item or pharmaceutical product. 18646 */ 18647 INGREDIENT, 18648 /** 18649 * Details of a Health Insurance product/plan provided by an organization. 18650 */ 18651 INSURANCEPLAN, 18652 /** 18653 * functional description of an inventory item used in inventory and supply-related workflows. 18654 */ 18655 INVENTORYITEM, 18656 /** 18657 * A report of inventory or stock items. 18658 */ 18659 INVENTORYREPORT, 18660 /** 18661 * Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose. 18662 */ 18663 INVOICE, 18664 /** 18665 * 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. 18666 */ 18667 LIBRARY, 18668 /** 18669 * Identifies two or more records (resource instances) that refer to the same real-world "occurrence". 18670 */ 18671 LINKAGE, 18672 /** 18673 * A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc. 18674 */ 18675 LIST, 18676 /** 18677 * Details and position information for a place where services are provided and resources and participants may be stored, found, contained, or accommodated. 18678 */ 18679 LOCATION, 18680 /** 18681 * The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product. 18682 */ 18683 MANUFACTUREDITEMDEFINITION, 18684 /** 18685 * The Measure resource provides the definition of a quality measure. 18686 */ 18687 MEASURE, 18688 /** 18689 * The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation. 18690 */ 18691 MEASUREREPORT, 18692 /** 18693 * 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. 18694 */ 18695 MEDICATION, 18696 /** 18697 * 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. 18698 */ 18699 MEDICATIONADMINISTRATION, 18700 /** 18701 * 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. 18702 */ 18703 MEDICATIONDISPENSE, 18704 /** 18705 * Information about a medication that is used to support knowledge. 18706 */ 18707 MEDICATIONKNOWLEDGE, 18708 /** 18709 * 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. 18710 */ 18711 MEDICATIONREQUEST, 18712 /** 18713 * 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. 18714 18715The 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. 18716 */ 18717 MEDICATIONSTATEMENT, 18718 /** 18719 * 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.). 18720 */ 18721 MEDICINALPRODUCTDEFINITION, 18722 /** 18723 * 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. 18724 */ 18725 MESSAGEDEFINITION, 18726 /** 18727 * 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. 18728 */ 18729 MESSAGEHEADER, 18730 /** 18731 * Common Interface declaration for conformance and knowledge artifact resources. 18732 */ 18733 METADATARESOURCE, 18734 /** 18735 * Representation of a molecular sequence. 18736 */ 18737 MOLECULARSEQUENCE, 18738 /** 18739 * 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. 18740 */ 18741 NAMINGSYSTEM, 18742 /** 18743 * 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. 18744 */ 18745 NUTRITIONINTAKE, 18746 /** 18747 * A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident. 18748 */ 18749 NUTRITIONORDER, 18750 /** 18751 * A food or supplement that is consumed by patients. 18752 */ 18753 NUTRITIONPRODUCT, 18754 /** 18755 * Measurements and simple assertions made about a patient, device or other subject. 18756 */ 18757 OBSERVATION, 18758 /** 18759 * Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service. 18760 */ 18761 OBSERVATIONDEFINITION, 18762 /** 18763 * A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction). 18764 */ 18765 OPERATIONDEFINITION, 18766 /** 18767 * A collection of error, warning, or information messages that result from a system action. 18768 */ 18769 OPERATIONOUTCOME, 18770 /** 18771 * 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. 18772 */ 18773 ORGANIZATION, 18774 /** 18775 * Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship. 18776 */ 18777 ORGANIZATIONAFFILIATION, 18778 /** 18779 * A medically related item or items, in a container or package. 18780 */ 18781 PACKAGEDPRODUCTDEFINITION, 18782 /** 18783 * 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. 18784 */ 18785 PARAMETERS, 18786 /** 18787 * Demographics and other administrative information about an individual or animal receiving care or other health-related services. 18788 */ 18789 PATIENT, 18790 /** 18791 * This resource provides the status of the payment for goods and services rendered, and the request and response resource references. 18792 */ 18793 PAYMENTNOTICE, 18794 /** 18795 * This resource provides the details including amount of a payment and allocates the payment items being paid. 18796 */ 18797 PAYMENTRECONCILIATION, 18798 /** 18799 * Permission resource holds access rules for a given data and context. 18800 */ 18801 PERMISSION, 18802 /** 18803 * Demographics and administrative information about a person independent of a specific health-related context. 18804 */ 18805 PERSON, 18806 /** 18807 * 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. 18808 */ 18809 PLANDEFINITION, 18810 /** 18811 * A person who is directly or indirectly involved in the provisioning of healthcare or related services. 18812 */ 18813 PRACTITIONER, 18814 /** 18815 * A specific set of Roles/Locations/specialties/services that a practitioner may perform, or has performed at an organization during a period of time. 18816 */ 18817 PRACTITIONERROLE, 18818 /** 18819 * 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. 18820 */ 18821 PROCEDURE, 18822 /** 18823 * 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. 18824 */ 18825 PROVENANCE, 18826 /** 18827 * 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. 18828 */ 18829 QUESTIONNAIRE, 18830 /** 18831 * 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. 18832 */ 18833 QUESTIONNAIRERESPONSE, 18834 /** 18835 * 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. 18836 */ 18837 REGULATEDAUTHORIZATION, 18838 /** 18839 * 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. 18840 */ 18841 RELATEDPERSON, 18842 /** 18843 * 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". 18844 */ 18845 REQUESTORCHESTRATION, 18846 /** 18847 * 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. 18848 */ 18849 REQUIREMENTS, 18850 /** 18851 * 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. 18852 */ 18853 RESEARCHSTUDY, 18854 /** 18855 * A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study. 18856 */ 18857 RESEARCHSUBJECT, 18858 /** 18859 * This is the base resource type for everything. 18860 */ 18861 RESOURCE, 18862 /** 18863 * An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome. 18864 */ 18865 RISKASSESSMENT, 18866 /** 18867 * A container for slots of time that may be available for booking appointments. 18868 */ 18869 SCHEDULE, 18870 /** 18871 * A search parameter that defines a named search item that can be used to search/filter on a resource. 18872 */ 18873 SEARCHPARAMETER, 18874 /** 18875 * A record of a request for service such as diagnostic investigations, treatments, or operations to be performed. 18876 */ 18877 SERVICEREQUEST, 18878 /** 18879 * A slot of time on a schedule that may be available for booking appointments. 18880 */ 18881 SLOT, 18882 /** 18883 * A sample to be used for analysis. 18884 */ 18885 SPECIMEN, 18886 /** 18887 * A kind of specimen with associated set of requirements. 18888 */ 18889 SPECIMENDEFINITION, 18890 /** 18891 * 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. 18892 */ 18893 STRUCTUREDEFINITION, 18894 /** 18895 * A Map of relationships between 2 structures that can be used to transform data. 18896 */ 18897 STRUCTUREMAP, 18898 /** 18899 * The subscription resource describes a particular client's request to be notified about a SubscriptionTopic. 18900 */ 18901 SUBSCRIPTION, 18902 /** 18903 * The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted. 18904 */ 18905 SUBSCRIPTIONSTATUS, 18906 /** 18907 * Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic. 18908 */ 18909 SUBSCRIPTIONTOPIC, 18910 /** 18911 * A homogeneous material with a definite composition. 18912 */ 18913 SUBSTANCE, 18914 /** 18915 * The detailed description of a substance, typically at a level beyond what is used for prescribing. 18916 */ 18917 SUBSTANCEDEFINITION, 18918 /** 18919 * 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. 18920 */ 18921 SUBSTANCENUCLEICACID, 18922 /** 18923 * Properties of a substance specific to it being a polymer. 18924 */ 18925 SUBSTANCEPOLYMER, 18926 /** 18927 * 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. 18928 */ 18929 SUBSTANCEPROTEIN, 18930 /** 18931 * Todo. 18932 */ 18933 SUBSTANCEREFERENCEINFORMATION, 18934 /** 18935 * 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. 18936 */ 18937 SUBSTANCESOURCEMATERIAL, 18938 /** 18939 * Record of delivery of what is supplied. 18940 */ 18941 SUPPLYDELIVERY, 18942 /** 18943 * 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. 18944 */ 18945 SUPPLYREQUEST, 18946 /** 18947 * A task to be performed. 18948 */ 18949 TASK, 18950 /** 18951 * 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. 18952 */ 18953 TERMINOLOGYCAPABILITIES, 18954 /** 18955 * A plan for executing testing on an artifact or specifications 18956 */ 18957 TESTPLAN, 18958 /** 18959 * A summary of information based on the results of executing a TestScript. 18960 */ 18961 TESTREPORT, 18962 /** 18963 * A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification. 18964 */ 18965 TESTSCRIPT, 18966 /** 18967 * Record of transport. 18968 */ 18969 TRANSPORT, 18970 /** 18971 * 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). 18972 */ 18973 VALUESET, 18974 /** 18975 * Describes validation requirements, source(s), status and dates for one or more elements. 18976 */ 18977 VERIFICATIONRESULT, 18978 /** 18979 * An authorization for the provision of glasses and/or contact lenses to a patient. 18980 */ 18981 VISIONPRESCRIPTION, 18982 /** 18983 * null 18984 */ 18985 BODYSITE, 18986 /** 18987 * null 18988 */ 18989 CATALOGENTRY, 18990 /** 18991 * null 18992 */ 18993 CONFORMANCE, 18994 /** 18995 * null 18996 */ 18997 DATAELEMENT, 18998 /** 18999 * null 19000 */ 19001 DEVICECOMPONENT, 19002 /** 19003 * null 19004 */ 19005 DEVICEUSEREQUEST, 19006 /** 19007 * null 19008 */ 19009 DEVICEUSESTATEMENT, 19010 /** 19011 * null 19012 */ 19013 DIAGNOSTICORDER, 19014 /** 19015 * null 19016 */ 19017 DOCUMENTMANIFEST, 19018 /** 19019 * null 19020 */ 19021 EFFECTEVIDENCESYNTHESIS, 19022 /** 19023 * null 19024 */ 19025 ELIGIBILITYREQUEST, 19026 /** 19027 * null 19028 */ 19029 ELIGIBILITYRESPONSE, 19030 /** 19031 * null 19032 */ 19033 EXPANSIONPROFILE, 19034 /** 19035 * null 19036 */ 19037 IMAGINGMANIFEST, 19038 /** 19039 * null 19040 */ 19041 IMAGINGOBJECTSELECTION, 19042 /** 19043 * null 19044 */ 19045 MEDIA, 19046 /** 19047 * null 19048 */ 19049 MEDICATIONORDER, 19050 /** 19051 * null 19052 */ 19053 MEDICATIONUSAGE, 19054 /** 19055 * null 19056 */ 19057 MEDICINALPRODUCT, 19058 /** 19059 * null 19060 */ 19061 MEDICINALPRODUCTAUTHORIZATION, 19062 /** 19063 * null 19064 */ 19065 MEDICINALPRODUCTCONTRAINDICATION, 19066 /** 19067 * null 19068 */ 19069 MEDICINALPRODUCTINDICATION, 19070 /** 19071 * null 19072 */ 19073 MEDICINALPRODUCTINGREDIENT, 19074 /** 19075 * null 19076 */ 19077 MEDICINALPRODUCTINTERACTION, 19078 /** 19079 * null 19080 */ 19081 MEDICINALPRODUCTMANUFACTURED, 19082 /** 19083 * null 19084 */ 19085 MEDICINALPRODUCTPACKAGED, 19086 /** 19087 * null 19088 */ 19089 MEDICINALPRODUCTPHARMACEUTICAL, 19090 /** 19091 * null 19092 */ 19093 MEDICINALPRODUCTUNDESIRABLEEFFECT, 19094 /** 19095 * null 19096 */ 19097 ORDER, 19098 /** 19099 * null 19100 */ 19101 ORDERRESPONSE, 19102 /** 19103 * null 19104 */ 19105 PROCEDUREREQUEST, 19106 /** 19107 * null 19108 */ 19109 PROCESSREQUEST, 19110 /** 19111 * null 19112 */ 19113 PROCESSRESPONSE, 19114 /** 19115 * null 19116 */ 19117 REFERRALREQUEST, 19118 /** 19119 * null 19120 */ 19121 REQUESTGROUP, 19122 /** 19123 * null 19124 */ 19125 RESEARCHDEFINITION, 19126 /** 19127 * null 19128 */ 19129 RESEARCHELEMENTDEFINITION, 19130 /** 19131 * null 19132 */ 19133 RISKEVIDENCESYNTHESIS, 19134 /** 19135 * null 19136 */ 19137 SEQUENCE, 19138 /** 19139 * null 19140 */ 19141 SERVICEDEFINITION, 19142 /** 19143 * null 19144 */ 19145 SUBSTANCESPECIFICATION, 19146 /** 19147 * Added in R6 19148 */ 19149 MOLECULARDEFINITION, 19150 /** 19151 * Added in R6 19152 */ 19153 CLINICALASSESSMENT, 19154 /** 19155 * added to help the parsers 19156 */ 19157 NULL; 19158 public static VersionIndependentResourceTypesAll fromCode(String codeString) throws FHIRException { 19159 if (codeString == null || "".equals(codeString)) 19160 return null; 19161 if ("Account".equals(codeString)) 19162 return ACCOUNT; 19163 if ("ActivityDefinition".equals(codeString)) 19164 return ACTIVITYDEFINITION; 19165 if ("ActorDefinition".equals(codeString)) 19166 return ACTORDEFINITION; 19167 if ("AdministrableProductDefinition".equals(codeString)) 19168 return ADMINISTRABLEPRODUCTDEFINITION; 19169 if ("AdverseEvent".equals(codeString)) 19170 return ADVERSEEVENT; 19171 if ("AllergyIntolerance".equals(codeString)) 19172 return ALLERGYINTOLERANCE; 19173 if ("Appointment".equals(codeString)) 19174 return APPOINTMENT; 19175 if ("AppointmentResponse".equals(codeString)) 19176 return APPOINTMENTRESPONSE; 19177 if ("ArtifactAssessment".equals(codeString)) 19178 return ARTIFACTASSESSMENT; 19179 if ("AuditEvent".equals(codeString)) 19180 return AUDITEVENT; 19181 if ("Basic".equals(codeString)) 19182 return BASIC; 19183 if ("Binary".equals(codeString)) 19184 return BINARY; 19185 if ("BiologicallyDerivedProduct".equals(codeString)) 19186 return BIOLOGICALLYDERIVEDPRODUCT; 19187 if ("BiologicallyDerivedProductDispense".equals(codeString)) 19188 return BIOLOGICALLYDERIVEDPRODUCTDISPENSE; 19189 if ("BodyStructure".equals(codeString)) 19190 return BODYSTRUCTURE; 19191 if ("Bundle".equals(codeString)) 19192 return BUNDLE; 19193 if ("CanonicalResource".equals(codeString)) 19194 return CANONICALRESOURCE; 19195 if ("CapabilityStatement".equals(codeString)) 19196 return CAPABILITYSTATEMENT; 19197 if ("CarePlan".equals(codeString)) 19198 return CAREPLAN; 19199 if ("CareTeam".equals(codeString)) 19200 return CARETEAM; 19201 if ("ChargeItem".equals(codeString)) 19202 return CHARGEITEM; 19203 if ("ChargeItemDefinition".equals(codeString)) 19204 return CHARGEITEMDEFINITION; 19205 if ("Citation".equals(codeString)) 19206 return CITATION; 19207 if ("Claim".equals(codeString)) 19208 return CLAIM; 19209 if ("ClaimResponse".equals(codeString)) 19210 return CLAIMRESPONSE; 19211 if ("ClinicalImpression".equals(codeString)) 19212 return CLINICALIMPRESSION; 19213 if ("ClinicalUseDefinition".equals(codeString)) 19214 return CLINICALUSEDEFINITION; 19215 if ("CodeSystem".equals(codeString)) 19216 return CODESYSTEM; 19217 if ("Communication".equals(codeString)) 19218 return COMMUNICATION; 19219 if ("CommunicationRequest".equals(codeString)) 19220 return COMMUNICATIONREQUEST; 19221 if ("CompartmentDefinition".equals(codeString)) 19222 return COMPARTMENTDEFINITION; 19223 if ("Composition".equals(codeString)) 19224 return COMPOSITION; 19225 if ("ConceptMap".equals(codeString)) 19226 return CONCEPTMAP; 19227 if ("Condition".equals(codeString)) 19228 return CONDITION; 19229 if ("ConditionDefinition".equals(codeString)) 19230 return CONDITIONDEFINITION; 19231 if ("Consent".equals(codeString)) 19232 return CONSENT; 19233 if ("Contract".equals(codeString)) 19234 return CONTRACT; 19235 if ("Coverage".equals(codeString)) 19236 return COVERAGE; 19237 if ("CoverageEligibilityRequest".equals(codeString)) 19238 return COVERAGEELIGIBILITYREQUEST; 19239 if ("CoverageEligibilityResponse".equals(codeString)) 19240 return COVERAGEELIGIBILITYRESPONSE; 19241 if ("DetectedIssue".equals(codeString)) 19242 return DETECTEDISSUE; 19243 if ("Device".equals(codeString)) 19244 return DEVICE; 19245 if ("DeviceAssociation".equals(codeString)) 19246 return DEVICEASSOCIATION; 19247 if ("DeviceDefinition".equals(codeString)) 19248 return DEVICEDEFINITION; 19249 if ("DeviceDispense".equals(codeString)) 19250 return DEVICEDISPENSE; 19251 if ("DeviceMetric".equals(codeString)) 19252 return DEVICEMETRIC; 19253 if ("DeviceRequest".equals(codeString)) 19254 return DEVICEREQUEST; 19255 if ("DeviceUsage".equals(codeString)) 19256 return DEVICEUSAGE; 19257 if ("DiagnosticReport".equals(codeString)) 19258 return DIAGNOSTICREPORT; 19259 if ("DocumentReference".equals(codeString)) 19260 return DOCUMENTREFERENCE; 19261 if ("DomainResource".equals(codeString)) 19262 return DOMAINRESOURCE; 19263 if ("Encounter".equals(codeString)) 19264 return ENCOUNTER; 19265 if ("EncounterHistory".equals(codeString)) 19266 return ENCOUNTERHISTORY; 19267 if ("Endpoint".equals(codeString)) 19268 return ENDPOINT; 19269 if ("EnrollmentRequest".equals(codeString)) 19270 return ENROLLMENTREQUEST; 19271 if ("EnrollmentResponse".equals(codeString)) 19272 return ENROLLMENTRESPONSE; 19273 if ("EpisodeOfCare".equals(codeString)) 19274 return EPISODEOFCARE; 19275 if ("EventDefinition".equals(codeString)) 19276 return EVENTDEFINITION; 19277 if ("Evidence".equals(codeString)) 19278 return EVIDENCE; 19279 if ("EvidenceReport".equals(codeString)) 19280 return EVIDENCEREPORT; 19281 if ("EvidenceVariable".equals(codeString)) 19282 return EVIDENCEVARIABLE; 19283 if ("ExampleScenario".equals(codeString)) 19284 return EXAMPLESCENARIO; 19285 if ("ExplanationOfBenefit".equals(codeString)) 19286 return EXPLANATIONOFBENEFIT; 19287 if ("FamilyMemberHistory".equals(codeString)) 19288 return FAMILYMEMBERHISTORY; 19289 if ("Flag".equals(codeString)) 19290 return FLAG; 19291 if ("FormularyItem".equals(codeString)) 19292 return FORMULARYITEM; 19293 if ("GenomicStudy".equals(codeString)) 19294 return GENOMICSTUDY; 19295 if ("Goal".equals(codeString)) 19296 return GOAL; 19297 if ("GraphDefinition".equals(codeString)) 19298 return GRAPHDEFINITION; 19299 if ("Group".equals(codeString)) 19300 return GROUP; 19301 if ("GuidanceResponse".equals(codeString)) 19302 return GUIDANCERESPONSE; 19303 if ("HealthcareService".equals(codeString)) 19304 return HEALTHCARESERVICE; 19305 if ("ImagingSelection".equals(codeString)) 19306 return IMAGINGSELECTION; 19307 if ("ImagingStudy".equals(codeString)) 19308 return IMAGINGSTUDY; 19309 if ("Immunization".equals(codeString)) 19310 return IMMUNIZATION; 19311 if ("ImmunizationEvaluation".equals(codeString)) 19312 return IMMUNIZATIONEVALUATION; 19313 if ("ImmunizationRecommendation".equals(codeString)) 19314 return IMMUNIZATIONRECOMMENDATION; 19315 if ("ImplementationGuide".equals(codeString)) 19316 return IMPLEMENTATIONGUIDE; 19317 if ("Ingredient".equals(codeString)) 19318 return INGREDIENT; 19319 if ("InsurancePlan".equals(codeString)) 19320 return INSURANCEPLAN; 19321 if ("InventoryItem".equals(codeString)) 19322 return INVENTORYITEM; 19323 if ("InventoryReport".equals(codeString)) 19324 return INVENTORYREPORT; 19325 if ("Invoice".equals(codeString)) 19326 return INVOICE; 19327 if ("Library".equals(codeString)) 19328 return LIBRARY; 19329 if ("Linkage".equals(codeString)) 19330 return LINKAGE; 19331 if ("List".equals(codeString)) 19332 return LIST; 19333 if ("Location".equals(codeString)) 19334 return LOCATION; 19335 if ("ManufacturedItemDefinition".equals(codeString)) 19336 return MANUFACTUREDITEMDEFINITION; 19337 if ("Measure".equals(codeString)) 19338 return MEASURE; 19339 if ("MeasureReport".equals(codeString)) 19340 return MEASUREREPORT; 19341 if ("Medication".equals(codeString)) 19342 return MEDICATION; 19343 if ("MedicationAdministration".equals(codeString)) 19344 return MEDICATIONADMINISTRATION; 19345 if ("MedicationDispense".equals(codeString)) 19346 return MEDICATIONDISPENSE; 19347 if ("MedicationKnowledge".equals(codeString)) 19348 return MEDICATIONKNOWLEDGE; 19349 if ("MedicationRequest".equals(codeString)) 19350 return MEDICATIONREQUEST; 19351 if ("MedicationStatement".equals(codeString)) 19352 return MEDICATIONSTATEMENT; 19353 if ("MedicinalProductDefinition".equals(codeString)) 19354 return MEDICINALPRODUCTDEFINITION; 19355 if ("MessageDefinition".equals(codeString)) 19356 return MESSAGEDEFINITION; 19357 if ("MessageHeader".equals(codeString)) 19358 return MESSAGEHEADER; 19359 if ("MetadataResource".equals(codeString)) 19360 return METADATARESOURCE; 19361 if ("MolecularSequence".equals(codeString)) 19362 return MOLECULARSEQUENCE; 19363 if ("NamingSystem".equals(codeString)) 19364 return NAMINGSYSTEM; 19365 if ("NutritionIntake".equals(codeString)) 19366 return NUTRITIONINTAKE; 19367 if ("NutritionOrder".equals(codeString)) 19368 return NUTRITIONORDER; 19369 if ("NutritionProduct".equals(codeString)) 19370 return NUTRITIONPRODUCT; 19371 if ("Observation".equals(codeString)) 19372 return OBSERVATION; 19373 if ("ObservationDefinition".equals(codeString)) 19374 return OBSERVATIONDEFINITION; 19375 if ("OperationDefinition".equals(codeString)) 19376 return OPERATIONDEFINITION; 19377 if ("OperationOutcome".equals(codeString)) 19378 return OPERATIONOUTCOME; 19379 if ("Organization".equals(codeString)) 19380 return ORGANIZATION; 19381 if ("OrganizationAffiliation".equals(codeString)) 19382 return ORGANIZATIONAFFILIATION; 19383 if ("PackagedProductDefinition".equals(codeString)) 19384 return PACKAGEDPRODUCTDEFINITION; 19385 if ("Parameters".equals(codeString)) 19386 return PARAMETERS; 19387 if ("Patient".equals(codeString)) 19388 return PATIENT; 19389 if ("PaymentNotice".equals(codeString)) 19390 return PAYMENTNOTICE; 19391 if ("PaymentReconciliation".equals(codeString)) 19392 return PAYMENTRECONCILIATION; 19393 if ("Permission".equals(codeString)) 19394 return PERMISSION; 19395 if ("Person".equals(codeString)) 19396 return PERSON; 19397 if ("PlanDefinition".equals(codeString)) 19398 return PLANDEFINITION; 19399 if ("Practitioner".equals(codeString)) 19400 return PRACTITIONER; 19401 if ("PractitionerRole".equals(codeString)) 19402 return PRACTITIONERROLE; 19403 if ("Procedure".equals(codeString)) 19404 return PROCEDURE; 19405 if ("Provenance".equals(codeString)) 19406 return PROVENANCE; 19407 if ("Questionnaire".equals(codeString)) 19408 return QUESTIONNAIRE; 19409 if ("QuestionnaireResponse".equals(codeString)) 19410 return QUESTIONNAIRERESPONSE; 19411 if ("RegulatedAuthorization".equals(codeString)) 19412 return REGULATEDAUTHORIZATION; 19413 if ("RelatedPerson".equals(codeString)) 19414 return RELATEDPERSON; 19415 if ("RequestOrchestration".equals(codeString)) 19416 return REQUESTORCHESTRATION; 19417 if ("Requirements".equals(codeString)) 19418 return REQUIREMENTS; 19419 if ("ResearchStudy".equals(codeString)) 19420 return RESEARCHSTUDY; 19421 if ("ResearchSubject".equals(codeString)) 19422 return RESEARCHSUBJECT; 19423 if ("Resource".equals(codeString)) 19424 return RESOURCE; 19425 if ("RiskAssessment".equals(codeString)) 19426 return RISKASSESSMENT; 19427 if ("Schedule".equals(codeString)) 19428 return SCHEDULE; 19429 if ("SearchParameter".equals(codeString)) 19430 return SEARCHPARAMETER; 19431 if ("ServiceRequest".equals(codeString)) 19432 return SERVICEREQUEST; 19433 if ("Slot".equals(codeString)) 19434 return SLOT; 19435 if ("Specimen".equals(codeString)) 19436 return SPECIMEN; 19437 if ("SpecimenDefinition".equals(codeString)) 19438 return SPECIMENDEFINITION; 19439 if ("StructureDefinition".equals(codeString)) 19440 return STRUCTUREDEFINITION; 19441 if ("StructureMap".equals(codeString)) 19442 return STRUCTUREMAP; 19443 if ("Subscription".equals(codeString)) 19444 return SUBSCRIPTION; 19445 if ("SubscriptionStatus".equals(codeString)) 19446 return SUBSCRIPTIONSTATUS; 19447 if ("SubscriptionTopic".equals(codeString)) 19448 return SUBSCRIPTIONTOPIC; 19449 if ("Substance".equals(codeString)) 19450 return SUBSTANCE; 19451 if ("SubstanceDefinition".equals(codeString)) 19452 return SUBSTANCEDEFINITION; 19453 if ("SubstanceNucleicAcid".equals(codeString)) 19454 return SUBSTANCENUCLEICACID; 19455 if ("SubstancePolymer".equals(codeString)) 19456 return SUBSTANCEPOLYMER; 19457 if ("SubstanceProtein".equals(codeString)) 19458 return SUBSTANCEPROTEIN; 19459 if ("SubstanceReferenceInformation".equals(codeString)) 19460 return SUBSTANCEREFERENCEINFORMATION; 19461 if ("SubstanceSourceMaterial".equals(codeString)) 19462 return SUBSTANCESOURCEMATERIAL; 19463 if ("SupplyDelivery".equals(codeString)) 19464 return SUPPLYDELIVERY; 19465 if ("SupplyRequest".equals(codeString)) 19466 return SUPPLYREQUEST; 19467 if ("Task".equals(codeString)) 19468 return TASK; 19469 if ("TerminologyCapabilities".equals(codeString)) 19470 return TERMINOLOGYCAPABILITIES; 19471 if ("TestPlan".equals(codeString)) 19472 return TESTPLAN; 19473 if ("TestReport".equals(codeString)) 19474 return TESTREPORT; 19475 if ("TestScript".equals(codeString)) 19476 return TESTSCRIPT; 19477 if ("Transport".equals(codeString)) 19478 return TRANSPORT; 19479 if ("ValueSet".equals(codeString)) 19480 return VALUESET; 19481 if ("VerificationResult".equals(codeString)) 19482 return VERIFICATIONRESULT; 19483 if ("VisionPrescription".equals(codeString)) 19484 return VISIONPRESCRIPTION; 19485 if ("BodySite".equals(codeString)) 19486 return BODYSITE; 19487 if ("CatalogEntry".equals(codeString)) 19488 return CATALOGENTRY; 19489 if ("Conformance".equals(codeString)) 19490 return CONFORMANCE; 19491 if ("DataElement".equals(codeString)) 19492 return DATAELEMENT; 19493 if ("DeviceComponent".equals(codeString)) 19494 return DEVICECOMPONENT; 19495 if ("DeviceUseRequest".equals(codeString)) 19496 return DEVICEUSEREQUEST; 19497 if ("DeviceUseStatement".equals(codeString)) 19498 return DEVICEUSESTATEMENT; 19499 if ("DiagnosticOrder".equals(codeString)) 19500 return DIAGNOSTICORDER; 19501 if ("DocumentManifest".equals(codeString)) 19502 return DOCUMENTMANIFEST; 19503 if ("EffectEvidenceSynthesis".equals(codeString)) 19504 return EFFECTEVIDENCESYNTHESIS; 19505 if ("EligibilityRequest".equals(codeString)) 19506 return ELIGIBILITYREQUEST; 19507 if ("EligibilityResponse".equals(codeString)) 19508 return ELIGIBILITYRESPONSE; 19509 if ("ExpansionProfile".equals(codeString)) 19510 return EXPANSIONPROFILE; 19511 if ("ImagingManifest".equals(codeString)) 19512 return IMAGINGMANIFEST; 19513 if ("ImagingObjectSelection".equals(codeString)) 19514 return IMAGINGOBJECTSELECTION; 19515 if ("Media".equals(codeString)) 19516 return MEDIA; 19517 if ("MedicationOrder".equals(codeString)) 19518 return MEDICATIONORDER; 19519 if ("MedicationUsage".equals(codeString)) 19520 return MEDICATIONUSAGE; 19521 if ("MedicinalProduct".equals(codeString)) 19522 return MEDICINALPRODUCT; 19523 if ("MedicinalProductAuthorization".equals(codeString)) 19524 return MEDICINALPRODUCTAUTHORIZATION; 19525 if ("MedicinalProductContraindication".equals(codeString)) 19526 return MEDICINALPRODUCTCONTRAINDICATION; 19527 if ("MedicinalProductIndication".equals(codeString)) 19528 return MEDICINALPRODUCTINDICATION; 19529 if ("MedicinalProductIngredient".equals(codeString)) 19530 return MEDICINALPRODUCTINGREDIENT; 19531 if ("MedicinalProductInteraction".equals(codeString)) 19532 return MEDICINALPRODUCTINTERACTION; 19533 if ("MedicinalProductManufactured".equals(codeString)) 19534 return MEDICINALPRODUCTMANUFACTURED; 19535 if ("MedicinalProductPackaged".equals(codeString)) 19536 return MEDICINALPRODUCTPACKAGED; 19537 if ("MedicinalProductPharmaceutical".equals(codeString)) 19538 return MEDICINALPRODUCTPHARMACEUTICAL; 19539 if ("MedicinalProductUndesirableEffect".equals(codeString)) 19540 return MEDICINALPRODUCTUNDESIRABLEEFFECT; 19541 if ("Order".equals(codeString)) 19542 return ORDER; 19543 if ("OrderResponse".equals(codeString)) 19544 return ORDERRESPONSE; 19545 if ("ProcedureRequest".equals(codeString)) 19546 return PROCEDUREREQUEST; 19547 if ("ProcessRequest".equals(codeString)) 19548 return PROCESSREQUEST; 19549 if ("ProcessResponse".equals(codeString)) 19550 return PROCESSRESPONSE; 19551 if ("ReferralRequest".equals(codeString)) 19552 return REFERRALREQUEST; 19553 if ("RequestGroup".equals(codeString)) 19554 return REQUESTGROUP; 19555 if ("ResearchDefinition".equals(codeString)) 19556 return RESEARCHDEFINITION; 19557 if ("ResearchElementDefinition".equals(codeString)) 19558 return RESEARCHELEMENTDEFINITION; 19559 if ("RiskEvidenceSynthesis".equals(codeString)) 19560 return RISKEVIDENCESYNTHESIS; 19561 if ("Sequence".equals(codeString)) 19562 return SEQUENCE; 19563 if ("ServiceDefinition".equals(codeString)) 19564 return SERVICEDEFINITION; 19565 if ("SubstanceSpecification".equals(codeString)) 19566 return SUBSTANCESPECIFICATION; 19567 if ("MolecularDefinition".equals(codeString)) 19568 return MOLECULARDEFINITION; 19569 if ("ClinicalAssessment".equals(codeString)) 19570 return CLINICALASSESSMENT; 19571 19572 throw new FHIRException("Unknown VersionIndependentResourceTypesAll code '"+codeString+"'"); 19573 } 19574 public static boolean isValidCode(String codeString) { 19575 if (codeString == null || "".equals(codeString)) 19576 return false; 19577 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"); 19578 } 19579 public String toCode() { 19580 switch (this) { 19581 case ACCOUNT: return "Account"; 19582 case ACTIVITYDEFINITION: return "ActivityDefinition"; 19583 case ACTORDEFINITION: return "ActorDefinition"; 19584 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 19585 case ADVERSEEVENT: return "AdverseEvent"; 19586 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 19587 case APPOINTMENT: return "Appointment"; 19588 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 19589 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 19590 case AUDITEVENT: return "AuditEvent"; 19591 case BASIC: return "Basic"; 19592 case BINARY: return "Binary"; 19593 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 19594 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "BiologicallyDerivedProductDispense"; 19595 case BODYSTRUCTURE: return "BodyStructure"; 19596 case BUNDLE: return "Bundle"; 19597 case CANONICALRESOURCE: return "CanonicalResource"; 19598 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 19599 case CAREPLAN: return "CarePlan"; 19600 case CARETEAM: return "CareTeam"; 19601 case CHARGEITEM: return "ChargeItem"; 19602 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 19603 case CITATION: return "Citation"; 19604 case CLAIM: return "Claim"; 19605 case CLAIMRESPONSE: return "ClaimResponse"; 19606 case CLINICALIMPRESSION: return "ClinicalImpression"; 19607 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 19608 case CODESYSTEM: return "CodeSystem"; 19609 case COMMUNICATION: return "Communication"; 19610 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 19611 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 19612 case COMPOSITION: return "Composition"; 19613 case CONCEPTMAP: return "ConceptMap"; 19614 case CONDITION: return "Condition"; 19615 case CONDITIONDEFINITION: return "ConditionDefinition"; 19616 case CONSENT: return "Consent"; 19617 case CONTRACT: return "Contract"; 19618 case COVERAGE: return "Coverage"; 19619 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 19620 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 19621 case DETECTEDISSUE: return "DetectedIssue"; 19622 case DEVICE: return "Device"; 19623 case DEVICEASSOCIATION: return "DeviceAssociation"; 19624 case DEVICEDEFINITION: return "DeviceDefinition"; 19625 case DEVICEDISPENSE: return "DeviceDispense"; 19626 case DEVICEMETRIC: return "DeviceMetric"; 19627 case DEVICEREQUEST: return "DeviceRequest"; 19628 case DEVICEUSAGE: return "DeviceUsage"; 19629 case DIAGNOSTICREPORT: return "DiagnosticReport"; 19630 case DOCUMENTREFERENCE: return "DocumentReference"; 19631 case DOMAINRESOURCE: return "DomainResource"; 19632 case ENCOUNTER: return "Encounter"; 19633 case ENCOUNTERHISTORY: return "EncounterHistory"; 19634 case ENDPOINT: return "Endpoint"; 19635 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 19636 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 19637 case EPISODEOFCARE: return "EpisodeOfCare"; 19638 case EVENTDEFINITION: return "EventDefinition"; 19639 case EVIDENCE: return "Evidence"; 19640 case EVIDENCEREPORT: return "EvidenceReport"; 19641 case EVIDENCEVARIABLE: return "EvidenceVariable"; 19642 case EXAMPLESCENARIO: return "ExampleScenario"; 19643 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 19644 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 19645 case FLAG: return "Flag"; 19646 case FORMULARYITEM: return "FormularyItem"; 19647 case GENOMICSTUDY: return "GenomicStudy"; 19648 case GOAL: return "Goal"; 19649 case GRAPHDEFINITION: return "GraphDefinition"; 19650 case GROUP: return "Group"; 19651 case GUIDANCERESPONSE: return "GuidanceResponse"; 19652 case HEALTHCARESERVICE: return "HealthcareService"; 19653 case IMAGINGSELECTION: return "ImagingSelection"; 19654 case IMAGINGSTUDY: return "ImagingStudy"; 19655 case IMMUNIZATION: return "Immunization"; 19656 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 19657 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 19658 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 19659 case INGREDIENT: return "Ingredient"; 19660 case INSURANCEPLAN: return "InsurancePlan"; 19661 case INVENTORYITEM: return "InventoryItem"; 19662 case INVENTORYREPORT: return "InventoryReport"; 19663 case INVOICE: return "Invoice"; 19664 case LIBRARY: return "Library"; 19665 case LINKAGE: return "Linkage"; 19666 case LIST: return "List"; 19667 case LOCATION: return "Location"; 19668 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 19669 case MEASURE: return "Measure"; 19670 case MEASUREREPORT: return "MeasureReport"; 19671 case MEDICATION: return "Medication"; 19672 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 19673 case MEDICATIONDISPENSE: return "MedicationDispense"; 19674 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 19675 case MEDICATIONREQUEST: return "MedicationRequest"; 19676 case MEDICATIONSTATEMENT: return "MedicationStatement"; 19677 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 19678 case MESSAGEDEFINITION: return "MessageDefinition"; 19679 case MESSAGEHEADER: return "MessageHeader"; 19680 case METADATARESOURCE: return "MetadataResource"; 19681 case MOLECULARSEQUENCE: return "MolecularSequence"; 19682 case NAMINGSYSTEM: return "NamingSystem"; 19683 case NUTRITIONINTAKE: return "NutritionIntake"; 19684 case NUTRITIONORDER: return "NutritionOrder"; 19685 case NUTRITIONPRODUCT: return "NutritionProduct"; 19686 case OBSERVATION: return "Observation"; 19687 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 19688 case OPERATIONDEFINITION: return "OperationDefinition"; 19689 case OPERATIONOUTCOME: return "OperationOutcome"; 19690 case ORGANIZATION: return "Organization"; 19691 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 19692 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 19693 case PARAMETERS: return "Parameters"; 19694 case PATIENT: return "Patient"; 19695 case PAYMENTNOTICE: return "PaymentNotice"; 19696 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 19697 case PERMISSION: return "Permission"; 19698 case PERSON: return "Person"; 19699 case PLANDEFINITION: return "PlanDefinition"; 19700 case PRACTITIONER: return "Practitioner"; 19701 case PRACTITIONERROLE: return "PractitionerRole"; 19702 case PROCEDURE: return "Procedure"; 19703 case PROVENANCE: return "Provenance"; 19704 case QUESTIONNAIRE: return "Questionnaire"; 19705 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 19706 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 19707 case RELATEDPERSON: return "RelatedPerson"; 19708 case REQUESTORCHESTRATION: return "RequestOrchestration"; 19709 case REQUIREMENTS: return "Requirements"; 19710 case RESEARCHSTUDY: return "ResearchStudy"; 19711 case RESEARCHSUBJECT: return "ResearchSubject"; 19712 case RESOURCE: return "Resource"; 19713 case RISKASSESSMENT: return "RiskAssessment"; 19714 case SCHEDULE: return "Schedule"; 19715 case SEARCHPARAMETER: return "SearchParameter"; 19716 case SERVICEREQUEST: return "ServiceRequest"; 19717 case SLOT: return "Slot"; 19718 case SPECIMEN: return "Specimen"; 19719 case SPECIMENDEFINITION: return "SpecimenDefinition"; 19720 case STRUCTUREDEFINITION: return "StructureDefinition"; 19721 case STRUCTUREMAP: return "StructureMap"; 19722 case SUBSCRIPTION: return "Subscription"; 19723 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 19724 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 19725 case SUBSTANCE: return "Substance"; 19726 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 19727 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 19728 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 19729 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 19730 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 19731 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 19732 case SUPPLYDELIVERY: return "SupplyDelivery"; 19733 case SUPPLYREQUEST: return "SupplyRequest"; 19734 case TASK: return "Task"; 19735 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 19736 case TESTPLAN: return "TestPlan"; 19737 case TESTREPORT: return "TestReport"; 19738 case TESTSCRIPT: return "TestScript"; 19739 case TRANSPORT: return "Transport"; 19740 case VALUESET: return "ValueSet"; 19741 case VERIFICATIONRESULT: return "VerificationResult"; 19742 case VISIONPRESCRIPTION: return "VisionPrescription"; 19743 case BODYSITE: return "BodySite"; 19744 case CATALOGENTRY: return "CatalogEntry"; 19745 case CONFORMANCE: return "Conformance"; 19746 case DATAELEMENT: return "DataElement"; 19747 case DEVICECOMPONENT: return "DeviceComponent"; 19748 case DEVICEUSEREQUEST: return "DeviceUseRequest"; 19749 case DEVICEUSESTATEMENT: return "DeviceUseStatement"; 19750 case DIAGNOSTICORDER: return "DiagnosticOrder"; 19751 case DOCUMENTMANIFEST: return "DocumentManifest"; 19752 case EFFECTEVIDENCESYNTHESIS: return "EffectEvidenceSynthesis"; 19753 case ELIGIBILITYREQUEST: return "EligibilityRequest"; 19754 case ELIGIBILITYRESPONSE: return "EligibilityResponse"; 19755 case EXPANSIONPROFILE: return "ExpansionProfile"; 19756 case IMAGINGMANIFEST: return "ImagingManifest"; 19757 case IMAGINGOBJECTSELECTION: return "ImagingObjectSelection"; 19758 case MEDIA: return "Media"; 19759 case MEDICATIONORDER: return "MedicationOrder"; 19760 case MEDICATIONUSAGE: return "MedicationUsage"; 19761 case MEDICINALPRODUCT: return "MedicinalProduct"; 19762 case MEDICINALPRODUCTAUTHORIZATION: return "MedicinalProductAuthorization"; 19763 case MEDICINALPRODUCTCONTRAINDICATION: return "MedicinalProductContraindication"; 19764 case MEDICINALPRODUCTINDICATION: return "MedicinalProductIndication"; 19765 case MEDICINALPRODUCTINGREDIENT: return "MedicinalProductIngredient"; 19766 case MEDICINALPRODUCTINTERACTION: return "MedicinalProductInteraction"; 19767 case MEDICINALPRODUCTMANUFACTURED: return "MedicinalProductManufactured"; 19768 case MEDICINALPRODUCTPACKAGED: return "MedicinalProductPackaged"; 19769 case MEDICINALPRODUCTPHARMACEUTICAL: return "MedicinalProductPharmaceutical"; 19770 case MEDICINALPRODUCTUNDESIRABLEEFFECT: return "MedicinalProductUndesirableEffect"; 19771 case ORDER: return "Order"; 19772 case ORDERRESPONSE: return "OrderResponse"; 19773 case PROCEDUREREQUEST: return "ProcedureRequest"; 19774 case PROCESSREQUEST: return "ProcessRequest"; 19775 case PROCESSRESPONSE: return "ProcessResponse"; 19776 case REFERRALREQUEST: return "ReferralRequest"; 19777 case REQUESTGROUP: return "RequestGroup"; 19778 case RESEARCHDEFINITION: return "ResearchDefinition"; 19779 case RESEARCHELEMENTDEFINITION: return "ResearchElementDefinition"; 19780 case RISKEVIDENCESYNTHESIS: return "RiskEvidenceSynthesis"; 19781 case SEQUENCE: return "Sequence"; 19782 case SERVICEDEFINITION: return "ServiceDefinition"; 19783 case SUBSTANCESPECIFICATION: return "SubstanceSpecification"; 19784 case MOLECULARDEFINITION: return "MolecularDefinition"; 19785 case CLINICALASSESSMENT: return "ClinicalAssessment"; 19786 case NULL: return null; 19787 default: return "?"; 19788 } 19789 } 19790 public String getSystem() { 19791 switch (this) { 19792 case ACCOUNT: return "http://hl7.org/fhir/fhir-types"; 19793 case ACTIVITYDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19794 case ACTORDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19795 case ADMINISTRABLEPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19796 case ADVERSEEVENT: return "http://hl7.org/fhir/fhir-types"; 19797 case ALLERGYINTOLERANCE: return "http://hl7.org/fhir/fhir-types"; 19798 case APPOINTMENT: return "http://hl7.org/fhir/fhir-types"; 19799 case APPOINTMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 19800 case ARTIFACTASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 19801 case AUDITEVENT: return "http://hl7.org/fhir/fhir-types"; 19802 case BASIC: return "http://hl7.org/fhir/fhir-types"; 19803 case BINARY: return "http://hl7.org/fhir/fhir-types"; 19804 case BIOLOGICALLYDERIVEDPRODUCT: return "http://hl7.org/fhir/fhir-types"; 19805 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "http://hl7.org/fhir/fhir-types"; 19806 case BODYSTRUCTURE: return "http://hl7.org/fhir/fhir-types"; 19807 case BUNDLE: return "http://hl7.org/fhir/fhir-types"; 19808 case CANONICALRESOURCE: return "http://hl7.org/fhir/fhir-types"; 19809 case CAPABILITYSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 19810 case CAREPLAN: return "http://hl7.org/fhir/fhir-types"; 19811 case CARETEAM: return "http://hl7.org/fhir/fhir-types"; 19812 case CHARGEITEM: return "http://hl7.org/fhir/fhir-types"; 19813 case CHARGEITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19814 case CITATION: return "http://hl7.org/fhir/fhir-types"; 19815 case CLAIM: return "http://hl7.org/fhir/fhir-types"; 19816 case CLAIMRESPONSE: return "http://hl7.org/fhir/fhir-types"; 19817 case CLINICALIMPRESSION: return "http://hl7.org/fhir/fhir-types"; 19818 case CLINICALUSEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19819 case CODESYSTEM: return "http://hl7.org/fhir/fhir-types"; 19820 case COMMUNICATION: return "http://hl7.org/fhir/fhir-types"; 19821 case COMMUNICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 19822 case COMPARTMENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19823 case COMPOSITION: return "http://hl7.org/fhir/fhir-types"; 19824 case CONCEPTMAP: return "http://hl7.org/fhir/fhir-types"; 19825 case CONDITION: return "http://hl7.org/fhir/fhir-types"; 19826 case CONDITIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19827 case CONSENT: return "http://hl7.org/fhir/fhir-types"; 19828 case CONTRACT: return "http://hl7.org/fhir/fhir-types"; 19829 case COVERAGE: return "http://hl7.org/fhir/fhir-types"; 19830 case COVERAGEELIGIBILITYREQUEST: return "http://hl7.org/fhir/fhir-types"; 19831 case COVERAGEELIGIBILITYRESPONSE: return "http://hl7.org/fhir/fhir-types"; 19832 case DETECTEDISSUE: return "http://hl7.org/fhir/fhir-types"; 19833 case DEVICE: return "http://hl7.org/fhir/fhir-types"; 19834 case DEVICEASSOCIATION: return "http://hl7.org/fhir/fhir-types"; 19835 case DEVICEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19836 case DEVICEDISPENSE: return "http://hl7.org/fhir/fhir-types"; 19837 case DEVICEMETRIC: return "http://hl7.org/fhir/fhir-types"; 19838 case DEVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 19839 case DEVICEUSAGE: return "http://hl7.org/fhir/fhir-types"; 19840 case DIAGNOSTICREPORT: return "http://hl7.org/fhir/fhir-types"; 19841 case DOCUMENTREFERENCE: return "http://hl7.org/fhir/fhir-types"; 19842 case DOMAINRESOURCE: return "http://hl7.org/fhir/fhir-types"; 19843 case ENCOUNTER: return "http://hl7.org/fhir/fhir-types"; 19844 case ENCOUNTERHISTORY: return "http://hl7.org/fhir/fhir-types"; 19845 case ENDPOINT: return "http://hl7.org/fhir/fhir-types"; 19846 case ENROLLMENTREQUEST: return "http://hl7.org/fhir/fhir-types"; 19847 case ENROLLMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 19848 case EPISODEOFCARE: return "http://hl7.org/fhir/fhir-types"; 19849 case EVENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19850 case EVIDENCE: return "http://hl7.org/fhir/fhir-types"; 19851 case EVIDENCEREPORT: return "http://hl7.org/fhir/fhir-types"; 19852 case EVIDENCEVARIABLE: return "http://hl7.org/fhir/fhir-types"; 19853 case EXAMPLESCENARIO: return "http://hl7.org/fhir/fhir-types"; 19854 case EXPLANATIONOFBENEFIT: return "http://hl7.org/fhir/fhir-types"; 19855 case FAMILYMEMBERHISTORY: return "http://hl7.org/fhir/fhir-types"; 19856 case FLAG: return "http://hl7.org/fhir/fhir-types"; 19857 case FORMULARYITEM: return "http://hl7.org/fhir/fhir-types"; 19858 case GENOMICSTUDY: return "http://hl7.org/fhir/fhir-types"; 19859 case GOAL: return "http://hl7.org/fhir/fhir-types"; 19860 case GRAPHDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19861 case GROUP: return "http://hl7.org/fhir/fhir-types"; 19862 case GUIDANCERESPONSE: return "http://hl7.org/fhir/fhir-types"; 19863 case HEALTHCARESERVICE: return "http://hl7.org/fhir/fhir-types"; 19864 case IMAGINGSELECTION: return "http://hl7.org/fhir/fhir-types"; 19865 case IMAGINGSTUDY: return "http://hl7.org/fhir/fhir-types"; 19866 case IMMUNIZATION: return "http://hl7.org/fhir/fhir-types"; 19867 case IMMUNIZATIONEVALUATION: return "http://hl7.org/fhir/fhir-types"; 19868 case IMMUNIZATIONRECOMMENDATION: return "http://hl7.org/fhir/fhir-types"; 19869 case IMPLEMENTATIONGUIDE: return "http://hl7.org/fhir/fhir-types"; 19870 case INGREDIENT: return "http://hl7.org/fhir/fhir-types"; 19871 case INSURANCEPLAN: return "http://hl7.org/fhir/fhir-types"; 19872 case INVENTORYITEM: return "http://hl7.org/fhir/fhir-types"; 19873 case INVENTORYREPORT: return "http://hl7.org/fhir/fhir-types"; 19874 case INVOICE: return "http://hl7.org/fhir/fhir-types"; 19875 case LIBRARY: return "http://hl7.org/fhir/fhir-types"; 19876 case LINKAGE: return "http://hl7.org/fhir/fhir-types"; 19877 case LIST: return "http://hl7.org/fhir/fhir-types"; 19878 case LOCATION: return "http://hl7.org/fhir/fhir-types"; 19879 case MANUFACTUREDITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19880 case MEASURE: return "http://hl7.org/fhir/fhir-types"; 19881 case MEASUREREPORT: return "http://hl7.org/fhir/fhir-types"; 19882 case MEDICATION: return "http://hl7.org/fhir/fhir-types"; 19883 case MEDICATIONADMINISTRATION: return "http://hl7.org/fhir/fhir-types"; 19884 case MEDICATIONDISPENSE: return "http://hl7.org/fhir/fhir-types"; 19885 case MEDICATIONKNOWLEDGE: return "http://hl7.org/fhir/fhir-types"; 19886 case MEDICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 19887 case MEDICATIONSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 19888 case MEDICINALPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19889 case MESSAGEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19890 case MESSAGEHEADER: return "http://hl7.org/fhir/fhir-types"; 19891 case METADATARESOURCE: return "http://hl7.org/fhir/fhir-types"; 19892 case MOLECULARSEQUENCE: return "http://hl7.org/fhir/fhir-types"; 19893 case NAMINGSYSTEM: return "http://hl7.org/fhir/fhir-types"; 19894 case NUTRITIONINTAKE: return "http://hl7.org/fhir/fhir-types"; 19895 case NUTRITIONORDER: return "http://hl7.org/fhir/fhir-types"; 19896 case NUTRITIONPRODUCT: return "http://hl7.org/fhir/fhir-types"; 19897 case OBSERVATION: return "http://hl7.org/fhir/fhir-types"; 19898 case OBSERVATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19899 case OPERATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19900 case OPERATIONOUTCOME: return "http://hl7.org/fhir/fhir-types"; 19901 case ORGANIZATION: return "http://hl7.org/fhir/fhir-types"; 19902 case ORGANIZATIONAFFILIATION: return "http://hl7.org/fhir/fhir-types"; 19903 case PACKAGEDPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19904 case PARAMETERS: return "http://hl7.org/fhir/fhir-types"; 19905 case PATIENT: return "http://hl7.org/fhir/fhir-types"; 19906 case PAYMENTNOTICE: return "http://hl7.org/fhir/fhir-types"; 19907 case PAYMENTRECONCILIATION: return "http://hl7.org/fhir/fhir-types"; 19908 case PERMISSION: return "http://hl7.org/fhir/fhir-types"; 19909 case PERSON: return "http://hl7.org/fhir/fhir-types"; 19910 case PLANDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19911 case PRACTITIONER: return "http://hl7.org/fhir/fhir-types"; 19912 case PRACTITIONERROLE: return "http://hl7.org/fhir/fhir-types"; 19913 case PROCEDURE: return "http://hl7.org/fhir/fhir-types"; 19914 case PROVENANCE: return "http://hl7.org/fhir/fhir-types"; 19915 case QUESTIONNAIRE: return "http://hl7.org/fhir/fhir-types"; 19916 case QUESTIONNAIRERESPONSE: return "http://hl7.org/fhir/fhir-types"; 19917 case REGULATEDAUTHORIZATION: return "http://hl7.org/fhir/fhir-types"; 19918 case RELATEDPERSON: return "http://hl7.org/fhir/fhir-types"; 19919 case REQUESTORCHESTRATION: return "http://hl7.org/fhir/fhir-types"; 19920 case REQUIREMENTS: return "http://hl7.org/fhir/fhir-types"; 19921 case RESEARCHSTUDY: return "http://hl7.org/fhir/fhir-types"; 19922 case RESEARCHSUBJECT: return "http://hl7.org/fhir/fhir-types"; 19923 case RESOURCE: return "http://hl7.org/fhir/fhir-types"; 19924 case RISKASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 19925 case SCHEDULE: return "http://hl7.org/fhir/fhir-types"; 19926 case SEARCHPARAMETER: return "http://hl7.org/fhir/fhir-types"; 19927 case SERVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 19928 case SLOT: return "http://hl7.org/fhir/fhir-types"; 19929 case SPECIMEN: return "http://hl7.org/fhir/fhir-types"; 19930 case SPECIMENDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19931 case STRUCTUREDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19932 case STRUCTUREMAP: return "http://hl7.org/fhir/fhir-types"; 19933 case SUBSCRIPTION: return "http://hl7.org/fhir/fhir-types"; 19934 case SUBSCRIPTIONSTATUS: return "http://hl7.org/fhir/fhir-types"; 19935 case SUBSCRIPTIONTOPIC: return "http://hl7.org/fhir/fhir-types"; 19936 case SUBSTANCE: return "http://hl7.org/fhir/fhir-types"; 19937 case SUBSTANCEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19938 case SUBSTANCENUCLEICACID: return "http://hl7.org/fhir/fhir-types"; 19939 case SUBSTANCEPOLYMER: return "http://hl7.org/fhir/fhir-types"; 19940 case SUBSTANCEPROTEIN: return "http://hl7.org/fhir/fhir-types"; 19941 case SUBSTANCEREFERENCEINFORMATION: return "http://hl7.org/fhir/fhir-types"; 19942 case SUBSTANCESOURCEMATERIAL: return "http://hl7.org/fhir/fhir-types"; 19943 case SUPPLYDELIVERY: return "http://hl7.org/fhir/fhir-types"; 19944 case SUPPLYREQUEST: return "http://hl7.org/fhir/fhir-types"; 19945 case TASK: return "http://hl7.org/fhir/fhir-types"; 19946 case TERMINOLOGYCAPABILITIES: return "http://hl7.org/fhir/fhir-types"; 19947 case TESTPLAN: return "http://hl7.org/fhir/fhir-types"; 19948 case TESTREPORT: return "http://hl7.org/fhir/fhir-types"; 19949 case TESTSCRIPT: return "http://hl7.org/fhir/fhir-types"; 19950 case TRANSPORT: return "http://hl7.org/fhir/fhir-types"; 19951 case VALUESET: return "http://hl7.org/fhir/fhir-types"; 19952 case VERIFICATIONRESULT: return "http://hl7.org/fhir/fhir-types"; 19953 case VISIONPRESCRIPTION: return "http://hl7.org/fhir/fhir-types"; 19954 case BODYSITE: return "http://hl7.org/fhir/fhir-old-types"; 19955 case CATALOGENTRY: return "http://hl7.org/fhir/fhir-old-types"; 19956 case CONFORMANCE: return "http://hl7.org/fhir/fhir-old-types"; 19957 case DATAELEMENT: return "http://hl7.org/fhir/fhir-old-types"; 19958 case DEVICECOMPONENT: return "http://hl7.org/fhir/fhir-old-types"; 19959 case DEVICEUSEREQUEST: return "http://hl7.org/fhir/fhir-old-types"; 19960 case DEVICEUSESTATEMENT: return "http://hl7.org/fhir/fhir-old-types"; 19961 case DIAGNOSTICORDER: return "http://hl7.org/fhir/fhir-old-types"; 19962 case DOCUMENTMANIFEST: return "http://hl7.org/fhir/fhir-old-types"; 19963 case EFFECTEVIDENCESYNTHESIS: return "http://hl7.org/fhir/fhir-old-types"; 19964 case ELIGIBILITYREQUEST: return "http://hl7.org/fhir/fhir-old-types"; 19965 case ELIGIBILITYRESPONSE: return "http://hl7.org/fhir/fhir-old-types"; 19966 case EXPANSIONPROFILE: return "http://hl7.org/fhir/fhir-old-types"; 19967 case IMAGINGMANIFEST: return "http://hl7.org/fhir/fhir-old-types"; 19968 case IMAGINGOBJECTSELECTION: return "http://hl7.org/fhir/fhir-old-types"; 19969 case MEDIA: return "http://hl7.org/fhir/fhir-old-types"; 19970 case MEDICATIONORDER: return "http://hl7.org/fhir/fhir-old-types"; 19971 case MEDICATIONUSAGE: return "http://hl7.org/fhir/fhir-old-types"; 19972 case MEDICINALPRODUCT: return "http://hl7.org/fhir/fhir-old-types"; 19973 case MEDICINALPRODUCTAUTHORIZATION: return "http://hl7.org/fhir/fhir-old-types"; 19974 case MEDICINALPRODUCTCONTRAINDICATION: return "http://hl7.org/fhir/fhir-old-types"; 19975 case MEDICINALPRODUCTINDICATION: return "http://hl7.org/fhir/fhir-old-types"; 19976 case MEDICINALPRODUCTINGREDIENT: return "http://hl7.org/fhir/fhir-old-types"; 19977 case MEDICINALPRODUCTINTERACTION: return "http://hl7.org/fhir/fhir-old-types"; 19978 case MEDICINALPRODUCTMANUFACTURED: return "http://hl7.org/fhir/fhir-old-types"; 19979 case MEDICINALPRODUCTPACKAGED: return "http://hl7.org/fhir/fhir-old-types"; 19980 case MEDICINALPRODUCTPHARMACEUTICAL: return "http://hl7.org/fhir/fhir-old-types"; 19981 case MEDICINALPRODUCTUNDESIRABLEEFFECT: return "http://hl7.org/fhir/fhir-old-types"; 19982 case ORDER: return "http://hl7.org/fhir/fhir-old-types"; 19983 case ORDERRESPONSE: return "http://hl7.org/fhir/fhir-old-types"; 19984 case PROCEDUREREQUEST: return "http://hl7.org/fhir/fhir-old-types"; 19985 case PROCESSREQUEST: return "http://hl7.org/fhir/fhir-old-types"; 19986 case PROCESSRESPONSE: return "http://hl7.org/fhir/fhir-old-types"; 19987 case REFERRALREQUEST: return "http://hl7.org/fhir/fhir-old-types"; 19988 case REQUESTGROUP: return "http://hl7.org/fhir/fhir-old-types"; 19989 case RESEARCHDEFINITION: return "http://hl7.org/fhir/fhir-old-types"; 19990 case RESEARCHELEMENTDEFINITION: return "http://hl7.org/fhir/fhir-old-types"; 19991 case RISKEVIDENCESYNTHESIS: return "http://hl7.org/fhir/fhir-old-types"; 19992 case SEQUENCE: return "http://hl7.org/fhir/fhir-old-types"; 19993 case SERVICEDEFINITION: return "http://hl7.org/fhir/fhir-old-types"; 19994 case SUBSTANCESPECIFICATION: return "http://hl7.org/fhir/fhir-old-types"; 19995 case MOLECULARDEFINITION: return "http://hl7.org/fhir/fhir-old-types"; 19996 case CLINICALASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 19997 case NULL: return null; 19998 default: return "?"; 19999 } 20000 } 20001 public String getDefinition() { 20002 switch (this) { 20003 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."; 20004 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."; 20005 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."; 20006 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)."; 20007 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."; 20008 case ALLERGYINTOLERANCE: return "Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance."; 20009 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)."; 20010 case APPOINTMENTRESPONSE: return "A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection."; 20011 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."; 20012 case AUDITEVENT: return "A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis."; 20013 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."; 20014 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."; 20015 case BIOLOGICALLYDERIVEDPRODUCT: return "A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity."; 20016 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "A record of dispensation of a biologically derived product."; 20017 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."; 20018 case BUNDLE: return "A container for a collection of resources."; 20019 case CANONICALRESOURCE: return "Common Interface declaration for conformance and knowledge artifact resources."; 20020 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."; 20021 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."; 20022 case CARETEAM: return "The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care."; 20023 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."; 20024 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."; 20025 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."; 20026 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."; 20027 case CLAIMRESPONSE: return "This resource provides the adjudication details from the processing of a Claim resource."; 20028 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."; 20029 case CLINICALUSEDEFINITION: return "A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure."; 20030 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."; 20031 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."; 20032 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."; 20033 case COMPARTMENTDEFINITION: return "A compartment definition that defines how resources are accessed on a server."; 20034 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.)."; 20035 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."; 20036 case CONDITION: return "A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern."; 20037 case CONDITIONDEFINITION: return "A definition of a condition and information relevant to managing it."; 20038 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."; 20039 case CONTRACT: return "Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement."; 20040 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."; 20041 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."; 20042 case COVERAGEELIGIBILITYRESPONSE: return "This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource."; 20043 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."; 20044 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."; 20045 case DEVICEASSOCIATION: return "A record of association of a device."; 20046 case DEVICEDEFINITION: return "This is a specialized resource that defines the characteristics and capabilities of a device."; 20047 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."; 20048 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. "; 20049 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."; 20050 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."; 20051 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."; 20052 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."; 20053 case DOMAINRESOURCE: return "A resource that includes narrative, extensions, and contained resources."; 20054 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)."; 20055 case ENCOUNTERHISTORY: return "A record of significant events/milestones key data throughout the history of an Encounter"; 20056 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."; 20057 case ENROLLMENTREQUEST: return "This resource provides the insurance enrollment details to the insurer regarding a specified coverage."; 20058 case ENROLLMENTRESPONSE: return "This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource."; 20059 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."; 20060 case EVENTDEFINITION: return "The EventDefinition resource provides a reusable description of when a particular event can occur."; 20061 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."; 20062 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."; 20063 case EVIDENCEVARIABLE: return "The EvidenceVariable resource describes an element that knowledge (Evidence) is about."; 20064 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."; 20065 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."; 20066 case FAMILYMEMBERHISTORY: return "Significant health conditions for a person related to the patient relevant in the context of care for the patient."; 20067 case FLAG: return "Prospective warnings of potential issues when providing care to the patient."; 20068 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."; 20069 case GENOMICSTUDY: return "A set of analyses performed to analyze and generate genomic data."; 20070 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."; 20071 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."; 20072 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."; 20073 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."; 20074 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."; 20075 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."; 20076 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."; 20077 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."; 20078 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."; 20079 case IMMUNIZATIONRECOMMENDATION: return "A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification."; 20080 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."; 20081 case INGREDIENT: return "An ingredient of a manufactured item or pharmaceutical product."; 20082 case INSURANCEPLAN: return "Details of a Health Insurance product/plan provided by an organization."; 20083 case INVENTORYITEM: return "functional description of an inventory item used in inventory and supply-related workflows."; 20084 case INVENTORYREPORT: return "A report of inventory or stock items."; 20085 case INVOICE: return "Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose."; 20086 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."; 20087 case LINKAGE: return "Identifies two or more records (resource instances) that refer to the same real-world \"occurrence\"."; 20088 case LIST: return "A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc."; 20089 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."; 20090 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."; 20091 case MEASURE: return "The Measure resource provides the definition of a quality measure."; 20092 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."; 20093 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."; 20094 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."; 20095 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."; 20096 case MEDICATIONKNOWLEDGE: return "Information about a medication that is used to support knowledge."; 20097 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."; 20098 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."; 20099 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.)."; 20100 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."; 20101 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."; 20102 case METADATARESOURCE: return "Common Interface declaration for conformance and knowledge artifact resources."; 20103 case MOLECULARSEQUENCE: return "Representation of a molecular sequence."; 20104 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."; 20105 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."; 20106 case NUTRITIONORDER: return "A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident."; 20107 case NUTRITIONPRODUCT: return "A food or supplement that is consumed by patients."; 20108 case OBSERVATION: return "Measurements and simple assertions made about a patient, device or other subject."; 20109 case OBSERVATIONDEFINITION: return "Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service."; 20110 case OPERATIONDEFINITION: return "A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction)."; 20111 case OPERATIONOUTCOME: return "A collection of error, warning, or information messages that result from a system action."; 20112 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."; 20113 case ORGANIZATIONAFFILIATION: return "Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship."; 20114 case PACKAGEDPRODUCTDEFINITION: return "A medically related item or items, in a container or package."; 20115 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."; 20116 case PATIENT: return "Demographics and other administrative information about an individual or animal receiving care or other health-related services."; 20117 case PAYMENTNOTICE: return "This resource provides the status of the payment for goods and services rendered, and the request and response resource references."; 20118 case PAYMENTRECONCILIATION: return "This resource provides the details including amount of a payment and allocates the payment items being paid."; 20119 case PERMISSION: return "Permission resource holds access rules for a given data and context."; 20120 case PERSON: return "Demographics and administrative information about a person independent of a specific health-related context."; 20121 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."; 20122 case PRACTITIONER: return "A person who is directly or indirectly involved in the provisioning of healthcare or related services."; 20123 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."; 20124 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."; 20125 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."; 20126 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."; 20127 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."; 20128 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."; 20129 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."; 20130 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\"."; 20131 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."; 20132 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."; 20133 case RESEARCHSUBJECT: return "A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study."; 20134 case RESOURCE: return "This is the base resource type for everything."; 20135 case RISKASSESSMENT: return "An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome."; 20136 case SCHEDULE: return "A container for slots of time that may be available for booking appointments."; 20137 case SEARCHPARAMETER: return "A search parameter that defines a named search item that can be used to search/filter on a resource."; 20138 case SERVICEREQUEST: return "A record of a request for service such as diagnostic investigations, treatments, or operations to be performed."; 20139 case SLOT: return "A slot of time on a schedule that may be available for booking appointments."; 20140 case SPECIMEN: return "A sample to be used for analysis."; 20141 case SPECIMENDEFINITION: return "A kind of specimen with associated set of requirements."; 20142 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."; 20143 case STRUCTUREMAP: return "A Map of relationships between 2 structures that can be used to transform data."; 20144 case SUBSCRIPTION: return "The subscription resource describes a particular client's request to be notified about a SubscriptionTopic."; 20145 case SUBSCRIPTIONSTATUS: return "The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted."; 20146 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."; 20147 case SUBSTANCE: return "A homogeneous material with a definite composition."; 20148 case SUBSTANCEDEFINITION: return "The detailed description of a substance, typically at a level beyond what is used for prescribing."; 20149 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."; 20150 case SUBSTANCEPOLYMER: return "Properties of a substance specific to it being a polymer."; 20151 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."; 20152 case SUBSTANCEREFERENCEINFORMATION: return "Todo."; 20153 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."; 20154 case SUPPLYDELIVERY: return "Record of delivery of what is supplied."; 20155 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."; 20156 case TASK: return "A task to be performed."; 20157 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."; 20158 case TESTPLAN: return "A plan for executing testing on an artifact or specifications"; 20159 case TESTREPORT: return "A summary of information based on the results of executing a TestScript."; 20160 case TESTSCRIPT: return "A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification."; 20161 case TRANSPORT: return "Record of transport."; 20162 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)."; 20163 case VERIFICATIONRESULT: return "Describes validation requirements, source(s), status and dates for one or more elements."; 20164 case VISIONPRESCRIPTION: return "An authorization for the provision of glasses and/or contact lenses to a patient."; 20165 case BODYSITE: return ""; 20166 case CATALOGENTRY: return ""; 20167 case CONFORMANCE: return ""; 20168 case DATAELEMENT: return ""; 20169 case DEVICECOMPONENT: return ""; 20170 case DEVICEUSEREQUEST: return ""; 20171 case DEVICEUSESTATEMENT: return ""; 20172 case DIAGNOSTICORDER: return ""; 20173 case DOCUMENTMANIFEST: return ""; 20174 case EFFECTEVIDENCESYNTHESIS: return ""; 20175 case ELIGIBILITYREQUEST: return ""; 20176 case ELIGIBILITYRESPONSE: return ""; 20177 case EXPANSIONPROFILE: return ""; 20178 case IMAGINGMANIFEST: return ""; 20179 case IMAGINGOBJECTSELECTION: return ""; 20180 case MEDIA: return ""; 20181 case MEDICATIONORDER: return ""; 20182 case MEDICATIONUSAGE: return ""; 20183 case MEDICINALPRODUCT: return ""; 20184 case MEDICINALPRODUCTAUTHORIZATION: return ""; 20185 case MEDICINALPRODUCTCONTRAINDICATION: return ""; 20186 case MEDICINALPRODUCTINDICATION: return ""; 20187 case MEDICINALPRODUCTINGREDIENT: return ""; 20188 case MEDICINALPRODUCTINTERACTION: return ""; 20189 case MEDICINALPRODUCTMANUFACTURED: return ""; 20190 case MEDICINALPRODUCTPACKAGED: return ""; 20191 case MEDICINALPRODUCTPHARMACEUTICAL: return ""; 20192 case MEDICINALPRODUCTUNDESIRABLEEFFECT: return ""; 20193 case ORDER: return ""; 20194 case ORDERRESPONSE: return ""; 20195 case PROCEDUREREQUEST: return ""; 20196 case PROCESSREQUEST: return ""; 20197 case PROCESSRESPONSE: return ""; 20198 case REFERRALREQUEST: return ""; 20199 case REQUESTGROUP: return ""; 20200 case RESEARCHDEFINITION: return ""; 20201 case RESEARCHELEMENTDEFINITION: return ""; 20202 case RISKEVIDENCESYNTHESIS: return ""; 20203 case SEQUENCE: return ""; 20204 case SERVICEDEFINITION: return ""; 20205 case SUBSTANCESPECIFICATION: return ""; 20206 case MOLECULARDEFINITION: return ""; 20207 case CLINICALASSESSMENT: return ""; 20208 case NULL: return null; 20209 default: return "?"; 20210 } 20211 } 20212 public String getDisplay() { 20213 switch (this) { 20214 case ACCOUNT: return "Account"; 20215 case ACTIVITYDEFINITION: return "ActivityDefinition"; 20216 case ACTORDEFINITION: return "ActorDefinition"; 20217 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 20218 case ADVERSEEVENT: return "AdverseEvent"; 20219 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 20220 case APPOINTMENT: return "Appointment"; 20221 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 20222 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 20223 case AUDITEVENT: return "AuditEvent"; 20224 case BASIC: return "Basic"; 20225 case BINARY: return "Binary"; 20226 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 20227 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "BiologicallyDerivedProductDispense"; 20228 case BODYSTRUCTURE: return "BodyStructure"; 20229 case BUNDLE: return "Bundle"; 20230 case CANONICALRESOURCE: return "CanonicalResource"; 20231 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 20232 case CAREPLAN: return "CarePlan"; 20233 case CARETEAM: return "CareTeam"; 20234 case CHARGEITEM: return "ChargeItem"; 20235 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 20236 case CITATION: return "Citation"; 20237 case CLAIM: return "Claim"; 20238 case CLAIMRESPONSE: return "ClaimResponse"; 20239 case CLINICALIMPRESSION: return "ClinicalImpression"; 20240 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 20241 case CODESYSTEM: return "CodeSystem"; 20242 case COMMUNICATION: return "Communication"; 20243 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 20244 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 20245 case COMPOSITION: return "Composition"; 20246 case CONCEPTMAP: return "ConceptMap"; 20247 case CONDITION: return "Condition"; 20248 case CONDITIONDEFINITION: return "ConditionDefinition"; 20249 case CONSENT: return "Consent"; 20250 case CONTRACT: return "Contract"; 20251 case COVERAGE: return "Coverage"; 20252 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 20253 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 20254 case DETECTEDISSUE: return "DetectedIssue"; 20255 case DEVICE: return "Device"; 20256 case DEVICEASSOCIATION: return "DeviceAssociation"; 20257 case DEVICEDEFINITION: return "DeviceDefinition"; 20258 case DEVICEDISPENSE: return "DeviceDispense"; 20259 case DEVICEMETRIC: return "DeviceMetric"; 20260 case DEVICEREQUEST: return "DeviceRequest"; 20261 case DEVICEUSAGE: return "DeviceUsage"; 20262 case DIAGNOSTICREPORT: return "DiagnosticReport"; 20263 case DOCUMENTREFERENCE: return "DocumentReference"; 20264 case DOMAINRESOURCE: return "DomainResource"; 20265 case ENCOUNTER: return "Encounter"; 20266 case ENCOUNTERHISTORY: return "EncounterHistory"; 20267 case ENDPOINT: return "Endpoint"; 20268 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 20269 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 20270 case EPISODEOFCARE: return "EpisodeOfCare"; 20271 case EVENTDEFINITION: return "EventDefinition"; 20272 case EVIDENCE: return "Evidence"; 20273 case EVIDENCEREPORT: return "EvidenceReport"; 20274 case EVIDENCEVARIABLE: return "EvidenceVariable"; 20275 case EXAMPLESCENARIO: return "ExampleScenario"; 20276 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 20277 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 20278 case FLAG: return "Flag"; 20279 case FORMULARYITEM: return "FormularyItem"; 20280 case GENOMICSTUDY: return "GenomicStudy"; 20281 case GOAL: return "Goal"; 20282 case GRAPHDEFINITION: return "GraphDefinition"; 20283 case GROUP: return "Group"; 20284 case GUIDANCERESPONSE: return "GuidanceResponse"; 20285 case HEALTHCARESERVICE: return "HealthcareService"; 20286 case IMAGINGSELECTION: return "ImagingSelection"; 20287 case IMAGINGSTUDY: return "ImagingStudy"; 20288 case IMMUNIZATION: return "Immunization"; 20289 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 20290 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 20291 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 20292 case INGREDIENT: return "Ingredient"; 20293 case INSURANCEPLAN: return "InsurancePlan"; 20294 case INVENTORYITEM: return "InventoryItem"; 20295 case INVENTORYREPORT: return "InventoryReport"; 20296 case INVOICE: return "Invoice"; 20297 case LIBRARY: return "Library"; 20298 case LINKAGE: return "Linkage"; 20299 case LIST: return "List"; 20300 case LOCATION: return "Location"; 20301 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 20302 case MEASURE: return "Measure"; 20303 case MEASUREREPORT: return "MeasureReport"; 20304 case MEDICATION: return "Medication"; 20305 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 20306 case MEDICATIONDISPENSE: return "MedicationDispense"; 20307 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 20308 case MEDICATIONREQUEST: return "MedicationRequest"; 20309 case MEDICATIONSTATEMENT: return "MedicationStatement"; 20310 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 20311 case MESSAGEDEFINITION: return "MessageDefinition"; 20312 case MESSAGEHEADER: return "MessageHeader"; 20313 case METADATARESOURCE: return "MetadataResource"; 20314 case MOLECULARSEQUENCE: return "MolecularSequence"; 20315 case NAMINGSYSTEM: return "NamingSystem"; 20316 case NUTRITIONINTAKE: return "NutritionIntake"; 20317 case NUTRITIONORDER: return "NutritionOrder"; 20318 case NUTRITIONPRODUCT: return "NutritionProduct"; 20319 case OBSERVATION: return "Observation"; 20320 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 20321 case OPERATIONDEFINITION: return "OperationDefinition"; 20322 case OPERATIONOUTCOME: return "OperationOutcome"; 20323 case ORGANIZATION: return "Organization"; 20324 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 20325 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 20326 case PARAMETERS: return "Parameters"; 20327 case PATIENT: return "Patient"; 20328 case PAYMENTNOTICE: return "PaymentNotice"; 20329 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 20330 case PERMISSION: return "Permission"; 20331 case PERSON: return "Person"; 20332 case PLANDEFINITION: return "PlanDefinition"; 20333 case PRACTITIONER: return "Practitioner"; 20334 case PRACTITIONERROLE: return "PractitionerRole"; 20335 case PROCEDURE: return "Procedure"; 20336 case PROVENANCE: return "Provenance"; 20337 case QUESTIONNAIRE: return "Questionnaire"; 20338 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 20339 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 20340 case RELATEDPERSON: return "RelatedPerson"; 20341 case REQUESTORCHESTRATION: return "RequestOrchestration"; 20342 case REQUIREMENTS: return "Requirements"; 20343 case RESEARCHSTUDY: return "ResearchStudy"; 20344 case RESEARCHSUBJECT: return "ResearchSubject"; 20345 case RESOURCE: return "Resource"; 20346 case RISKASSESSMENT: return "RiskAssessment"; 20347 case SCHEDULE: return "Schedule"; 20348 case SEARCHPARAMETER: return "SearchParameter"; 20349 case SERVICEREQUEST: return "ServiceRequest"; 20350 case SLOT: return "Slot"; 20351 case SPECIMEN: return "Specimen"; 20352 case SPECIMENDEFINITION: return "SpecimenDefinition"; 20353 case STRUCTUREDEFINITION: return "StructureDefinition"; 20354 case STRUCTUREMAP: return "StructureMap"; 20355 case SUBSCRIPTION: return "Subscription"; 20356 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 20357 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 20358 case SUBSTANCE: return "Substance"; 20359 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 20360 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 20361 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 20362 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 20363 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 20364 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 20365 case SUPPLYDELIVERY: return "SupplyDelivery"; 20366 case SUPPLYREQUEST: return "SupplyRequest"; 20367 case TASK: return "Task"; 20368 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 20369 case TESTPLAN: return "TestPlan"; 20370 case TESTREPORT: return "TestReport"; 20371 case TESTSCRIPT: return "TestScript"; 20372 case TRANSPORT: return "Transport"; 20373 case VALUESET: return "ValueSet"; 20374 case VERIFICATIONRESULT: return "VerificationResult"; 20375 case VISIONPRESCRIPTION: return "VisionPrescription"; 20376 case BODYSITE: return "BodySite"; 20377 case CATALOGENTRY: return "CatalogEntry"; 20378 case CONFORMANCE: return "Conformance"; 20379 case DATAELEMENT: return "DataElement"; 20380 case DEVICECOMPONENT: return "DeviceComponent"; 20381 case DEVICEUSEREQUEST: return "DeviceUseRequest"; 20382 case DEVICEUSESTATEMENT: return "DeviceUseStatement"; 20383 case DIAGNOSTICORDER: return "DiagnosticOrder"; 20384 case DOCUMENTMANIFEST: return "DocumentManifest"; 20385 case EFFECTEVIDENCESYNTHESIS: return "EffectEvidenceSynthesis"; 20386 case ELIGIBILITYREQUEST: return "EligibilityRequest"; 20387 case ELIGIBILITYRESPONSE: return "EligibilityResponse"; 20388 case EXPANSIONPROFILE: return "ExpansionProfile"; 20389 case IMAGINGMANIFEST: return "ImagingManifest"; 20390 case IMAGINGOBJECTSELECTION: return "ImagingObjectSelection"; 20391 case MEDIA: return "Media"; 20392 case MEDICATIONORDER: return "MedicationOrder"; 20393 case MEDICATIONUSAGE: return "MedicationUsage"; 20394 case MEDICINALPRODUCT: return "MedicinalProduct"; 20395 case MEDICINALPRODUCTAUTHORIZATION: return "MedicinalProductAuthorization"; 20396 case MEDICINALPRODUCTCONTRAINDICATION: return "MedicinalProductContraindication"; 20397 case MEDICINALPRODUCTINDICATION: return "MedicinalProductIndication"; 20398 case MEDICINALPRODUCTINGREDIENT: return "MedicinalProductIngredient"; 20399 case MEDICINALPRODUCTINTERACTION: return "MedicinalProductInteraction"; 20400 case MEDICINALPRODUCTMANUFACTURED: return "MedicinalProductManufactured"; 20401 case MEDICINALPRODUCTPACKAGED: return "MedicinalProductPackaged"; 20402 case MEDICINALPRODUCTPHARMACEUTICAL: return "MedicinalProductPharmaceutical"; 20403 case MEDICINALPRODUCTUNDESIRABLEEFFECT: return "MedicinalProductUndesirableEffect"; 20404 case ORDER: return "Order"; 20405 case ORDERRESPONSE: return "OrderResponse"; 20406 case PROCEDUREREQUEST: return "ProcedureRequest"; 20407 case PROCESSREQUEST: return "ProcessRequest"; 20408 case PROCESSRESPONSE: return "ProcessResponse"; 20409 case REFERRALREQUEST: return "ReferralRequest"; 20410 case REQUESTGROUP: return "RequestGroup"; 20411 case RESEARCHDEFINITION: return "ResearchDefinition"; 20412 case RESEARCHELEMENTDEFINITION: return "ResearchElementDefinition"; 20413 case RISKEVIDENCESYNTHESIS: return "RiskEvidenceSynthesis"; 20414 case SEQUENCE: return "Sequence"; 20415 case SERVICEDEFINITION: return "ServiceDefinition"; 20416 case SUBSTANCESPECIFICATION: return "SubstanceSpecification"; 20417 case MOLECULARDEFINITION: return "MolecularDefinition"; 20418 case CLINICALASSESSMENT: return "ClinicalAssessment"; 20419 case NULL: return null; 20420 default: return "?"; 20421 } 20422 } 20423 } 20424 20425 public static class VersionIndependentResourceTypesAllEnumFactory implements EnumFactory<VersionIndependentResourceTypesAll> { 20426 public VersionIndependentResourceTypesAll fromCode(String codeString) throws IllegalArgumentException { 20427 if (codeString == null || "".equals(codeString)) 20428 if (codeString == null || "".equals(codeString)) 20429 return null; 20430 if ("Account".equals(codeString)) 20431 return VersionIndependentResourceTypesAll.ACCOUNT; 20432 if ("ActivityDefinition".equals(codeString)) 20433 return VersionIndependentResourceTypesAll.ACTIVITYDEFINITION; 20434 if ("ActorDefinition".equals(codeString)) 20435 return VersionIndependentResourceTypesAll.ACTORDEFINITION; 20436 if ("AdministrableProductDefinition".equals(codeString)) 20437 return VersionIndependentResourceTypesAll.ADMINISTRABLEPRODUCTDEFINITION; 20438 if ("AdverseEvent".equals(codeString)) 20439 return VersionIndependentResourceTypesAll.ADVERSEEVENT; 20440 if ("AllergyIntolerance".equals(codeString)) 20441 return VersionIndependentResourceTypesAll.ALLERGYINTOLERANCE; 20442 if ("Appointment".equals(codeString)) 20443 return VersionIndependentResourceTypesAll.APPOINTMENT; 20444 if ("AppointmentResponse".equals(codeString)) 20445 return VersionIndependentResourceTypesAll.APPOINTMENTRESPONSE; 20446 if ("ArtifactAssessment".equals(codeString)) 20447 return VersionIndependentResourceTypesAll.ARTIFACTASSESSMENT; 20448 if ("AuditEvent".equals(codeString)) 20449 return VersionIndependentResourceTypesAll.AUDITEVENT; 20450 if ("Basic".equals(codeString)) 20451 return VersionIndependentResourceTypesAll.BASIC; 20452 if ("Binary".equals(codeString)) 20453 return VersionIndependentResourceTypesAll.BINARY; 20454 if ("BiologicallyDerivedProduct".equals(codeString)) 20455 return VersionIndependentResourceTypesAll.BIOLOGICALLYDERIVEDPRODUCT; 20456 if ("BiologicallyDerivedProductDispense".equals(codeString)) 20457 return VersionIndependentResourceTypesAll.BIOLOGICALLYDERIVEDPRODUCTDISPENSE; 20458 if ("BodyStructure".equals(codeString)) 20459 return VersionIndependentResourceTypesAll.BODYSTRUCTURE; 20460 if ("Bundle".equals(codeString)) 20461 return VersionIndependentResourceTypesAll.BUNDLE; 20462 if ("CanonicalResource".equals(codeString)) 20463 return VersionIndependentResourceTypesAll.CANONICALRESOURCE; 20464 if ("CapabilityStatement".equals(codeString)) 20465 return VersionIndependentResourceTypesAll.CAPABILITYSTATEMENT; 20466 if ("CarePlan".equals(codeString)) 20467 return VersionIndependentResourceTypesAll.CAREPLAN; 20468 if ("CareTeam".equals(codeString)) 20469 return VersionIndependentResourceTypesAll.CARETEAM; 20470 if ("ChargeItem".equals(codeString)) 20471 return VersionIndependentResourceTypesAll.CHARGEITEM; 20472 if ("ChargeItemDefinition".equals(codeString)) 20473 return VersionIndependentResourceTypesAll.CHARGEITEMDEFINITION; 20474 if ("Citation".equals(codeString)) 20475 return VersionIndependentResourceTypesAll.CITATION; 20476 if ("Claim".equals(codeString)) 20477 return VersionIndependentResourceTypesAll.CLAIM; 20478 if ("ClaimResponse".equals(codeString)) 20479 return VersionIndependentResourceTypesAll.CLAIMRESPONSE; 20480 if ("ClinicalImpression".equals(codeString)) 20481 return VersionIndependentResourceTypesAll.CLINICALIMPRESSION; 20482 if ("ClinicalUseDefinition".equals(codeString)) 20483 return VersionIndependentResourceTypesAll.CLINICALUSEDEFINITION; 20484 if ("CodeSystem".equals(codeString)) 20485 return VersionIndependentResourceTypesAll.CODESYSTEM; 20486 if ("Communication".equals(codeString)) 20487 return VersionIndependentResourceTypesAll.COMMUNICATION; 20488 if ("CommunicationRequest".equals(codeString)) 20489 return VersionIndependentResourceTypesAll.COMMUNICATIONREQUEST; 20490 if ("CompartmentDefinition".equals(codeString)) 20491 return VersionIndependentResourceTypesAll.COMPARTMENTDEFINITION; 20492 if ("Composition".equals(codeString)) 20493 return VersionIndependentResourceTypesAll.COMPOSITION; 20494 if ("ConceptMap".equals(codeString)) 20495 return VersionIndependentResourceTypesAll.CONCEPTMAP; 20496 if ("Condition".equals(codeString)) 20497 return VersionIndependentResourceTypesAll.CONDITION; 20498 if ("ConditionDefinition".equals(codeString)) 20499 return VersionIndependentResourceTypesAll.CONDITIONDEFINITION; 20500 if ("Consent".equals(codeString)) 20501 return VersionIndependentResourceTypesAll.CONSENT; 20502 if ("Contract".equals(codeString)) 20503 return VersionIndependentResourceTypesAll.CONTRACT; 20504 if ("Coverage".equals(codeString)) 20505 return VersionIndependentResourceTypesAll.COVERAGE; 20506 if ("CoverageEligibilityRequest".equals(codeString)) 20507 return VersionIndependentResourceTypesAll.COVERAGEELIGIBILITYREQUEST; 20508 if ("CoverageEligibilityResponse".equals(codeString)) 20509 return VersionIndependentResourceTypesAll.COVERAGEELIGIBILITYRESPONSE; 20510 if ("DetectedIssue".equals(codeString)) 20511 return VersionIndependentResourceTypesAll.DETECTEDISSUE; 20512 if ("Device".equals(codeString)) 20513 return VersionIndependentResourceTypesAll.DEVICE; 20514 if ("DeviceAssociation".equals(codeString)) 20515 return VersionIndependentResourceTypesAll.DEVICEASSOCIATION; 20516 if ("DeviceDefinition".equals(codeString)) 20517 return VersionIndependentResourceTypesAll.DEVICEDEFINITION; 20518 if ("DeviceDispense".equals(codeString)) 20519 return VersionIndependentResourceTypesAll.DEVICEDISPENSE; 20520 if ("DeviceMetric".equals(codeString)) 20521 return VersionIndependentResourceTypesAll.DEVICEMETRIC; 20522 if ("DeviceRequest".equals(codeString)) 20523 return VersionIndependentResourceTypesAll.DEVICEREQUEST; 20524 if ("DeviceUsage".equals(codeString)) 20525 return VersionIndependentResourceTypesAll.DEVICEUSAGE; 20526 if ("DiagnosticReport".equals(codeString)) 20527 return VersionIndependentResourceTypesAll.DIAGNOSTICREPORT; 20528 if ("DocumentReference".equals(codeString)) 20529 return VersionIndependentResourceTypesAll.DOCUMENTREFERENCE; 20530 if ("DomainResource".equals(codeString)) 20531 return VersionIndependentResourceTypesAll.DOMAINRESOURCE; 20532 if ("Encounter".equals(codeString)) 20533 return VersionIndependentResourceTypesAll.ENCOUNTER; 20534 if ("EncounterHistory".equals(codeString)) 20535 return VersionIndependentResourceTypesAll.ENCOUNTERHISTORY; 20536 if ("Endpoint".equals(codeString)) 20537 return VersionIndependentResourceTypesAll.ENDPOINT; 20538 if ("EnrollmentRequest".equals(codeString)) 20539 return VersionIndependentResourceTypesAll.ENROLLMENTREQUEST; 20540 if ("EnrollmentResponse".equals(codeString)) 20541 return VersionIndependentResourceTypesAll.ENROLLMENTRESPONSE; 20542 if ("EpisodeOfCare".equals(codeString)) 20543 return VersionIndependentResourceTypesAll.EPISODEOFCARE; 20544 if ("EventDefinition".equals(codeString)) 20545 return VersionIndependentResourceTypesAll.EVENTDEFINITION; 20546 if ("Evidence".equals(codeString)) 20547 return VersionIndependentResourceTypesAll.EVIDENCE; 20548 if ("EvidenceReport".equals(codeString)) 20549 return VersionIndependentResourceTypesAll.EVIDENCEREPORT; 20550 if ("EvidenceVariable".equals(codeString)) 20551 return VersionIndependentResourceTypesAll.EVIDENCEVARIABLE; 20552 if ("ExampleScenario".equals(codeString)) 20553 return VersionIndependentResourceTypesAll.EXAMPLESCENARIO; 20554 if ("ExplanationOfBenefit".equals(codeString)) 20555 return VersionIndependentResourceTypesAll.EXPLANATIONOFBENEFIT; 20556 if ("FamilyMemberHistory".equals(codeString)) 20557 return VersionIndependentResourceTypesAll.FAMILYMEMBERHISTORY; 20558 if ("Flag".equals(codeString)) 20559 return VersionIndependentResourceTypesAll.FLAG; 20560 if ("FormularyItem".equals(codeString)) 20561 return VersionIndependentResourceTypesAll.FORMULARYITEM; 20562 if ("GenomicStudy".equals(codeString)) 20563 return VersionIndependentResourceTypesAll.GENOMICSTUDY; 20564 if ("Goal".equals(codeString)) 20565 return VersionIndependentResourceTypesAll.GOAL; 20566 if ("GraphDefinition".equals(codeString)) 20567 return VersionIndependentResourceTypesAll.GRAPHDEFINITION; 20568 if ("Group".equals(codeString)) 20569 return VersionIndependentResourceTypesAll.GROUP; 20570 if ("GuidanceResponse".equals(codeString)) 20571 return VersionIndependentResourceTypesAll.GUIDANCERESPONSE; 20572 if ("HealthcareService".equals(codeString)) 20573 return VersionIndependentResourceTypesAll.HEALTHCARESERVICE; 20574 if ("ImagingSelection".equals(codeString)) 20575 return VersionIndependentResourceTypesAll.IMAGINGSELECTION; 20576 if ("ImagingStudy".equals(codeString)) 20577 return VersionIndependentResourceTypesAll.IMAGINGSTUDY; 20578 if ("Immunization".equals(codeString)) 20579 return VersionIndependentResourceTypesAll.IMMUNIZATION; 20580 if ("ImmunizationEvaluation".equals(codeString)) 20581 return VersionIndependentResourceTypesAll.IMMUNIZATIONEVALUATION; 20582 if ("ImmunizationRecommendation".equals(codeString)) 20583 return VersionIndependentResourceTypesAll.IMMUNIZATIONRECOMMENDATION; 20584 if ("ImplementationGuide".equals(codeString)) 20585 return VersionIndependentResourceTypesAll.IMPLEMENTATIONGUIDE; 20586 if ("Ingredient".equals(codeString)) 20587 return VersionIndependentResourceTypesAll.INGREDIENT; 20588 if ("InsurancePlan".equals(codeString)) 20589 return VersionIndependentResourceTypesAll.INSURANCEPLAN; 20590 if ("InventoryItem".equals(codeString)) 20591 return VersionIndependentResourceTypesAll.INVENTORYITEM; 20592 if ("InventoryReport".equals(codeString)) 20593 return VersionIndependentResourceTypesAll.INVENTORYREPORT; 20594 if ("Invoice".equals(codeString)) 20595 return VersionIndependentResourceTypesAll.INVOICE; 20596 if ("Library".equals(codeString)) 20597 return VersionIndependentResourceTypesAll.LIBRARY; 20598 if ("Linkage".equals(codeString)) 20599 return VersionIndependentResourceTypesAll.LINKAGE; 20600 if ("List".equals(codeString)) 20601 return VersionIndependentResourceTypesAll.LIST; 20602 if ("Location".equals(codeString)) 20603 return VersionIndependentResourceTypesAll.LOCATION; 20604 if ("ManufacturedItemDefinition".equals(codeString)) 20605 return VersionIndependentResourceTypesAll.MANUFACTUREDITEMDEFINITION; 20606 if ("Measure".equals(codeString)) 20607 return VersionIndependentResourceTypesAll.MEASURE; 20608 if ("MeasureReport".equals(codeString)) 20609 return VersionIndependentResourceTypesAll.MEASUREREPORT; 20610 if ("Medication".equals(codeString)) 20611 return VersionIndependentResourceTypesAll.MEDICATION; 20612 if ("MedicationAdministration".equals(codeString)) 20613 return VersionIndependentResourceTypesAll.MEDICATIONADMINISTRATION; 20614 if ("MedicationDispense".equals(codeString)) 20615 return VersionIndependentResourceTypesAll.MEDICATIONDISPENSE; 20616 if ("MedicationKnowledge".equals(codeString)) 20617 return VersionIndependentResourceTypesAll.MEDICATIONKNOWLEDGE; 20618 if ("MedicationRequest".equals(codeString)) 20619 return VersionIndependentResourceTypesAll.MEDICATIONREQUEST; 20620 if ("MedicationStatement".equals(codeString)) 20621 return VersionIndependentResourceTypesAll.MEDICATIONSTATEMENT; 20622 if ("MedicinalProductDefinition".equals(codeString)) 20623 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTDEFINITION; 20624 if ("MessageDefinition".equals(codeString)) 20625 return VersionIndependentResourceTypesAll.MESSAGEDEFINITION; 20626 if ("MessageHeader".equals(codeString)) 20627 return VersionIndependentResourceTypesAll.MESSAGEHEADER; 20628 if ("MetadataResource".equals(codeString)) 20629 return VersionIndependentResourceTypesAll.METADATARESOURCE; 20630 if ("MolecularSequence".equals(codeString)) 20631 return VersionIndependentResourceTypesAll.MOLECULARSEQUENCE; 20632 if ("NamingSystem".equals(codeString)) 20633 return VersionIndependentResourceTypesAll.NAMINGSYSTEM; 20634 if ("NutritionIntake".equals(codeString)) 20635 return VersionIndependentResourceTypesAll.NUTRITIONINTAKE; 20636 if ("NutritionOrder".equals(codeString)) 20637 return VersionIndependentResourceTypesAll.NUTRITIONORDER; 20638 if ("NutritionProduct".equals(codeString)) 20639 return VersionIndependentResourceTypesAll.NUTRITIONPRODUCT; 20640 if ("Observation".equals(codeString)) 20641 return VersionIndependentResourceTypesAll.OBSERVATION; 20642 if ("ObservationDefinition".equals(codeString)) 20643 return VersionIndependentResourceTypesAll.OBSERVATIONDEFINITION; 20644 if ("OperationDefinition".equals(codeString)) 20645 return VersionIndependentResourceTypesAll.OPERATIONDEFINITION; 20646 if ("OperationOutcome".equals(codeString)) 20647 return VersionIndependentResourceTypesAll.OPERATIONOUTCOME; 20648 if ("Organization".equals(codeString)) 20649 return VersionIndependentResourceTypesAll.ORGANIZATION; 20650 if ("OrganizationAffiliation".equals(codeString)) 20651 return VersionIndependentResourceTypesAll.ORGANIZATIONAFFILIATION; 20652 if ("PackagedProductDefinition".equals(codeString)) 20653 return VersionIndependentResourceTypesAll.PACKAGEDPRODUCTDEFINITION; 20654 if ("Parameters".equals(codeString)) 20655 return VersionIndependentResourceTypesAll.PARAMETERS; 20656 if ("Patient".equals(codeString)) 20657 return VersionIndependentResourceTypesAll.PATIENT; 20658 if ("PaymentNotice".equals(codeString)) 20659 return VersionIndependentResourceTypesAll.PAYMENTNOTICE; 20660 if ("PaymentReconciliation".equals(codeString)) 20661 return VersionIndependentResourceTypesAll.PAYMENTRECONCILIATION; 20662 if ("Permission".equals(codeString)) 20663 return VersionIndependentResourceTypesAll.PERMISSION; 20664 if ("Person".equals(codeString)) 20665 return VersionIndependentResourceTypesAll.PERSON; 20666 if ("PlanDefinition".equals(codeString)) 20667 return VersionIndependentResourceTypesAll.PLANDEFINITION; 20668 if ("Practitioner".equals(codeString)) 20669 return VersionIndependentResourceTypesAll.PRACTITIONER; 20670 if ("PractitionerRole".equals(codeString)) 20671 return VersionIndependentResourceTypesAll.PRACTITIONERROLE; 20672 if ("Procedure".equals(codeString)) 20673 return VersionIndependentResourceTypesAll.PROCEDURE; 20674 if ("Provenance".equals(codeString)) 20675 return VersionIndependentResourceTypesAll.PROVENANCE; 20676 if ("Questionnaire".equals(codeString)) 20677 return VersionIndependentResourceTypesAll.QUESTIONNAIRE; 20678 if ("QuestionnaireResponse".equals(codeString)) 20679 return VersionIndependentResourceTypesAll.QUESTIONNAIRERESPONSE; 20680 if ("RegulatedAuthorization".equals(codeString)) 20681 return VersionIndependentResourceTypesAll.REGULATEDAUTHORIZATION; 20682 if ("RelatedPerson".equals(codeString)) 20683 return VersionIndependentResourceTypesAll.RELATEDPERSON; 20684 if ("RequestOrchestration".equals(codeString)) 20685 return VersionIndependentResourceTypesAll.REQUESTORCHESTRATION; 20686 if ("Requirements".equals(codeString)) 20687 return VersionIndependentResourceTypesAll.REQUIREMENTS; 20688 if ("ResearchStudy".equals(codeString)) 20689 return VersionIndependentResourceTypesAll.RESEARCHSTUDY; 20690 if ("ResearchSubject".equals(codeString)) 20691 return VersionIndependentResourceTypesAll.RESEARCHSUBJECT; 20692 if ("Resource".equals(codeString)) 20693 return VersionIndependentResourceTypesAll.RESOURCE; 20694 if ("RiskAssessment".equals(codeString)) 20695 return VersionIndependentResourceTypesAll.RISKASSESSMENT; 20696 if ("Schedule".equals(codeString)) 20697 return VersionIndependentResourceTypesAll.SCHEDULE; 20698 if ("SearchParameter".equals(codeString)) 20699 return VersionIndependentResourceTypesAll.SEARCHPARAMETER; 20700 if ("ServiceRequest".equals(codeString)) 20701 return VersionIndependentResourceTypesAll.SERVICEREQUEST; 20702 if ("Slot".equals(codeString)) 20703 return VersionIndependentResourceTypesAll.SLOT; 20704 if ("Specimen".equals(codeString)) 20705 return VersionIndependentResourceTypesAll.SPECIMEN; 20706 if ("SpecimenDefinition".equals(codeString)) 20707 return VersionIndependentResourceTypesAll.SPECIMENDEFINITION; 20708 if ("StructureDefinition".equals(codeString)) 20709 return VersionIndependentResourceTypesAll.STRUCTUREDEFINITION; 20710 if ("StructureMap".equals(codeString)) 20711 return VersionIndependentResourceTypesAll.STRUCTUREMAP; 20712 if ("Subscription".equals(codeString)) 20713 return VersionIndependentResourceTypesAll.SUBSCRIPTION; 20714 if ("SubscriptionStatus".equals(codeString)) 20715 return VersionIndependentResourceTypesAll.SUBSCRIPTIONSTATUS; 20716 if ("SubscriptionTopic".equals(codeString)) 20717 return VersionIndependentResourceTypesAll.SUBSCRIPTIONTOPIC; 20718 if ("Substance".equals(codeString)) 20719 return VersionIndependentResourceTypesAll.SUBSTANCE; 20720 if ("SubstanceDefinition".equals(codeString)) 20721 return VersionIndependentResourceTypesAll.SUBSTANCEDEFINITION; 20722 if ("SubstanceNucleicAcid".equals(codeString)) 20723 return VersionIndependentResourceTypesAll.SUBSTANCENUCLEICACID; 20724 if ("SubstancePolymer".equals(codeString)) 20725 return VersionIndependentResourceTypesAll.SUBSTANCEPOLYMER; 20726 if ("SubstanceProtein".equals(codeString)) 20727 return VersionIndependentResourceTypesAll.SUBSTANCEPROTEIN; 20728 if ("SubstanceReferenceInformation".equals(codeString)) 20729 return VersionIndependentResourceTypesAll.SUBSTANCEREFERENCEINFORMATION; 20730 if ("SubstanceSourceMaterial".equals(codeString)) 20731 return VersionIndependentResourceTypesAll.SUBSTANCESOURCEMATERIAL; 20732 if ("SupplyDelivery".equals(codeString)) 20733 return VersionIndependentResourceTypesAll.SUPPLYDELIVERY; 20734 if ("SupplyRequest".equals(codeString)) 20735 return VersionIndependentResourceTypesAll.SUPPLYREQUEST; 20736 if ("Task".equals(codeString)) 20737 return VersionIndependentResourceTypesAll.TASK; 20738 if ("TerminologyCapabilities".equals(codeString)) 20739 return VersionIndependentResourceTypesAll.TERMINOLOGYCAPABILITIES; 20740 if ("TestPlan".equals(codeString)) 20741 return VersionIndependentResourceTypesAll.TESTPLAN; 20742 if ("TestReport".equals(codeString)) 20743 return VersionIndependentResourceTypesAll.TESTREPORT; 20744 if ("TestScript".equals(codeString)) 20745 return VersionIndependentResourceTypesAll.TESTSCRIPT; 20746 if ("Transport".equals(codeString)) 20747 return VersionIndependentResourceTypesAll.TRANSPORT; 20748 if ("ValueSet".equals(codeString)) 20749 return VersionIndependentResourceTypesAll.VALUESET; 20750 if ("VerificationResult".equals(codeString)) 20751 return VersionIndependentResourceTypesAll.VERIFICATIONRESULT; 20752 if ("VisionPrescription".equals(codeString)) 20753 return VersionIndependentResourceTypesAll.VISIONPRESCRIPTION; 20754 if ("BodySite".equals(codeString)) 20755 return VersionIndependentResourceTypesAll.BODYSITE; 20756 if ("CatalogEntry".equals(codeString)) 20757 return VersionIndependentResourceTypesAll.CATALOGENTRY; 20758 if ("Conformance".equals(codeString)) 20759 return VersionIndependentResourceTypesAll.CONFORMANCE; 20760 if ("DataElement".equals(codeString)) 20761 return VersionIndependentResourceTypesAll.DATAELEMENT; 20762 if ("DeviceComponent".equals(codeString)) 20763 return VersionIndependentResourceTypesAll.DEVICECOMPONENT; 20764 if ("DeviceUseRequest".equals(codeString)) 20765 return VersionIndependentResourceTypesAll.DEVICEUSEREQUEST; 20766 if ("DeviceUseStatement".equals(codeString)) 20767 return VersionIndependentResourceTypesAll.DEVICEUSESTATEMENT; 20768 if ("DiagnosticOrder".equals(codeString)) 20769 return VersionIndependentResourceTypesAll.DIAGNOSTICORDER; 20770 if ("DocumentManifest".equals(codeString)) 20771 return VersionIndependentResourceTypesAll.DOCUMENTMANIFEST; 20772 if ("EffectEvidenceSynthesis".equals(codeString)) 20773 return VersionIndependentResourceTypesAll.EFFECTEVIDENCESYNTHESIS; 20774 if ("EligibilityRequest".equals(codeString)) 20775 return VersionIndependentResourceTypesAll.ELIGIBILITYREQUEST; 20776 if ("EligibilityResponse".equals(codeString)) 20777 return VersionIndependentResourceTypesAll.ELIGIBILITYRESPONSE; 20778 if ("ExpansionProfile".equals(codeString)) 20779 return VersionIndependentResourceTypesAll.EXPANSIONPROFILE; 20780 if ("ImagingManifest".equals(codeString)) 20781 return VersionIndependentResourceTypesAll.IMAGINGMANIFEST; 20782 if ("ImagingObjectSelection".equals(codeString)) 20783 return VersionIndependentResourceTypesAll.IMAGINGOBJECTSELECTION; 20784 if ("Media".equals(codeString)) 20785 return VersionIndependentResourceTypesAll.MEDIA; 20786 if ("MedicationOrder".equals(codeString)) 20787 return VersionIndependentResourceTypesAll.MEDICATIONORDER; 20788 if ("MedicationUsage".equals(codeString)) 20789 return VersionIndependentResourceTypesAll.MEDICATIONUSAGE; 20790 if ("MedicinalProduct".equals(codeString)) 20791 return VersionIndependentResourceTypesAll.MEDICINALPRODUCT; 20792 if ("MedicinalProductAuthorization".equals(codeString)) 20793 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTAUTHORIZATION; 20794 if ("MedicinalProductContraindication".equals(codeString)) 20795 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTCONTRAINDICATION; 20796 if ("MedicinalProductIndication".equals(codeString)) 20797 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTINDICATION; 20798 if ("MedicinalProductIngredient".equals(codeString)) 20799 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTINGREDIENT; 20800 if ("MedicinalProductInteraction".equals(codeString)) 20801 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTINTERACTION; 20802 if ("MedicinalProductManufactured".equals(codeString)) 20803 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTMANUFACTURED; 20804 if ("MedicinalProductPackaged".equals(codeString)) 20805 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTPACKAGED; 20806 if ("MedicinalProductPharmaceutical".equals(codeString)) 20807 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTPHARMACEUTICAL; 20808 if ("MedicinalProductUndesirableEffect".equals(codeString)) 20809 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTUNDESIRABLEEFFECT; 20810 if ("Order".equals(codeString)) 20811 return VersionIndependentResourceTypesAll.ORDER; 20812 if ("OrderResponse".equals(codeString)) 20813 return VersionIndependentResourceTypesAll.ORDERRESPONSE; 20814 if ("ProcedureRequest".equals(codeString)) 20815 return VersionIndependentResourceTypesAll.PROCEDUREREQUEST; 20816 if ("ProcessRequest".equals(codeString)) 20817 return VersionIndependentResourceTypesAll.PROCESSREQUEST; 20818 if ("ProcessResponse".equals(codeString)) 20819 return VersionIndependentResourceTypesAll.PROCESSRESPONSE; 20820 if ("ReferralRequest".equals(codeString)) 20821 return VersionIndependentResourceTypesAll.REFERRALREQUEST; 20822 if ("RequestGroup".equals(codeString)) 20823 return VersionIndependentResourceTypesAll.REQUESTGROUP; 20824 if ("ResearchDefinition".equals(codeString)) 20825 return VersionIndependentResourceTypesAll.RESEARCHDEFINITION; 20826 if ("ResearchElementDefinition".equals(codeString)) 20827 return VersionIndependentResourceTypesAll.RESEARCHELEMENTDEFINITION; 20828 if ("RiskEvidenceSynthesis".equals(codeString)) 20829 return VersionIndependentResourceTypesAll.RISKEVIDENCESYNTHESIS; 20830 if ("Sequence".equals(codeString)) 20831 return VersionIndependentResourceTypesAll.SEQUENCE; 20832 if ("ServiceDefinition".equals(codeString)) 20833 return VersionIndependentResourceTypesAll.SERVICEDEFINITION; 20834 if ("SubstanceSpecification".equals(codeString)) 20835 return VersionIndependentResourceTypesAll.SUBSTANCESPECIFICATION; 20836 if ("MolecularDefinition".equals(codeString)) 20837 return VersionIndependentResourceTypesAll.MOLECULARDEFINITION; 20838 if ("ClinicalAssessment".equals(codeString)) 20839 return VersionIndependentResourceTypesAll.CLINICALASSESSMENT; 20840 throw new IllegalArgumentException("Unknown VersionIndependentResourceTypesAll code '"+codeString+"'"); 20841 } 20842 20843 public Enumeration<VersionIndependentResourceTypesAll> fromType(PrimitiveType<?> code) throws FHIRException { 20844 if (code == null) 20845 return null; 20846 if (code.isEmpty()) 20847 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.NULL, code); 20848 String codeString = ((PrimitiveType) code).asStringValue(); 20849 if (codeString == null || "".equals(codeString)) 20850 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.NULL, code); 20851 if ("Account".equals(codeString)) 20852 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ACCOUNT, code); 20853 if ("ActivityDefinition".equals(codeString)) 20854 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ACTIVITYDEFINITION, code); 20855 if ("ActorDefinition".equals(codeString)) 20856 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ACTORDEFINITION, code); 20857 if ("AdministrableProductDefinition".equals(codeString)) 20858 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ADMINISTRABLEPRODUCTDEFINITION, code); 20859 if ("AdverseEvent".equals(codeString)) 20860 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ADVERSEEVENT, code); 20861 if ("AllergyIntolerance".equals(codeString)) 20862 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ALLERGYINTOLERANCE, code); 20863 if ("Appointment".equals(codeString)) 20864 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.APPOINTMENT, code); 20865 if ("AppointmentResponse".equals(codeString)) 20866 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.APPOINTMENTRESPONSE, code); 20867 if ("ArtifactAssessment".equals(codeString)) 20868 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ARTIFACTASSESSMENT, code); 20869 if ("AuditEvent".equals(codeString)) 20870 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.AUDITEVENT, code); 20871 if ("Basic".equals(codeString)) 20872 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BASIC, code); 20873 if ("Binary".equals(codeString)) 20874 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BINARY, code); 20875 if ("BiologicallyDerivedProduct".equals(codeString)) 20876 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BIOLOGICALLYDERIVEDPRODUCT, code); 20877 if ("BiologicallyDerivedProductDispense".equals(codeString)) 20878 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BIOLOGICALLYDERIVEDPRODUCTDISPENSE, code); 20879 if ("BodyStructure".equals(codeString)) 20880 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BODYSTRUCTURE, code); 20881 if ("Bundle".equals(codeString)) 20882 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BUNDLE, code); 20883 if ("CanonicalResource".equals(codeString)) 20884 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CANONICALRESOURCE, code); 20885 if ("CapabilityStatement".equals(codeString)) 20886 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CAPABILITYSTATEMENT, code); 20887 if ("CarePlan".equals(codeString)) 20888 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CAREPLAN, code); 20889 if ("CareTeam".equals(codeString)) 20890 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CARETEAM, code); 20891 if ("ChargeItem".equals(codeString)) 20892 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CHARGEITEM, code); 20893 if ("ChargeItemDefinition".equals(codeString)) 20894 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CHARGEITEMDEFINITION, code); 20895 if ("Citation".equals(codeString)) 20896 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CITATION, code); 20897 if ("Claim".equals(codeString)) 20898 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CLAIM, code); 20899 if ("ClaimResponse".equals(codeString)) 20900 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CLAIMRESPONSE, code); 20901 if ("ClinicalImpression".equals(codeString)) 20902 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CLINICALIMPRESSION, code); 20903 if ("ClinicalUseDefinition".equals(codeString)) 20904 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CLINICALUSEDEFINITION, code); 20905 if ("CodeSystem".equals(codeString)) 20906 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CODESYSTEM, code); 20907 if ("Communication".equals(codeString)) 20908 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COMMUNICATION, code); 20909 if ("CommunicationRequest".equals(codeString)) 20910 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COMMUNICATIONREQUEST, code); 20911 if ("CompartmentDefinition".equals(codeString)) 20912 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COMPARTMENTDEFINITION, code); 20913 if ("Composition".equals(codeString)) 20914 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COMPOSITION, code); 20915 if ("ConceptMap".equals(codeString)) 20916 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CONCEPTMAP, code); 20917 if ("Condition".equals(codeString)) 20918 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CONDITION, code); 20919 if ("ConditionDefinition".equals(codeString)) 20920 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CONDITIONDEFINITION, code); 20921 if ("Consent".equals(codeString)) 20922 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CONSENT, code); 20923 if ("Contract".equals(codeString)) 20924 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CONTRACT, code); 20925 if ("Coverage".equals(codeString)) 20926 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COVERAGE, code); 20927 if ("CoverageEligibilityRequest".equals(codeString)) 20928 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COVERAGEELIGIBILITYREQUEST, code); 20929 if ("CoverageEligibilityResponse".equals(codeString)) 20930 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COVERAGEELIGIBILITYRESPONSE, code); 20931 if ("DetectedIssue".equals(codeString)) 20932 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DETECTEDISSUE, code); 20933 if ("Device".equals(codeString)) 20934 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICE, code); 20935 if ("DeviceAssociation".equals(codeString)) 20936 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEASSOCIATION, code); 20937 if ("DeviceDefinition".equals(codeString)) 20938 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEDEFINITION, code); 20939 if ("DeviceDispense".equals(codeString)) 20940 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEDISPENSE, code); 20941 if ("DeviceMetric".equals(codeString)) 20942 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEMETRIC, code); 20943 if ("DeviceRequest".equals(codeString)) 20944 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEREQUEST, code); 20945 if ("DeviceUsage".equals(codeString)) 20946 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEUSAGE, code); 20947 if ("DiagnosticReport".equals(codeString)) 20948 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DIAGNOSTICREPORT, code); 20949 if ("DocumentReference".equals(codeString)) 20950 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DOCUMENTREFERENCE, code); 20951 if ("DomainResource".equals(codeString)) 20952 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DOMAINRESOURCE, code); 20953 if ("Encounter".equals(codeString)) 20954 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ENCOUNTER, code); 20955 if ("EncounterHistory".equals(codeString)) 20956 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ENCOUNTERHISTORY, code); 20957 if ("Endpoint".equals(codeString)) 20958 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ENDPOINT, code); 20959 if ("EnrollmentRequest".equals(codeString)) 20960 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ENROLLMENTREQUEST, code); 20961 if ("EnrollmentResponse".equals(codeString)) 20962 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ENROLLMENTRESPONSE, code); 20963 if ("EpisodeOfCare".equals(codeString)) 20964 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EPISODEOFCARE, code); 20965 if ("EventDefinition".equals(codeString)) 20966 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EVENTDEFINITION, code); 20967 if ("Evidence".equals(codeString)) 20968 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EVIDENCE, code); 20969 if ("EvidenceReport".equals(codeString)) 20970 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EVIDENCEREPORT, code); 20971 if ("EvidenceVariable".equals(codeString)) 20972 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EVIDENCEVARIABLE, code); 20973 if ("ExampleScenario".equals(codeString)) 20974 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EXAMPLESCENARIO, code); 20975 if ("ExplanationOfBenefit".equals(codeString)) 20976 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EXPLANATIONOFBENEFIT, code); 20977 if ("FamilyMemberHistory".equals(codeString)) 20978 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.FAMILYMEMBERHISTORY, code); 20979 if ("Flag".equals(codeString)) 20980 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.FLAG, code); 20981 if ("FormularyItem".equals(codeString)) 20982 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.FORMULARYITEM, code); 20983 if ("GenomicStudy".equals(codeString)) 20984 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.GENOMICSTUDY, code); 20985 if ("Goal".equals(codeString)) 20986 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.GOAL, code); 20987 if ("GraphDefinition".equals(codeString)) 20988 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.GRAPHDEFINITION, code); 20989 if ("Group".equals(codeString)) 20990 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.GROUP, code); 20991 if ("GuidanceResponse".equals(codeString)) 20992 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.GUIDANCERESPONSE, code); 20993 if ("HealthcareService".equals(codeString)) 20994 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.HEALTHCARESERVICE, code); 20995 if ("ImagingSelection".equals(codeString)) 20996 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMAGINGSELECTION, code); 20997 if ("ImagingStudy".equals(codeString)) 20998 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMAGINGSTUDY, code); 20999 if ("Immunization".equals(codeString)) 21000 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMMUNIZATION, code); 21001 if ("ImmunizationEvaluation".equals(codeString)) 21002 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMMUNIZATIONEVALUATION, code); 21003 if ("ImmunizationRecommendation".equals(codeString)) 21004 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMMUNIZATIONRECOMMENDATION, code); 21005 if ("ImplementationGuide".equals(codeString)) 21006 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMPLEMENTATIONGUIDE, code); 21007 if ("Ingredient".equals(codeString)) 21008 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.INGREDIENT, code); 21009 if ("InsurancePlan".equals(codeString)) 21010 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.INSURANCEPLAN, code); 21011 if ("InventoryItem".equals(codeString)) 21012 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.INVENTORYITEM, code); 21013 if ("InventoryReport".equals(codeString)) 21014 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.INVENTORYREPORT, code); 21015 if ("Invoice".equals(codeString)) 21016 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.INVOICE, code); 21017 if ("Library".equals(codeString)) 21018 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.LIBRARY, code); 21019 if ("Linkage".equals(codeString)) 21020 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.LINKAGE, code); 21021 if ("List".equals(codeString)) 21022 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.LIST, code); 21023 if ("Location".equals(codeString)) 21024 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.LOCATION, code); 21025 if ("ManufacturedItemDefinition".equals(codeString)) 21026 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MANUFACTUREDITEMDEFINITION, code); 21027 if ("Measure".equals(codeString)) 21028 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEASURE, code); 21029 if ("MeasureReport".equals(codeString)) 21030 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEASUREREPORT, code); 21031 if ("Medication".equals(codeString)) 21032 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATION, code); 21033 if ("MedicationAdministration".equals(codeString)) 21034 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONADMINISTRATION, code); 21035 if ("MedicationDispense".equals(codeString)) 21036 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONDISPENSE, code); 21037 if ("MedicationKnowledge".equals(codeString)) 21038 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONKNOWLEDGE, code); 21039 if ("MedicationRequest".equals(codeString)) 21040 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONREQUEST, code); 21041 if ("MedicationStatement".equals(codeString)) 21042 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONSTATEMENT, code); 21043 if ("MedicinalProductDefinition".equals(codeString)) 21044 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTDEFINITION, code); 21045 if ("MessageDefinition".equals(codeString)) 21046 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MESSAGEDEFINITION, code); 21047 if ("MessageHeader".equals(codeString)) 21048 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MESSAGEHEADER, code); 21049 if ("MetadataResource".equals(codeString)) 21050 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.METADATARESOURCE, code); 21051 if ("MolecularSequence".equals(codeString)) 21052 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MOLECULARSEQUENCE, code); 21053 if ("NamingSystem".equals(codeString)) 21054 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.NAMINGSYSTEM, code); 21055 if ("NutritionIntake".equals(codeString)) 21056 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.NUTRITIONINTAKE, code); 21057 if ("NutritionOrder".equals(codeString)) 21058 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.NUTRITIONORDER, code); 21059 if ("NutritionProduct".equals(codeString)) 21060 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.NUTRITIONPRODUCT, code); 21061 if ("Observation".equals(codeString)) 21062 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.OBSERVATION, code); 21063 if ("ObservationDefinition".equals(codeString)) 21064 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.OBSERVATIONDEFINITION, code); 21065 if ("OperationDefinition".equals(codeString)) 21066 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.OPERATIONDEFINITION, code); 21067 if ("OperationOutcome".equals(codeString)) 21068 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.OPERATIONOUTCOME, code); 21069 if ("Organization".equals(codeString)) 21070 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ORGANIZATION, code); 21071 if ("OrganizationAffiliation".equals(codeString)) 21072 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ORGANIZATIONAFFILIATION, code); 21073 if ("PackagedProductDefinition".equals(codeString)) 21074 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PACKAGEDPRODUCTDEFINITION, code); 21075 if ("Parameters".equals(codeString)) 21076 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PARAMETERS, code); 21077 if ("Patient".equals(codeString)) 21078 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PATIENT, code); 21079 if ("PaymentNotice".equals(codeString)) 21080 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PAYMENTNOTICE, code); 21081 if ("PaymentReconciliation".equals(codeString)) 21082 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PAYMENTRECONCILIATION, code); 21083 if ("Permission".equals(codeString)) 21084 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PERMISSION, code); 21085 if ("Person".equals(codeString)) 21086 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PERSON, code); 21087 if ("PlanDefinition".equals(codeString)) 21088 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PLANDEFINITION, code); 21089 if ("Practitioner".equals(codeString)) 21090 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PRACTITIONER, code); 21091 if ("PractitionerRole".equals(codeString)) 21092 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PRACTITIONERROLE, code); 21093 if ("Procedure".equals(codeString)) 21094 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PROCEDURE, code); 21095 if ("Provenance".equals(codeString)) 21096 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PROVENANCE, code); 21097 if ("Questionnaire".equals(codeString)) 21098 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.QUESTIONNAIRE, code); 21099 if ("QuestionnaireResponse".equals(codeString)) 21100 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.QUESTIONNAIRERESPONSE, code); 21101 if ("RegulatedAuthorization".equals(codeString)) 21102 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.REGULATEDAUTHORIZATION, code); 21103 if ("RelatedPerson".equals(codeString)) 21104 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RELATEDPERSON, code); 21105 if ("RequestOrchestration".equals(codeString)) 21106 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.REQUESTORCHESTRATION, code); 21107 if ("Requirements".equals(codeString)) 21108 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.REQUIREMENTS, code); 21109 if ("ResearchStudy".equals(codeString)) 21110 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RESEARCHSTUDY, code); 21111 if ("ResearchSubject".equals(codeString)) 21112 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RESEARCHSUBJECT, code); 21113 if ("Resource".equals(codeString)) 21114 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RESOURCE, code); 21115 if ("RiskAssessment".equals(codeString)) 21116 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RISKASSESSMENT, code); 21117 if ("Schedule".equals(codeString)) 21118 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SCHEDULE, code); 21119 if ("SearchParameter".equals(codeString)) 21120 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SEARCHPARAMETER, code); 21121 if ("ServiceRequest".equals(codeString)) 21122 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SERVICEREQUEST, code); 21123 if ("Slot".equals(codeString)) 21124 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SLOT, code); 21125 if ("Specimen".equals(codeString)) 21126 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SPECIMEN, code); 21127 if ("SpecimenDefinition".equals(codeString)) 21128 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SPECIMENDEFINITION, code); 21129 if ("StructureDefinition".equals(codeString)) 21130 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.STRUCTUREDEFINITION, code); 21131 if ("StructureMap".equals(codeString)) 21132 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.STRUCTUREMAP, code); 21133 if ("Subscription".equals(codeString)) 21134 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSCRIPTION, code); 21135 if ("SubscriptionStatus".equals(codeString)) 21136 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSCRIPTIONSTATUS, code); 21137 if ("SubscriptionTopic".equals(codeString)) 21138 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSCRIPTIONTOPIC, code); 21139 if ("Substance".equals(codeString)) 21140 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCE, code); 21141 if ("SubstanceDefinition".equals(codeString)) 21142 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCEDEFINITION, code); 21143 if ("SubstanceNucleicAcid".equals(codeString)) 21144 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCENUCLEICACID, code); 21145 if ("SubstancePolymer".equals(codeString)) 21146 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCEPOLYMER, code); 21147 if ("SubstanceProtein".equals(codeString)) 21148 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCEPROTEIN, code); 21149 if ("SubstanceReferenceInformation".equals(codeString)) 21150 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCEREFERENCEINFORMATION, code); 21151 if ("SubstanceSourceMaterial".equals(codeString)) 21152 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCESOURCEMATERIAL, code); 21153 if ("SupplyDelivery".equals(codeString)) 21154 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUPPLYDELIVERY, code); 21155 if ("SupplyRequest".equals(codeString)) 21156 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUPPLYREQUEST, code); 21157 if ("Task".equals(codeString)) 21158 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.TASK, code); 21159 if ("TerminologyCapabilities".equals(codeString)) 21160 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.TERMINOLOGYCAPABILITIES, code); 21161 if ("TestPlan".equals(codeString)) 21162 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.TESTPLAN, code); 21163 if ("TestReport".equals(codeString)) 21164 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.TESTREPORT, code); 21165 if ("TestScript".equals(codeString)) 21166 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.TESTSCRIPT, code); 21167 if ("Transport".equals(codeString)) 21168 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.TRANSPORT, code); 21169 if ("ValueSet".equals(codeString)) 21170 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.VALUESET, code); 21171 if ("VerificationResult".equals(codeString)) 21172 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.VERIFICATIONRESULT, code); 21173 if ("VisionPrescription".equals(codeString)) 21174 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.VISIONPRESCRIPTION, code); 21175 if ("BodySite".equals(codeString)) 21176 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BODYSITE, code); 21177 if ("CatalogEntry".equals(codeString)) 21178 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CATALOGENTRY, code); 21179 if ("Conformance".equals(codeString)) 21180 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CONFORMANCE, code); 21181 if ("DataElement".equals(codeString)) 21182 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DATAELEMENT, code); 21183 if ("DeviceComponent".equals(codeString)) 21184 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICECOMPONENT, code); 21185 if ("DeviceUseRequest".equals(codeString)) 21186 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEUSEREQUEST, code); 21187 if ("DeviceUseStatement".equals(codeString)) 21188 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEUSESTATEMENT, code); 21189 if ("DiagnosticOrder".equals(codeString)) 21190 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DIAGNOSTICORDER, code); 21191 if ("DocumentManifest".equals(codeString)) 21192 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DOCUMENTMANIFEST, code); 21193 if ("EffectEvidenceSynthesis".equals(codeString)) 21194 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EFFECTEVIDENCESYNTHESIS, code); 21195 if ("EligibilityRequest".equals(codeString)) 21196 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ELIGIBILITYREQUEST, code); 21197 if ("EligibilityResponse".equals(codeString)) 21198 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ELIGIBILITYRESPONSE, code); 21199 if ("ExpansionProfile".equals(codeString)) 21200 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EXPANSIONPROFILE, code); 21201 if ("ImagingManifest".equals(codeString)) 21202 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMAGINGMANIFEST, code); 21203 if ("ImagingObjectSelection".equals(codeString)) 21204 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMAGINGOBJECTSELECTION, code); 21205 if ("Media".equals(codeString)) 21206 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDIA, code); 21207 if ("MedicationOrder".equals(codeString)) 21208 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONORDER, code); 21209 if ("MedicationUsage".equals(codeString)) 21210 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONUSAGE, code); 21211 if ("MedicinalProduct".equals(codeString)) 21212 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCT, code); 21213 if ("MedicinalProductAuthorization".equals(codeString)) 21214 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTAUTHORIZATION, code); 21215 if ("MedicinalProductContraindication".equals(codeString)) 21216 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTCONTRAINDICATION, code); 21217 if ("MedicinalProductIndication".equals(codeString)) 21218 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTINDICATION, code); 21219 if ("MedicinalProductIngredient".equals(codeString)) 21220 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTINGREDIENT, code); 21221 if ("MedicinalProductInteraction".equals(codeString)) 21222 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTINTERACTION, code); 21223 if ("MedicinalProductManufactured".equals(codeString)) 21224 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTMANUFACTURED, code); 21225 if ("MedicinalProductPackaged".equals(codeString)) 21226 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTPACKAGED, code); 21227 if ("MedicinalProductPharmaceutical".equals(codeString)) 21228 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTPHARMACEUTICAL, code); 21229 if ("MedicinalProductUndesirableEffect".equals(codeString)) 21230 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTUNDESIRABLEEFFECT, code); 21231 if ("Order".equals(codeString)) 21232 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ORDER, code); 21233 if ("OrderResponse".equals(codeString)) 21234 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ORDERRESPONSE, code); 21235 if ("ProcedureRequest".equals(codeString)) 21236 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PROCEDUREREQUEST, code); 21237 if ("ProcessRequest".equals(codeString)) 21238 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PROCESSREQUEST, code); 21239 if ("ProcessResponse".equals(codeString)) 21240 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PROCESSRESPONSE, code); 21241 if ("ReferralRequest".equals(codeString)) 21242 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.REFERRALREQUEST, code); 21243 if ("RequestGroup".equals(codeString)) 21244 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.REQUESTGROUP, code); 21245 if ("ResearchDefinition".equals(codeString)) 21246 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RESEARCHDEFINITION, code); 21247 if ("ResearchElementDefinition".equals(codeString)) 21248 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RESEARCHELEMENTDEFINITION, code); 21249 if ("RiskEvidenceSynthesis".equals(codeString)) 21250 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RISKEVIDENCESYNTHESIS, code); 21251 if ("Sequence".equals(codeString)) 21252 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SEQUENCE, code); 21253 if ("ServiceDefinition".equals(codeString)) 21254 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SERVICEDEFINITION, code); 21255 if ("SubstanceSpecification".equals(codeString)) 21256 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCESPECIFICATION, code); 21257 if ("MolecularDefinition".equals(codeString)) 21258 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MOLECULARDEFINITION, code); 21259 if ("ClinicalAssessment".equals(codeString)) 21260 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CLINICALASSESSMENT, code); 21261 throw new FHIRException("Unknown VersionIndependentResourceTypesAll code '"+codeString+"'"); 21262 } 21263 public String toCode(VersionIndependentResourceTypesAll code) { 21264 if (code == VersionIndependentResourceTypesAll.NULL) 21265 return null; 21266 if (code == VersionIndependentResourceTypesAll.ACCOUNT) 21267 return "Account"; 21268 if (code == VersionIndependentResourceTypesAll.ACTIVITYDEFINITION) 21269 return "ActivityDefinition"; 21270 if (code == VersionIndependentResourceTypesAll.ACTORDEFINITION) 21271 return "ActorDefinition"; 21272 if (code == VersionIndependentResourceTypesAll.ADMINISTRABLEPRODUCTDEFINITION) 21273 return "AdministrableProductDefinition"; 21274 if (code == VersionIndependentResourceTypesAll.ADVERSEEVENT) 21275 return "AdverseEvent"; 21276 if (code == VersionIndependentResourceTypesAll.ALLERGYINTOLERANCE) 21277 return "AllergyIntolerance"; 21278 if (code == VersionIndependentResourceTypesAll.APPOINTMENT) 21279 return "Appointment"; 21280 if (code == VersionIndependentResourceTypesAll.APPOINTMENTRESPONSE) 21281 return "AppointmentResponse"; 21282 if (code == VersionIndependentResourceTypesAll.ARTIFACTASSESSMENT) 21283 return "ArtifactAssessment"; 21284 if (code == VersionIndependentResourceTypesAll.AUDITEVENT) 21285 return "AuditEvent"; 21286 if (code == VersionIndependentResourceTypesAll.BASIC) 21287 return "Basic"; 21288 if (code == VersionIndependentResourceTypesAll.BINARY) 21289 return "Binary"; 21290 if (code == VersionIndependentResourceTypesAll.BIOLOGICALLYDERIVEDPRODUCT) 21291 return "BiologicallyDerivedProduct"; 21292 if (code == VersionIndependentResourceTypesAll.BIOLOGICALLYDERIVEDPRODUCTDISPENSE) 21293 return "BiologicallyDerivedProductDispense"; 21294 if (code == VersionIndependentResourceTypesAll.BODYSTRUCTURE) 21295 return "BodyStructure"; 21296 if (code == VersionIndependentResourceTypesAll.BUNDLE) 21297 return "Bundle"; 21298 if (code == VersionIndependentResourceTypesAll.CANONICALRESOURCE) 21299 return "CanonicalResource"; 21300 if (code == VersionIndependentResourceTypesAll.CAPABILITYSTATEMENT) 21301 return "CapabilityStatement"; 21302 if (code == VersionIndependentResourceTypesAll.CAREPLAN) 21303 return "CarePlan"; 21304 if (code == VersionIndependentResourceTypesAll.CARETEAM) 21305 return "CareTeam"; 21306 if (code == VersionIndependentResourceTypesAll.CHARGEITEM) 21307 return "ChargeItem"; 21308 if (code == VersionIndependentResourceTypesAll.CHARGEITEMDEFINITION) 21309 return "ChargeItemDefinition"; 21310 if (code == VersionIndependentResourceTypesAll.CITATION) 21311 return "Citation"; 21312 if (code == VersionIndependentResourceTypesAll.CLAIM) 21313 return "Claim"; 21314 if (code == VersionIndependentResourceTypesAll.CLAIMRESPONSE) 21315 return "ClaimResponse"; 21316 if (code == VersionIndependentResourceTypesAll.CLINICALIMPRESSION) 21317 return "ClinicalImpression"; 21318 if (code == VersionIndependentResourceTypesAll.CLINICALUSEDEFINITION) 21319 return "ClinicalUseDefinition"; 21320 if (code == VersionIndependentResourceTypesAll.CODESYSTEM) 21321 return "CodeSystem"; 21322 if (code == VersionIndependentResourceTypesAll.COMMUNICATION) 21323 return "Communication"; 21324 if (code == VersionIndependentResourceTypesAll.COMMUNICATIONREQUEST) 21325 return "CommunicationRequest"; 21326 if (code == VersionIndependentResourceTypesAll.COMPARTMENTDEFINITION) 21327 return "CompartmentDefinition"; 21328 if (code == VersionIndependentResourceTypesAll.COMPOSITION) 21329 return "Composition"; 21330 if (code == VersionIndependentResourceTypesAll.CONCEPTMAP) 21331 return "ConceptMap"; 21332 if (code == VersionIndependentResourceTypesAll.CONDITION) 21333 return "Condition"; 21334 if (code == VersionIndependentResourceTypesAll.CONDITIONDEFINITION) 21335 return "ConditionDefinition"; 21336 if (code == VersionIndependentResourceTypesAll.CONSENT) 21337 return "Consent"; 21338 if (code == VersionIndependentResourceTypesAll.CONTRACT) 21339 return "Contract"; 21340 if (code == VersionIndependentResourceTypesAll.COVERAGE) 21341 return "Coverage"; 21342 if (code == VersionIndependentResourceTypesAll.COVERAGEELIGIBILITYREQUEST) 21343 return "CoverageEligibilityRequest"; 21344 if (code == VersionIndependentResourceTypesAll.COVERAGEELIGIBILITYRESPONSE) 21345 return "CoverageEligibilityResponse"; 21346 if (code == VersionIndependentResourceTypesAll.DETECTEDISSUE) 21347 return "DetectedIssue"; 21348 if (code == VersionIndependentResourceTypesAll.DEVICE) 21349 return "Device"; 21350 if (code == VersionIndependentResourceTypesAll.DEVICEASSOCIATION) 21351 return "DeviceAssociation"; 21352 if (code == VersionIndependentResourceTypesAll.DEVICEDEFINITION) 21353 return "DeviceDefinition"; 21354 if (code == VersionIndependentResourceTypesAll.DEVICEDISPENSE) 21355 return "DeviceDispense"; 21356 if (code == VersionIndependentResourceTypesAll.DEVICEMETRIC) 21357 return "DeviceMetric"; 21358 if (code == VersionIndependentResourceTypesAll.DEVICEREQUEST) 21359 return "DeviceRequest"; 21360 if (code == VersionIndependentResourceTypesAll.DEVICEUSAGE) 21361 return "DeviceUsage"; 21362 if (code == VersionIndependentResourceTypesAll.DIAGNOSTICREPORT) 21363 return "DiagnosticReport"; 21364 if (code == VersionIndependentResourceTypesAll.DOCUMENTREFERENCE) 21365 return "DocumentReference"; 21366 if (code == VersionIndependentResourceTypesAll.DOMAINRESOURCE) 21367 return "DomainResource"; 21368 if (code == VersionIndependentResourceTypesAll.ENCOUNTER) 21369 return "Encounter"; 21370 if (code == VersionIndependentResourceTypesAll.ENCOUNTERHISTORY) 21371 return "EncounterHistory"; 21372 if (code == VersionIndependentResourceTypesAll.ENDPOINT) 21373 return "Endpoint"; 21374 if (code == VersionIndependentResourceTypesAll.ENROLLMENTREQUEST) 21375 return "EnrollmentRequest"; 21376 if (code == VersionIndependentResourceTypesAll.ENROLLMENTRESPONSE) 21377 return "EnrollmentResponse"; 21378 if (code == VersionIndependentResourceTypesAll.EPISODEOFCARE) 21379 return "EpisodeOfCare"; 21380 if (code == VersionIndependentResourceTypesAll.EVENTDEFINITION) 21381 return "EventDefinition"; 21382 if (code == VersionIndependentResourceTypesAll.EVIDENCE) 21383 return "Evidence"; 21384 if (code == VersionIndependentResourceTypesAll.EVIDENCEREPORT) 21385 return "EvidenceReport"; 21386 if (code == VersionIndependentResourceTypesAll.EVIDENCEVARIABLE) 21387 return "EvidenceVariable"; 21388 if (code == VersionIndependentResourceTypesAll.EXAMPLESCENARIO) 21389 return "ExampleScenario"; 21390 if (code == VersionIndependentResourceTypesAll.EXPLANATIONOFBENEFIT) 21391 return "ExplanationOfBenefit"; 21392 if (code == VersionIndependentResourceTypesAll.FAMILYMEMBERHISTORY) 21393 return "FamilyMemberHistory"; 21394 if (code == VersionIndependentResourceTypesAll.FLAG) 21395 return "Flag"; 21396 if (code == VersionIndependentResourceTypesAll.FORMULARYITEM) 21397 return "FormularyItem"; 21398 if (code == VersionIndependentResourceTypesAll.GENOMICSTUDY) 21399 return "GenomicStudy"; 21400 if (code == VersionIndependentResourceTypesAll.GOAL) 21401 return "Goal"; 21402 if (code == VersionIndependentResourceTypesAll.GRAPHDEFINITION) 21403 return "GraphDefinition"; 21404 if (code == VersionIndependentResourceTypesAll.GROUP) 21405 return "Group"; 21406 if (code == VersionIndependentResourceTypesAll.GUIDANCERESPONSE) 21407 return "GuidanceResponse"; 21408 if (code == VersionIndependentResourceTypesAll.HEALTHCARESERVICE) 21409 return "HealthcareService"; 21410 if (code == VersionIndependentResourceTypesAll.IMAGINGSELECTION) 21411 return "ImagingSelection"; 21412 if (code == VersionIndependentResourceTypesAll.IMAGINGSTUDY) 21413 return "ImagingStudy"; 21414 if (code == VersionIndependentResourceTypesAll.IMMUNIZATION) 21415 return "Immunization"; 21416 if (code == VersionIndependentResourceTypesAll.IMMUNIZATIONEVALUATION) 21417 return "ImmunizationEvaluation"; 21418 if (code == VersionIndependentResourceTypesAll.IMMUNIZATIONRECOMMENDATION) 21419 return "ImmunizationRecommendation"; 21420 if (code == VersionIndependentResourceTypesAll.IMPLEMENTATIONGUIDE) 21421 return "ImplementationGuide"; 21422 if (code == VersionIndependentResourceTypesAll.INGREDIENT) 21423 return "Ingredient"; 21424 if (code == VersionIndependentResourceTypesAll.INSURANCEPLAN) 21425 return "InsurancePlan"; 21426 if (code == VersionIndependentResourceTypesAll.INVENTORYITEM) 21427 return "InventoryItem"; 21428 if (code == VersionIndependentResourceTypesAll.INVENTORYREPORT) 21429 return "InventoryReport"; 21430 if (code == VersionIndependentResourceTypesAll.INVOICE) 21431 return "Invoice"; 21432 if (code == VersionIndependentResourceTypesAll.LIBRARY) 21433 return "Library"; 21434 if (code == VersionIndependentResourceTypesAll.LINKAGE) 21435 return "Linkage"; 21436 if (code == VersionIndependentResourceTypesAll.LIST) 21437 return "List"; 21438 if (code == VersionIndependentResourceTypesAll.LOCATION) 21439 return "Location"; 21440 if (code == VersionIndependentResourceTypesAll.MANUFACTUREDITEMDEFINITION) 21441 return "ManufacturedItemDefinition"; 21442 if (code == VersionIndependentResourceTypesAll.MEASURE) 21443 return "Measure"; 21444 if (code == VersionIndependentResourceTypesAll.MEASUREREPORT) 21445 return "MeasureReport"; 21446 if (code == VersionIndependentResourceTypesAll.MEDICATION) 21447 return "Medication"; 21448 if (code == VersionIndependentResourceTypesAll.MEDICATIONADMINISTRATION) 21449 return "MedicationAdministration"; 21450 if (code == VersionIndependentResourceTypesAll.MEDICATIONDISPENSE) 21451 return "MedicationDispense"; 21452 if (code == VersionIndependentResourceTypesAll.MEDICATIONKNOWLEDGE) 21453 return "MedicationKnowledge"; 21454 if (code == VersionIndependentResourceTypesAll.MEDICATIONREQUEST) 21455 return "MedicationRequest"; 21456 if (code == VersionIndependentResourceTypesAll.MEDICATIONSTATEMENT) 21457 return "MedicationStatement"; 21458 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTDEFINITION) 21459 return "MedicinalProductDefinition"; 21460 if (code == VersionIndependentResourceTypesAll.MESSAGEDEFINITION) 21461 return "MessageDefinition"; 21462 if (code == VersionIndependentResourceTypesAll.MESSAGEHEADER) 21463 return "MessageHeader"; 21464 if (code == VersionIndependentResourceTypesAll.METADATARESOURCE) 21465 return "MetadataResource"; 21466 if (code == VersionIndependentResourceTypesAll.MOLECULARSEQUENCE) 21467 return "MolecularSequence"; 21468 if (code == VersionIndependentResourceTypesAll.NAMINGSYSTEM) 21469 return "NamingSystem"; 21470 if (code == VersionIndependentResourceTypesAll.NUTRITIONINTAKE) 21471 return "NutritionIntake"; 21472 if (code == VersionIndependentResourceTypesAll.NUTRITIONORDER) 21473 return "NutritionOrder"; 21474 if (code == VersionIndependentResourceTypesAll.NUTRITIONPRODUCT) 21475 return "NutritionProduct"; 21476 if (code == VersionIndependentResourceTypesAll.OBSERVATION) 21477 return "Observation"; 21478 if (code == VersionIndependentResourceTypesAll.OBSERVATIONDEFINITION) 21479 return "ObservationDefinition"; 21480 if (code == VersionIndependentResourceTypesAll.OPERATIONDEFINITION) 21481 return "OperationDefinition"; 21482 if (code == VersionIndependentResourceTypesAll.OPERATIONOUTCOME) 21483 return "OperationOutcome"; 21484 if (code == VersionIndependentResourceTypesAll.ORGANIZATION) 21485 return "Organization"; 21486 if (code == VersionIndependentResourceTypesAll.ORGANIZATIONAFFILIATION) 21487 return "OrganizationAffiliation"; 21488 if (code == VersionIndependentResourceTypesAll.PACKAGEDPRODUCTDEFINITION) 21489 return "PackagedProductDefinition"; 21490 if (code == VersionIndependentResourceTypesAll.PARAMETERS) 21491 return "Parameters"; 21492 if (code == VersionIndependentResourceTypesAll.PATIENT) 21493 return "Patient"; 21494 if (code == VersionIndependentResourceTypesAll.PAYMENTNOTICE) 21495 return "PaymentNotice"; 21496 if (code == VersionIndependentResourceTypesAll.PAYMENTRECONCILIATION) 21497 return "PaymentReconciliation"; 21498 if (code == VersionIndependentResourceTypesAll.PERMISSION) 21499 return "Permission"; 21500 if (code == VersionIndependentResourceTypesAll.PERSON) 21501 return "Person"; 21502 if (code == VersionIndependentResourceTypesAll.PLANDEFINITION) 21503 return "PlanDefinition"; 21504 if (code == VersionIndependentResourceTypesAll.PRACTITIONER) 21505 return "Practitioner"; 21506 if (code == VersionIndependentResourceTypesAll.PRACTITIONERROLE) 21507 return "PractitionerRole"; 21508 if (code == VersionIndependentResourceTypesAll.PROCEDURE) 21509 return "Procedure"; 21510 if (code == VersionIndependentResourceTypesAll.PROVENANCE) 21511 return "Provenance"; 21512 if (code == VersionIndependentResourceTypesAll.QUESTIONNAIRE) 21513 return "Questionnaire"; 21514 if (code == VersionIndependentResourceTypesAll.QUESTIONNAIRERESPONSE) 21515 return "QuestionnaireResponse"; 21516 if (code == VersionIndependentResourceTypesAll.REGULATEDAUTHORIZATION) 21517 return "RegulatedAuthorization"; 21518 if (code == VersionIndependentResourceTypesAll.RELATEDPERSON) 21519 return "RelatedPerson"; 21520 if (code == VersionIndependentResourceTypesAll.REQUESTORCHESTRATION) 21521 return "RequestOrchestration"; 21522 if (code == VersionIndependentResourceTypesAll.REQUIREMENTS) 21523 return "Requirements"; 21524 if (code == VersionIndependentResourceTypesAll.RESEARCHSTUDY) 21525 return "ResearchStudy"; 21526 if (code == VersionIndependentResourceTypesAll.RESEARCHSUBJECT) 21527 return "ResearchSubject"; 21528 if (code == VersionIndependentResourceTypesAll.RESOURCE) 21529 return "Resource"; 21530 if (code == VersionIndependentResourceTypesAll.RISKASSESSMENT) 21531 return "RiskAssessment"; 21532 if (code == VersionIndependentResourceTypesAll.SCHEDULE) 21533 return "Schedule"; 21534 if (code == VersionIndependentResourceTypesAll.SEARCHPARAMETER) 21535 return "SearchParameter"; 21536 if (code == VersionIndependentResourceTypesAll.SERVICEREQUEST) 21537 return "ServiceRequest"; 21538 if (code == VersionIndependentResourceTypesAll.SLOT) 21539 return "Slot"; 21540 if (code == VersionIndependentResourceTypesAll.SPECIMEN) 21541 return "Specimen"; 21542 if (code == VersionIndependentResourceTypesAll.SPECIMENDEFINITION) 21543 return "SpecimenDefinition"; 21544 if (code == VersionIndependentResourceTypesAll.STRUCTUREDEFINITION) 21545 return "StructureDefinition"; 21546 if (code == VersionIndependentResourceTypesAll.STRUCTUREMAP) 21547 return "StructureMap"; 21548 if (code == VersionIndependentResourceTypesAll.SUBSCRIPTION) 21549 return "Subscription"; 21550 if (code == VersionIndependentResourceTypesAll.SUBSCRIPTIONSTATUS) 21551 return "SubscriptionStatus"; 21552 if (code == VersionIndependentResourceTypesAll.SUBSCRIPTIONTOPIC) 21553 return "SubscriptionTopic"; 21554 if (code == VersionIndependentResourceTypesAll.SUBSTANCE) 21555 return "Substance"; 21556 if (code == VersionIndependentResourceTypesAll.SUBSTANCEDEFINITION) 21557 return "SubstanceDefinition"; 21558 if (code == VersionIndependentResourceTypesAll.SUBSTANCENUCLEICACID) 21559 return "SubstanceNucleicAcid"; 21560 if (code == VersionIndependentResourceTypesAll.SUBSTANCEPOLYMER) 21561 return "SubstancePolymer"; 21562 if (code == VersionIndependentResourceTypesAll.SUBSTANCEPROTEIN) 21563 return "SubstanceProtein"; 21564 if (code == VersionIndependentResourceTypesAll.SUBSTANCEREFERENCEINFORMATION) 21565 return "SubstanceReferenceInformation"; 21566 if (code == VersionIndependentResourceTypesAll.SUBSTANCESOURCEMATERIAL) 21567 return "SubstanceSourceMaterial"; 21568 if (code == VersionIndependentResourceTypesAll.SUPPLYDELIVERY) 21569 return "SupplyDelivery"; 21570 if (code == VersionIndependentResourceTypesAll.SUPPLYREQUEST) 21571 return "SupplyRequest"; 21572 if (code == VersionIndependentResourceTypesAll.TASK) 21573 return "Task"; 21574 if (code == VersionIndependentResourceTypesAll.TERMINOLOGYCAPABILITIES) 21575 return "TerminologyCapabilities"; 21576 if (code == VersionIndependentResourceTypesAll.TESTPLAN) 21577 return "TestPlan"; 21578 if (code == VersionIndependentResourceTypesAll.TESTREPORT) 21579 return "TestReport"; 21580 if (code == VersionIndependentResourceTypesAll.TESTSCRIPT) 21581 return "TestScript"; 21582 if (code == VersionIndependentResourceTypesAll.TRANSPORT) 21583 return "Transport"; 21584 if (code == VersionIndependentResourceTypesAll.VALUESET) 21585 return "ValueSet"; 21586 if (code == VersionIndependentResourceTypesAll.VERIFICATIONRESULT) 21587 return "VerificationResult"; 21588 if (code == VersionIndependentResourceTypesAll.VISIONPRESCRIPTION) 21589 return "VisionPrescription"; 21590 if (code == VersionIndependentResourceTypesAll.BODYSITE) 21591 return "BodySite"; 21592 if (code == VersionIndependentResourceTypesAll.CATALOGENTRY) 21593 return "CatalogEntry"; 21594 if (code == VersionIndependentResourceTypesAll.CONFORMANCE) 21595 return "Conformance"; 21596 if (code == VersionIndependentResourceTypesAll.DATAELEMENT) 21597 return "DataElement"; 21598 if (code == VersionIndependentResourceTypesAll.DEVICECOMPONENT) 21599 return "DeviceComponent"; 21600 if (code == VersionIndependentResourceTypesAll.DEVICEUSEREQUEST) 21601 return "DeviceUseRequest"; 21602 if (code == VersionIndependentResourceTypesAll.DEVICEUSESTATEMENT) 21603 return "DeviceUseStatement"; 21604 if (code == VersionIndependentResourceTypesAll.DIAGNOSTICORDER) 21605 return "DiagnosticOrder"; 21606 if (code == VersionIndependentResourceTypesAll.DOCUMENTMANIFEST) 21607 return "DocumentManifest"; 21608 if (code == VersionIndependentResourceTypesAll.EFFECTEVIDENCESYNTHESIS) 21609 return "EffectEvidenceSynthesis"; 21610 if (code == VersionIndependentResourceTypesAll.ELIGIBILITYREQUEST) 21611 return "EligibilityRequest"; 21612 if (code == VersionIndependentResourceTypesAll.ELIGIBILITYRESPONSE) 21613 return "EligibilityResponse"; 21614 if (code == VersionIndependentResourceTypesAll.EXPANSIONPROFILE) 21615 return "ExpansionProfile"; 21616 if (code == VersionIndependentResourceTypesAll.IMAGINGMANIFEST) 21617 return "ImagingManifest"; 21618 if (code == VersionIndependentResourceTypesAll.IMAGINGOBJECTSELECTION) 21619 return "ImagingObjectSelection"; 21620 if (code == VersionIndependentResourceTypesAll.MEDIA) 21621 return "Media"; 21622 if (code == VersionIndependentResourceTypesAll.MEDICATIONORDER) 21623 return "MedicationOrder"; 21624 if (code == VersionIndependentResourceTypesAll.MEDICATIONUSAGE) 21625 return "MedicationUsage"; 21626 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCT) 21627 return "MedicinalProduct"; 21628 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTAUTHORIZATION) 21629 return "MedicinalProductAuthorization"; 21630 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTCONTRAINDICATION) 21631 return "MedicinalProductContraindication"; 21632 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTINDICATION) 21633 return "MedicinalProductIndication"; 21634 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTINGREDIENT) 21635 return "MedicinalProductIngredient"; 21636 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTINTERACTION) 21637 return "MedicinalProductInteraction"; 21638 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTMANUFACTURED) 21639 return "MedicinalProductManufactured"; 21640 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTPACKAGED) 21641 return "MedicinalProductPackaged"; 21642 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTPHARMACEUTICAL) 21643 return "MedicinalProductPharmaceutical"; 21644 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTUNDESIRABLEEFFECT) 21645 return "MedicinalProductUndesirableEffect"; 21646 if (code == VersionIndependentResourceTypesAll.ORDER) 21647 return "Order"; 21648 if (code == VersionIndependentResourceTypesAll.ORDERRESPONSE) 21649 return "OrderResponse"; 21650 if (code == VersionIndependentResourceTypesAll.PROCEDUREREQUEST) 21651 return "ProcedureRequest"; 21652 if (code == VersionIndependentResourceTypesAll.PROCESSREQUEST) 21653 return "ProcessRequest"; 21654 if (code == VersionIndependentResourceTypesAll.PROCESSRESPONSE) 21655 return "ProcessResponse"; 21656 if (code == VersionIndependentResourceTypesAll.REFERRALREQUEST) 21657 return "ReferralRequest"; 21658 if (code == VersionIndependentResourceTypesAll.REQUESTGROUP) 21659 return "RequestGroup"; 21660 if (code == VersionIndependentResourceTypesAll.RESEARCHDEFINITION) 21661 return "ResearchDefinition"; 21662 if (code == VersionIndependentResourceTypesAll.RESEARCHELEMENTDEFINITION) 21663 return "ResearchElementDefinition"; 21664 if (code == VersionIndependentResourceTypesAll.RISKEVIDENCESYNTHESIS) 21665 return "RiskEvidenceSynthesis"; 21666 if (code == VersionIndependentResourceTypesAll.SEQUENCE) 21667 return "Sequence"; 21668 if (code == VersionIndependentResourceTypesAll.SERVICEDEFINITION) 21669 return "ServiceDefinition"; 21670 if (code == VersionIndependentResourceTypesAll.SUBSTANCESPECIFICATION) 21671 return "SubstanceSpecification"; 21672 if (code == VersionIndependentResourceTypesAll.MOLECULARDEFINITION) 21673 return "MolecularDefinition"; 21674 return "?"; 21675 } 21676 public String toSystem(VersionIndependentResourceTypesAll code) { 21677 return code.getSystem(); 21678 } 21679 } 21680 21681 21682} 21683