001package org.hl7.fhir.r5.model; 002 003 004/* 005 Copyright (c) 2011+, HL7, Inc. 006 All rights reserved. 007 008 Redistribution and use in source and binary forms, with or without modification, \ 009 are permitted provided that the following conditions are met: 010 011 * Redistributions of source code must retain the above copyright notice, this \ 012 list of conditions and the following disclaimer. 013 * Redistributions in binary form must reproduce the above copyright notice, \ 014 this list of conditions and the following disclaimer in the documentation \ 015 and/or other materials provided with the distribution. 016 * Neither the name of HL7 nor the names of its contributors may be used to 017 endorse or promote products derived from this software without specific 018 prior written permission. 019 020 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \ 021 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \ 022 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \ 023 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \ 024 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \ 025 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \ 026 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \ 027 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \ 028 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \ 029 POSSIBILITY OF SUCH DAMAGE. 030 */ 031 032// Generated on Thu, Mar 23, 2023 19:59+1100 for FHIR v5.0.0 033 034 035import org.hl7.fhir.instance.model.api.*; 036import org.hl7.fhir.utilities.Utilities; 037import org.hl7.fhir.exceptions.FHIRException; 038 039public class Enumerations { 040 041// In here: 042// ActionCardinalityBehavior: Defines behavior for an action or a group for how many times that item may be repeated.[PlanDefinition, RequestOrchestration] 043// ActionConditionKind: Defines the kinds of conditions that can appear on actions.[PlanDefinition, RequestOrchestration] 044// ActionGroupingBehavior: Defines organization behavior of a group.[PlanDefinition, RequestOrchestration] 045// ActionParticipantType: The type of participant for the action.[ActivityDefinition, PlanDefinition, RequestOrchestration] 046// ActionPrecheckBehavior: Defines selection frequency behavior for an action or group.[PlanDefinition, RequestOrchestration] 047// ActionRelationshipType: Defines the types of relationships between actions.[PlanDefinition, RequestOrchestration] 048// ActionRequiredBehavior: Defines expectations around whether an action or action group is required.[PlanDefinition, RequestOrchestration] 049// ActionSelectionBehavior: Defines selection behavior of a group.[PlanDefinition, RequestOrchestration] 050// AdministrativeGender: The gender of a person used for administrative purposes.[ObservationDefinition, Patient, Person, Practitioner, RelatedPerson] 051// AllLanguages: This value set includes all possible codes from BCP-47 (see http://tools.ietf.org/html/bcp47)[Account, ActivityDefinition, ActorDefinition, AdministrableProductDefinition, AdverseEvent, AllergyIntolerance, Appointment, AppointmentResponse, ArtifactAssessment, Attachment, AuditEvent, Basic, Binary, BiologicallyDerivedProduct, BiologicallyDerivedProductDispense, BodyStructure, Bundle, CanonicalResource, CapabilityStatement, CarePlan, CareTeam, ChargeItem, ChargeItemDefinition, Citation, Claim, ClaimResponse, ClinicalImpression, ClinicalUseDefinition, CodeSystem, Communication, CommunicationRequest, CompartmentDefinition, Composition, ConceptMap, Condition, ConditionDefinition, Consent, Contract, Coverage, CoverageEligibilityRequest, CoverageEligibilityResponse, DetectedIssue, Device, DeviceAssociation, DeviceDefinition, DeviceDispense, DeviceMetric, DeviceRequest, DeviceUsage, DiagnosticReport, DocumentReference, DomainResource, Encounter, EncounterHistory, Endpoint, EnrollmentRequest, EnrollmentResponse, EpisodeOfCare, EventDefinition, Evidence, EvidenceReport, EvidenceVariable, ExampleScenario, ExplanationOfBenefit, FamilyMemberHistory, Flag, FormularyItem, GenomicStudy, Goal, GraphDefinition, Group, GuidanceResponse, HealthcareService, ImagingSelection, ImagingStudy, Immunization, ImmunizationEvaluation, ImmunizationRecommendation, ImplementationGuide, Ingredient, InsurancePlan, InventoryItem, InventoryReport, Invoice, Library, Linkage, List, Location, ManufacturedItemDefinition, Measure, MeasureReport, Medication, MedicationAdministration, MedicationDispense, MedicationKnowledge, MedicationRequest, MedicationStatement, MedicinalProductDefinition, MessageDefinition, MessageHeader, MetadataResource, MolecularSequence, NamingSystem, NutritionIntake, NutritionOrder, NutritionProduct, Observation, ObservationDefinition, OperationDefinition, OperationOutcome, Organization, OrganizationAffiliation, PackagedProductDefinition, Parameters, Patient, PaymentNotice, PaymentReconciliation, Permission, Person, PlanDefinition, Practitioner, PractitionerRole, Procedure, Provenance, Questionnaire, QuestionnaireResponse, RegulatedAuthorization, RelatedPerson, RequestOrchestration, Requirements, ResearchStudy, ResearchSubject, Resource, RiskAssessment, Schedule, SearchParameter, ServiceRequest, Slot, Specimen, SpecimenDefinition, StructureDefinition, StructureMap, Subscription, SubscriptionStatus, SubscriptionTopic, Substance, SubstanceDefinition, SubstanceNucleicAcid, SubstancePolymer, SubstanceProtein, SubstanceReferenceInformation, SubstanceSourceMaterial, SupplyDelivery, SupplyRequest, Task, TerminologyCapabilities, TestPlan, TestReport, TestScript, Transport, ValueSet, VerificationResult, VisionPrescription] 052// BindingStrength: Indication of the degree of conformance expectations associated with a binding.[ElementDefinition, OperationDefinition] 053// CapabilityStatementKind: How a capability statement is intended to be used.[CapabilityStatement, TerminologyCapabilities] 054// ClaimProcessingCodes: This value set includes Claim Processing Outcome codes.[ClaimResponse, ExplanationOfBenefit] 055// CodeSystemContentMode: The extent of the content of the code system (the concepts and codes it defines) are represented in a code system resource.[CodeSystem, TerminologyCapabilities] 056// CommonLanguages: This value set includes common codes from BCP-47 (see http://tools.ietf.org/html/bcp47)[InventoryItem, TerminologyCapabilities] 057// CompartmentType: Which type a compartment definition describes.[CompartmentDefinition, GraphDefinition] 058// CompositionStatus: The workflow/clinical status of the composition.[Composition, DocumentReference] 059// ConceptMapRelationship: The relationship between concepts.[ConceptMap] 060// ConsentDataMeaning: How a resource reference is interpreted when testing consent restrictions.[Consent, Permission] 061// ConsentProvisionType: How a rule statement is applied, such as adding additional consent or removing consent.[Consent, Permission] 062// Currencies: Currency codes from ISO 4217 (see https://www.iso.org/iso-4217-currency-codes.html)[Account, Money] 063// DaysOfWeek: The days of the week.[Appointment, Availability, Timing] 064// DeviceNameType: The type of name the device is referred by.[Device, DeviceDefinition] 065// EncounterStatus: Current state of the encounter.[Encounter, EncounterHistory] 066// EventStatus: Codes identifying the lifecycle stage of an event.[ClinicalImpression, Communication, NutritionIntake, Procedure] 067// EvidenceVariableHandling: The handling of the variable in statistical analysis for exposures or outcomes (E.g. Dichotomous, Continuous, Descriptive).[Evidence, EvidenceVariable] 068// ExampleScenarioActorType: The type of actor - system or human.[ActorDefinition, ExampleScenario] 069// FHIRTypes: All FHIR types[DataRequirement, Measure, OperationDefinition, ParameterDefinition] 070// FHIRVersion: All published FHIR Versions.[CapabilityStatement, ImplementationGuide, StructureDefinition] 071// FilterOperator: The kind of operation to perform as a part of a property based filter.[CodeSystem, ValueSet] 072// FinancialResourceStatusCodes: This value set includes Status codes.[Claim, ClaimResponse, Coverage, CoverageEligibilityRequest, CoverageEligibilityResponse, EnrollmentRequest, EnrollmentResponse, PaymentNotice, PaymentReconciliation, VisionPrescription] 073// ListMode: The processing mode that applies to this list.[EvidenceReport, List] 074// MeasureImprovementNotation: Observation values that indicate what change in a measurement value or score is indicative of an improvement in the measured item or scored issue.[Measure, MeasureReport] 075// MimeTypes: This value set includes all possible codes from BCP-13 (see http://tools.ietf.org/html/bcp13)[Attachment, Binary, CapabilityStatement, ElementDefinition, Endpoint, Signature, Subscription, TestScript] 076// ObservationStatus: Codes providing the status of an observation.[Observation, RiskAssessment] 077// OperationParameterUse: Whether an operation parameter is an input or an output parameter.[OperationDefinition, ParameterDefinition] 078// PublicationStatus: The lifecycle status of an artifact.[ActivityDefinition, ActorDefinition, AdministrableProductDefinition, CanonicalResource, CapabilityStatement, ChargeItemDefinition, Citation, CodeSystem, CompartmentDefinition, ConceptMap, ConditionDefinition, EventDefinition, Evidence, EvidenceReport, EvidenceVariable, ExampleScenario, GraphDefinition, ImplementationGuide, Ingredient, InsurancePlan, Library, ManufacturedItemDefinition, Measure, MessageDefinition, MetadataResource, NamingSystem, ObservationDefinition, OperationDefinition, PlanDefinition, Questionnaire, RelatedArtifact, Requirements, ResearchStudy, ResearchSubject, SearchParameter, SpecimenDefinition, StructureDefinition, StructureMap, SubscriptionTopic, TerminologyCapabilities, TestPlan, TestScript, ValueSet] 079// QuantityComparator: How the Quantity should be understood and represented.[Age, Count, Distance, Duration, Quantity] 080// RequestIntent: Codes indicating the degree of authority/intentionality associated with a request.[ActivityDefinition, CommunicationRequest, DeviceRequest, NutritionOrder, RequestOrchestration, ServiceRequest] 081// RequestPriority: Identifies the level of importance to be assigned to actioning the request.[ActivityDefinition, Communication, CommunicationRequest, DeviceRequest, MedicationRequest, NutritionOrder, PlanDefinition, RequestOrchestration, ServiceRequest, SupplyRequest, Task, Transport] 082// RequestStatus: Codes identifying the lifecycle stage of a request.[CarePlan, CommunicationRequest, DeviceRequest, NutritionOrder, RequestOrchestration, ServiceRequest] 083// ResourceTypeEnum: Concrete FHIR Resource Types[CapabilityStatement, CompartmentDefinition, ImplementationGuide, MessageDefinition, Questionnaire] 084// SearchComparator: What Search Comparator Codes are supported in search.[SearchParameter, Subscription, SubscriptionTopic] 085// SearchModifierCode: A supported modifier for a search parameter.[SearchParameter, Subscription, SubscriptionTopic] 086// SearchParamType: Data types allowed to be used for search parameters.[CapabilityStatement, OperationDefinition, SearchParameter] 087// SubscriptionStatusCodes: State values for FHIR Subscriptions.[Subscription, SubscriptionStatus] 088// Use: The purpose of the Claim: predetermination, preauthorization, claim.[Claim, ClaimResponse, ExplanationOfBenefit] 089// VersionIndependentResourceTypesAll: Current and past FHIR resource types (deleted or renamed), including abstract types[GraphDefinition, OperationDefinition, SearchParameter] 090 091 092 public enum ActionCardinalityBehavior { 093 /** 094 * The action may only be selected one time. 095 */ 096 SINGLE, 097 /** 098 * The action may be selected multiple times. 099 */ 100 MULTIPLE, 101 /** 102 * added to help the parsers 103 */ 104 NULL; 105 public static ActionCardinalityBehavior fromCode(String codeString) throws FHIRException { 106 if (codeString == null || "".equals(codeString)) 107 return null; 108 if ("single".equals(codeString)) 109 return SINGLE; 110 if ("multiple".equals(codeString)) 111 return MULTIPLE; 112 throw new FHIRException("Unknown ActionCardinalityBehavior code '"+codeString+"'"); 113 } 114 public static boolean isValidCode(String codeString) { 115 if (codeString == null || "".equals(codeString)) 116 return false; 117 return Utilities.existsInList(codeString, "single", "multiple"); 118 } 119 public String toCode() { 120 switch (this) { 121 case SINGLE: return "single"; 122 case MULTIPLE: return "multiple"; 123 case NULL: return null; 124 default: return "?"; 125 } 126 } 127 public String getSystem() { 128 switch (this) { 129 case SINGLE: return "http://hl7.org/fhir/action-cardinality-behavior"; 130 case MULTIPLE: return "http://hl7.org/fhir/action-cardinality-behavior"; 131 case NULL: return null; 132 default: return "?"; 133 } 134 } 135 public String getDefinition() { 136 switch (this) { 137 case SINGLE: return "The action may only be selected one time."; 138 case MULTIPLE: return "The action may be selected multiple times."; 139 case NULL: return null; 140 default: return "?"; 141 } 142 } 143 public String getDisplay() { 144 switch (this) { 145 case SINGLE: return "Single"; 146 case MULTIPLE: return "Multiple"; 147 case NULL: return null; 148 default: return "?"; 149 } 150 } 151 } 152 153 public static class ActionCardinalityBehaviorEnumFactory implements EnumFactory<ActionCardinalityBehavior> { 154 public ActionCardinalityBehavior fromCode(String codeString) throws IllegalArgumentException { 155 if (codeString == null || "".equals(codeString)) 156 if (codeString == null || "".equals(codeString)) 157 return null; 158 if ("single".equals(codeString)) 159 return ActionCardinalityBehavior.SINGLE; 160 if ("multiple".equals(codeString)) 161 return ActionCardinalityBehavior.MULTIPLE; 162 throw new IllegalArgumentException("Unknown ActionCardinalityBehavior code '"+codeString+"'"); 163 } 164 165 public Enumeration<ActionCardinalityBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 166 if (code == null) 167 return null; 168 if (code.isEmpty()) 169 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.NULL, code); 170 String codeString = ((PrimitiveType) code).asStringValue(); 171 if (codeString == null || "".equals(codeString)) 172 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.NULL, code); 173 if ("single".equals(codeString)) 174 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.SINGLE, code); 175 if ("multiple".equals(codeString)) 176 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.MULTIPLE, code); 177 throw new FHIRException("Unknown ActionCardinalityBehavior code '"+codeString+"'"); 178 } 179 public String toCode(ActionCardinalityBehavior code) { 180 if (code == ActionCardinalityBehavior.SINGLE) 181 return "single"; 182 if (code == ActionCardinalityBehavior.MULTIPLE) 183 return "multiple"; 184 return "?"; 185 } 186 public String toSystem(ActionCardinalityBehavior code) { 187 return code.getSystem(); 188 } 189 } 190 191 public enum ActionConditionKind { 192 /** 193 * The condition describes whether or not a given action is applicable. 194 */ 195 APPLICABILITY, 196 /** 197 * The condition is a starting condition for the action. 198 */ 199 START, 200 /** 201 * The condition is a stop, or exit condition for the action. 202 */ 203 STOP, 204 /** 205 * added to help the parsers 206 */ 207 NULL; 208 public static ActionConditionKind fromCode(String codeString) throws FHIRException { 209 if (codeString == null || "".equals(codeString)) 210 return null; 211 if ("applicability".equals(codeString)) 212 return APPLICABILITY; 213 if ("start".equals(codeString)) 214 return START; 215 if ("stop".equals(codeString)) 216 return STOP; 217 throw new FHIRException("Unknown ActionConditionKind code '"+codeString+"'"); 218 } 219 public static boolean isValidCode(String codeString) { 220 if (codeString == null || "".equals(codeString)) 221 return false; 222 return Utilities.existsInList(codeString, "applicability", "start", "stop"); 223 } 224 public String toCode() { 225 switch (this) { 226 case APPLICABILITY: return "applicability"; 227 case START: return "start"; 228 case STOP: return "stop"; 229 case NULL: return null; 230 default: return "?"; 231 } 232 } 233 public String getSystem() { 234 switch (this) { 235 case APPLICABILITY: return "http://hl7.org/fhir/action-condition-kind"; 236 case START: return "http://hl7.org/fhir/action-condition-kind"; 237 case STOP: return "http://hl7.org/fhir/action-condition-kind"; 238 case NULL: return null; 239 default: return "?"; 240 } 241 } 242 public String getDefinition() { 243 switch (this) { 244 case APPLICABILITY: return "The condition describes whether or not a given action is applicable."; 245 case START: return "The condition is a starting condition for the action."; 246 case STOP: return "The condition is a stop, or exit condition for the action."; 247 case NULL: return null; 248 default: return "?"; 249 } 250 } 251 public String getDisplay() { 252 switch (this) { 253 case APPLICABILITY: return "Applicability"; 254 case START: return "Start"; 255 case STOP: return "Stop"; 256 case NULL: return null; 257 default: return "?"; 258 } 259 } 260 } 261 262 public static class ActionConditionKindEnumFactory implements EnumFactory<ActionConditionKind> { 263 public ActionConditionKind fromCode(String codeString) throws IllegalArgumentException { 264 if (codeString == null || "".equals(codeString)) 265 if (codeString == null || "".equals(codeString)) 266 return null; 267 if ("applicability".equals(codeString)) 268 return ActionConditionKind.APPLICABILITY; 269 if ("start".equals(codeString)) 270 return ActionConditionKind.START; 271 if ("stop".equals(codeString)) 272 return ActionConditionKind.STOP; 273 throw new IllegalArgumentException("Unknown ActionConditionKind code '"+codeString+"'"); 274 } 275 276 public Enumeration<ActionConditionKind> fromType(PrimitiveType<?> code) throws FHIRException { 277 if (code == null) 278 return null; 279 if (code.isEmpty()) 280 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.NULL, code); 281 String codeString = ((PrimitiveType) code).asStringValue(); 282 if (codeString == null || "".equals(codeString)) 283 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.NULL, code); 284 if ("applicability".equals(codeString)) 285 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.APPLICABILITY, code); 286 if ("start".equals(codeString)) 287 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.START, code); 288 if ("stop".equals(codeString)) 289 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.STOP, code); 290 throw new FHIRException("Unknown ActionConditionKind code '"+codeString+"'"); 291 } 292 public String toCode(ActionConditionKind code) { 293 if (code == ActionConditionKind.APPLICABILITY) 294 return "applicability"; 295 if (code == ActionConditionKind.START) 296 return "start"; 297 if (code == ActionConditionKind.STOP) 298 return "stop"; 299 return "?"; 300 } 301 public String toSystem(ActionConditionKind code) { 302 return code.getSystem(); 303 } 304 } 305 306 public enum ActionGroupingBehavior { 307 /** 308 * Any group marked with this behavior should be displayed as a visual group to the end user. 309 */ 310 VISUALGROUP, 311 /** 312 * A group with this behavior logically groups its sub-elements, and may be shown as a visual group to the end user, but it is not required to do so. 313 */ 314 LOGICALGROUP, 315 /** 316 * A group of related alternative actions is a sentence group if the target referenced by the action is the same in all the actions and each action simply constitutes a different variation on how to specify the details for the target. For example, two actions that could be in a SentenceGroup are "aspirin, 500 mg, 2 times per day" and "aspirin, 300 mg, 3 times per day". In both cases, aspirin is the target referenced by the action, and the two actions represent different options for how aspirin might be ordered for the patient. Note that a SentenceGroup would almost always have an associated selection behavior of "AtMostOne", unless it's a required action, in which case, it would be "ExactlyOne". 317 */ 318 SENTENCEGROUP, 319 /** 320 * added to help the parsers 321 */ 322 NULL; 323 public static ActionGroupingBehavior fromCode(String codeString) throws FHIRException { 324 if (codeString == null || "".equals(codeString)) 325 return null; 326 if ("visual-group".equals(codeString)) 327 return VISUALGROUP; 328 if ("logical-group".equals(codeString)) 329 return LOGICALGROUP; 330 if ("sentence-group".equals(codeString)) 331 return SENTENCEGROUP; 332 throw new FHIRException("Unknown ActionGroupingBehavior code '"+codeString+"'"); 333 } 334 public static boolean isValidCode(String codeString) { 335 if (codeString == null || "".equals(codeString)) 336 return false; 337 return Utilities.existsInList(codeString, "visual-group", "logical-group", "sentence-group"); 338 } 339 public String toCode() { 340 switch (this) { 341 case VISUALGROUP: return "visual-group"; 342 case LOGICALGROUP: return "logical-group"; 343 case SENTENCEGROUP: return "sentence-group"; 344 case NULL: return null; 345 default: return "?"; 346 } 347 } 348 public String getSystem() { 349 switch (this) { 350 case VISUALGROUP: return "http://hl7.org/fhir/action-grouping-behavior"; 351 case LOGICALGROUP: return "http://hl7.org/fhir/action-grouping-behavior"; 352 case SENTENCEGROUP: return "http://hl7.org/fhir/action-grouping-behavior"; 353 case NULL: return null; 354 default: return "?"; 355 } 356 } 357 public String getDefinition() { 358 switch (this) { 359 case VISUALGROUP: return "Any group marked with this behavior should be displayed as a visual group to the end user."; 360 case LOGICALGROUP: return "A group with this behavior logically groups its sub-elements, and may be shown as a visual group to the end user, but it is not required to do so."; 361 case SENTENCEGROUP: return "A group of related alternative actions is a sentence group if the target referenced by the action is the same in all the actions and each action simply constitutes a different variation on how to specify the details for the target. For example, two actions that could be in a SentenceGroup are \"aspirin, 500 mg, 2 times per day\" and \"aspirin, 300 mg, 3 times per day\". In both cases, aspirin is the target referenced by the action, and the two actions represent different options for how aspirin might be ordered for the patient. Note that a SentenceGroup would almost always have an associated selection behavior of \"AtMostOne\", unless it's a required action, in which case, it would be \"ExactlyOne\"."; 362 case NULL: return null; 363 default: return "?"; 364 } 365 } 366 public String getDisplay() { 367 switch (this) { 368 case VISUALGROUP: return "Visual Group"; 369 case LOGICALGROUP: return "Logical Group"; 370 case SENTENCEGROUP: return "Sentence Group"; 371 case NULL: return null; 372 default: return "?"; 373 } 374 } 375 } 376 377 public static class ActionGroupingBehaviorEnumFactory implements EnumFactory<ActionGroupingBehavior> { 378 public ActionGroupingBehavior fromCode(String codeString) throws IllegalArgumentException { 379 if (codeString == null || "".equals(codeString)) 380 if (codeString == null || "".equals(codeString)) 381 return null; 382 if ("visual-group".equals(codeString)) 383 return ActionGroupingBehavior.VISUALGROUP; 384 if ("logical-group".equals(codeString)) 385 return ActionGroupingBehavior.LOGICALGROUP; 386 if ("sentence-group".equals(codeString)) 387 return ActionGroupingBehavior.SENTENCEGROUP; 388 throw new IllegalArgumentException("Unknown ActionGroupingBehavior code '"+codeString+"'"); 389 } 390 391 public Enumeration<ActionGroupingBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 392 if (code == null) 393 return null; 394 if (code.isEmpty()) 395 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.NULL, code); 396 String codeString = ((PrimitiveType) code).asStringValue(); 397 if (codeString == null || "".equals(codeString)) 398 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.NULL, code); 399 if ("visual-group".equals(codeString)) 400 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.VISUALGROUP, code); 401 if ("logical-group".equals(codeString)) 402 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.LOGICALGROUP, code); 403 if ("sentence-group".equals(codeString)) 404 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.SENTENCEGROUP, code); 405 throw new FHIRException("Unknown ActionGroupingBehavior code '"+codeString+"'"); 406 } 407 public String toCode(ActionGroupingBehavior code) { 408 if (code == ActionGroupingBehavior.VISUALGROUP) 409 return "visual-group"; 410 if (code == ActionGroupingBehavior.LOGICALGROUP) 411 return "logical-group"; 412 if (code == ActionGroupingBehavior.SENTENCEGROUP) 413 return "sentence-group"; 414 return "?"; 415 } 416 public String toSystem(ActionGroupingBehavior code) { 417 return code.getSystem(); 418 } 419 } 420 421 public enum ActionParticipantType { 422 /** 423 * The participant is a care team caring for the patient under evaluation. 424 */ 425 CARETEAM, 426 /** 427 * The participant is a system or device used in the care of the patient. 428 */ 429 DEVICE, 430 /** 431 * The participant is a group of participants involved in the care of the patient. 432 */ 433 GROUP, 434 /** 435 * The participant is an institution that can provide the given healthcare service used in the care of the patient. 436 */ 437 HEALTHCARESERVICE, 438 /** 439 * The participant is a location involved in the care of the patient. 440 */ 441 LOCATION, 442 /** 443 * The participant is an organization involved in the care of the patient. 444 */ 445 ORGANIZATION, 446 /** 447 * The participant is the patient under evaluation. 448 */ 449 PATIENT, 450 /** 451 * The participant is a practitioner involved in the patient's care. 452 */ 453 PRACTITIONER, 454 /** 455 * The participant is a particular practitioner role involved in the patient's care. 456 */ 457 PRACTITIONERROLE, 458 /** 459 * The participant is a person related to the patient. 460 */ 461 RELATEDPERSON, 462 /** 463 * added to help the parsers 464 */ 465 NULL; 466 public static ActionParticipantType fromCode(String codeString) throws FHIRException { 467 if (codeString == null || "".equals(codeString)) 468 return null; 469 if ("careteam".equals(codeString)) 470 return CARETEAM; 471 if ("device".equals(codeString)) 472 return DEVICE; 473 if ("group".equals(codeString)) 474 return GROUP; 475 if ("healthcareservice".equals(codeString)) 476 return HEALTHCARESERVICE; 477 if ("location".equals(codeString)) 478 return LOCATION; 479 if ("organization".equals(codeString)) 480 return ORGANIZATION; 481 if ("patient".equals(codeString)) 482 return PATIENT; 483 if ("practitioner".equals(codeString)) 484 return PRACTITIONER; 485 if ("practitionerrole".equals(codeString)) 486 return PRACTITIONERROLE; 487 if ("relatedperson".equals(codeString)) 488 return RELATEDPERSON; 489 throw new FHIRException("Unknown ActionParticipantType code '"+codeString+"'"); 490 } 491 public static boolean isValidCode(String codeString) { 492 if (codeString == null || "".equals(codeString)) 493 return false; 494 return Utilities.existsInList(codeString, "careteam", "device", "group", "healthcareservice", "location", "organization", "patient", "practitioner", "practitionerrole", "relatedperson"); 495 } 496 public String toCode() { 497 switch (this) { 498 case CARETEAM: return "careteam"; 499 case DEVICE: return "device"; 500 case GROUP: return "group"; 501 case HEALTHCARESERVICE: return "healthcareservice"; 502 case LOCATION: return "location"; 503 case ORGANIZATION: return "organization"; 504 case PATIENT: return "patient"; 505 case PRACTITIONER: return "practitioner"; 506 case PRACTITIONERROLE: return "practitionerrole"; 507 case RELATEDPERSON: return "relatedperson"; 508 case NULL: return null; 509 default: return "?"; 510 } 511 } 512 public String getSystem() { 513 switch (this) { 514 case CARETEAM: return "http://hl7.org/fhir/action-participant-type"; 515 case DEVICE: return "http://hl7.org/fhir/action-participant-type"; 516 case GROUP: return "http://hl7.org/fhir/action-participant-type"; 517 case HEALTHCARESERVICE: return "http://hl7.org/fhir/action-participant-type"; 518 case LOCATION: return "http://hl7.org/fhir/action-participant-type"; 519 case ORGANIZATION: return "http://hl7.org/fhir/action-participant-type"; 520 case PATIENT: return "http://hl7.org/fhir/action-participant-type"; 521 case PRACTITIONER: return "http://hl7.org/fhir/action-participant-type"; 522 case PRACTITIONERROLE: return "http://hl7.org/fhir/action-participant-type"; 523 case RELATEDPERSON: return "http://hl7.org/fhir/action-participant-type"; 524 case NULL: return null; 525 default: return "?"; 526 } 527 } 528 public String getDefinition() { 529 switch (this) { 530 case CARETEAM: return "The participant is a care team caring for the patient under evaluation."; 531 case DEVICE: return "The participant is a system or device used in the care of the patient."; 532 case GROUP: return "The participant is a group of participants involved in the care of the patient."; 533 case HEALTHCARESERVICE: return "The participant is an institution that can provide the given healthcare service used in the care of the patient."; 534 case LOCATION: return "The participant is a location involved in the care of the patient."; 535 case ORGANIZATION: return "The participant is an organization involved in the care of the patient."; 536 case PATIENT: return "The participant is the patient under evaluation."; 537 case PRACTITIONER: return "The participant is a practitioner involved in the patient's care."; 538 case PRACTITIONERROLE: return "The participant is a particular practitioner role involved in the patient's care."; 539 case RELATEDPERSON: return "The participant is a person related to the patient."; 540 case NULL: return null; 541 default: return "?"; 542 } 543 } 544 public String getDisplay() { 545 switch (this) { 546 case CARETEAM: return "CareTeam"; 547 case DEVICE: return "Device"; 548 case GROUP: return "Group"; 549 case HEALTHCARESERVICE: return "HealthcareService"; 550 case LOCATION: return "Location"; 551 case ORGANIZATION: return "Organization"; 552 case PATIENT: return "Patient"; 553 case PRACTITIONER: return "Practitioner"; 554 case PRACTITIONERROLE: return "PractitionerRole"; 555 case RELATEDPERSON: return "RelatedPerson"; 556 case NULL: return null; 557 default: return "?"; 558 } 559 } 560 } 561 562 public static class ActionParticipantTypeEnumFactory implements EnumFactory<ActionParticipantType> { 563 public ActionParticipantType fromCode(String codeString) throws IllegalArgumentException { 564 if (codeString == null || "".equals(codeString)) 565 if (codeString == null || "".equals(codeString)) 566 return null; 567 if ("careteam".equals(codeString)) 568 return ActionParticipantType.CARETEAM; 569 if ("device".equals(codeString)) 570 return ActionParticipantType.DEVICE; 571 if ("group".equals(codeString)) 572 return ActionParticipantType.GROUP; 573 if ("healthcareservice".equals(codeString)) 574 return ActionParticipantType.HEALTHCARESERVICE; 575 if ("location".equals(codeString)) 576 return ActionParticipantType.LOCATION; 577 if ("organization".equals(codeString)) 578 return ActionParticipantType.ORGANIZATION; 579 if ("patient".equals(codeString)) 580 return ActionParticipantType.PATIENT; 581 if ("practitioner".equals(codeString)) 582 return ActionParticipantType.PRACTITIONER; 583 if ("practitionerrole".equals(codeString)) 584 return ActionParticipantType.PRACTITIONERROLE; 585 if ("relatedperson".equals(codeString)) 586 return ActionParticipantType.RELATEDPERSON; 587 throw new IllegalArgumentException("Unknown ActionParticipantType code '"+codeString+"'"); 588 } 589 590 public Enumeration<ActionParticipantType> fromType(PrimitiveType<?> code) throws FHIRException { 591 if (code == null) 592 return null; 593 if (code.isEmpty()) 594 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.NULL, code); 595 String codeString = ((PrimitiveType) code).asStringValue(); 596 if (codeString == null || "".equals(codeString)) 597 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.NULL, code); 598 if ("careteam".equals(codeString)) 599 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.CARETEAM, code); 600 if ("device".equals(codeString)) 601 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.DEVICE, code); 602 if ("group".equals(codeString)) 603 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.GROUP, code); 604 if ("healthcareservice".equals(codeString)) 605 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.HEALTHCARESERVICE, code); 606 if ("location".equals(codeString)) 607 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.LOCATION, code); 608 if ("organization".equals(codeString)) 609 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.ORGANIZATION, code); 610 if ("patient".equals(codeString)) 611 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PATIENT, code); 612 if ("practitioner".equals(codeString)) 613 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PRACTITIONER, code); 614 if ("practitionerrole".equals(codeString)) 615 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PRACTITIONERROLE, code); 616 if ("relatedperson".equals(codeString)) 617 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.RELATEDPERSON, code); 618 throw new FHIRException("Unknown ActionParticipantType code '"+codeString+"'"); 619 } 620 public String toCode(ActionParticipantType code) { 621 if (code == ActionParticipantType.CARETEAM) 622 return "careteam"; 623 if (code == ActionParticipantType.DEVICE) 624 return "device"; 625 if (code == ActionParticipantType.GROUP) 626 return "group"; 627 if (code == ActionParticipantType.HEALTHCARESERVICE) 628 return "healthcareservice"; 629 if (code == ActionParticipantType.LOCATION) 630 return "location"; 631 if (code == ActionParticipantType.ORGANIZATION) 632 return "organization"; 633 if (code == ActionParticipantType.PATIENT) 634 return "patient"; 635 if (code == ActionParticipantType.PRACTITIONER) 636 return "practitioner"; 637 if (code == ActionParticipantType.PRACTITIONERROLE) 638 return "practitionerrole"; 639 if (code == ActionParticipantType.RELATEDPERSON) 640 return "relatedperson"; 641 return "?"; 642 } 643 public String toSystem(ActionParticipantType code) { 644 return code.getSystem(); 645 } 646 } 647 648 public enum ActionPrecheckBehavior { 649 /** 650 * An action with this behavior is one of the most frequent action that is, or should be, included by an end user, for the particular context in which the action occurs. The system displaying the action to the end user should consider "pre-checking" such an action as a convenience for the user. 651 */ 652 YES, 653 /** 654 * An action with this behavior is one of the less frequent actions included by the end user, for the particular context in which the action occurs. The system displaying the actions to the end user would typically not "pre-check" such an action. 655 */ 656 NO, 657 /** 658 * added to help the parsers 659 */ 660 NULL; 661 public static ActionPrecheckBehavior fromCode(String codeString) throws FHIRException { 662 if (codeString == null || "".equals(codeString)) 663 return null; 664 if ("yes".equals(codeString)) 665 return YES; 666 if ("no".equals(codeString)) 667 return NO; 668 throw new FHIRException("Unknown ActionPrecheckBehavior code '"+codeString+"'"); 669 } 670 public static boolean isValidCode(String codeString) { 671 if (codeString == null || "".equals(codeString)) 672 return false; 673 return Utilities.existsInList(codeString, "yes", "no"); 674 } 675 public String toCode() { 676 switch (this) { 677 case YES: return "yes"; 678 case NO: return "no"; 679 case NULL: return null; 680 default: return "?"; 681 } 682 } 683 public String getSystem() { 684 switch (this) { 685 case YES: return "http://hl7.org/fhir/action-precheck-behavior"; 686 case NO: return "http://hl7.org/fhir/action-precheck-behavior"; 687 case NULL: return null; 688 default: return "?"; 689 } 690 } 691 public String getDefinition() { 692 switch (this) { 693 case YES: return "An action with this behavior is one of the most frequent action that is, or should be, included by an end user, for the particular context in which the action occurs. The system displaying the action to the end user should consider \"pre-checking\" such an action as a convenience for the user."; 694 case NO: return "An action with this behavior is one of the less frequent actions included by the end user, for the particular context in which the action occurs. The system displaying the actions to the end user would typically not \"pre-check\" such an action."; 695 case NULL: return null; 696 default: return "?"; 697 } 698 } 699 public String getDisplay() { 700 switch (this) { 701 case YES: return "Yes"; 702 case NO: return "No"; 703 case NULL: return null; 704 default: return "?"; 705 } 706 } 707 } 708 709 public static class ActionPrecheckBehaviorEnumFactory implements EnumFactory<ActionPrecheckBehavior> { 710 public ActionPrecheckBehavior fromCode(String codeString) throws IllegalArgumentException { 711 if (codeString == null || "".equals(codeString)) 712 if (codeString == null || "".equals(codeString)) 713 return null; 714 if ("yes".equals(codeString)) 715 return ActionPrecheckBehavior.YES; 716 if ("no".equals(codeString)) 717 return ActionPrecheckBehavior.NO; 718 throw new IllegalArgumentException("Unknown ActionPrecheckBehavior code '"+codeString+"'"); 719 } 720 721 public Enumeration<ActionPrecheckBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 722 if (code == null) 723 return null; 724 if (code.isEmpty()) 725 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NULL, code); 726 String codeString = ((PrimitiveType) code).asStringValue(); 727 if (codeString == null || "".equals(codeString)) 728 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NULL, code); 729 if ("yes".equals(codeString)) 730 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.YES, code); 731 if ("no".equals(codeString)) 732 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NO, code); 733 throw new FHIRException("Unknown ActionPrecheckBehavior code '"+codeString+"'"); 734 } 735 public String toCode(ActionPrecheckBehavior code) { 736 if (code == ActionPrecheckBehavior.YES) 737 return "yes"; 738 if (code == ActionPrecheckBehavior.NO) 739 return "no"; 740 return "?"; 741 } 742 public String toSystem(ActionPrecheckBehavior code) { 743 return code.getSystem(); 744 } 745 } 746 747 public enum ActionRelationshipType { 748 /** 749 * The action must be performed before the related action. 750 */ 751 BEFORE, 752 /** 753 * The action must be performed before the start of the related action. 754 */ 755 BEFORESTART, 756 /** 757 * The action must be performed before the end of the related action. 758 */ 759 BEFOREEND, 760 /** 761 * The action must be performed concurrent with the related action. 762 */ 763 CONCURRENT, 764 /** 765 * The action must be performed concurrent with the start of the related action. 766 */ 767 CONCURRENTWITHSTART, 768 /** 769 * The action must be performed concurrent with the end of the related action. 770 */ 771 CONCURRENTWITHEND, 772 /** 773 * The action must be performed after the related action. 774 */ 775 AFTER, 776 /** 777 * The action must be performed after the start of the related action. 778 */ 779 AFTERSTART, 780 /** 781 * The action must be performed after the end of the related action. 782 */ 783 AFTEREND, 784 /** 785 * added to help the parsers 786 */ 787 NULL; 788 public static ActionRelationshipType fromCode(String codeString) throws FHIRException { 789 if (codeString == null || "".equals(codeString)) 790 return null; 791 if ("before".equals(codeString)) 792 return BEFORE; 793 if ("before-start".equals(codeString)) 794 return BEFORESTART; 795 if ("before-end".equals(codeString)) 796 return BEFOREEND; 797 if ("concurrent".equals(codeString)) 798 return CONCURRENT; 799 if ("concurrent-with-start".equals(codeString)) 800 return CONCURRENTWITHSTART; 801 if ("concurrent-with-end".equals(codeString)) 802 return CONCURRENTWITHEND; 803 if ("after".equals(codeString)) 804 return AFTER; 805 if ("after-start".equals(codeString)) 806 return AFTERSTART; 807 if ("after-end".equals(codeString)) 808 return AFTEREND; 809 throw new FHIRException("Unknown ActionRelationshipType code '"+codeString+"'"); 810 } 811 public static boolean isValidCode(String codeString) { 812 if (codeString == null || "".equals(codeString)) 813 return false; 814 return Utilities.existsInList(codeString, "before", "before-start", "before-end", "concurrent", "concurrent-with-start", "concurrent-with-end", "after", "after-start", "after-end"); 815 } 816 public String toCode() { 817 switch (this) { 818 case BEFORE: return "before"; 819 case BEFORESTART: return "before-start"; 820 case BEFOREEND: return "before-end"; 821 case CONCURRENT: return "concurrent"; 822 case CONCURRENTWITHSTART: return "concurrent-with-start"; 823 case CONCURRENTWITHEND: return "concurrent-with-end"; 824 case AFTER: return "after"; 825 case AFTERSTART: return "after-start"; 826 case AFTEREND: return "after-end"; 827 case NULL: return null; 828 default: return "?"; 829 } 830 } 831 public String getSystem() { 832 switch (this) { 833 case BEFORE: return "http://hl7.org/fhir/action-relationship-type"; 834 case BEFORESTART: return "http://hl7.org/fhir/action-relationship-type"; 835 case BEFOREEND: return "http://hl7.org/fhir/action-relationship-type"; 836 case CONCURRENT: return "http://hl7.org/fhir/action-relationship-type"; 837 case CONCURRENTWITHSTART: return "http://hl7.org/fhir/action-relationship-type"; 838 case CONCURRENTWITHEND: return "http://hl7.org/fhir/action-relationship-type"; 839 case AFTER: return "http://hl7.org/fhir/action-relationship-type"; 840 case AFTERSTART: return "http://hl7.org/fhir/action-relationship-type"; 841 case AFTEREND: return "http://hl7.org/fhir/action-relationship-type"; 842 case NULL: return null; 843 default: return "?"; 844 } 845 } 846 public String getDefinition() { 847 switch (this) { 848 case BEFORE: return "The action must be performed before the related action."; 849 case BEFORESTART: return "The action must be performed before the start of the related action."; 850 case BEFOREEND: return "The action must be performed before the end of the related action."; 851 case CONCURRENT: return "The action must be performed concurrent with the related action."; 852 case CONCURRENTWITHSTART: return "The action must be performed concurrent with the start of the related action."; 853 case CONCURRENTWITHEND: return "The action must be performed concurrent with the end of the related action."; 854 case AFTER: return "The action must be performed after the related action."; 855 case AFTERSTART: return "The action must be performed after the start of the related action."; 856 case AFTEREND: return "The action must be performed after the end of the related action."; 857 case NULL: return null; 858 default: return "?"; 859 } 860 } 861 public String getDisplay() { 862 switch (this) { 863 case BEFORE: return "Before"; 864 case BEFORESTART: return "Before Start"; 865 case BEFOREEND: return "Before End"; 866 case CONCURRENT: return "Concurrent"; 867 case CONCURRENTWITHSTART: return "Concurrent With Start"; 868 case CONCURRENTWITHEND: return "Concurrent With End"; 869 case AFTER: return "After"; 870 case AFTERSTART: return "After Start"; 871 case AFTEREND: return "After End"; 872 case NULL: return null; 873 default: return "?"; 874 } 875 } 876 } 877 878 public static class ActionRelationshipTypeEnumFactory implements EnumFactory<ActionRelationshipType> { 879 public ActionRelationshipType fromCode(String codeString) throws IllegalArgumentException { 880 if (codeString == null || "".equals(codeString)) 881 if (codeString == null || "".equals(codeString)) 882 return null; 883 if ("before".equals(codeString)) 884 return ActionRelationshipType.BEFORE; 885 if ("before-start".equals(codeString)) 886 return ActionRelationshipType.BEFORESTART; 887 if ("before-end".equals(codeString)) 888 return ActionRelationshipType.BEFOREEND; 889 if ("concurrent".equals(codeString)) 890 return ActionRelationshipType.CONCURRENT; 891 if ("concurrent-with-start".equals(codeString)) 892 return ActionRelationshipType.CONCURRENTWITHSTART; 893 if ("concurrent-with-end".equals(codeString)) 894 return ActionRelationshipType.CONCURRENTWITHEND; 895 if ("after".equals(codeString)) 896 return ActionRelationshipType.AFTER; 897 if ("after-start".equals(codeString)) 898 return ActionRelationshipType.AFTERSTART; 899 if ("after-end".equals(codeString)) 900 return ActionRelationshipType.AFTEREND; 901 throw new IllegalArgumentException("Unknown ActionRelationshipType code '"+codeString+"'"); 902 } 903 904 public Enumeration<ActionRelationshipType> fromType(PrimitiveType<?> code) throws FHIRException { 905 if (code == null) 906 return null; 907 if (code.isEmpty()) 908 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.NULL, code); 909 String codeString = ((PrimitiveType) code).asStringValue(); 910 if (codeString == null || "".equals(codeString)) 911 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.NULL, code); 912 if ("before".equals(codeString)) 913 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORE, code); 914 if ("before-start".equals(codeString)) 915 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORESTART, code); 916 if ("before-end".equals(codeString)) 917 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFOREEND, code); 918 if ("concurrent".equals(codeString)) 919 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENT, code); 920 if ("concurrent-with-start".equals(codeString)) 921 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHSTART, code); 922 if ("concurrent-with-end".equals(codeString)) 923 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHEND, code); 924 if ("after".equals(codeString)) 925 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTER, code); 926 if ("after-start".equals(codeString)) 927 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTERSTART, code); 928 if ("after-end".equals(codeString)) 929 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTEREND, code); 930 throw new FHIRException("Unknown ActionRelationshipType code '"+codeString+"'"); 931 } 932 public String toCode(ActionRelationshipType code) { 933 if (code == ActionRelationshipType.BEFORE) 934 return "before"; 935 if (code == ActionRelationshipType.BEFORESTART) 936 return "before-start"; 937 if (code == ActionRelationshipType.BEFOREEND) 938 return "before-end"; 939 if (code == ActionRelationshipType.CONCURRENT) 940 return "concurrent"; 941 if (code == ActionRelationshipType.CONCURRENTWITHSTART) 942 return "concurrent-with-start"; 943 if (code == ActionRelationshipType.CONCURRENTWITHEND) 944 return "concurrent-with-end"; 945 if (code == ActionRelationshipType.AFTER) 946 return "after"; 947 if (code == ActionRelationshipType.AFTERSTART) 948 return "after-start"; 949 if (code == ActionRelationshipType.AFTEREND) 950 return "after-end"; 951 return "?"; 952 } 953 public String toSystem(ActionRelationshipType code) { 954 return code.getSystem(); 955 } 956 } 957 958 public enum ActionRequiredBehavior { 959 /** 960 * An action with this behavior must be included in the actions processed by the end user; the end user SHALL NOT choose not to include this action. 961 */ 962 MUST, 963 /** 964 * An action with this behavior may be included in the set of actions processed by the end user. 965 */ 966 COULD, 967 /** 968 * An action with this behavior must be included in the set of actions processed by the end user, unless the end user provides documentation as to why the action was not included. 969 */ 970 MUSTUNLESSDOCUMENTED, 971 /** 972 * added to help the parsers 973 */ 974 NULL; 975 public static ActionRequiredBehavior fromCode(String codeString) throws FHIRException { 976 if (codeString == null || "".equals(codeString)) 977 return null; 978 if ("must".equals(codeString)) 979 return MUST; 980 if ("could".equals(codeString)) 981 return COULD; 982 if ("must-unless-documented".equals(codeString)) 983 return MUSTUNLESSDOCUMENTED; 984 throw new FHIRException("Unknown ActionRequiredBehavior code '"+codeString+"'"); 985 } 986 public static boolean isValidCode(String codeString) { 987 if (codeString == null || "".equals(codeString)) 988 return false; 989 return Utilities.existsInList(codeString, "must", "could", "must-unless-documented"); 990 } 991 public String toCode() { 992 switch (this) { 993 case MUST: return "must"; 994 case COULD: return "could"; 995 case MUSTUNLESSDOCUMENTED: return "must-unless-documented"; 996 case NULL: return null; 997 default: return "?"; 998 } 999 } 1000 public String getSystem() { 1001 switch (this) { 1002 case MUST: return "http://hl7.org/fhir/action-required-behavior"; 1003 case COULD: return "http://hl7.org/fhir/action-required-behavior"; 1004 case MUSTUNLESSDOCUMENTED: return "http://hl7.org/fhir/action-required-behavior"; 1005 case NULL: return null; 1006 default: return "?"; 1007 } 1008 } 1009 public String getDefinition() { 1010 switch (this) { 1011 case MUST: return "An action with this behavior must be included in the actions processed by the end user; the end user SHALL NOT choose not to include this action."; 1012 case COULD: return "An action with this behavior may be included in the set of actions processed by the end user."; 1013 case MUSTUNLESSDOCUMENTED: return "An action with this behavior must be included in the set of actions processed by the end user, unless the end user provides documentation as to why the action was not included."; 1014 case NULL: return null; 1015 default: return "?"; 1016 } 1017 } 1018 public String getDisplay() { 1019 switch (this) { 1020 case MUST: return "Must"; 1021 case COULD: return "Could"; 1022 case MUSTUNLESSDOCUMENTED: return "Must Unless Documented"; 1023 case NULL: return null; 1024 default: return "?"; 1025 } 1026 } 1027 } 1028 1029 public static class ActionRequiredBehaviorEnumFactory implements EnumFactory<ActionRequiredBehavior> { 1030 public ActionRequiredBehavior fromCode(String codeString) throws IllegalArgumentException { 1031 if (codeString == null || "".equals(codeString)) 1032 if (codeString == null || "".equals(codeString)) 1033 return null; 1034 if ("must".equals(codeString)) 1035 return ActionRequiredBehavior.MUST; 1036 if ("could".equals(codeString)) 1037 return ActionRequiredBehavior.COULD; 1038 if ("must-unless-documented".equals(codeString)) 1039 return ActionRequiredBehavior.MUSTUNLESSDOCUMENTED; 1040 throw new IllegalArgumentException("Unknown ActionRequiredBehavior code '"+codeString+"'"); 1041 } 1042 1043 public Enumeration<ActionRequiredBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1044 if (code == null) 1045 return null; 1046 if (code.isEmpty()) 1047 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.NULL, code); 1048 String codeString = ((PrimitiveType) code).asStringValue(); 1049 if (codeString == null || "".equals(codeString)) 1050 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.NULL, code); 1051 if ("must".equals(codeString)) 1052 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUST, code); 1053 if ("could".equals(codeString)) 1054 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.COULD, code); 1055 if ("must-unless-documented".equals(codeString)) 1056 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUSTUNLESSDOCUMENTED, code); 1057 throw new FHIRException("Unknown ActionRequiredBehavior code '"+codeString+"'"); 1058 } 1059 public String toCode(ActionRequiredBehavior code) { 1060 if (code == ActionRequiredBehavior.MUST) 1061 return "must"; 1062 if (code == ActionRequiredBehavior.COULD) 1063 return "could"; 1064 if (code == ActionRequiredBehavior.MUSTUNLESSDOCUMENTED) 1065 return "must-unless-documented"; 1066 return "?"; 1067 } 1068 public String toSystem(ActionRequiredBehavior code) { 1069 return code.getSystem(); 1070 } 1071 } 1072 1073 public enum ActionSelectionBehavior { 1074 /** 1075 * Any number of the actions in the group may be chosen, from zero to all. 1076 */ 1077 ANY, 1078 /** 1079 * All the actions in the group must be selected as a single unit. 1080 */ 1081 ALL, 1082 /** 1083 * All the actions in the group are meant to be chosen as a single unit: either all must be selected by the end user, or none may be selected. 1084 */ 1085 ALLORNONE, 1086 /** 1087 * The end user must choose one and only one of the selectable actions in the group. The user SHALL NOT choose none of the actions in the group. 1088 */ 1089 EXACTLYONE, 1090 /** 1091 * The end user may choose zero or at most one of the actions in the group. 1092 */ 1093 ATMOSTONE, 1094 /** 1095 * The end user must choose a minimum of one, and as many additional as desired. 1096 */ 1097 ONEORMORE, 1098 /** 1099 * added to help the parsers 1100 */ 1101 NULL; 1102 public static ActionSelectionBehavior fromCode(String codeString) throws FHIRException { 1103 if (codeString == null || "".equals(codeString)) 1104 return null; 1105 if ("any".equals(codeString)) 1106 return ANY; 1107 if ("all".equals(codeString)) 1108 return ALL; 1109 if ("all-or-none".equals(codeString)) 1110 return ALLORNONE; 1111 if ("exactly-one".equals(codeString)) 1112 return EXACTLYONE; 1113 if ("at-most-one".equals(codeString)) 1114 return ATMOSTONE; 1115 if ("one-or-more".equals(codeString)) 1116 return ONEORMORE; 1117 throw new FHIRException("Unknown ActionSelectionBehavior code '"+codeString+"'"); 1118 } 1119 public static boolean isValidCode(String codeString) { 1120 if (codeString == null || "".equals(codeString)) 1121 return false; 1122 return Utilities.existsInList(codeString, "any", "all", "all-or-none", "exactly-one", "at-most-one", "one-or-more"); 1123 } 1124 public String toCode() { 1125 switch (this) { 1126 case ANY: return "any"; 1127 case ALL: return "all"; 1128 case ALLORNONE: return "all-or-none"; 1129 case EXACTLYONE: return "exactly-one"; 1130 case ATMOSTONE: return "at-most-one"; 1131 case ONEORMORE: return "one-or-more"; 1132 case NULL: return null; 1133 default: return "?"; 1134 } 1135 } 1136 public String getSystem() { 1137 switch (this) { 1138 case ANY: return "http://hl7.org/fhir/action-selection-behavior"; 1139 case ALL: return "http://hl7.org/fhir/action-selection-behavior"; 1140 case ALLORNONE: return "http://hl7.org/fhir/action-selection-behavior"; 1141 case EXACTLYONE: return "http://hl7.org/fhir/action-selection-behavior"; 1142 case ATMOSTONE: return "http://hl7.org/fhir/action-selection-behavior"; 1143 case ONEORMORE: return "http://hl7.org/fhir/action-selection-behavior"; 1144 case NULL: return null; 1145 default: return "?"; 1146 } 1147 } 1148 public String getDefinition() { 1149 switch (this) { 1150 case ANY: return "Any number of the actions in the group may be chosen, from zero to all."; 1151 case ALL: return "All the actions in the group must be selected as a single unit."; 1152 case ALLORNONE: return "All the actions in the group are meant to be chosen as a single unit: either all must be selected by the end user, or none may be selected."; 1153 case EXACTLYONE: return "The end user must choose one and only one of the selectable actions in the group. The user SHALL NOT choose none of the actions in the group."; 1154 case ATMOSTONE: return "The end user may choose zero or at most one of the actions in the group."; 1155 case ONEORMORE: return "The end user must choose a minimum of one, and as many additional as desired."; 1156 case NULL: return null; 1157 default: return "?"; 1158 } 1159 } 1160 public String getDisplay() { 1161 switch (this) { 1162 case ANY: return "Any"; 1163 case ALL: return "All"; 1164 case ALLORNONE: return "All Or None"; 1165 case EXACTLYONE: return "Exactly One"; 1166 case ATMOSTONE: return "At Most One"; 1167 case ONEORMORE: return "One Or More"; 1168 case NULL: return null; 1169 default: return "?"; 1170 } 1171 } 1172 } 1173 1174 public static class ActionSelectionBehaviorEnumFactory implements EnumFactory<ActionSelectionBehavior> { 1175 public ActionSelectionBehavior fromCode(String codeString) throws IllegalArgumentException { 1176 if (codeString == null || "".equals(codeString)) 1177 if (codeString == null || "".equals(codeString)) 1178 return null; 1179 if ("any".equals(codeString)) 1180 return ActionSelectionBehavior.ANY; 1181 if ("all".equals(codeString)) 1182 return ActionSelectionBehavior.ALL; 1183 if ("all-or-none".equals(codeString)) 1184 return ActionSelectionBehavior.ALLORNONE; 1185 if ("exactly-one".equals(codeString)) 1186 return ActionSelectionBehavior.EXACTLYONE; 1187 if ("at-most-one".equals(codeString)) 1188 return ActionSelectionBehavior.ATMOSTONE; 1189 if ("one-or-more".equals(codeString)) 1190 return ActionSelectionBehavior.ONEORMORE; 1191 throw new IllegalArgumentException("Unknown ActionSelectionBehavior code '"+codeString+"'"); 1192 } 1193 1194 public Enumeration<ActionSelectionBehavior> fromType(PrimitiveType<?> code) throws FHIRException { 1195 if (code == null) 1196 return null; 1197 if (code.isEmpty()) 1198 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.NULL, code); 1199 String codeString = ((PrimitiveType) code).asStringValue(); 1200 if (codeString == null || "".equals(codeString)) 1201 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.NULL, code); 1202 if ("any".equals(codeString)) 1203 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ANY, code); 1204 if ("all".equals(codeString)) 1205 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALL, code); 1206 if ("all-or-none".equals(codeString)) 1207 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALLORNONE, code); 1208 if ("exactly-one".equals(codeString)) 1209 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.EXACTLYONE, code); 1210 if ("at-most-one".equals(codeString)) 1211 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ATMOSTONE, code); 1212 if ("one-or-more".equals(codeString)) 1213 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ONEORMORE, code); 1214 throw new FHIRException("Unknown ActionSelectionBehavior code '"+codeString+"'"); 1215 } 1216 public String toCode(ActionSelectionBehavior code) { 1217 if (code == ActionSelectionBehavior.ANY) 1218 return "any"; 1219 if (code == ActionSelectionBehavior.ALL) 1220 return "all"; 1221 if (code == ActionSelectionBehavior.ALLORNONE) 1222 return "all-or-none"; 1223 if (code == ActionSelectionBehavior.EXACTLYONE) 1224 return "exactly-one"; 1225 if (code == ActionSelectionBehavior.ATMOSTONE) 1226 return "at-most-one"; 1227 if (code == ActionSelectionBehavior.ONEORMORE) 1228 return "one-or-more"; 1229 return "?"; 1230 } 1231 public String toSystem(ActionSelectionBehavior code) { 1232 return code.getSystem(); 1233 } 1234 } 1235 1236 public enum AdministrativeGender { 1237 /** 1238 * Male. 1239 */ 1240 MALE, 1241 /** 1242 * Female. 1243 */ 1244 FEMALE, 1245 /** 1246 * Other. 1247 */ 1248 OTHER, 1249 /** 1250 * Unknown. 1251 */ 1252 UNKNOWN, 1253 /** 1254 * added to help the parsers 1255 */ 1256 NULL; 1257 public static AdministrativeGender fromCode(String codeString) throws FHIRException { 1258 if (codeString == null || "".equals(codeString)) 1259 return null; 1260 if ("male".equals(codeString)) 1261 return MALE; 1262 if ("female".equals(codeString)) 1263 return FEMALE; 1264 if ("other".equals(codeString)) 1265 return OTHER; 1266 if ("unknown".equals(codeString)) 1267 return UNKNOWN; 1268 throw new FHIRException("Unknown AdministrativeGender code '"+codeString+"'"); 1269 } 1270 public static boolean isValidCode(String codeString) { 1271 if (codeString == null || "".equals(codeString)) 1272 return false; 1273 return Utilities.existsInList(codeString, "male", "female", "other", "unknown"); 1274 } 1275 public String toCode() { 1276 switch (this) { 1277 case MALE: return "male"; 1278 case FEMALE: return "female"; 1279 case OTHER: return "other"; 1280 case UNKNOWN: return "unknown"; 1281 case NULL: return null; 1282 default: return "?"; 1283 } 1284 } 1285 public String getSystem() { 1286 switch (this) { 1287 case MALE: return "http://hl7.org/fhir/administrative-gender"; 1288 case FEMALE: return "http://hl7.org/fhir/administrative-gender"; 1289 case OTHER: return "http://hl7.org/fhir/administrative-gender"; 1290 case UNKNOWN: return "http://hl7.org/fhir/administrative-gender"; 1291 case NULL: return null; 1292 default: return "?"; 1293 } 1294 } 1295 public String getDefinition() { 1296 switch (this) { 1297 case MALE: return "Male."; 1298 case FEMALE: return "Female."; 1299 case OTHER: return "Other."; 1300 case UNKNOWN: return "Unknown."; 1301 case NULL: return null; 1302 default: return "?"; 1303 } 1304 } 1305 public String getDisplay() { 1306 switch (this) { 1307 case MALE: return "Male"; 1308 case FEMALE: return "Female"; 1309 case OTHER: return "Other"; 1310 case UNKNOWN: return "Unknown"; 1311 case NULL: return null; 1312 default: return "?"; 1313 } 1314 } 1315 } 1316 1317 public static class AdministrativeGenderEnumFactory implements EnumFactory<AdministrativeGender> { 1318 public AdministrativeGender fromCode(String codeString) throws IllegalArgumentException { 1319 if (codeString == null || "".equals(codeString)) 1320 if (codeString == null || "".equals(codeString)) 1321 return null; 1322 if ("male".equals(codeString)) 1323 return AdministrativeGender.MALE; 1324 if ("female".equals(codeString)) 1325 return AdministrativeGender.FEMALE; 1326 if ("other".equals(codeString)) 1327 return AdministrativeGender.OTHER; 1328 if ("unknown".equals(codeString)) 1329 return AdministrativeGender.UNKNOWN; 1330 throw new IllegalArgumentException("Unknown AdministrativeGender code '"+codeString+"'"); 1331 } 1332 1333 public Enumeration<AdministrativeGender> fromType(PrimitiveType<?> code) throws FHIRException { 1334 if (code == null) 1335 return null; 1336 if (code.isEmpty()) 1337 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.NULL, code); 1338 String codeString = ((PrimitiveType) code).asStringValue(); 1339 if (codeString == null || "".equals(codeString)) 1340 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.NULL, code); 1341 if ("male".equals(codeString)) 1342 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.MALE, code); 1343 if ("female".equals(codeString)) 1344 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.FEMALE, code); 1345 if ("other".equals(codeString)) 1346 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.OTHER, code); 1347 if ("unknown".equals(codeString)) 1348 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.UNKNOWN, code); 1349 throw new FHIRException("Unknown AdministrativeGender code '"+codeString+"'"); 1350 } 1351 public String toCode(AdministrativeGender code) { 1352 if (code == AdministrativeGender.MALE) 1353 return "male"; 1354 if (code == AdministrativeGender.FEMALE) 1355 return "female"; 1356 if (code == AdministrativeGender.OTHER) 1357 return "other"; 1358 if (code == AdministrativeGender.UNKNOWN) 1359 return "unknown"; 1360 return "?"; 1361 } 1362 public String toSystem(AdministrativeGender code) { 1363 return code.getSystem(); 1364 } 1365 } 1366 1367 public enum AllLanguages { 1368 /** 1369 * added to help the parsers 1370 */ 1371 NULL; 1372 public static AllLanguages fromCode(String codeString) throws FHIRException { 1373 if (codeString == null || "".equals(codeString)) 1374 return null; 1375 throw new FHIRException("Unknown AllLanguages code '"+codeString+"'"); 1376 } 1377 public static boolean isValidCode(String codeString) { 1378 if (codeString == null || "".equals(codeString)) 1379 return false; 1380 return Utilities.existsInList(codeString); 1381 } 1382 public String toCode() { 1383 switch (this) { 1384 case NULL: return null; 1385 default: return "?"; 1386 } 1387 } 1388 public String getSystem() { 1389 switch (this) { 1390 case NULL: return null; 1391 default: return "?"; 1392 } 1393 } 1394 public String getDefinition() { 1395 switch (this) { 1396 case NULL: return null; 1397 default: return "?"; 1398 } 1399 } 1400 public String getDisplay() { 1401 switch (this) { 1402 case NULL: return null; 1403 default: return "?"; 1404 } 1405 } 1406 } 1407 1408 public static class AllLanguagesEnumFactory implements EnumFactory<AllLanguages> { 1409 public AllLanguages fromCode(String codeString) throws IllegalArgumentException { 1410 if (codeString == null || "".equals(codeString)) 1411 if (codeString == null || "".equals(codeString)) 1412 return null; 1413 throw new IllegalArgumentException("Unknown AllLanguages code '"+codeString+"'"); 1414 } 1415 1416 public Enumeration<AllLanguages> fromType(PrimitiveType<?> code) throws FHIRException { 1417 if (code == null) 1418 return null; 1419 if (code.isEmpty()) 1420 return new Enumeration<AllLanguages>(this, AllLanguages.NULL, code); 1421 String codeString = ((PrimitiveType) code).asStringValue(); 1422 if (codeString == null || "".equals(codeString)) 1423 return new Enumeration<AllLanguages>(this, AllLanguages.NULL, code); 1424 throw new FHIRException("Unknown AllLanguages code '"+codeString+"'"); 1425 } 1426 public String toCode(AllLanguages code) { 1427 return "?"; 1428 } 1429 public String toSystem(AllLanguages code) { 1430 return code.getSystem(); 1431 } 1432 } 1433 1434 public enum BindingStrength { 1435 /** 1436 * To be conformant, the concept in this element SHALL be from the specified value set. 1437 */ 1438 REQUIRED, 1439 /** 1440 * To be conformant, the concept in this element SHALL be from the specified value set if any of the codes within the value set can apply to the concept being communicated. If the value set does not cover the concept (based on human review), alternate codings (or, data type allowing, text) may be included instead. 1441 */ 1442 EXTENSIBLE, 1443 /** 1444 * Instances are encouraged to draw from the specified codes for interoperability purposes but are not required to do so to be considered conformant. 1445 */ 1446 PREFERRED, 1447 /** 1448 * Instances are not expected or even encouraged to draw from the specified value set. The value set merely provides examples of the types of concepts intended to be included. 1449 */ 1450 EXAMPLE, 1451 /** 1452 * added to help the parsers 1453 */ 1454 NULL; 1455 public static BindingStrength fromCode(String codeString) throws FHIRException { 1456 if (codeString == null || "".equals(codeString)) 1457 return null; 1458 if ("required".equals(codeString)) 1459 return REQUIRED; 1460 if ("extensible".equals(codeString)) 1461 return EXTENSIBLE; 1462 if ("preferred".equals(codeString)) 1463 return PREFERRED; 1464 if ("example".equals(codeString)) 1465 return EXAMPLE; 1466 throw new FHIRException("Unknown BindingStrength code '"+codeString+"'"); 1467 } 1468 public static boolean isValidCode(String codeString) { 1469 if (codeString == null || "".equals(codeString)) 1470 return false; 1471 return Utilities.existsInList(codeString, "required", "extensible", "preferred", "example"); 1472 } 1473 public String toCode() { 1474 switch (this) { 1475 case REQUIRED: return "required"; 1476 case EXTENSIBLE: return "extensible"; 1477 case PREFERRED: return "preferred"; 1478 case EXAMPLE: return "example"; 1479 case NULL: return null; 1480 default: return "?"; 1481 } 1482 } 1483 public String getSystem() { 1484 switch (this) { 1485 case REQUIRED: return "http://hl7.org/fhir/binding-strength"; 1486 case EXTENSIBLE: return "http://hl7.org/fhir/binding-strength"; 1487 case PREFERRED: return "http://hl7.org/fhir/binding-strength"; 1488 case EXAMPLE: return "http://hl7.org/fhir/binding-strength"; 1489 case NULL: return null; 1490 default: return "?"; 1491 } 1492 } 1493 public String getDefinition() { 1494 switch (this) { 1495 case REQUIRED: return "To be conformant, the concept in this element SHALL be from the specified value set."; 1496 case EXTENSIBLE: return "To be conformant, the concept in this element SHALL be from the specified value set if any of the codes within the value set can apply to the concept being communicated. If the value set does not cover the concept (based on human review), alternate codings (or, data type allowing, text) may be included instead."; 1497 case PREFERRED: return "Instances are encouraged to draw from the specified codes for interoperability purposes but are not required to do so to be considered conformant."; 1498 case EXAMPLE: return "Instances are not expected or even encouraged to draw from the specified value set. The value set merely provides examples of the types of concepts intended to be included."; 1499 case NULL: return null; 1500 default: return "?"; 1501 } 1502 } 1503 public String getDisplay() { 1504 switch (this) { 1505 case REQUIRED: return "Required"; 1506 case EXTENSIBLE: return "Extensible"; 1507 case PREFERRED: return "Preferred"; 1508 case EXAMPLE: return "Example"; 1509 case NULL: return null; 1510 default: return "?"; 1511 } 1512 } 1513 } 1514 1515 public static class BindingStrengthEnumFactory implements EnumFactory<BindingStrength> { 1516 public BindingStrength fromCode(String codeString) throws IllegalArgumentException { 1517 if (codeString == null || "".equals(codeString)) 1518 if (codeString == null || "".equals(codeString)) 1519 return null; 1520 if ("required".equals(codeString)) 1521 return BindingStrength.REQUIRED; 1522 if ("extensible".equals(codeString)) 1523 return BindingStrength.EXTENSIBLE; 1524 if ("preferred".equals(codeString)) 1525 return BindingStrength.PREFERRED; 1526 if ("example".equals(codeString)) 1527 return BindingStrength.EXAMPLE; 1528 throw new IllegalArgumentException("Unknown BindingStrength code '"+codeString+"'"); 1529 } 1530 1531 public Enumeration<BindingStrength> fromType(PrimitiveType<?> code) throws FHIRException { 1532 if (code == null) 1533 return null; 1534 if (code.isEmpty()) 1535 return new Enumeration<BindingStrength>(this, BindingStrength.NULL, code); 1536 String codeString = ((PrimitiveType) code).asStringValue(); 1537 if (codeString == null || "".equals(codeString)) 1538 return new Enumeration<BindingStrength>(this, BindingStrength.NULL, code); 1539 if ("required".equals(codeString)) 1540 return new Enumeration<BindingStrength>(this, BindingStrength.REQUIRED, code); 1541 if ("extensible".equals(codeString)) 1542 return new Enumeration<BindingStrength>(this, BindingStrength.EXTENSIBLE, code); 1543 if ("preferred".equals(codeString)) 1544 return new Enumeration<BindingStrength>(this, BindingStrength.PREFERRED, code); 1545 if ("example".equals(codeString)) 1546 return new Enumeration<BindingStrength>(this, BindingStrength.EXAMPLE, code); 1547 throw new FHIRException("Unknown BindingStrength code '"+codeString+"'"); 1548 } 1549 public String toCode(BindingStrength code) { 1550 if (code == BindingStrength.REQUIRED) 1551 return "required"; 1552 if (code == BindingStrength.EXTENSIBLE) 1553 return "extensible"; 1554 if (code == BindingStrength.PREFERRED) 1555 return "preferred"; 1556 if (code == BindingStrength.EXAMPLE) 1557 return "example"; 1558 return "?"; 1559 } 1560 public String toSystem(BindingStrength code) { 1561 return code.getSystem(); 1562 } 1563 } 1564 1565 public enum CapabilityStatementKind { 1566 /** 1567 * The CapabilityStatement instance represents the present capabilities of a specific system instance. This is the kind returned by /metadata for a FHIR server end-point. 1568 */ 1569 INSTANCE, 1570 /** 1571 * The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation. 1572 */ 1573 CAPABILITY, 1574 /** 1575 * The CapabilityStatement instance represents a set of requirements for other systems to meet; e.g. as part of an implementation guide or 'request for proposal'. 1576 */ 1577 REQUIREMENTS, 1578 /** 1579 * added to help the parsers 1580 */ 1581 NULL; 1582 public static CapabilityStatementKind fromCode(String codeString) throws FHIRException { 1583 if (codeString == null || "".equals(codeString)) 1584 return null; 1585 if ("instance".equals(codeString)) 1586 return INSTANCE; 1587 if ("capability".equals(codeString)) 1588 return CAPABILITY; 1589 if ("requirements".equals(codeString)) 1590 return REQUIREMENTS; 1591 throw new FHIRException("Unknown CapabilityStatementKind code '"+codeString+"'"); 1592 } 1593 public static boolean isValidCode(String codeString) { 1594 if (codeString == null || "".equals(codeString)) 1595 return false; 1596 return Utilities.existsInList(codeString, "instance", "capability", "requirements"); 1597 } 1598 public String toCode() { 1599 switch (this) { 1600 case INSTANCE: return "instance"; 1601 case CAPABILITY: return "capability"; 1602 case REQUIREMENTS: return "requirements"; 1603 case NULL: return null; 1604 default: return "?"; 1605 } 1606 } 1607 public String getSystem() { 1608 switch (this) { 1609 case INSTANCE: return "http://hl7.org/fhir/capability-statement-kind"; 1610 case CAPABILITY: return "http://hl7.org/fhir/capability-statement-kind"; 1611 case REQUIREMENTS: return "http://hl7.org/fhir/capability-statement-kind"; 1612 case NULL: return null; 1613 default: return "?"; 1614 } 1615 } 1616 public String getDefinition() { 1617 switch (this) { 1618 case INSTANCE: return "The CapabilityStatement instance represents the present capabilities of a specific system instance. This is the kind returned by /metadata for a FHIR server end-point."; 1619 case CAPABILITY: return "The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation."; 1620 case REQUIREMENTS: return "The CapabilityStatement instance represents a set of requirements for other systems to meet; e.g. as part of an implementation guide or 'request for proposal'."; 1621 case NULL: return null; 1622 default: return "?"; 1623 } 1624 } 1625 public String getDisplay() { 1626 switch (this) { 1627 case INSTANCE: return "Instance"; 1628 case CAPABILITY: return "Capability"; 1629 case REQUIREMENTS: return "Requirements"; 1630 case NULL: return null; 1631 default: return "?"; 1632 } 1633 } 1634 } 1635 1636 public static class CapabilityStatementKindEnumFactory implements EnumFactory<CapabilityStatementKind> { 1637 public CapabilityStatementKind fromCode(String codeString) throws IllegalArgumentException { 1638 if (codeString == null || "".equals(codeString)) 1639 if (codeString == null || "".equals(codeString)) 1640 return null; 1641 if ("instance".equals(codeString)) 1642 return CapabilityStatementKind.INSTANCE; 1643 if ("capability".equals(codeString)) 1644 return CapabilityStatementKind.CAPABILITY; 1645 if ("requirements".equals(codeString)) 1646 return CapabilityStatementKind.REQUIREMENTS; 1647 throw new IllegalArgumentException("Unknown CapabilityStatementKind code '"+codeString+"'"); 1648 } 1649 1650 public Enumeration<CapabilityStatementKind> fromType(PrimitiveType<?> code) throws FHIRException { 1651 if (code == null) 1652 return null; 1653 if (code.isEmpty()) 1654 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.NULL, code); 1655 String codeString = ((PrimitiveType) code).asStringValue(); 1656 if (codeString == null || "".equals(codeString)) 1657 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.NULL, code); 1658 if ("instance".equals(codeString)) 1659 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.INSTANCE, code); 1660 if ("capability".equals(codeString)) 1661 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.CAPABILITY, code); 1662 if ("requirements".equals(codeString)) 1663 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.REQUIREMENTS, code); 1664 throw new FHIRException("Unknown CapabilityStatementKind code '"+codeString+"'"); 1665 } 1666 public String toCode(CapabilityStatementKind code) { 1667 if (code == CapabilityStatementKind.INSTANCE) 1668 return "instance"; 1669 if (code == CapabilityStatementKind.CAPABILITY) 1670 return "capability"; 1671 if (code == CapabilityStatementKind.REQUIREMENTS) 1672 return "requirements"; 1673 return "?"; 1674 } 1675 public String toSystem(CapabilityStatementKind code) { 1676 return code.getSystem(); 1677 } 1678 } 1679 1680 public enum ClaimProcessingCodes { 1681 /** 1682 * The Claim/Pre-authorization/Pre-determination has been received but processing has not begun. 1683 */ 1684 QUEUED, 1685 /** 1686 * The processing has completed without errors 1687 */ 1688 COMPLETE, 1689 /** 1690 * One or more errors have been detected in the Claim 1691 */ 1692 ERROR, 1693 /** 1694 * No errors have been detected in the Claim and some of the adjudication has been performed. 1695 */ 1696 PARTIAL, 1697 /** 1698 * added to help the parsers 1699 */ 1700 NULL; 1701 public static ClaimProcessingCodes fromCode(String codeString) throws FHIRException { 1702 if (codeString == null || "".equals(codeString)) 1703 return null; 1704 if ("queued".equals(codeString)) 1705 return QUEUED; 1706 if ("complete".equals(codeString)) 1707 return COMPLETE; 1708 if ("error".equals(codeString)) 1709 return ERROR; 1710 if ("partial".equals(codeString)) 1711 return PARTIAL; 1712 throw new FHIRException("Unknown ClaimProcessingCodes code '"+codeString+"'"); 1713 } 1714 public static boolean isValidCode(String codeString) { 1715 if (codeString == null || "".equals(codeString)) 1716 return false; 1717 return Utilities.existsInList(codeString, "queued", "complete", "error", "partial"); 1718 } 1719 public String toCode() { 1720 switch (this) { 1721 case QUEUED: return "queued"; 1722 case COMPLETE: return "complete"; 1723 case ERROR: return "error"; 1724 case PARTIAL: return "partial"; 1725 case NULL: return null; 1726 default: return "?"; 1727 } 1728 } 1729 public String getSystem() { 1730 switch (this) { 1731 case QUEUED: return "http://hl7.org/fhir/claim-outcome"; 1732 case COMPLETE: return "http://hl7.org/fhir/claim-outcome"; 1733 case ERROR: return "http://hl7.org/fhir/claim-outcome"; 1734 case PARTIAL: return "http://hl7.org/fhir/claim-outcome"; 1735 case NULL: return null; 1736 default: return "?"; 1737 } 1738 } 1739 public String getDefinition() { 1740 switch (this) { 1741 case QUEUED: return "The Claim/Pre-authorization/Pre-determination has been received but processing has not begun."; 1742 case COMPLETE: return "The processing has completed without errors"; 1743 case ERROR: return "One or more errors have been detected in the Claim"; 1744 case PARTIAL: return "No errors have been detected in the Claim and some of the adjudication has been performed."; 1745 case NULL: return null; 1746 default: return "?"; 1747 } 1748 } 1749 public String getDisplay() { 1750 switch (this) { 1751 case QUEUED: return "Queued"; 1752 case COMPLETE: return "Processing Complete"; 1753 case ERROR: return "Error"; 1754 case PARTIAL: return "Partial Processing"; 1755 case NULL: return null; 1756 default: return "?"; 1757 } 1758 } 1759 } 1760 1761 public static class ClaimProcessingCodesEnumFactory implements EnumFactory<ClaimProcessingCodes> { 1762 public ClaimProcessingCodes fromCode(String codeString) throws IllegalArgumentException { 1763 if (codeString == null || "".equals(codeString)) 1764 if (codeString == null || "".equals(codeString)) 1765 return null; 1766 if ("queued".equals(codeString)) 1767 return ClaimProcessingCodes.QUEUED; 1768 if ("complete".equals(codeString)) 1769 return ClaimProcessingCodes.COMPLETE; 1770 if ("error".equals(codeString)) 1771 return ClaimProcessingCodes.ERROR; 1772 if ("partial".equals(codeString)) 1773 return ClaimProcessingCodes.PARTIAL; 1774 throw new IllegalArgumentException("Unknown ClaimProcessingCodes code '"+codeString+"'"); 1775 } 1776 1777 public Enumeration<ClaimProcessingCodes> fromType(PrimitiveType<?> code) throws FHIRException { 1778 if (code == null) 1779 return null; 1780 if (code.isEmpty()) 1781 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.NULL, code); 1782 String codeString = ((PrimitiveType) code).asStringValue(); 1783 if (codeString == null || "".equals(codeString)) 1784 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.NULL, code); 1785 if ("queued".equals(codeString)) 1786 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.QUEUED, code); 1787 if ("complete".equals(codeString)) 1788 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.COMPLETE, code); 1789 if ("error".equals(codeString)) 1790 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.ERROR, code); 1791 if ("partial".equals(codeString)) 1792 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.PARTIAL, code); 1793 throw new FHIRException("Unknown ClaimProcessingCodes code '"+codeString+"'"); 1794 } 1795 public String toCode(ClaimProcessingCodes code) { 1796 if (code == ClaimProcessingCodes.QUEUED) 1797 return "queued"; 1798 if (code == ClaimProcessingCodes.COMPLETE) 1799 return "complete"; 1800 if (code == ClaimProcessingCodes.ERROR) 1801 return "error"; 1802 if (code == ClaimProcessingCodes.PARTIAL) 1803 return "partial"; 1804 return "?"; 1805 } 1806 public String toSystem(ClaimProcessingCodes code) { 1807 return code.getSystem(); 1808 } 1809 } 1810 1811 public enum CodeSystemContentMode { 1812 /** 1813 * None of the concepts defined by the code system are included in the code system resource. 1814 */ 1815 NOTPRESENT, 1816 /** 1817 * A subset of the valid externally defined concepts are included in the code system resource. There is no specific purpose or documented intent other than for illustrative purposes. 1818 */ 1819 EXAMPLE, 1820 /** 1821 * A subset of the code system concepts are included in the code system resource. This is a curated subset released for a specific purpose under the governance of the code system steward, and that the intent, bounds and consequences of the fragmentation are clearly defined in the fragment or the code system documentation. Fragments are also known as partitions. 1822 */ 1823 FRAGMENT, 1824 /** 1825 * All the concepts defined by the code system are included in the code system resource. 1826 */ 1827 COMPLETE, 1828 /** 1829 * The resource doesn't define any new concepts; it just provides additional designations and properties to another code system. 1830 */ 1831 SUPPLEMENT, 1832 /** 1833 * added to help the parsers 1834 */ 1835 NULL; 1836 public static CodeSystemContentMode fromCode(String codeString) throws FHIRException { 1837 if (codeString == null || "".equals(codeString)) 1838 return null; 1839 if ("not-present".equals(codeString)) 1840 return NOTPRESENT; 1841 if ("example".equals(codeString)) 1842 return EXAMPLE; 1843 if ("fragment".equals(codeString)) 1844 return FRAGMENT; 1845 if ("complete".equals(codeString)) 1846 return COMPLETE; 1847 if ("supplement".equals(codeString)) 1848 return SUPPLEMENT; 1849 throw new FHIRException("Unknown CodeSystemContentMode code '"+codeString+"'"); 1850 } 1851 public static boolean isValidCode(String codeString) { 1852 if (codeString == null || "".equals(codeString)) 1853 return false; 1854 return Utilities.existsInList(codeString, "not-present", "example", "fragment", "complete", "supplement"); 1855 } 1856 public String toCode() { 1857 switch (this) { 1858 case NOTPRESENT: return "not-present"; 1859 case EXAMPLE: return "example"; 1860 case FRAGMENT: return "fragment"; 1861 case COMPLETE: return "complete"; 1862 case SUPPLEMENT: return "supplement"; 1863 case NULL: return null; 1864 default: return "?"; 1865 } 1866 } 1867 public String getSystem() { 1868 switch (this) { 1869 case NOTPRESENT: return "http://hl7.org/fhir/codesystem-content-mode"; 1870 case EXAMPLE: return "http://hl7.org/fhir/codesystem-content-mode"; 1871 case FRAGMENT: return "http://hl7.org/fhir/codesystem-content-mode"; 1872 case COMPLETE: return "http://hl7.org/fhir/codesystem-content-mode"; 1873 case SUPPLEMENT: return "http://hl7.org/fhir/codesystem-content-mode"; 1874 case NULL: return null; 1875 default: return "?"; 1876 } 1877 } 1878 public String getDefinition() { 1879 switch (this) { 1880 case NOTPRESENT: return "None of the concepts defined by the code system are included in the code system resource."; 1881 case EXAMPLE: return "A subset of the valid externally defined concepts are included in the code system resource. There is no specific purpose or documented intent other than for illustrative purposes."; 1882 case FRAGMENT: return "A subset of the code system concepts are included in the code system resource. This is a curated subset released for a specific purpose under the governance of the code system steward, and that the intent, bounds and consequences of the fragmentation are clearly defined in the fragment or the code system documentation. Fragments are also known as partitions."; 1883 case COMPLETE: return "All the concepts defined by the code system are included in the code system resource."; 1884 case SUPPLEMENT: return "The resource doesn't define any new concepts; it just provides additional designations and properties to another code system."; 1885 case NULL: return null; 1886 default: return "?"; 1887 } 1888 } 1889 public String getDisplay() { 1890 switch (this) { 1891 case NOTPRESENT: return "Not Present"; 1892 case EXAMPLE: return "Example"; 1893 case FRAGMENT: return "Fragment"; 1894 case COMPLETE: return "Complete"; 1895 case SUPPLEMENT: return "Supplement"; 1896 case NULL: return null; 1897 default: return "?"; 1898 } 1899 } 1900 } 1901 1902 public static class CodeSystemContentModeEnumFactory implements EnumFactory<CodeSystemContentMode> { 1903 public CodeSystemContentMode fromCode(String codeString) throws IllegalArgumentException { 1904 if (codeString == null || "".equals(codeString)) 1905 if (codeString == null || "".equals(codeString)) 1906 return null; 1907 if ("not-present".equals(codeString)) 1908 return CodeSystemContentMode.NOTPRESENT; 1909 if ("example".equals(codeString)) 1910 return CodeSystemContentMode.EXAMPLE; 1911 if ("fragment".equals(codeString)) 1912 return CodeSystemContentMode.FRAGMENT; 1913 if ("complete".equals(codeString)) 1914 return CodeSystemContentMode.COMPLETE; 1915 if ("supplement".equals(codeString)) 1916 return CodeSystemContentMode.SUPPLEMENT; 1917 throw new IllegalArgumentException("Unknown CodeSystemContentMode code '"+codeString+"'"); 1918 } 1919 1920 public Enumeration<CodeSystemContentMode> fromType(PrimitiveType<?> code) throws FHIRException { 1921 if (code == null) 1922 return null; 1923 if (code.isEmpty()) 1924 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.NULL, code); 1925 String codeString = ((PrimitiveType) code).asStringValue(); 1926 if (codeString == null || "".equals(codeString)) 1927 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.NULL, code); 1928 if ("not-present".equals(codeString)) 1929 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.NOTPRESENT, code); 1930 if ("example".equals(codeString)) 1931 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.EXAMPLE, code); 1932 if ("fragment".equals(codeString)) 1933 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.FRAGMENT, code); 1934 if ("complete".equals(codeString)) 1935 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.COMPLETE, code); 1936 if ("supplement".equals(codeString)) 1937 return new Enumeration<CodeSystemContentMode>(this, CodeSystemContentMode.SUPPLEMENT, code); 1938 throw new FHIRException("Unknown CodeSystemContentMode code '"+codeString+"'"); 1939 } 1940 public String toCode(CodeSystemContentMode code) { 1941 if (code == CodeSystemContentMode.NOTPRESENT) 1942 return "not-present"; 1943 if (code == CodeSystemContentMode.EXAMPLE) 1944 return "example"; 1945 if (code == CodeSystemContentMode.FRAGMENT) 1946 return "fragment"; 1947 if (code == CodeSystemContentMode.COMPLETE) 1948 return "complete"; 1949 if (code == CodeSystemContentMode.SUPPLEMENT) 1950 return "supplement"; 1951 return "?"; 1952 } 1953 public String toSystem(CodeSystemContentMode code) { 1954 return code.getSystem(); 1955 } 1956 } 1957 1958 public enum CommonLanguages { 1959 /** 1960 * null 1961 */ 1962 AR, 1963 /** 1964 * null 1965 */ 1966 BG, 1967 /** 1968 * null 1969 */ 1970 BGBG, 1971 /** 1972 * null 1973 */ 1974 BN, 1975 /** 1976 * null 1977 */ 1978 CS, 1979 /** 1980 * null 1981 */ 1982 CSCZ, 1983 /** 1984 * null 1985 */ 1986 BS, 1987 /** 1988 * null 1989 */ 1990 BSBA, 1991 /** 1992 * null 1993 */ 1994 DA, 1995 /** 1996 * null 1997 */ 1998 DADK, 1999 /** 2000 * null 2001 */ 2002 DE, 2003 /** 2004 * null 2005 */ 2006 DEAT, 2007 /** 2008 * null 2009 */ 2010 DECH, 2011 /** 2012 * null 2013 */ 2014 DEDE, 2015 /** 2016 * null 2017 */ 2018 EL, 2019 /** 2020 * null 2021 */ 2022 ELGR, 2023 /** 2024 * null 2025 */ 2026 EN, 2027 /** 2028 * null 2029 */ 2030 ENAU, 2031 /** 2032 * null 2033 */ 2034 ENCA, 2035 /** 2036 * null 2037 */ 2038 ENGB, 2039 /** 2040 * null 2041 */ 2042 ENIN, 2043 /** 2044 * null 2045 */ 2046 ENNZ, 2047 /** 2048 * null 2049 */ 2050 ENSG, 2051 /** 2052 * null 2053 */ 2054 ENUS, 2055 /** 2056 * null 2057 */ 2058 ES, 2059 /** 2060 * null 2061 */ 2062 ESAR, 2063 /** 2064 * null 2065 */ 2066 ESES, 2067 /** 2068 * null 2069 */ 2070 ESUY, 2071 /** 2072 * null 2073 */ 2074 ET, 2075 /** 2076 * null 2077 */ 2078 ETEE, 2079 /** 2080 * null 2081 */ 2082 FI, 2083 /** 2084 * null 2085 */ 2086 FR, 2087 /** 2088 * null 2089 */ 2090 FRBE, 2091 /** 2092 * null 2093 */ 2094 FRCH, 2095 /** 2096 * null 2097 */ 2098 FRFR, 2099 /** 2100 * null 2101 */ 2102 FIFI, 2103 /** 2104 * null 2105 */ 2106 FRCA, 2107 /** 2108 * null 2109 */ 2110 FY, 2111 /** 2112 * null 2113 */ 2114 FYNL, 2115 /** 2116 * null 2117 */ 2118 HI, 2119 /** 2120 * null 2121 */ 2122 HR, 2123 /** 2124 * null 2125 */ 2126 HRHR, 2127 /** 2128 * null 2129 */ 2130 IS, 2131 /** 2132 * null 2133 */ 2134 ISIS, 2135 /** 2136 * null 2137 */ 2138 IT, 2139 /** 2140 * null 2141 */ 2142 ITCH, 2143 /** 2144 * null 2145 */ 2146 ITIT, 2147 /** 2148 * null 2149 */ 2150 JA, 2151 /** 2152 * null 2153 */ 2154 KO, 2155 /** 2156 * null 2157 */ 2158 LT, 2159 /** 2160 * null 2161 */ 2162 LTLT, 2163 /** 2164 * null 2165 */ 2166 LV, 2167 /** 2168 * null 2169 */ 2170 LVLV, 2171 /** 2172 * null 2173 */ 2174 NL, 2175 /** 2176 * null 2177 */ 2178 NLBE, 2179 /** 2180 * null 2181 */ 2182 NLNL, 2183 /** 2184 * null 2185 */ 2186 NO, 2187 /** 2188 * null 2189 */ 2190 NONO, 2191 /** 2192 * null 2193 */ 2194 PA, 2195 /** 2196 * null 2197 */ 2198 PL, 2199 /** 2200 * null 2201 */ 2202 PLPL, 2203 /** 2204 * null 2205 */ 2206 PT, 2207 /** 2208 * null 2209 */ 2210 PTPT, 2211 /** 2212 * null 2213 */ 2214 PTBR, 2215 /** 2216 * null 2217 */ 2218 RO, 2219 /** 2220 * null 2221 */ 2222 RORO, 2223 /** 2224 * null 2225 */ 2226 RU, 2227 /** 2228 * null 2229 */ 2230 RURU, 2231 /** 2232 * null 2233 */ 2234 SK, 2235 /** 2236 * null 2237 */ 2238 SKSK, 2239 /** 2240 * null 2241 */ 2242 SL, 2243 /** 2244 * null 2245 */ 2246 SLSI, 2247 /** 2248 * null 2249 */ 2250 SR, 2251 /** 2252 * null 2253 */ 2254 SRRS, 2255 /** 2256 * null 2257 */ 2258 SV, 2259 /** 2260 * null 2261 */ 2262 SVSE, 2263 /** 2264 * null 2265 */ 2266 TE, 2267 /** 2268 * null 2269 */ 2270 ZH, 2271 /** 2272 * null 2273 */ 2274 ZHCN, 2275 /** 2276 * null 2277 */ 2278 ZHHK, 2279 /** 2280 * null 2281 */ 2282 ZHSG, 2283 /** 2284 * null 2285 */ 2286 ZHTW, 2287 /** 2288 * added to help the parsers 2289 */ 2290 NULL; 2291 public static CommonLanguages fromCode(String codeString) throws FHIRException { 2292 if (codeString == null || "".equals(codeString)) 2293 return null; 2294 if ("ar".equals(codeString)) 2295 return AR; 2296 if ("bg".equals(codeString)) 2297 return BG; 2298 if ("bg-BG".equals(codeString)) 2299 return BGBG; 2300 if ("bn".equals(codeString)) 2301 return BN; 2302 if ("cs".equals(codeString)) 2303 return CS; 2304 if ("cs-CZ".equals(codeString)) 2305 return CSCZ; 2306 if ("bs".equals(codeString)) 2307 return BS; 2308 if ("bs-BA".equals(codeString)) 2309 return BSBA; 2310 if ("da".equals(codeString)) 2311 return DA; 2312 if ("da-DK".equals(codeString)) 2313 return DADK; 2314 if ("de".equals(codeString)) 2315 return DE; 2316 if ("de-AT".equals(codeString)) 2317 return DEAT; 2318 if ("de-CH".equals(codeString)) 2319 return DECH; 2320 if ("de-DE".equals(codeString)) 2321 return DEDE; 2322 if ("el".equals(codeString)) 2323 return EL; 2324 if ("el-GR".equals(codeString)) 2325 return ELGR; 2326 if ("en".equals(codeString)) 2327 return EN; 2328 if ("en-AU".equals(codeString)) 2329 return ENAU; 2330 if ("en-CA".equals(codeString)) 2331 return ENCA; 2332 if ("en-GB".equals(codeString)) 2333 return ENGB; 2334 if ("en-IN".equals(codeString)) 2335 return ENIN; 2336 if ("en-NZ".equals(codeString)) 2337 return ENNZ; 2338 if ("en-SG".equals(codeString)) 2339 return ENSG; 2340 if ("en-US".equals(codeString)) 2341 return ENUS; 2342 if ("es".equals(codeString)) 2343 return ES; 2344 if ("es-AR".equals(codeString)) 2345 return ESAR; 2346 if ("es-ES".equals(codeString)) 2347 return ESES; 2348 if ("es-UY".equals(codeString)) 2349 return ESUY; 2350 if ("et".equals(codeString)) 2351 return ET; 2352 if ("et-EE".equals(codeString)) 2353 return ETEE; 2354 if ("fi".equals(codeString)) 2355 return FI; 2356 if ("fr".equals(codeString)) 2357 return FR; 2358 if ("fr-BE".equals(codeString)) 2359 return FRBE; 2360 if ("fr-CH".equals(codeString)) 2361 return FRCH; 2362 if ("fr-FR".equals(codeString)) 2363 return FRFR; 2364 if ("fi-FI".equals(codeString)) 2365 return FIFI; 2366 if ("fr-CA".equals(codeString)) 2367 return FRCA; 2368 if ("fy".equals(codeString)) 2369 return FY; 2370 if ("fy-NL".equals(codeString)) 2371 return FYNL; 2372 if ("hi".equals(codeString)) 2373 return HI; 2374 if ("hr".equals(codeString)) 2375 return HR; 2376 if ("hr-HR".equals(codeString)) 2377 return HRHR; 2378 if ("is".equals(codeString)) 2379 return IS; 2380 if ("is-IS".equals(codeString)) 2381 return ISIS; 2382 if ("it".equals(codeString)) 2383 return IT; 2384 if ("it-CH".equals(codeString)) 2385 return ITCH; 2386 if ("it-IT".equals(codeString)) 2387 return ITIT; 2388 if ("ja".equals(codeString)) 2389 return JA; 2390 if ("ko".equals(codeString)) 2391 return KO; 2392 if ("lt".equals(codeString)) 2393 return LT; 2394 if ("lt-LT".equals(codeString)) 2395 return LTLT; 2396 if ("lv".equals(codeString)) 2397 return LV; 2398 if ("lv-LV".equals(codeString)) 2399 return LVLV; 2400 if ("nl".equals(codeString)) 2401 return NL; 2402 if ("nl-BE".equals(codeString)) 2403 return NLBE; 2404 if ("nl-NL".equals(codeString)) 2405 return NLNL; 2406 if ("no".equals(codeString)) 2407 return NO; 2408 if ("no-NO".equals(codeString)) 2409 return NONO; 2410 if ("pa".equals(codeString)) 2411 return PA; 2412 if ("pl".equals(codeString)) 2413 return PL; 2414 if ("pl-PL".equals(codeString)) 2415 return PLPL; 2416 if ("pt".equals(codeString)) 2417 return PT; 2418 if ("pt-PT".equals(codeString)) 2419 return PTPT; 2420 if ("pt-BR".equals(codeString)) 2421 return PTBR; 2422 if ("ro".equals(codeString)) 2423 return RO; 2424 if ("ro-RO".equals(codeString)) 2425 return RORO; 2426 if ("ru".equals(codeString)) 2427 return RU; 2428 if ("ru-RU".equals(codeString)) 2429 return RURU; 2430 if ("sk".equals(codeString)) 2431 return SK; 2432 if ("sk-SK".equals(codeString)) 2433 return SKSK; 2434 if ("sl".equals(codeString)) 2435 return SL; 2436 if ("sl-SI".equals(codeString)) 2437 return SLSI; 2438 if ("sr".equals(codeString)) 2439 return SR; 2440 if ("sr-RS".equals(codeString)) 2441 return SRRS; 2442 if ("sv".equals(codeString)) 2443 return SV; 2444 if ("sv-SE".equals(codeString)) 2445 return SVSE; 2446 if ("te".equals(codeString)) 2447 return TE; 2448 if ("zh".equals(codeString)) 2449 return ZH; 2450 if ("zh-CN".equals(codeString)) 2451 return ZHCN; 2452 if ("zh-HK".equals(codeString)) 2453 return ZHHK; 2454 if ("zh-SG".equals(codeString)) 2455 return ZHSG; 2456 if ("zh-TW".equals(codeString)) 2457 return ZHTW; 2458 throw new FHIRException("Unknown CommonLanguages code '"+codeString+"'"); 2459 } 2460 public static boolean isValidCode(String codeString) { 2461 if (codeString == null || "".equals(codeString)) 2462 return false; 2463 return Utilities.existsInList(codeString, "ar", "bg", "bg-BG", "bn", "cs", "cs-CZ", "bs", "bs-BA", "da", "da-DK", "de", "de-AT", "de-CH", "de-DE", "el", "el-GR", "en", "en-AU", "en-CA", "en-GB", "en-IN", "en-NZ", "en-SG", "en-US", "es", "es-AR", "es-ES", "es-UY", "et", "et-EE", "fi", "fr", "fr-BE", "fr-CH", "fr-FR", "fi-FI", "fr-CA", "fy", "fy-NL", "hi", "hr", "hr-HR", "is", "is-IS", "it", "it-CH", "it-IT", "ja", "ko", "lt", "lt-LT", "lv", "lv-LV", "nl", "nl-BE", "nl-NL", "no", "no-NO", "pa", "pl", "pl-PL", "pt", "pt-PT", "pt-BR", "ro", "ro-RO", "ru", "ru-RU", "sk", "sk-SK", "sl", "sl-SI", "sr", "sr-RS", "sv", "sv-SE", "te", "zh", "zh-CN", "zh-HK", "zh-SG", "zh-TW"); 2464 } 2465 public String toCode() { 2466 switch (this) { 2467 case AR: return "ar"; 2468 case BG: return "bg"; 2469 case BGBG: return "bg-BG"; 2470 case BN: return "bn"; 2471 case CS: return "cs"; 2472 case CSCZ: return "cs-CZ"; 2473 case BS: return "bs"; 2474 case BSBA: return "bs-BA"; 2475 case DA: return "da"; 2476 case DADK: return "da-DK"; 2477 case DE: return "de"; 2478 case DEAT: return "de-AT"; 2479 case DECH: return "de-CH"; 2480 case DEDE: return "de-DE"; 2481 case EL: return "el"; 2482 case ELGR: return "el-GR"; 2483 case EN: return "en"; 2484 case ENAU: return "en-AU"; 2485 case ENCA: return "en-CA"; 2486 case ENGB: return "en-GB"; 2487 case ENIN: return "en-IN"; 2488 case ENNZ: return "en-NZ"; 2489 case ENSG: return "en-SG"; 2490 case ENUS: return "en-US"; 2491 case ES: return "es"; 2492 case ESAR: return "es-AR"; 2493 case ESES: return "es-ES"; 2494 case ESUY: return "es-UY"; 2495 case ET: return "et"; 2496 case ETEE: return "et-EE"; 2497 case FI: return "fi"; 2498 case FR: return "fr"; 2499 case FRBE: return "fr-BE"; 2500 case FRCH: return "fr-CH"; 2501 case FRFR: return "fr-FR"; 2502 case FIFI: return "fi-FI"; 2503 case FRCA: return "fr-CA"; 2504 case FY: return "fy"; 2505 case FYNL: return "fy-NL"; 2506 case HI: return "hi"; 2507 case HR: return "hr"; 2508 case HRHR: return "hr-HR"; 2509 case IS: return "is"; 2510 case ISIS: return "is-IS"; 2511 case IT: return "it"; 2512 case ITCH: return "it-CH"; 2513 case ITIT: return "it-IT"; 2514 case JA: return "ja"; 2515 case KO: return "ko"; 2516 case LT: return "lt"; 2517 case LTLT: return "lt-LT"; 2518 case LV: return "lv"; 2519 case LVLV: return "lv-LV"; 2520 case NL: return "nl"; 2521 case NLBE: return "nl-BE"; 2522 case NLNL: return "nl-NL"; 2523 case NO: return "no"; 2524 case NONO: return "no-NO"; 2525 case PA: return "pa"; 2526 case PL: return "pl"; 2527 case PLPL: return "pl-PL"; 2528 case PT: return "pt"; 2529 case PTPT: return "pt-PT"; 2530 case PTBR: return "pt-BR"; 2531 case RO: return "ro"; 2532 case RORO: return "ro-RO"; 2533 case RU: return "ru"; 2534 case RURU: return "ru-RU"; 2535 case SK: return "sk"; 2536 case SKSK: return "sk-SK"; 2537 case SL: return "sl"; 2538 case SLSI: return "sl-SI"; 2539 case SR: return "sr"; 2540 case SRRS: return "sr-RS"; 2541 case SV: return "sv"; 2542 case SVSE: return "sv-SE"; 2543 case TE: return "te"; 2544 case ZH: return "zh"; 2545 case ZHCN: return "zh-CN"; 2546 case ZHHK: return "zh-HK"; 2547 case ZHSG: return "zh-SG"; 2548 case ZHTW: return "zh-TW"; 2549 case NULL: return null; 2550 default: return "?"; 2551 } 2552 } 2553 public String getSystem() { 2554 switch (this) { 2555 case AR: return "urn:ietf:bcp:47"; 2556 case BG: return "urn:ietf:bcp:47"; 2557 case BGBG: return "urn:ietf:bcp:47"; 2558 case BN: return "urn:ietf:bcp:47"; 2559 case CS: return "urn:ietf:bcp:47"; 2560 case CSCZ: return "urn:ietf:bcp:47"; 2561 case BS: return "urn:ietf:bcp:47"; 2562 case BSBA: return "urn:ietf:bcp:47"; 2563 case DA: return "urn:ietf:bcp:47"; 2564 case DADK: return "urn:ietf:bcp:47"; 2565 case DE: return "urn:ietf:bcp:47"; 2566 case DEAT: return "urn:ietf:bcp:47"; 2567 case DECH: return "urn:ietf:bcp:47"; 2568 case DEDE: return "urn:ietf:bcp:47"; 2569 case EL: return "urn:ietf:bcp:47"; 2570 case ELGR: return "urn:ietf:bcp:47"; 2571 case EN: return "urn:ietf:bcp:47"; 2572 case ENAU: return "urn:ietf:bcp:47"; 2573 case ENCA: return "urn:ietf:bcp:47"; 2574 case ENGB: return "urn:ietf:bcp:47"; 2575 case ENIN: return "urn:ietf:bcp:47"; 2576 case ENNZ: return "urn:ietf:bcp:47"; 2577 case ENSG: return "urn:ietf:bcp:47"; 2578 case ENUS: return "urn:ietf:bcp:47"; 2579 case ES: return "urn:ietf:bcp:47"; 2580 case ESAR: return "urn:ietf:bcp:47"; 2581 case ESES: return "urn:ietf:bcp:47"; 2582 case ESUY: return "urn:ietf:bcp:47"; 2583 case ET: return "urn:ietf:bcp:47"; 2584 case ETEE: return "urn:ietf:bcp:47"; 2585 case FI: return "urn:ietf:bcp:47"; 2586 case FR: return "urn:ietf:bcp:47"; 2587 case FRBE: return "urn:ietf:bcp:47"; 2588 case FRCH: return "urn:ietf:bcp:47"; 2589 case FRFR: return "urn:ietf:bcp:47"; 2590 case FIFI: return "urn:ietf:bcp:47"; 2591 case FRCA: return "urn:ietf:bcp:47"; 2592 case FY: return "urn:ietf:bcp:47"; 2593 case FYNL: return "urn:ietf:bcp:47"; 2594 case HI: return "urn:ietf:bcp:47"; 2595 case HR: return "urn:ietf:bcp:47"; 2596 case HRHR: return "urn:ietf:bcp:47"; 2597 case IS: return "urn:ietf:bcp:47"; 2598 case ISIS: return "urn:ietf:bcp:47"; 2599 case IT: return "urn:ietf:bcp:47"; 2600 case ITCH: return "urn:ietf:bcp:47"; 2601 case ITIT: return "urn:ietf:bcp:47"; 2602 case JA: return "urn:ietf:bcp:47"; 2603 case KO: return "urn:ietf:bcp:47"; 2604 case LT: return "urn:ietf:bcp:47"; 2605 case LTLT: return "urn:ietf:bcp:47"; 2606 case LV: return "urn:ietf:bcp:47"; 2607 case LVLV: return "urn:ietf:bcp:47"; 2608 case NL: return "urn:ietf:bcp:47"; 2609 case NLBE: return "urn:ietf:bcp:47"; 2610 case NLNL: return "urn:ietf:bcp:47"; 2611 case NO: return "urn:ietf:bcp:47"; 2612 case NONO: return "urn:ietf:bcp:47"; 2613 case PA: return "urn:ietf:bcp:47"; 2614 case PL: return "urn:ietf:bcp:47"; 2615 case PLPL: return "urn:ietf:bcp:47"; 2616 case PT: return "urn:ietf:bcp:47"; 2617 case PTPT: return "urn:ietf:bcp:47"; 2618 case PTBR: return "urn:ietf:bcp:47"; 2619 case RO: return "urn:ietf:bcp:47"; 2620 case RORO: return "urn:ietf:bcp:47"; 2621 case RU: return "urn:ietf:bcp:47"; 2622 case RURU: return "urn:ietf:bcp:47"; 2623 case SK: return "urn:ietf:bcp:47"; 2624 case SKSK: return "urn:ietf:bcp:47"; 2625 case SL: return "urn:ietf:bcp:47"; 2626 case SLSI: return "urn:ietf:bcp:47"; 2627 case SR: return "urn:ietf:bcp:47"; 2628 case SRRS: return "urn:ietf:bcp:47"; 2629 case SV: return "urn:ietf:bcp:47"; 2630 case SVSE: return "urn:ietf:bcp:47"; 2631 case TE: return "urn:ietf:bcp:47"; 2632 case ZH: return "urn:ietf:bcp:47"; 2633 case ZHCN: return "urn:ietf:bcp:47"; 2634 case ZHHK: return "urn:ietf:bcp:47"; 2635 case ZHSG: return "urn:ietf:bcp:47"; 2636 case ZHTW: return "urn:ietf:bcp:47"; 2637 case NULL: return null; 2638 default: return "?"; 2639 } 2640 } 2641 public String getDefinition() { 2642 switch (this) { 2643 case AR: return ""; 2644 case BG: return ""; 2645 case BGBG: return ""; 2646 case BN: return ""; 2647 case CS: return ""; 2648 case CSCZ: return ""; 2649 case BS: return ""; 2650 case BSBA: return ""; 2651 case DA: return ""; 2652 case DADK: return ""; 2653 case DE: return ""; 2654 case DEAT: return ""; 2655 case DECH: return ""; 2656 case DEDE: return ""; 2657 case EL: return ""; 2658 case ELGR: return ""; 2659 case EN: return ""; 2660 case ENAU: return ""; 2661 case ENCA: return ""; 2662 case ENGB: return ""; 2663 case ENIN: return ""; 2664 case ENNZ: return ""; 2665 case ENSG: return ""; 2666 case ENUS: return ""; 2667 case ES: return ""; 2668 case ESAR: return ""; 2669 case ESES: return ""; 2670 case ESUY: return ""; 2671 case ET: return ""; 2672 case ETEE: return ""; 2673 case FI: return ""; 2674 case FR: return ""; 2675 case FRBE: return ""; 2676 case FRCH: return ""; 2677 case FRFR: return ""; 2678 case FIFI: return ""; 2679 case FRCA: return ""; 2680 case FY: return ""; 2681 case FYNL: return ""; 2682 case HI: return ""; 2683 case HR: return ""; 2684 case HRHR: return ""; 2685 case IS: return ""; 2686 case ISIS: return ""; 2687 case IT: return ""; 2688 case ITCH: return ""; 2689 case ITIT: return ""; 2690 case JA: return ""; 2691 case KO: return ""; 2692 case LT: return ""; 2693 case LTLT: return ""; 2694 case LV: return ""; 2695 case LVLV: return ""; 2696 case NL: return ""; 2697 case NLBE: return ""; 2698 case NLNL: return ""; 2699 case NO: return ""; 2700 case NONO: return ""; 2701 case PA: return ""; 2702 case PL: return ""; 2703 case PLPL: return ""; 2704 case PT: return ""; 2705 case PTPT: return ""; 2706 case PTBR: return ""; 2707 case RO: return ""; 2708 case RORO: return ""; 2709 case RU: return ""; 2710 case RURU: return ""; 2711 case SK: return ""; 2712 case SKSK: return ""; 2713 case SL: return ""; 2714 case SLSI: return ""; 2715 case SR: return ""; 2716 case SRRS: return ""; 2717 case SV: return ""; 2718 case SVSE: return ""; 2719 case TE: return ""; 2720 case ZH: return ""; 2721 case ZHCN: return ""; 2722 case ZHHK: return ""; 2723 case ZHSG: return ""; 2724 case ZHTW: return ""; 2725 case NULL: return null; 2726 default: return "?"; 2727 } 2728 } 2729 public String getDisplay() { 2730 switch (this) { 2731 case AR: return "Arabisk"; 2732 case BG: return "Bulgarian"; 2733 case BGBG: return "Bulgarian (Bulgaria)"; 2734 case BN: return "Bengali"; 2735 case CS: return "Czech"; 2736 case CSCZ: return "Czech (Czechia)"; 2737 case BS: return "Bosnian"; 2738 case BSBA: return "Bosnian (Bosnia and Herzegovina))"; 2739 case DA: return "Danish"; 2740 case DADK: return "Danish (Denmark)"; 2741 case DE: return "German"; 2742 case DEAT: return "German (Austria)"; 2743 case DECH: return "German (Switzerland)"; 2744 case DEDE: return "German (Germany)"; 2745 case EL: return "Greek"; 2746 case ELGR: return "Greek (Greece)"; 2747 case EN: return "English"; 2748 case ENAU: return "English (Australia)"; 2749 case ENCA: return "English (Canada)"; 2750 case ENGB: return "English (Great Britain)"; 2751 case ENIN: return "English (India)"; 2752 case ENNZ: return "English (New Zealand)"; 2753 case ENSG: return "English (Singapore)"; 2754 case ENUS: return "English (United States)"; 2755 case ES: return "Spanish"; 2756 case ESAR: return "Spanish (Argentina)"; 2757 case ESES: return "Spanish (Spain)"; 2758 case ESUY: return "Spanish (Uruguay)"; 2759 case ET: return "Estonian"; 2760 case ETEE: return "Estonian (Estonia)"; 2761 case FI: return "Finnish"; 2762 case FR: return "French"; 2763 case FRBE: return "French (Belgium)"; 2764 case FRCH: return "French (Switzerland)"; 2765 case FRFR: return "French (France)"; 2766 case FIFI: return "Finnish (Finland)"; 2767 case FRCA: return "French (Canada)"; 2768 case FY: return "Frisian"; 2769 case FYNL: return "Frisian (Netherlands)"; 2770 case HI: return "Hindi"; 2771 case HR: return "Croatian"; 2772 case HRHR: return "Croatian (Croatia)"; 2773 case IS: return "Icelandic"; 2774 case ISIS: return "Icelandic (Iceland)"; 2775 case IT: return "Italian"; 2776 case ITCH: return "Italian (Switzerland)"; 2777 case ITIT: return "Italian (Italy)"; 2778 case JA: return "Japanese"; 2779 case KO: return "Korean"; 2780 case LT: return "Lithuanian"; 2781 case LTLT: return "Lithuanian (Lithuania)"; 2782 case LV: return "Latvian"; 2783 case LVLV: return "Latvian (Latvia)"; 2784 case NL: return "Dutch"; 2785 case NLBE: return "Dutch (Belgium)"; 2786 case NLNL: return "Dutch (Netherlands)"; 2787 case NO: return "Norwegian"; 2788 case NONO: return "Norwegian (Norway)"; 2789 case PA: return "Punjabi"; 2790 case PL: return "Polskie"; 2791 case PLPL: return "Polish (Poland)"; 2792 case PT: return "Portuguese"; 2793 case PTPT: return "Portuguese (Portugal)"; 2794 case PTBR: return "Portuguese (Brazil)"; 2795 case RO: return "Romanian"; 2796 case RORO: return "Romanian (Romania)"; 2797 case RU: return "Russian"; 2798 case RURU: return "Russian (Russia)"; 2799 case SK: return "Slovakian"; 2800 case SKSK: return "Slovakian (Slovakia)"; 2801 case SL: return "Slovenian"; 2802 case SLSI: return "Slovenian (Slovenia)"; 2803 case SR: return "Serbian"; 2804 case SRRS: return "Serbian (Serbia)"; 2805 case SV: return "Swedish"; 2806 case SVSE: return "Swedish (Sweden)"; 2807 case TE: return "Telugu"; 2808 case ZH: return "Chinese"; 2809 case ZHCN: return "Chinese (China)"; 2810 case ZHHK: return "Chinese (Hong Kong)"; 2811 case ZHSG: return "Chinese (Singapore)"; 2812 case ZHTW: return "Chinese (Taiwan)"; 2813 case NULL: return null; 2814 default: return "?"; 2815 } 2816 } 2817 } 2818 2819 public static class CommonLanguagesEnumFactory implements EnumFactory<CommonLanguages> { 2820 public CommonLanguages fromCode(String codeString) throws IllegalArgumentException { 2821 if (codeString == null || "".equals(codeString)) 2822 if (codeString == null || "".equals(codeString)) 2823 return null; 2824 if ("ar".equals(codeString)) 2825 return CommonLanguages.AR; 2826 if ("bg".equals(codeString)) 2827 return CommonLanguages.BG; 2828 if ("bg-BG".equals(codeString)) 2829 return CommonLanguages.BGBG; 2830 if ("bn".equals(codeString)) 2831 return CommonLanguages.BN; 2832 if ("cs".equals(codeString)) 2833 return CommonLanguages.CS; 2834 if ("cs-CZ".equals(codeString)) 2835 return CommonLanguages.CSCZ; 2836 if ("bs".equals(codeString)) 2837 return CommonLanguages.BS; 2838 if ("bs-BA".equals(codeString)) 2839 return CommonLanguages.BSBA; 2840 if ("da".equals(codeString)) 2841 return CommonLanguages.DA; 2842 if ("da-DK".equals(codeString)) 2843 return CommonLanguages.DADK; 2844 if ("de".equals(codeString)) 2845 return CommonLanguages.DE; 2846 if ("de-AT".equals(codeString)) 2847 return CommonLanguages.DEAT; 2848 if ("de-CH".equals(codeString)) 2849 return CommonLanguages.DECH; 2850 if ("de-DE".equals(codeString)) 2851 return CommonLanguages.DEDE; 2852 if ("el".equals(codeString)) 2853 return CommonLanguages.EL; 2854 if ("el-GR".equals(codeString)) 2855 return CommonLanguages.ELGR; 2856 if ("en".equals(codeString)) 2857 return CommonLanguages.EN; 2858 if ("en-AU".equals(codeString)) 2859 return CommonLanguages.ENAU; 2860 if ("en-CA".equals(codeString)) 2861 return CommonLanguages.ENCA; 2862 if ("en-GB".equals(codeString)) 2863 return CommonLanguages.ENGB; 2864 if ("en-IN".equals(codeString)) 2865 return CommonLanguages.ENIN; 2866 if ("en-NZ".equals(codeString)) 2867 return CommonLanguages.ENNZ; 2868 if ("en-SG".equals(codeString)) 2869 return CommonLanguages.ENSG; 2870 if ("en-US".equals(codeString)) 2871 return CommonLanguages.ENUS; 2872 if ("es".equals(codeString)) 2873 return CommonLanguages.ES; 2874 if ("es-AR".equals(codeString)) 2875 return CommonLanguages.ESAR; 2876 if ("es-ES".equals(codeString)) 2877 return CommonLanguages.ESES; 2878 if ("es-UY".equals(codeString)) 2879 return CommonLanguages.ESUY; 2880 if ("et".equals(codeString)) 2881 return CommonLanguages.ET; 2882 if ("et-EE".equals(codeString)) 2883 return CommonLanguages.ETEE; 2884 if ("fi".equals(codeString)) 2885 return CommonLanguages.FI; 2886 if ("fr".equals(codeString)) 2887 return CommonLanguages.FR; 2888 if ("fr-BE".equals(codeString)) 2889 return CommonLanguages.FRBE; 2890 if ("fr-CH".equals(codeString)) 2891 return CommonLanguages.FRCH; 2892 if ("fr-FR".equals(codeString)) 2893 return CommonLanguages.FRFR; 2894 if ("fi-FI".equals(codeString)) 2895 return CommonLanguages.FIFI; 2896 if ("fr-CA".equals(codeString)) 2897 return CommonLanguages.FRCA; 2898 if ("fy".equals(codeString)) 2899 return CommonLanguages.FY; 2900 if ("fy-NL".equals(codeString)) 2901 return CommonLanguages.FYNL; 2902 if ("hi".equals(codeString)) 2903 return CommonLanguages.HI; 2904 if ("hr".equals(codeString)) 2905 return CommonLanguages.HR; 2906 if ("hr-HR".equals(codeString)) 2907 return CommonLanguages.HRHR; 2908 if ("is".equals(codeString)) 2909 return CommonLanguages.IS; 2910 if ("is-IS".equals(codeString)) 2911 return CommonLanguages.ISIS; 2912 if ("it".equals(codeString)) 2913 return CommonLanguages.IT; 2914 if ("it-CH".equals(codeString)) 2915 return CommonLanguages.ITCH; 2916 if ("it-IT".equals(codeString)) 2917 return CommonLanguages.ITIT; 2918 if ("ja".equals(codeString)) 2919 return CommonLanguages.JA; 2920 if ("ko".equals(codeString)) 2921 return CommonLanguages.KO; 2922 if ("lt".equals(codeString)) 2923 return CommonLanguages.LT; 2924 if ("lt-LT".equals(codeString)) 2925 return CommonLanguages.LTLT; 2926 if ("lv".equals(codeString)) 2927 return CommonLanguages.LV; 2928 if ("lv-LV".equals(codeString)) 2929 return CommonLanguages.LVLV; 2930 if ("nl".equals(codeString)) 2931 return CommonLanguages.NL; 2932 if ("nl-BE".equals(codeString)) 2933 return CommonLanguages.NLBE; 2934 if ("nl-NL".equals(codeString)) 2935 return CommonLanguages.NLNL; 2936 if ("no".equals(codeString)) 2937 return CommonLanguages.NO; 2938 if ("no-NO".equals(codeString)) 2939 return CommonLanguages.NONO; 2940 if ("pa".equals(codeString)) 2941 return CommonLanguages.PA; 2942 if ("pl".equals(codeString)) 2943 return CommonLanguages.PL; 2944 if ("pl-PL".equals(codeString)) 2945 return CommonLanguages.PLPL; 2946 if ("pt".equals(codeString)) 2947 return CommonLanguages.PT; 2948 if ("pt-PT".equals(codeString)) 2949 return CommonLanguages.PTPT; 2950 if ("pt-BR".equals(codeString)) 2951 return CommonLanguages.PTBR; 2952 if ("ro".equals(codeString)) 2953 return CommonLanguages.RO; 2954 if ("ro-RO".equals(codeString)) 2955 return CommonLanguages.RORO; 2956 if ("ru".equals(codeString)) 2957 return CommonLanguages.RU; 2958 if ("ru-RU".equals(codeString)) 2959 return CommonLanguages.RURU; 2960 if ("sk".equals(codeString)) 2961 return CommonLanguages.SK; 2962 if ("sk-SK".equals(codeString)) 2963 return CommonLanguages.SKSK; 2964 if ("sl".equals(codeString)) 2965 return CommonLanguages.SL; 2966 if ("sl-SI".equals(codeString)) 2967 return CommonLanguages.SLSI; 2968 if ("sr".equals(codeString)) 2969 return CommonLanguages.SR; 2970 if ("sr-RS".equals(codeString)) 2971 return CommonLanguages.SRRS; 2972 if ("sv".equals(codeString)) 2973 return CommonLanguages.SV; 2974 if ("sv-SE".equals(codeString)) 2975 return CommonLanguages.SVSE; 2976 if ("te".equals(codeString)) 2977 return CommonLanguages.TE; 2978 if ("zh".equals(codeString)) 2979 return CommonLanguages.ZH; 2980 if ("zh-CN".equals(codeString)) 2981 return CommonLanguages.ZHCN; 2982 if ("zh-HK".equals(codeString)) 2983 return CommonLanguages.ZHHK; 2984 if ("zh-SG".equals(codeString)) 2985 return CommonLanguages.ZHSG; 2986 if ("zh-TW".equals(codeString)) 2987 return CommonLanguages.ZHTW; 2988 throw new IllegalArgumentException("Unknown CommonLanguages code '"+codeString+"'"); 2989 } 2990 2991 public Enumeration<CommonLanguages> fromType(PrimitiveType<?> code) throws FHIRException { 2992 if (code == null) 2993 return null; 2994 if (code.isEmpty()) 2995 return new Enumeration<CommonLanguages>(this, CommonLanguages.NULL, code); 2996 String codeString = ((PrimitiveType) code).asStringValue(); 2997 if (codeString == null || "".equals(codeString)) 2998 return new Enumeration<CommonLanguages>(this, CommonLanguages.NULL, code); 2999 if ("ar".equals(codeString)) 3000 return new Enumeration<CommonLanguages>(this, CommonLanguages.AR, code); 3001 if ("bg".equals(codeString)) 3002 return new Enumeration<CommonLanguages>(this, CommonLanguages.BG, code); 3003 if ("bg-BG".equals(codeString)) 3004 return new Enumeration<CommonLanguages>(this, CommonLanguages.BGBG, code); 3005 if ("bn".equals(codeString)) 3006 return new Enumeration<CommonLanguages>(this, CommonLanguages.BN, code); 3007 if ("cs".equals(codeString)) 3008 return new Enumeration<CommonLanguages>(this, CommonLanguages.CS, code); 3009 if ("cs-CZ".equals(codeString)) 3010 return new Enumeration<CommonLanguages>(this, CommonLanguages.CSCZ, code); 3011 if ("bs".equals(codeString)) 3012 return new Enumeration<CommonLanguages>(this, CommonLanguages.BS, code); 3013 if ("bs-BA".equals(codeString)) 3014 return new Enumeration<CommonLanguages>(this, CommonLanguages.BSBA, code); 3015 if ("da".equals(codeString)) 3016 return new Enumeration<CommonLanguages>(this, CommonLanguages.DA, code); 3017 if ("da-DK".equals(codeString)) 3018 return new Enumeration<CommonLanguages>(this, CommonLanguages.DADK, code); 3019 if ("de".equals(codeString)) 3020 return new Enumeration<CommonLanguages>(this, CommonLanguages.DE, code); 3021 if ("de-AT".equals(codeString)) 3022 return new Enumeration<CommonLanguages>(this, CommonLanguages.DEAT, code); 3023 if ("de-CH".equals(codeString)) 3024 return new Enumeration<CommonLanguages>(this, CommonLanguages.DECH, code); 3025 if ("de-DE".equals(codeString)) 3026 return new Enumeration<CommonLanguages>(this, CommonLanguages.DEDE, code); 3027 if ("el".equals(codeString)) 3028 return new Enumeration<CommonLanguages>(this, CommonLanguages.EL, code); 3029 if ("el-GR".equals(codeString)) 3030 return new Enumeration<CommonLanguages>(this, CommonLanguages.ELGR, code); 3031 if ("en".equals(codeString)) 3032 return new Enumeration<CommonLanguages>(this, CommonLanguages.EN, code); 3033 if ("en-AU".equals(codeString)) 3034 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENAU, code); 3035 if ("en-CA".equals(codeString)) 3036 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENCA, code); 3037 if ("en-GB".equals(codeString)) 3038 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENGB, code); 3039 if ("en-IN".equals(codeString)) 3040 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENIN, code); 3041 if ("en-NZ".equals(codeString)) 3042 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENNZ, code); 3043 if ("en-SG".equals(codeString)) 3044 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENSG, code); 3045 if ("en-US".equals(codeString)) 3046 return new Enumeration<CommonLanguages>(this, CommonLanguages.ENUS, code); 3047 if ("es".equals(codeString)) 3048 return new Enumeration<CommonLanguages>(this, CommonLanguages.ES, code); 3049 if ("es-AR".equals(codeString)) 3050 return new Enumeration<CommonLanguages>(this, CommonLanguages.ESAR, code); 3051 if ("es-ES".equals(codeString)) 3052 return new Enumeration<CommonLanguages>(this, CommonLanguages.ESES, code); 3053 if ("es-UY".equals(codeString)) 3054 return new Enumeration<CommonLanguages>(this, CommonLanguages.ESUY, code); 3055 if ("et".equals(codeString)) 3056 return new Enumeration<CommonLanguages>(this, CommonLanguages.ET, code); 3057 if ("et-EE".equals(codeString)) 3058 return new Enumeration<CommonLanguages>(this, CommonLanguages.ETEE, code); 3059 if ("fi".equals(codeString)) 3060 return new Enumeration<CommonLanguages>(this, CommonLanguages.FI, code); 3061 if ("fr".equals(codeString)) 3062 return new Enumeration<CommonLanguages>(this, CommonLanguages.FR, code); 3063 if ("fr-BE".equals(codeString)) 3064 return new Enumeration<CommonLanguages>(this, CommonLanguages.FRBE, code); 3065 if ("fr-CH".equals(codeString)) 3066 return new Enumeration<CommonLanguages>(this, CommonLanguages.FRCH, code); 3067 if ("fr-FR".equals(codeString)) 3068 return new Enumeration<CommonLanguages>(this, CommonLanguages.FRFR, code); 3069 if ("fi-FI".equals(codeString)) 3070 return new Enumeration<CommonLanguages>(this, CommonLanguages.FIFI, code); 3071 if ("fr-CA".equals(codeString)) 3072 return new Enumeration<CommonLanguages>(this, CommonLanguages.FRCA, code); 3073 if ("fy".equals(codeString)) 3074 return new Enumeration<CommonLanguages>(this, CommonLanguages.FY, code); 3075 if ("fy-NL".equals(codeString)) 3076 return new Enumeration<CommonLanguages>(this, CommonLanguages.FYNL, code); 3077 if ("hi".equals(codeString)) 3078 return new Enumeration<CommonLanguages>(this, CommonLanguages.HI, code); 3079 if ("hr".equals(codeString)) 3080 return new Enumeration<CommonLanguages>(this, CommonLanguages.HR, code); 3081 if ("hr-HR".equals(codeString)) 3082 return new Enumeration<CommonLanguages>(this, CommonLanguages.HRHR, code); 3083 if ("is".equals(codeString)) 3084 return new Enumeration<CommonLanguages>(this, CommonLanguages.IS, code); 3085 if ("is-IS".equals(codeString)) 3086 return new Enumeration<CommonLanguages>(this, CommonLanguages.ISIS, code); 3087 if ("it".equals(codeString)) 3088 return new Enumeration<CommonLanguages>(this, CommonLanguages.IT, code); 3089 if ("it-CH".equals(codeString)) 3090 return new Enumeration<CommonLanguages>(this, CommonLanguages.ITCH, code); 3091 if ("it-IT".equals(codeString)) 3092 return new Enumeration<CommonLanguages>(this, CommonLanguages.ITIT, code); 3093 if ("ja".equals(codeString)) 3094 return new Enumeration<CommonLanguages>(this, CommonLanguages.JA, code); 3095 if ("ko".equals(codeString)) 3096 return new Enumeration<CommonLanguages>(this, CommonLanguages.KO, code); 3097 if ("lt".equals(codeString)) 3098 return new Enumeration<CommonLanguages>(this, CommonLanguages.LT, code); 3099 if ("lt-LT".equals(codeString)) 3100 return new Enumeration<CommonLanguages>(this, CommonLanguages.LTLT, code); 3101 if ("lv".equals(codeString)) 3102 return new Enumeration<CommonLanguages>(this, CommonLanguages.LV, code); 3103 if ("lv-LV".equals(codeString)) 3104 return new Enumeration<CommonLanguages>(this, CommonLanguages.LVLV, code); 3105 if ("nl".equals(codeString)) 3106 return new Enumeration<CommonLanguages>(this, CommonLanguages.NL, code); 3107 if ("nl-BE".equals(codeString)) 3108 return new Enumeration<CommonLanguages>(this, CommonLanguages.NLBE, code); 3109 if ("nl-NL".equals(codeString)) 3110 return new Enumeration<CommonLanguages>(this, CommonLanguages.NLNL, code); 3111 if ("no".equals(codeString)) 3112 return new Enumeration<CommonLanguages>(this, CommonLanguages.NO, code); 3113 if ("no-NO".equals(codeString)) 3114 return new Enumeration<CommonLanguages>(this, CommonLanguages.NONO, code); 3115 if ("pa".equals(codeString)) 3116 return new Enumeration<CommonLanguages>(this, CommonLanguages.PA, code); 3117 if ("pl".equals(codeString)) 3118 return new Enumeration<CommonLanguages>(this, CommonLanguages.PL, code); 3119 if ("pl-PL".equals(codeString)) 3120 return new Enumeration<CommonLanguages>(this, CommonLanguages.PLPL, code); 3121 if ("pt".equals(codeString)) 3122 return new Enumeration<CommonLanguages>(this, CommonLanguages.PT, code); 3123 if ("pt-PT".equals(codeString)) 3124 return new Enumeration<CommonLanguages>(this, CommonLanguages.PTPT, code); 3125 if ("pt-BR".equals(codeString)) 3126 return new Enumeration<CommonLanguages>(this, CommonLanguages.PTBR, code); 3127 if ("ro".equals(codeString)) 3128 return new Enumeration<CommonLanguages>(this, CommonLanguages.RO, code); 3129 if ("ro-RO".equals(codeString)) 3130 return new Enumeration<CommonLanguages>(this, CommonLanguages.RORO, code); 3131 if ("ru".equals(codeString)) 3132 return new Enumeration<CommonLanguages>(this, CommonLanguages.RU, code); 3133 if ("ru-RU".equals(codeString)) 3134 return new Enumeration<CommonLanguages>(this, CommonLanguages.RURU, code); 3135 if ("sk".equals(codeString)) 3136 return new Enumeration<CommonLanguages>(this, CommonLanguages.SK, code); 3137 if ("sk-SK".equals(codeString)) 3138 return new Enumeration<CommonLanguages>(this, CommonLanguages.SKSK, code); 3139 if ("sl".equals(codeString)) 3140 return new Enumeration<CommonLanguages>(this, CommonLanguages.SL, code); 3141 if ("sl-SI".equals(codeString)) 3142 return new Enumeration<CommonLanguages>(this, CommonLanguages.SLSI, code); 3143 if ("sr".equals(codeString)) 3144 return new Enumeration<CommonLanguages>(this, CommonLanguages.SR, code); 3145 if ("sr-RS".equals(codeString)) 3146 return new Enumeration<CommonLanguages>(this, CommonLanguages.SRRS, code); 3147 if ("sv".equals(codeString)) 3148 return new Enumeration<CommonLanguages>(this, CommonLanguages.SV, code); 3149 if ("sv-SE".equals(codeString)) 3150 return new Enumeration<CommonLanguages>(this, CommonLanguages.SVSE, code); 3151 if ("te".equals(codeString)) 3152 return new Enumeration<CommonLanguages>(this, CommonLanguages.TE, code); 3153 if ("zh".equals(codeString)) 3154 return new Enumeration<CommonLanguages>(this, CommonLanguages.ZH, code); 3155 if ("zh-CN".equals(codeString)) 3156 return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHCN, code); 3157 if ("zh-HK".equals(codeString)) 3158 return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHHK, code); 3159 if ("zh-SG".equals(codeString)) 3160 return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHSG, code); 3161 if ("zh-TW".equals(codeString)) 3162 return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHTW, code); 3163 throw new FHIRException("Unknown CommonLanguages code '"+codeString+"'"); 3164 } 3165 public String toCode(CommonLanguages code) { 3166 if (code == CommonLanguages.AR) 3167 return "ar"; 3168 if (code == CommonLanguages.BG) 3169 return "bg"; 3170 if (code == CommonLanguages.BGBG) 3171 return "bg-BG"; 3172 if (code == CommonLanguages.BN) 3173 return "bn"; 3174 if (code == CommonLanguages.CS) 3175 return "cs"; 3176 if (code == CommonLanguages.CSCZ) 3177 return "cs-CZ"; 3178 if (code == CommonLanguages.BS) 3179 return "bs"; 3180 if (code == CommonLanguages.BSBA) 3181 return "bs-BA"; 3182 if (code == CommonLanguages.DA) 3183 return "da"; 3184 if (code == CommonLanguages.DADK) 3185 return "da-DK"; 3186 if (code == CommonLanguages.DE) 3187 return "de"; 3188 if (code == CommonLanguages.DEAT) 3189 return "de-AT"; 3190 if (code == CommonLanguages.DECH) 3191 return "de-CH"; 3192 if (code == CommonLanguages.DEDE) 3193 return "de-DE"; 3194 if (code == CommonLanguages.EL) 3195 return "el"; 3196 if (code == CommonLanguages.ELGR) 3197 return "el-GR"; 3198 if (code == CommonLanguages.EN) 3199 return "en"; 3200 if (code == CommonLanguages.ENAU) 3201 return "en-AU"; 3202 if (code == CommonLanguages.ENCA) 3203 return "en-CA"; 3204 if (code == CommonLanguages.ENGB) 3205 return "en-GB"; 3206 if (code == CommonLanguages.ENIN) 3207 return "en-IN"; 3208 if (code == CommonLanguages.ENNZ) 3209 return "en-NZ"; 3210 if (code == CommonLanguages.ENSG) 3211 return "en-SG"; 3212 if (code == CommonLanguages.ENUS) 3213 return "en-US"; 3214 if (code == CommonLanguages.ES) 3215 return "es"; 3216 if (code == CommonLanguages.ESAR) 3217 return "es-AR"; 3218 if (code == CommonLanguages.ESES) 3219 return "es-ES"; 3220 if (code == CommonLanguages.ESUY) 3221 return "es-UY"; 3222 if (code == CommonLanguages.ET) 3223 return "et"; 3224 if (code == CommonLanguages.ETEE) 3225 return "et-EE"; 3226 if (code == CommonLanguages.FI) 3227 return "fi"; 3228 if (code == CommonLanguages.FR) 3229 return "fr"; 3230 if (code == CommonLanguages.FRBE) 3231 return "fr-BE"; 3232 if (code == CommonLanguages.FRCH) 3233 return "fr-CH"; 3234 if (code == CommonLanguages.FRFR) 3235 return "fr-FR"; 3236 if (code == CommonLanguages.FIFI) 3237 return "fi-FI"; 3238 if (code == CommonLanguages.FRCA) 3239 return "fr-CA"; 3240 if (code == CommonLanguages.FY) 3241 return "fy"; 3242 if (code == CommonLanguages.FYNL) 3243 return "fy-NL"; 3244 if (code == CommonLanguages.HI) 3245 return "hi"; 3246 if (code == CommonLanguages.HR) 3247 return "hr"; 3248 if (code == CommonLanguages.HRHR) 3249 return "hr-HR"; 3250 if (code == CommonLanguages.IS) 3251 return "is"; 3252 if (code == CommonLanguages.ISIS) 3253 return "is-IS"; 3254 if (code == CommonLanguages.IT) 3255 return "it"; 3256 if (code == CommonLanguages.ITCH) 3257 return "it-CH"; 3258 if (code == CommonLanguages.ITIT) 3259 return "it-IT"; 3260 if (code == CommonLanguages.JA) 3261 return "ja"; 3262 if (code == CommonLanguages.KO) 3263 return "ko"; 3264 if (code == CommonLanguages.LT) 3265 return "lt"; 3266 if (code == CommonLanguages.LTLT) 3267 return "lt-LT"; 3268 if (code == CommonLanguages.LV) 3269 return "lv"; 3270 if (code == CommonLanguages.LVLV) 3271 return "lv-LV"; 3272 if (code == CommonLanguages.NL) 3273 return "nl"; 3274 if (code == CommonLanguages.NLBE) 3275 return "nl-BE"; 3276 if (code == CommonLanguages.NLNL) 3277 return "nl-NL"; 3278 if (code == CommonLanguages.NO) 3279 return "no"; 3280 if (code == CommonLanguages.NONO) 3281 return "no-NO"; 3282 if (code == CommonLanguages.PA) 3283 return "pa"; 3284 if (code == CommonLanguages.PL) 3285 return "pl"; 3286 if (code == CommonLanguages.PLPL) 3287 return "pl-PL"; 3288 if (code == CommonLanguages.PT) 3289 return "pt"; 3290 if (code == CommonLanguages.PTPT) 3291 return "pt-PT"; 3292 if (code == CommonLanguages.PTBR) 3293 return "pt-BR"; 3294 if (code == CommonLanguages.RO) 3295 return "ro"; 3296 if (code == CommonLanguages.RORO) 3297 return "ro-RO"; 3298 if (code == CommonLanguages.RU) 3299 return "ru"; 3300 if (code == CommonLanguages.RURU) 3301 return "ru-RU"; 3302 if (code == CommonLanguages.SK) 3303 return "sk"; 3304 if (code == CommonLanguages.SKSK) 3305 return "sk-SK"; 3306 if (code == CommonLanguages.SL) 3307 return "sl"; 3308 if (code == CommonLanguages.SLSI) 3309 return "sl-SI"; 3310 if (code == CommonLanguages.SR) 3311 return "sr"; 3312 if (code == CommonLanguages.SRRS) 3313 return "sr-RS"; 3314 if (code == CommonLanguages.SV) 3315 return "sv"; 3316 if (code == CommonLanguages.SVSE) 3317 return "sv-SE"; 3318 if (code == CommonLanguages.TE) 3319 return "te"; 3320 if (code == CommonLanguages.ZH) 3321 return "zh"; 3322 if (code == CommonLanguages.ZHCN) 3323 return "zh-CN"; 3324 if (code == CommonLanguages.ZHHK) 3325 return "zh-HK"; 3326 if (code == CommonLanguages.ZHSG) 3327 return "zh-SG"; 3328 if (code == CommonLanguages.ZHTW) 3329 return "zh-TW"; 3330 return "?"; 3331 } 3332 public String toSystem(CommonLanguages code) { 3333 return code.getSystem(); 3334 } 3335 } 3336 3337 public enum CompartmentType { 3338 /** 3339 * The compartment definition is for the patient compartment. 3340 */ 3341 PATIENT, 3342 /** 3343 * The compartment definition is for the encounter compartment. 3344 */ 3345 ENCOUNTER, 3346 /** 3347 * The compartment definition is for the related-person compartment. 3348 */ 3349 RELATEDPERSON, 3350 /** 3351 * The compartment definition is for the practitioner compartment. 3352 */ 3353 PRACTITIONER, 3354 /** 3355 * The compartment definition is for the device compartment. 3356 */ 3357 DEVICE, 3358 /** 3359 * The compartment definition is for the episodeofcare compartment. 3360 */ 3361 EPISODEOFCARE, 3362 /** 3363 * added to help the parsers 3364 */ 3365 NULL; 3366 public static CompartmentType fromCode(String codeString) throws FHIRException { 3367 if (codeString == null || "".equals(codeString)) 3368 return null; 3369 if ("Patient".equals(codeString)) 3370 return PATIENT; 3371 if ("Encounter".equals(codeString)) 3372 return ENCOUNTER; 3373 if ("RelatedPerson".equals(codeString)) 3374 return RELATEDPERSON; 3375 if ("Practitioner".equals(codeString)) 3376 return PRACTITIONER; 3377 if ("Device".equals(codeString)) 3378 return DEVICE; 3379 if ("EpisodeOfCare".equals(codeString)) 3380 return EPISODEOFCARE; 3381 throw new FHIRException("Unknown CompartmentType code '"+codeString+"'"); 3382 } 3383 public static boolean isValidCode(String codeString) { 3384 if (codeString == null || "".equals(codeString)) 3385 return false; 3386 return Utilities.existsInList(codeString, "Patient", "Encounter", "RelatedPerson", "Practitioner", "Device", "EpisodeOfCare"); 3387 } 3388 public String toCode() { 3389 switch (this) { 3390 case PATIENT: return "Patient"; 3391 case ENCOUNTER: return "Encounter"; 3392 case RELATEDPERSON: return "RelatedPerson"; 3393 case PRACTITIONER: return "Practitioner"; 3394 case DEVICE: return "Device"; 3395 case EPISODEOFCARE: return "EpisodeOfCare"; 3396 case NULL: return null; 3397 default: return "?"; 3398 } 3399 } 3400 public String getSystem() { 3401 switch (this) { 3402 case PATIENT: return "http://hl7.org/fhir/compartment-type"; 3403 case ENCOUNTER: return "http://hl7.org/fhir/compartment-type"; 3404 case RELATEDPERSON: return "http://hl7.org/fhir/compartment-type"; 3405 case PRACTITIONER: return "http://hl7.org/fhir/compartment-type"; 3406 case DEVICE: return "http://hl7.org/fhir/compartment-type"; 3407 case EPISODEOFCARE: return "http://hl7.org/fhir/compartment-type"; 3408 case NULL: return null; 3409 default: return "?"; 3410 } 3411 } 3412 public String getDefinition() { 3413 switch (this) { 3414 case PATIENT: return "The compartment definition is for the patient compartment."; 3415 case ENCOUNTER: return "The compartment definition is for the encounter compartment."; 3416 case RELATEDPERSON: return "The compartment definition is for the related-person compartment."; 3417 case PRACTITIONER: return "The compartment definition is for the practitioner compartment."; 3418 case DEVICE: return "The compartment definition is for the device compartment."; 3419 case EPISODEOFCARE: return "The compartment definition is for the episodeofcare compartment."; 3420 case NULL: return null; 3421 default: return "?"; 3422 } 3423 } 3424 public String getDisplay() { 3425 switch (this) { 3426 case PATIENT: return "Patient"; 3427 case ENCOUNTER: return "Encounter"; 3428 case RELATEDPERSON: return "RelatedPerson"; 3429 case PRACTITIONER: return "Practitioner"; 3430 case DEVICE: return "Device"; 3431 case EPISODEOFCARE: return "EpisodeOfCare"; 3432 case NULL: return null; 3433 default: return "?"; 3434 } 3435 } 3436 } 3437 3438 public static class CompartmentTypeEnumFactory implements EnumFactory<CompartmentType> { 3439 public CompartmentType fromCode(String codeString) throws IllegalArgumentException { 3440 if (codeString == null || "".equals(codeString)) 3441 if (codeString == null || "".equals(codeString)) 3442 return null; 3443 if ("Patient".equals(codeString)) 3444 return CompartmentType.PATIENT; 3445 if ("Encounter".equals(codeString)) 3446 return CompartmentType.ENCOUNTER; 3447 if ("RelatedPerson".equals(codeString)) 3448 return CompartmentType.RELATEDPERSON; 3449 if ("Practitioner".equals(codeString)) 3450 return CompartmentType.PRACTITIONER; 3451 if ("Device".equals(codeString)) 3452 return CompartmentType.DEVICE; 3453 if ("EpisodeOfCare".equals(codeString)) 3454 return CompartmentType.EPISODEOFCARE; 3455 throw new IllegalArgumentException("Unknown CompartmentType code '"+codeString+"'"); 3456 } 3457 3458 public Enumeration<CompartmentType> fromType(PrimitiveType<?> code) throws FHIRException { 3459 if (code == null) 3460 return null; 3461 if (code.isEmpty()) 3462 return new Enumeration<CompartmentType>(this, CompartmentType.NULL, code); 3463 String codeString = ((PrimitiveType) code).asStringValue(); 3464 if (codeString == null || "".equals(codeString)) 3465 return new Enumeration<CompartmentType>(this, CompartmentType.NULL, code); 3466 if ("Patient".equals(codeString)) 3467 return new Enumeration<CompartmentType>(this, CompartmentType.PATIENT, code); 3468 if ("Encounter".equals(codeString)) 3469 return new Enumeration<CompartmentType>(this, CompartmentType.ENCOUNTER, code); 3470 if ("RelatedPerson".equals(codeString)) 3471 return new Enumeration<CompartmentType>(this, CompartmentType.RELATEDPERSON, code); 3472 if ("Practitioner".equals(codeString)) 3473 return new Enumeration<CompartmentType>(this, CompartmentType.PRACTITIONER, code); 3474 if ("Device".equals(codeString)) 3475 return new Enumeration<CompartmentType>(this, CompartmentType.DEVICE, code); 3476 if ("EpisodeOfCare".equals(codeString)) 3477 return new Enumeration<CompartmentType>(this, CompartmentType.EPISODEOFCARE, code); 3478 throw new FHIRException("Unknown CompartmentType code '"+codeString+"'"); 3479 } 3480 public String toCode(CompartmentType code) { 3481 if (code == CompartmentType.PATIENT) 3482 return "Patient"; 3483 if (code == CompartmentType.ENCOUNTER) 3484 return "Encounter"; 3485 if (code == CompartmentType.RELATEDPERSON) 3486 return "RelatedPerson"; 3487 if (code == CompartmentType.PRACTITIONER) 3488 return "Practitioner"; 3489 if (code == CompartmentType.DEVICE) 3490 return "Device"; 3491 if (code == CompartmentType.EPISODEOFCARE) 3492 return "EpisodeOfCare"; 3493 return "?"; 3494 } 3495 public String toSystem(CompartmentType code) { 3496 return code.getSystem(); 3497 } 3498 } 3499 3500 public enum CompositionStatus { 3501 /** 3502 * The existence of the composition is registered, but there is nothing yet available. 3503 */ 3504 REGISTERED, 3505 /** 3506 * This is a partial (e.g. initial, interim or preliminary) composition: data in the composition may be incomplete or unverified. 3507 */ 3508 PARTIAL, 3509 /** 3510 * Verified early results are available, but not all results are final. 3511 */ 3512 PRELIMINARY, 3513 /** 3514 * This version of the composition is complete and verified by an appropriate person and no further work is planned. Any subsequent updates would be on a new version of the composition. 3515 */ 3516 FINAL, 3517 /** 3518 * The composition content or the referenced resources have been modified (edited or added to) subsequent to being released as "final" and the composition is complete and verified by an authorized person. 3519 */ 3520 AMENDED, 3521 /** 3522 * Subsequent to being final, the composition content has been modified to correct an error in the composition or referenced results. 3523 */ 3524 CORRECTED, 3525 /** 3526 * Subsequent to being final, the composition content has been modified by adding new content. The existing content is unchanged. 3527 */ 3528 APPENDED, 3529 /** 3530 * The composition is unavailable because the measurement was not started or not completed (also sometimes called "aborted"). 3531 */ 3532 CANCELLED, 3533 /** 3534 * The composition or document was originally created/issued in error, and this is an amendment that marks that the entire series should not be considered as valid. 3535 */ 3536 ENTEREDINERROR, 3537 /** 3538 * This composition has been withdrawn or superseded and should no longer be used. 3539 */ 3540 DEPRECATED, 3541 /** 3542 * The authoring/source system does not know which of the status values currently applies for this observation. Note: This concept is not to be used for "other" - one of the listed statuses is presumed to apply, but the authoring/source system does not know which. 3543 */ 3544 UNKNOWN, 3545 /** 3546 * added to help the parsers 3547 */ 3548 NULL; 3549 public static CompositionStatus fromCode(String codeString) throws FHIRException { 3550 if (codeString == null || "".equals(codeString)) 3551 return null; 3552 if ("registered".equals(codeString)) 3553 return REGISTERED; 3554 if ("partial".equals(codeString)) 3555 return PARTIAL; 3556 if ("preliminary".equals(codeString)) 3557 return PRELIMINARY; 3558 if ("final".equals(codeString)) 3559 return FINAL; 3560 if ("amended".equals(codeString)) 3561 return AMENDED; 3562 if ("corrected".equals(codeString)) 3563 return CORRECTED; 3564 if ("appended".equals(codeString)) 3565 return APPENDED; 3566 if ("cancelled".equals(codeString)) 3567 return CANCELLED; 3568 if ("entered-in-error".equals(codeString)) 3569 return ENTEREDINERROR; 3570 if ("deprecated".equals(codeString)) 3571 return DEPRECATED; 3572 if ("unknown".equals(codeString)) 3573 return UNKNOWN; 3574 throw new FHIRException("Unknown CompositionStatus code '"+codeString+"'"); 3575 } 3576 public static boolean isValidCode(String codeString) { 3577 if (codeString == null || "".equals(codeString)) 3578 return false; 3579 return Utilities.existsInList(codeString, "registered", "partial", "preliminary", "final", "amended", "corrected", "appended", "cancelled", "entered-in-error", "deprecated", "unknown"); 3580 } 3581 public String toCode() { 3582 switch (this) { 3583 case REGISTERED: return "registered"; 3584 case PARTIAL: return "partial"; 3585 case PRELIMINARY: return "preliminary"; 3586 case FINAL: return "final"; 3587 case AMENDED: return "amended"; 3588 case CORRECTED: return "corrected"; 3589 case APPENDED: return "appended"; 3590 case CANCELLED: return "cancelled"; 3591 case ENTEREDINERROR: return "entered-in-error"; 3592 case DEPRECATED: return "deprecated"; 3593 case UNKNOWN: return "unknown"; 3594 case NULL: return null; 3595 default: return "?"; 3596 } 3597 } 3598 public String getSystem() { 3599 switch (this) { 3600 case REGISTERED: return "http://hl7.org/fhir/composition-status"; 3601 case PARTIAL: return "http://hl7.org/fhir/composition-status"; 3602 case PRELIMINARY: return "http://hl7.org/fhir/composition-status"; 3603 case FINAL: return "http://hl7.org/fhir/composition-status"; 3604 case AMENDED: return "http://hl7.org/fhir/composition-status"; 3605 case CORRECTED: return "http://hl7.org/fhir/composition-status"; 3606 case APPENDED: return "http://hl7.org/fhir/composition-status"; 3607 case CANCELLED: return "http://hl7.org/fhir/composition-status"; 3608 case ENTEREDINERROR: return "http://hl7.org/fhir/composition-status"; 3609 case DEPRECATED: return "http://hl7.org/fhir/composition-status"; 3610 case UNKNOWN: return "http://hl7.org/fhir/composition-status"; 3611 case NULL: return null; 3612 default: return "?"; 3613 } 3614 } 3615 public String getDefinition() { 3616 switch (this) { 3617 case REGISTERED: return "The existence of the composition is registered, but there is nothing yet available."; 3618 case PARTIAL: return "This is a partial (e.g. initial, interim or preliminary) composition: data in the composition may be incomplete or unverified."; 3619 case PRELIMINARY: return "Verified early results are available, but not all results are final."; 3620 case FINAL: return "This version of the composition is complete and verified by an appropriate person and no further work is planned. Any subsequent updates would be on a new version of the composition."; 3621 case AMENDED: return "The composition content or the referenced resources have been modified (edited or added to) subsequent to being released as \"final\" and the composition is complete and verified by an authorized person."; 3622 case CORRECTED: return "Subsequent to being final, the composition content has been modified to correct an error in the composition or referenced results."; 3623 case APPENDED: return "Subsequent to being final, the composition content has been modified by adding new content. The existing content is unchanged."; 3624 case CANCELLED: return "The composition is unavailable because the measurement was not started or not completed (also sometimes called \"aborted\")."; 3625 case ENTEREDINERROR: return "The composition or document was originally created/issued in error, and this is an amendment that marks that the entire series should not be considered as valid."; 3626 case DEPRECATED: return "This composition has been withdrawn or superseded and should no longer be used."; 3627 case UNKNOWN: return "The authoring/source system does not know which of the status values currently applies for this observation. Note: This concept is not to be used for \"other\" - one of the listed statuses is presumed to apply, but the authoring/source system does not know which."; 3628 case NULL: return null; 3629 default: return "?"; 3630 } 3631 } 3632 public String getDisplay() { 3633 switch (this) { 3634 case REGISTERED: return "Registered"; 3635 case PARTIAL: return "Partial"; 3636 case PRELIMINARY: return "Preliminary"; 3637 case FINAL: return "Final"; 3638 case AMENDED: return "Amended"; 3639 case CORRECTED: return "Corrected"; 3640 case APPENDED: return "Appended"; 3641 case CANCELLED: return "Cancelled"; 3642 case ENTEREDINERROR: return "Entered in Error"; 3643 case DEPRECATED: return "Deprecated"; 3644 case UNKNOWN: return "Unknown"; 3645 case NULL: return null; 3646 default: return "?"; 3647 } 3648 } 3649 } 3650 3651 public static class CompositionStatusEnumFactory implements EnumFactory<CompositionStatus> { 3652 public CompositionStatus fromCode(String codeString) throws IllegalArgumentException { 3653 if (codeString == null || "".equals(codeString)) 3654 if (codeString == null || "".equals(codeString)) 3655 return null; 3656 if ("registered".equals(codeString)) 3657 return CompositionStatus.REGISTERED; 3658 if ("partial".equals(codeString)) 3659 return CompositionStatus.PARTIAL; 3660 if ("preliminary".equals(codeString)) 3661 return CompositionStatus.PRELIMINARY; 3662 if ("final".equals(codeString)) 3663 return CompositionStatus.FINAL; 3664 if ("amended".equals(codeString)) 3665 return CompositionStatus.AMENDED; 3666 if ("corrected".equals(codeString)) 3667 return CompositionStatus.CORRECTED; 3668 if ("appended".equals(codeString)) 3669 return CompositionStatus.APPENDED; 3670 if ("cancelled".equals(codeString)) 3671 return CompositionStatus.CANCELLED; 3672 if ("entered-in-error".equals(codeString)) 3673 return CompositionStatus.ENTEREDINERROR; 3674 if ("deprecated".equals(codeString)) 3675 return CompositionStatus.DEPRECATED; 3676 if ("unknown".equals(codeString)) 3677 return CompositionStatus.UNKNOWN; 3678 throw new IllegalArgumentException("Unknown CompositionStatus code '"+codeString+"'"); 3679 } 3680 3681 public Enumeration<CompositionStatus> fromType(PrimitiveType<?> code) throws FHIRException { 3682 if (code == null) 3683 return null; 3684 if (code.isEmpty()) 3685 return new Enumeration<CompositionStatus>(this, CompositionStatus.NULL, code); 3686 String codeString = ((PrimitiveType) code).asStringValue(); 3687 if (codeString == null || "".equals(codeString)) 3688 return new Enumeration<CompositionStatus>(this, CompositionStatus.NULL, code); 3689 if ("registered".equals(codeString)) 3690 return new Enumeration<CompositionStatus>(this, CompositionStatus.REGISTERED, code); 3691 if ("partial".equals(codeString)) 3692 return new Enumeration<CompositionStatus>(this, CompositionStatus.PARTIAL, code); 3693 if ("preliminary".equals(codeString)) 3694 return new Enumeration<CompositionStatus>(this, CompositionStatus.PRELIMINARY, code); 3695 if ("final".equals(codeString)) 3696 return new Enumeration<CompositionStatus>(this, CompositionStatus.FINAL, code); 3697 if ("amended".equals(codeString)) 3698 return new Enumeration<CompositionStatus>(this, CompositionStatus.AMENDED, code); 3699 if ("corrected".equals(codeString)) 3700 return new Enumeration<CompositionStatus>(this, CompositionStatus.CORRECTED, code); 3701 if ("appended".equals(codeString)) 3702 return new Enumeration<CompositionStatus>(this, CompositionStatus.APPENDED, code); 3703 if ("cancelled".equals(codeString)) 3704 return new Enumeration<CompositionStatus>(this, CompositionStatus.CANCELLED, code); 3705 if ("entered-in-error".equals(codeString)) 3706 return new Enumeration<CompositionStatus>(this, CompositionStatus.ENTEREDINERROR, code); 3707 if ("deprecated".equals(codeString)) 3708 return new Enumeration<CompositionStatus>(this, CompositionStatus.DEPRECATED, code); 3709 if ("unknown".equals(codeString)) 3710 return new Enumeration<CompositionStatus>(this, CompositionStatus.UNKNOWN, code); 3711 throw new FHIRException("Unknown CompositionStatus code '"+codeString+"'"); 3712 } 3713 public String toCode(CompositionStatus code) { 3714 if (code == CompositionStatus.REGISTERED) 3715 return "registered"; 3716 if (code == CompositionStatus.PARTIAL) 3717 return "partial"; 3718 if (code == CompositionStatus.PRELIMINARY) 3719 return "preliminary"; 3720 if (code == CompositionStatus.FINAL) 3721 return "final"; 3722 if (code == CompositionStatus.AMENDED) 3723 return "amended"; 3724 if (code == CompositionStatus.CORRECTED) 3725 return "corrected"; 3726 if (code == CompositionStatus.APPENDED) 3727 return "appended"; 3728 if (code == CompositionStatus.CANCELLED) 3729 return "cancelled"; 3730 if (code == CompositionStatus.ENTEREDINERROR) 3731 return "entered-in-error"; 3732 if (code == CompositionStatus.DEPRECATED) 3733 return "deprecated"; 3734 if (code == CompositionStatus.UNKNOWN) 3735 return "unknown"; 3736 return "?"; 3737 } 3738 public String toSystem(CompositionStatus code) { 3739 return code.getSystem(); 3740 } 3741 } 3742 3743 public enum ConceptMapRelationship { 3744 /** 3745 * The concepts are related to each other, but the exact relationship is not known. 3746 */ 3747 RELATEDTO, 3748 /** 3749 * The definitions of the concepts mean the same thing. 3750 */ 3751 EQUIVALENT, 3752 /** 3753 * The source concept is narrower in meaning than the target concept. 3754 */ 3755 SOURCEISNARROWERTHANTARGET, 3756 /** 3757 * The source concept is broader in meaning than the target concept. 3758 */ 3759 SOURCEISBROADERTHANTARGET, 3760 /** 3761 * This is an explicit assertion that the target concept is not related to the source concept. 3762 */ 3763 NOTRELATEDTO, 3764 /** 3765 * added to help the parsers 3766 */ 3767 NULL; 3768 public static ConceptMapRelationship fromCode(String codeString) throws FHIRException { 3769 if (codeString == null || "".equals(codeString)) 3770 return null; 3771 if ("related-to".equals(codeString)) 3772 return RELATEDTO; 3773 if ("equivalent".equals(codeString)) 3774 return EQUIVALENT; 3775 if ("source-is-narrower-than-target".equals(codeString)) 3776 return SOURCEISNARROWERTHANTARGET; 3777 if ("source-is-broader-than-target".equals(codeString)) 3778 return SOURCEISBROADERTHANTARGET; 3779 if ("not-related-to".equals(codeString)) 3780 return NOTRELATEDTO; 3781 throw new FHIRException("Unknown ConceptMapRelationship code '"+codeString+"'"); 3782 } 3783 public static boolean isValidCode(String codeString) { 3784 if (codeString == null || "".equals(codeString)) 3785 return false; 3786 return Utilities.existsInList(codeString, "related-to", "equivalent", "source-is-narrower-than-target", "source-is-broader-than-target", "not-related-to"); 3787 } 3788 public String toCode() { 3789 switch (this) { 3790 case RELATEDTO: return "related-to"; 3791 case EQUIVALENT: return "equivalent"; 3792 case SOURCEISNARROWERTHANTARGET: return "source-is-narrower-than-target"; 3793 case SOURCEISBROADERTHANTARGET: return "source-is-broader-than-target"; 3794 case NOTRELATEDTO: return "not-related-to"; 3795 case NULL: return null; 3796 default: return "?"; 3797 } 3798 } 3799 public String getSystem() { 3800 switch (this) { 3801 case RELATEDTO: return "http://hl7.org/fhir/concept-map-relationship"; 3802 case EQUIVALENT: return "http://hl7.org/fhir/concept-map-relationship"; 3803 case SOURCEISNARROWERTHANTARGET: return "http://hl7.org/fhir/concept-map-relationship"; 3804 case SOURCEISBROADERTHANTARGET: return "http://hl7.org/fhir/concept-map-relationship"; 3805 case NOTRELATEDTO: return "http://hl7.org/fhir/concept-map-relationship"; 3806 case NULL: return null; 3807 default: return "?"; 3808 } 3809 } 3810 public String getDefinition() { 3811 switch (this) { 3812 case RELATEDTO: return "The concepts are related to each other, but the exact relationship is not known."; 3813 case EQUIVALENT: return "The definitions of the concepts mean the same thing."; 3814 case SOURCEISNARROWERTHANTARGET: return "The source concept is narrower in meaning than the target concept."; 3815 case SOURCEISBROADERTHANTARGET: return "The source concept is broader in meaning than the target concept."; 3816 case NOTRELATEDTO: return "This is an explicit assertion that the target concept is not related to the source concept."; 3817 case NULL: return null; 3818 default: return "?"; 3819 } 3820 } 3821 public String getDisplay() { 3822 switch (this) { 3823 case RELATEDTO: return "Related To"; 3824 case EQUIVALENT: return "Equivalent"; 3825 case SOURCEISNARROWERTHANTARGET: return "Source Is Narrower Than Target"; 3826 case SOURCEISBROADERTHANTARGET: return "Source Is Broader Than Target"; 3827 case NOTRELATEDTO: return "Not Related To"; 3828 case NULL: return null; 3829 default: return "?"; 3830 } 3831 } 3832 } 3833 3834 public static class ConceptMapRelationshipEnumFactory implements EnumFactory<ConceptMapRelationship> { 3835 public ConceptMapRelationship fromCode(String codeString) throws IllegalArgumentException { 3836 if (codeString == null || "".equals(codeString)) 3837 if (codeString == null || "".equals(codeString)) 3838 return null; 3839 if ("related-to".equals(codeString)) 3840 return ConceptMapRelationship.RELATEDTO; 3841 if ("equivalent".equals(codeString)) 3842 return ConceptMapRelationship.EQUIVALENT; 3843 if ("source-is-narrower-than-target".equals(codeString)) 3844 return ConceptMapRelationship.SOURCEISNARROWERTHANTARGET; 3845 if ("source-is-broader-than-target".equals(codeString)) 3846 return ConceptMapRelationship.SOURCEISBROADERTHANTARGET; 3847 if ("not-related-to".equals(codeString)) 3848 return ConceptMapRelationship.NOTRELATEDTO; 3849 throw new IllegalArgumentException("Unknown ConceptMapRelationship code '"+codeString+"'"); 3850 } 3851 3852 public Enumeration<ConceptMapRelationship> fromType(PrimitiveType<?> code) throws FHIRException { 3853 if (code == null) 3854 return null; 3855 if (code.isEmpty()) 3856 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NULL, code); 3857 String codeString = ((PrimitiveType) code).asStringValue(); 3858 if (codeString == null || "".equals(codeString)) 3859 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NULL, code); 3860 if ("related-to".equals(codeString)) 3861 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.RELATEDTO, code); 3862 if ("equivalent".equals(codeString)) 3863 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.EQUIVALENT, code); 3864 if ("source-is-narrower-than-target".equals(codeString)) 3865 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.SOURCEISNARROWERTHANTARGET, code); 3866 if ("source-is-broader-than-target".equals(codeString)) 3867 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.SOURCEISBROADERTHANTARGET, code); 3868 if ("not-related-to".equals(codeString)) 3869 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NOTRELATEDTO, code); 3870 throw new FHIRException("Unknown ConceptMapRelationship code '"+codeString+"'"); 3871 } 3872 public String toCode(ConceptMapRelationship code) { 3873 if (code == ConceptMapRelationship.RELATEDTO) 3874 return "related-to"; 3875 if (code == ConceptMapRelationship.EQUIVALENT) 3876 return "equivalent"; 3877 if (code == ConceptMapRelationship.SOURCEISNARROWERTHANTARGET) 3878 return "source-is-narrower-than-target"; 3879 if (code == ConceptMapRelationship.SOURCEISBROADERTHANTARGET) 3880 return "source-is-broader-than-target"; 3881 if (code == ConceptMapRelationship.NOTRELATEDTO) 3882 return "not-related-to"; 3883 return "?"; 3884 } 3885 public String toSystem(ConceptMapRelationship code) { 3886 return code.getSystem(); 3887 } 3888 } 3889 3890 public enum ConsentDataMeaning { 3891 /** 3892 * The consent applies directly to the instance of the resource. 3893 */ 3894 INSTANCE, 3895 /** 3896 * The consent applies directly to the instance of the resource and instances it refers to. 3897 */ 3898 RELATED, 3899 /** 3900 * The consent applies directly to the instance of the resource and instances that refer to it. 3901 */ 3902 DEPENDENTS, 3903 /** 3904 * The consent applies to instances of resources that are authored by. 3905 */ 3906 AUTHOREDBY, 3907 /** 3908 * added to help the parsers 3909 */ 3910 NULL; 3911 public static ConsentDataMeaning fromCode(String codeString) throws FHIRException { 3912 if (codeString == null || "".equals(codeString)) 3913 return null; 3914 if ("instance".equals(codeString)) 3915 return INSTANCE; 3916 if ("related".equals(codeString)) 3917 return RELATED; 3918 if ("dependents".equals(codeString)) 3919 return DEPENDENTS; 3920 if ("authoredby".equals(codeString)) 3921 return AUTHOREDBY; 3922 throw new FHIRException("Unknown ConsentDataMeaning code '"+codeString+"'"); 3923 } 3924 public static boolean isValidCode(String codeString) { 3925 if (codeString == null || "".equals(codeString)) 3926 return false; 3927 return Utilities.existsInList(codeString, "instance", "related", "dependents", "authoredby"); 3928 } 3929 public String toCode() { 3930 switch (this) { 3931 case INSTANCE: return "instance"; 3932 case RELATED: return "related"; 3933 case DEPENDENTS: return "dependents"; 3934 case AUTHOREDBY: return "authoredby"; 3935 case NULL: return null; 3936 default: return "?"; 3937 } 3938 } 3939 public String getSystem() { 3940 switch (this) { 3941 case INSTANCE: return "http://hl7.org/fhir/consent-data-meaning"; 3942 case RELATED: return "http://hl7.org/fhir/consent-data-meaning"; 3943 case DEPENDENTS: return "http://hl7.org/fhir/consent-data-meaning"; 3944 case AUTHOREDBY: return "http://hl7.org/fhir/consent-data-meaning"; 3945 case NULL: return null; 3946 default: return "?"; 3947 } 3948 } 3949 public String getDefinition() { 3950 switch (this) { 3951 case INSTANCE: return "The consent applies directly to the instance of the resource."; 3952 case RELATED: return "The consent applies directly to the instance of the resource and instances it refers to."; 3953 case DEPENDENTS: return "The consent applies directly to the instance of the resource and instances that refer to it."; 3954 case AUTHOREDBY: return "The consent applies to instances of resources that are authored by."; 3955 case NULL: return null; 3956 default: return "?"; 3957 } 3958 } 3959 public String getDisplay() { 3960 switch (this) { 3961 case INSTANCE: return "Instance"; 3962 case RELATED: return "Related"; 3963 case DEPENDENTS: return "Dependents"; 3964 case AUTHOREDBY: return "AuthoredBy"; 3965 case NULL: return null; 3966 default: return "?"; 3967 } 3968 } 3969 } 3970 3971 public static class ConsentDataMeaningEnumFactory implements EnumFactory<ConsentDataMeaning> { 3972 public ConsentDataMeaning fromCode(String codeString) throws IllegalArgumentException { 3973 if (codeString == null || "".equals(codeString)) 3974 if (codeString == null || "".equals(codeString)) 3975 return null; 3976 if ("instance".equals(codeString)) 3977 return ConsentDataMeaning.INSTANCE; 3978 if ("related".equals(codeString)) 3979 return ConsentDataMeaning.RELATED; 3980 if ("dependents".equals(codeString)) 3981 return ConsentDataMeaning.DEPENDENTS; 3982 if ("authoredby".equals(codeString)) 3983 return ConsentDataMeaning.AUTHOREDBY; 3984 throw new IllegalArgumentException("Unknown ConsentDataMeaning code '"+codeString+"'"); 3985 } 3986 3987 public Enumeration<ConsentDataMeaning> fromType(PrimitiveType<?> code) throws FHIRException { 3988 if (code == null) 3989 return null; 3990 if (code.isEmpty()) 3991 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.NULL, code); 3992 String codeString = ((PrimitiveType) code).asStringValue(); 3993 if (codeString == null || "".equals(codeString)) 3994 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.NULL, code); 3995 if ("instance".equals(codeString)) 3996 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.INSTANCE, code); 3997 if ("related".equals(codeString)) 3998 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.RELATED, code); 3999 if ("dependents".equals(codeString)) 4000 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.DEPENDENTS, code); 4001 if ("authoredby".equals(codeString)) 4002 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.AUTHOREDBY, code); 4003 throw new FHIRException("Unknown ConsentDataMeaning code '"+codeString+"'"); 4004 } 4005 public String toCode(ConsentDataMeaning code) { 4006 if (code == ConsentDataMeaning.INSTANCE) 4007 return "instance"; 4008 if (code == ConsentDataMeaning.RELATED) 4009 return "related"; 4010 if (code == ConsentDataMeaning.DEPENDENTS) 4011 return "dependents"; 4012 if (code == ConsentDataMeaning.AUTHOREDBY) 4013 return "authoredby"; 4014 return "?"; 4015 } 4016 public String toSystem(ConsentDataMeaning code) { 4017 return code.getSystem(); 4018 } 4019 } 4020 4021 public enum ConsentProvisionType { 4022 /** 4023 * Consent is denied for actions meeting these rules. 4024 */ 4025 DENY, 4026 /** 4027 * Consent is provided for actions meeting these rules. 4028 */ 4029 PERMIT, 4030 /** 4031 * added to help the parsers 4032 */ 4033 NULL; 4034 public static ConsentProvisionType fromCode(String codeString) throws FHIRException { 4035 if (codeString == null || "".equals(codeString)) 4036 return null; 4037 if ("deny".equals(codeString)) 4038 return DENY; 4039 if ("permit".equals(codeString)) 4040 return PERMIT; 4041 throw new FHIRException("Unknown ConsentProvisionType code '"+codeString+"'"); 4042 } 4043 public static boolean isValidCode(String codeString) { 4044 if (codeString == null || "".equals(codeString)) 4045 return false; 4046 return Utilities.existsInList(codeString, "deny", "permit"); 4047 } 4048 public String toCode() { 4049 switch (this) { 4050 case DENY: return "deny"; 4051 case PERMIT: return "permit"; 4052 case NULL: return null; 4053 default: return "?"; 4054 } 4055 } 4056 public String getSystem() { 4057 switch (this) { 4058 case DENY: return "http://hl7.org/fhir/consent-provision-type"; 4059 case PERMIT: return "http://hl7.org/fhir/consent-provision-type"; 4060 case NULL: return null; 4061 default: return "?"; 4062 } 4063 } 4064 public String getDefinition() { 4065 switch (this) { 4066 case DENY: return "Consent is denied for actions meeting these rules."; 4067 case PERMIT: return "Consent is provided for actions meeting these rules."; 4068 case NULL: return null; 4069 default: return "?"; 4070 } 4071 } 4072 public String getDisplay() { 4073 switch (this) { 4074 case DENY: return "Deny"; 4075 case PERMIT: return "Permit"; 4076 case NULL: return null; 4077 default: return "?"; 4078 } 4079 } 4080 } 4081 4082 public static class ConsentProvisionTypeEnumFactory implements EnumFactory<ConsentProvisionType> { 4083 public ConsentProvisionType fromCode(String codeString) throws IllegalArgumentException { 4084 if (codeString == null || "".equals(codeString)) 4085 if (codeString == null || "".equals(codeString)) 4086 return null; 4087 if ("deny".equals(codeString)) 4088 return ConsentProvisionType.DENY; 4089 if ("permit".equals(codeString)) 4090 return ConsentProvisionType.PERMIT; 4091 throw new IllegalArgumentException("Unknown ConsentProvisionType code '"+codeString+"'"); 4092 } 4093 4094 public Enumeration<ConsentProvisionType> fromType(PrimitiveType<?> code) throws FHIRException { 4095 if (code == null) 4096 return null; 4097 if (code.isEmpty()) 4098 return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.NULL, code); 4099 String codeString = ((PrimitiveType) code).asStringValue(); 4100 if (codeString == null || "".equals(codeString)) 4101 return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.NULL, code); 4102 if ("deny".equals(codeString)) 4103 return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.DENY, code); 4104 if ("permit".equals(codeString)) 4105 return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.PERMIT, code); 4106 throw new FHIRException("Unknown ConsentProvisionType code '"+codeString+"'"); 4107 } 4108 public String toCode(ConsentProvisionType code) { 4109 if (code == ConsentProvisionType.DENY) 4110 return "deny"; 4111 if (code == ConsentProvisionType.PERMIT) 4112 return "permit"; 4113 return "?"; 4114 } 4115 public String toSystem(ConsentProvisionType code) { 4116 return code.getSystem(); 4117 } 4118 } 4119 4120 public enum Currencies { 4121 /** 4122 * null 4123 */ 4124 AED, 4125 /** 4126 * null 4127 */ 4128 AFN, 4129 /** 4130 * null 4131 */ 4132 ALL, 4133 /** 4134 * null 4135 */ 4136 AMD, 4137 /** 4138 * null 4139 */ 4140 ANG, 4141 /** 4142 * null 4143 */ 4144 AOA, 4145 /** 4146 * null 4147 */ 4148 ARS, 4149 /** 4150 * null 4151 */ 4152 AUD, 4153 /** 4154 * null 4155 */ 4156 AWG, 4157 /** 4158 * null 4159 */ 4160 AZN, 4161 /** 4162 * null 4163 */ 4164 BAM, 4165 /** 4166 * null 4167 */ 4168 BBD, 4169 /** 4170 * null 4171 */ 4172 BDT, 4173 /** 4174 * null 4175 */ 4176 BGN, 4177 /** 4178 * null 4179 */ 4180 BHD, 4181 /** 4182 * null 4183 */ 4184 BIF, 4185 /** 4186 * null 4187 */ 4188 BMD, 4189 /** 4190 * null 4191 */ 4192 BND, 4193 /** 4194 * null 4195 */ 4196 BOB, 4197 /** 4198 * null 4199 */ 4200 BOV, 4201 /** 4202 * null 4203 */ 4204 BRL, 4205 /** 4206 * null 4207 */ 4208 BSD, 4209 /** 4210 * null 4211 */ 4212 BTN, 4213 /** 4214 * null 4215 */ 4216 BWP, 4217 /** 4218 * null 4219 */ 4220 BYN, 4221 /** 4222 * null 4223 */ 4224 BZD, 4225 /** 4226 * null 4227 */ 4228 CAD, 4229 /** 4230 * null 4231 */ 4232 CDF, 4233 /** 4234 * null 4235 */ 4236 CHE, 4237 /** 4238 * null 4239 */ 4240 CHF, 4241 /** 4242 * null 4243 */ 4244 CHW, 4245 /** 4246 * null 4247 */ 4248 CLF, 4249 /** 4250 * null 4251 */ 4252 CLP, 4253 /** 4254 * null 4255 */ 4256 CNY, 4257 /** 4258 * null 4259 */ 4260 COP, 4261 /** 4262 * null 4263 */ 4264 COU, 4265 /** 4266 * null 4267 */ 4268 CRC, 4269 /** 4270 * null 4271 */ 4272 CUC, 4273 /** 4274 * null 4275 */ 4276 CUP, 4277 /** 4278 * null 4279 */ 4280 CVE, 4281 /** 4282 * null 4283 */ 4284 CZK, 4285 /** 4286 * null 4287 */ 4288 DJF, 4289 /** 4290 * null 4291 */ 4292 DKK, 4293 /** 4294 * null 4295 */ 4296 DOP, 4297 /** 4298 * null 4299 */ 4300 DZD, 4301 /** 4302 * null 4303 */ 4304 EGP, 4305 /** 4306 * null 4307 */ 4308 ERN, 4309 /** 4310 * null 4311 */ 4312 ETB, 4313 /** 4314 * null 4315 */ 4316 EUR, 4317 /** 4318 * null 4319 */ 4320 FJD, 4321 /** 4322 * null 4323 */ 4324 FKP, 4325 /** 4326 * null 4327 */ 4328 GBP, 4329 /** 4330 * null 4331 */ 4332 GEL, 4333 /** 4334 * null 4335 */ 4336 GGP, 4337 /** 4338 * null 4339 */ 4340 GHS, 4341 /** 4342 * null 4343 */ 4344 GIP, 4345 /** 4346 * null 4347 */ 4348 GMD, 4349 /** 4350 * null 4351 */ 4352 GNF, 4353 /** 4354 * null 4355 */ 4356 GTQ, 4357 /** 4358 * null 4359 */ 4360 GYD, 4361 /** 4362 * null 4363 */ 4364 HKD, 4365 /** 4366 * null 4367 */ 4368 HNL, 4369 /** 4370 * null 4371 */ 4372 HRK, 4373 /** 4374 * null 4375 */ 4376 HTG, 4377 /** 4378 * null 4379 */ 4380 HUF, 4381 /** 4382 * null 4383 */ 4384 IDR, 4385 /** 4386 * null 4387 */ 4388 ILS, 4389 /** 4390 * null 4391 */ 4392 IMP, 4393 /** 4394 * null 4395 */ 4396 INR, 4397 /** 4398 * null 4399 */ 4400 IQD, 4401 /** 4402 * null 4403 */ 4404 IRR, 4405 /** 4406 * null 4407 */ 4408 ISK, 4409 /** 4410 * null 4411 */ 4412 JEP, 4413 /** 4414 * null 4415 */ 4416 JMD, 4417 /** 4418 * null 4419 */ 4420 JOD, 4421 /** 4422 * null 4423 */ 4424 JPY, 4425 /** 4426 * null 4427 */ 4428 KES, 4429 /** 4430 * null 4431 */ 4432 KGS, 4433 /** 4434 * null 4435 */ 4436 KHR, 4437 /** 4438 * null 4439 */ 4440 KMF, 4441 /** 4442 * null 4443 */ 4444 KPW, 4445 /** 4446 * null 4447 */ 4448 KRW, 4449 /** 4450 * null 4451 */ 4452 KWD, 4453 /** 4454 * null 4455 */ 4456 KYD, 4457 /** 4458 * null 4459 */ 4460 KZT, 4461 /** 4462 * null 4463 */ 4464 LAK, 4465 /** 4466 * null 4467 */ 4468 LBP, 4469 /** 4470 * null 4471 */ 4472 LKR, 4473 /** 4474 * null 4475 */ 4476 LRD, 4477 /** 4478 * null 4479 */ 4480 LSL, 4481 /** 4482 * null 4483 */ 4484 LYD, 4485 /** 4486 * null 4487 */ 4488 MAD, 4489 /** 4490 * null 4491 */ 4492 MDL, 4493 /** 4494 * null 4495 */ 4496 MGA, 4497 /** 4498 * null 4499 */ 4500 MKD, 4501 /** 4502 * null 4503 */ 4504 MMK, 4505 /** 4506 * null 4507 */ 4508 MNT, 4509 /** 4510 * null 4511 */ 4512 MOP, 4513 /** 4514 * null 4515 */ 4516 MRU, 4517 /** 4518 * null 4519 */ 4520 MUR, 4521 /** 4522 * null 4523 */ 4524 MVR, 4525 /** 4526 * null 4527 */ 4528 MWK, 4529 /** 4530 * null 4531 */ 4532 MXN, 4533 /** 4534 * null 4535 */ 4536 MXV, 4537 /** 4538 * null 4539 */ 4540 MYR, 4541 /** 4542 * null 4543 */ 4544 MZN, 4545 /** 4546 * null 4547 */ 4548 NAD, 4549 /** 4550 * null 4551 */ 4552 NGN, 4553 /** 4554 * null 4555 */ 4556 NIO, 4557 /** 4558 * null 4559 */ 4560 NOK, 4561 /** 4562 * null 4563 */ 4564 NPR, 4565 /** 4566 * null 4567 */ 4568 NZD, 4569 /** 4570 * null 4571 */ 4572 OMR, 4573 /** 4574 * null 4575 */ 4576 PAB, 4577 /** 4578 * null 4579 */ 4580 PEN, 4581 /** 4582 * null 4583 */ 4584 PGK, 4585 /** 4586 * null 4587 */ 4588 PHP, 4589 /** 4590 * null 4591 */ 4592 PKR, 4593 /** 4594 * null 4595 */ 4596 PLN, 4597 /** 4598 * null 4599 */ 4600 PYG, 4601 /** 4602 * null 4603 */ 4604 QAR, 4605 /** 4606 * null 4607 */ 4608 RON, 4609 /** 4610 * null 4611 */ 4612 RSD, 4613 /** 4614 * null 4615 */ 4616 RUB, 4617 /** 4618 * null 4619 */ 4620 RWF, 4621 /** 4622 * null 4623 */ 4624 SAR, 4625 /** 4626 * null 4627 */ 4628 SBD, 4629 /** 4630 * null 4631 */ 4632 SCR, 4633 /** 4634 * null 4635 */ 4636 SDG, 4637 /** 4638 * null 4639 */ 4640 SEK, 4641 /** 4642 * null 4643 */ 4644 SGD, 4645 /** 4646 * null 4647 */ 4648 SHP, 4649 /** 4650 * null 4651 */ 4652 SLL, 4653 /** 4654 * null 4655 */ 4656 SOS, 4657 /** 4658 * null 4659 */ 4660 SRD, 4661 /** 4662 * null 4663 */ 4664 SSP, 4665 /** 4666 * null 4667 */ 4668 STN, 4669 /** 4670 * null 4671 */ 4672 SVC, 4673 /** 4674 * null 4675 */ 4676 SYP, 4677 /** 4678 * null 4679 */ 4680 SZL, 4681 /** 4682 * null 4683 */ 4684 THB, 4685 /** 4686 * null 4687 */ 4688 TJS, 4689 /** 4690 * null 4691 */ 4692 TMT, 4693 /** 4694 * null 4695 */ 4696 TND, 4697 /** 4698 * null 4699 */ 4700 TOP, 4701 /** 4702 * null 4703 */ 4704 TRY, 4705 /** 4706 * null 4707 */ 4708 TTD, 4709 /** 4710 * null 4711 */ 4712 TVD, 4713 /** 4714 * null 4715 */ 4716 TWD, 4717 /** 4718 * null 4719 */ 4720 TZS, 4721 /** 4722 * null 4723 */ 4724 UAH, 4725 /** 4726 * null 4727 */ 4728 UGX, 4729 /** 4730 * null 4731 */ 4732 USD, 4733 /** 4734 * null 4735 */ 4736 USN, 4737 /** 4738 * null 4739 */ 4740 UYI, 4741 /** 4742 * null 4743 */ 4744 UYU, 4745 /** 4746 * null 4747 */ 4748 UZS, 4749 /** 4750 * null 4751 */ 4752 VEF, 4753 /** 4754 * null 4755 */ 4756 VND, 4757 /** 4758 * null 4759 */ 4760 VUV, 4761 /** 4762 * null 4763 */ 4764 WST, 4765 /** 4766 * null 4767 */ 4768 XAF, 4769 /** 4770 * null 4771 */ 4772 XAG, 4773 /** 4774 * null 4775 */ 4776 XAU, 4777 /** 4778 * null 4779 */ 4780 XBA, 4781 /** 4782 * null 4783 */ 4784 XBB, 4785 /** 4786 * null 4787 */ 4788 XBC, 4789 /** 4790 * null 4791 */ 4792 XBD, 4793 /** 4794 * null 4795 */ 4796 XCD, 4797 /** 4798 * null 4799 */ 4800 XDR, 4801 /** 4802 * null 4803 */ 4804 XOF, 4805 /** 4806 * null 4807 */ 4808 XPD, 4809 /** 4810 * null 4811 */ 4812 XPF, 4813 /** 4814 * null 4815 */ 4816 XPT, 4817 /** 4818 * null 4819 */ 4820 XSU, 4821 /** 4822 * null 4823 */ 4824 XTS, 4825 /** 4826 * null 4827 */ 4828 XUA, 4829 /** 4830 * null 4831 */ 4832 XXX, 4833 /** 4834 * null 4835 */ 4836 YER, 4837 /** 4838 * null 4839 */ 4840 ZAR, 4841 /** 4842 * null 4843 */ 4844 ZMW, 4845 /** 4846 * null 4847 */ 4848 ZWL, 4849 /** 4850 * added to help the parsers 4851 */ 4852 NULL; 4853 public static Currencies fromCode(String codeString) throws FHIRException { 4854 if (codeString == null || "".equals(codeString)) 4855 return null; 4856 if ("AED".equals(codeString)) 4857 return AED; 4858 if ("AFN".equals(codeString)) 4859 return AFN; 4860 if ("ALL".equals(codeString)) 4861 return ALL; 4862 if ("AMD".equals(codeString)) 4863 return AMD; 4864 if ("ANG".equals(codeString)) 4865 return ANG; 4866 if ("AOA".equals(codeString)) 4867 return AOA; 4868 if ("ARS".equals(codeString)) 4869 return ARS; 4870 if ("AUD".equals(codeString)) 4871 return AUD; 4872 if ("AWG".equals(codeString)) 4873 return AWG; 4874 if ("AZN".equals(codeString)) 4875 return AZN; 4876 if ("BAM".equals(codeString)) 4877 return BAM; 4878 if ("BBD".equals(codeString)) 4879 return BBD; 4880 if ("BDT".equals(codeString)) 4881 return BDT; 4882 if ("BGN".equals(codeString)) 4883 return BGN; 4884 if ("BHD".equals(codeString)) 4885 return BHD; 4886 if ("BIF".equals(codeString)) 4887 return BIF; 4888 if ("BMD".equals(codeString)) 4889 return BMD; 4890 if ("BND".equals(codeString)) 4891 return BND; 4892 if ("BOB".equals(codeString)) 4893 return BOB; 4894 if ("BOV".equals(codeString)) 4895 return BOV; 4896 if ("BRL".equals(codeString)) 4897 return BRL; 4898 if ("BSD".equals(codeString)) 4899 return BSD; 4900 if ("BTN".equals(codeString)) 4901 return BTN; 4902 if ("BWP".equals(codeString)) 4903 return BWP; 4904 if ("BYN".equals(codeString)) 4905 return BYN; 4906 if ("BZD".equals(codeString)) 4907 return BZD; 4908 if ("CAD".equals(codeString)) 4909 return CAD; 4910 if ("CDF".equals(codeString)) 4911 return CDF; 4912 if ("CHE".equals(codeString)) 4913 return CHE; 4914 if ("CHF".equals(codeString)) 4915 return CHF; 4916 if ("CHW".equals(codeString)) 4917 return CHW; 4918 if ("CLF".equals(codeString)) 4919 return CLF; 4920 if ("CLP".equals(codeString)) 4921 return CLP; 4922 if ("CNY".equals(codeString)) 4923 return CNY; 4924 if ("COP".equals(codeString)) 4925 return COP; 4926 if ("COU".equals(codeString)) 4927 return COU; 4928 if ("CRC".equals(codeString)) 4929 return CRC; 4930 if ("CUC".equals(codeString)) 4931 return CUC; 4932 if ("CUP".equals(codeString)) 4933 return CUP; 4934 if ("CVE".equals(codeString)) 4935 return CVE; 4936 if ("CZK".equals(codeString)) 4937 return CZK; 4938 if ("DJF".equals(codeString)) 4939 return DJF; 4940 if ("DKK".equals(codeString)) 4941 return DKK; 4942 if ("DOP".equals(codeString)) 4943 return DOP; 4944 if ("DZD".equals(codeString)) 4945 return DZD; 4946 if ("EGP".equals(codeString)) 4947 return EGP; 4948 if ("ERN".equals(codeString)) 4949 return ERN; 4950 if ("ETB".equals(codeString)) 4951 return ETB; 4952 if ("EUR".equals(codeString)) 4953 return EUR; 4954 if ("FJD".equals(codeString)) 4955 return FJD; 4956 if ("FKP".equals(codeString)) 4957 return FKP; 4958 if ("GBP".equals(codeString)) 4959 return GBP; 4960 if ("GEL".equals(codeString)) 4961 return GEL; 4962 if ("GGP".equals(codeString)) 4963 return GGP; 4964 if ("GHS".equals(codeString)) 4965 return GHS; 4966 if ("GIP".equals(codeString)) 4967 return GIP; 4968 if ("GMD".equals(codeString)) 4969 return GMD; 4970 if ("GNF".equals(codeString)) 4971 return GNF; 4972 if ("GTQ".equals(codeString)) 4973 return GTQ; 4974 if ("GYD".equals(codeString)) 4975 return GYD; 4976 if ("HKD".equals(codeString)) 4977 return HKD; 4978 if ("HNL".equals(codeString)) 4979 return HNL; 4980 if ("HRK".equals(codeString)) 4981 return HRK; 4982 if ("HTG".equals(codeString)) 4983 return HTG; 4984 if ("HUF".equals(codeString)) 4985 return HUF; 4986 if ("IDR".equals(codeString)) 4987 return IDR; 4988 if ("ILS".equals(codeString)) 4989 return ILS; 4990 if ("IMP".equals(codeString)) 4991 return IMP; 4992 if ("INR".equals(codeString)) 4993 return INR; 4994 if ("IQD".equals(codeString)) 4995 return IQD; 4996 if ("IRR".equals(codeString)) 4997 return IRR; 4998 if ("ISK".equals(codeString)) 4999 return ISK; 5000 if ("JEP".equals(codeString)) 5001 return JEP; 5002 if ("JMD".equals(codeString)) 5003 return JMD; 5004 if ("JOD".equals(codeString)) 5005 return JOD; 5006 if ("JPY".equals(codeString)) 5007 return JPY; 5008 if ("KES".equals(codeString)) 5009 return KES; 5010 if ("KGS".equals(codeString)) 5011 return KGS; 5012 if ("KHR".equals(codeString)) 5013 return KHR; 5014 if ("KMF".equals(codeString)) 5015 return KMF; 5016 if ("KPW".equals(codeString)) 5017 return KPW; 5018 if ("KRW".equals(codeString)) 5019 return KRW; 5020 if ("KWD".equals(codeString)) 5021 return KWD; 5022 if ("KYD".equals(codeString)) 5023 return KYD; 5024 if ("KZT".equals(codeString)) 5025 return KZT; 5026 if ("LAK".equals(codeString)) 5027 return LAK; 5028 if ("LBP".equals(codeString)) 5029 return LBP; 5030 if ("LKR".equals(codeString)) 5031 return LKR; 5032 if ("LRD".equals(codeString)) 5033 return LRD; 5034 if ("LSL".equals(codeString)) 5035 return LSL; 5036 if ("LYD".equals(codeString)) 5037 return LYD; 5038 if ("MAD".equals(codeString)) 5039 return MAD; 5040 if ("MDL".equals(codeString)) 5041 return MDL; 5042 if ("MGA".equals(codeString)) 5043 return MGA; 5044 if ("MKD".equals(codeString)) 5045 return MKD; 5046 if ("MMK".equals(codeString)) 5047 return MMK; 5048 if ("MNT".equals(codeString)) 5049 return MNT; 5050 if ("MOP".equals(codeString)) 5051 return MOP; 5052 if ("MRU".equals(codeString)) 5053 return MRU; 5054 if ("MUR".equals(codeString)) 5055 return MUR; 5056 if ("MVR".equals(codeString)) 5057 return MVR; 5058 if ("MWK".equals(codeString)) 5059 return MWK; 5060 if ("MXN".equals(codeString)) 5061 return MXN; 5062 if ("MXV".equals(codeString)) 5063 return MXV; 5064 if ("MYR".equals(codeString)) 5065 return MYR; 5066 if ("MZN".equals(codeString)) 5067 return MZN; 5068 if ("NAD".equals(codeString)) 5069 return NAD; 5070 if ("NGN".equals(codeString)) 5071 return NGN; 5072 if ("NIO".equals(codeString)) 5073 return NIO; 5074 if ("NOK".equals(codeString)) 5075 return NOK; 5076 if ("NPR".equals(codeString)) 5077 return NPR; 5078 if ("NZD".equals(codeString)) 5079 return NZD; 5080 if ("OMR".equals(codeString)) 5081 return OMR; 5082 if ("PAB".equals(codeString)) 5083 return PAB; 5084 if ("PEN".equals(codeString)) 5085 return PEN; 5086 if ("PGK".equals(codeString)) 5087 return PGK; 5088 if ("PHP".equals(codeString)) 5089 return PHP; 5090 if ("PKR".equals(codeString)) 5091 return PKR; 5092 if ("PLN".equals(codeString)) 5093 return PLN; 5094 if ("PYG".equals(codeString)) 5095 return PYG; 5096 if ("QAR".equals(codeString)) 5097 return QAR; 5098 if ("RON".equals(codeString)) 5099 return RON; 5100 if ("RSD".equals(codeString)) 5101 return RSD; 5102 if ("RUB".equals(codeString)) 5103 return RUB; 5104 if ("RWF".equals(codeString)) 5105 return RWF; 5106 if ("SAR".equals(codeString)) 5107 return SAR; 5108 if ("SBD".equals(codeString)) 5109 return SBD; 5110 if ("SCR".equals(codeString)) 5111 return SCR; 5112 if ("SDG".equals(codeString)) 5113 return SDG; 5114 if ("SEK".equals(codeString)) 5115 return SEK; 5116 if ("SGD".equals(codeString)) 5117 return SGD; 5118 if ("SHP".equals(codeString)) 5119 return SHP; 5120 if ("SLL".equals(codeString)) 5121 return SLL; 5122 if ("SOS".equals(codeString)) 5123 return SOS; 5124 if ("SRD".equals(codeString)) 5125 return SRD; 5126 if ("SSP".equals(codeString)) 5127 return SSP; 5128 if ("STN".equals(codeString)) 5129 return STN; 5130 if ("SVC".equals(codeString)) 5131 return SVC; 5132 if ("SYP".equals(codeString)) 5133 return SYP; 5134 if ("SZL".equals(codeString)) 5135 return SZL; 5136 if ("THB".equals(codeString)) 5137 return THB; 5138 if ("TJS".equals(codeString)) 5139 return TJS; 5140 if ("TMT".equals(codeString)) 5141 return TMT; 5142 if ("TND".equals(codeString)) 5143 return TND; 5144 if ("TOP".equals(codeString)) 5145 return TOP; 5146 if ("TRY".equals(codeString)) 5147 return TRY; 5148 if ("TTD".equals(codeString)) 5149 return TTD; 5150 if ("TVD".equals(codeString)) 5151 return TVD; 5152 if ("TWD".equals(codeString)) 5153 return TWD; 5154 if ("TZS".equals(codeString)) 5155 return TZS; 5156 if ("UAH".equals(codeString)) 5157 return UAH; 5158 if ("UGX".equals(codeString)) 5159 return UGX; 5160 if ("USD".equals(codeString)) 5161 return USD; 5162 if ("USN".equals(codeString)) 5163 return USN; 5164 if ("UYI".equals(codeString)) 5165 return UYI; 5166 if ("UYU".equals(codeString)) 5167 return UYU; 5168 if ("UZS".equals(codeString)) 5169 return UZS; 5170 if ("VEF".equals(codeString)) 5171 return VEF; 5172 if ("VND".equals(codeString)) 5173 return VND; 5174 if ("VUV".equals(codeString)) 5175 return VUV; 5176 if ("WST".equals(codeString)) 5177 return WST; 5178 if ("XAF".equals(codeString)) 5179 return XAF; 5180 if ("XAG".equals(codeString)) 5181 return XAG; 5182 if ("XAU".equals(codeString)) 5183 return XAU; 5184 if ("XBA".equals(codeString)) 5185 return XBA; 5186 if ("XBB".equals(codeString)) 5187 return XBB; 5188 if ("XBC".equals(codeString)) 5189 return XBC; 5190 if ("XBD".equals(codeString)) 5191 return XBD; 5192 if ("XCD".equals(codeString)) 5193 return XCD; 5194 if ("XDR".equals(codeString)) 5195 return XDR; 5196 if ("XOF".equals(codeString)) 5197 return XOF; 5198 if ("XPD".equals(codeString)) 5199 return XPD; 5200 if ("XPF".equals(codeString)) 5201 return XPF; 5202 if ("XPT".equals(codeString)) 5203 return XPT; 5204 if ("XSU".equals(codeString)) 5205 return XSU; 5206 if ("XTS".equals(codeString)) 5207 return XTS; 5208 if ("XUA".equals(codeString)) 5209 return XUA; 5210 if ("XXX".equals(codeString)) 5211 return XXX; 5212 if ("YER".equals(codeString)) 5213 return YER; 5214 if ("ZAR".equals(codeString)) 5215 return ZAR; 5216 if ("ZMW".equals(codeString)) 5217 return ZMW; 5218 if ("ZWL".equals(codeString)) 5219 return ZWL; 5220 throw new FHIRException("Unknown Currencies code '"+codeString+"'"); 5221 } 5222 public static boolean isValidCode(String codeString) { 5223 if (codeString == null || "".equals(codeString)) 5224 return false; 5225 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"); 5226 } 5227 public String toCode() { 5228 switch (this) { 5229 case AED: return "AED"; 5230 case AFN: return "AFN"; 5231 case ALL: return "ALL"; 5232 case AMD: return "AMD"; 5233 case ANG: return "ANG"; 5234 case AOA: return "AOA"; 5235 case ARS: return "ARS"; 5236 case AUD: return "AUD"; 5237 case AWG: return "AWG"; 5238 case AZN: return "AZN"; 5239 case BAM: return "BAM"; 5240 case BBD: return "BBD"; 5241 case BDT: return "BDT"; 5242 case BGN: return "BGN"; 5243 case BHD: return "BHD"; 5244 case BIF: return "BIF"; 5245 case BMD: return "BMD"; 5246 case BND: return "BND"; 5247 case BOB: return "BOB"; 5248 case BOV: return "BOV"; 5249 case BRL: return "BRL"; 5250 case BSD: return "BSD"; 5251 case BTN: return "BTN"; 5252 case BWP: return "BWP"; 5253 case BYN: return "BYN"; 5254 case BZD: return "BZD"; 5255 case CAD: return "CAD"; 5256 case CDF: return "CDF"; 5257 case CHE: return "CHE"; 5258 case CHF: return "CHF"; 5259 case CHW: return "CHW"; 5260 case CLF: return "CLF"; 5261 case CLP: return "CLP"; 5262 case CNY: return "CNY"; 5263 case COP: return "COP"; 5264 case COU: return "COU"; 5265 case CRC: return "CRC"; 5266 case CUC: return "CUC"; 5267 case CUP: return "CUP"; 5268 case CVE: return "CVE"; 5269 case CZK: return "CZK"; 5270 case DJF: return "DJF"; 5271 case DKK: return "DKK"; 5272 case DOP: return "DOP"; 5273 case DZD: return "DZD"; 5274 case EGP: return "EGP"; 5275 case ERN: return "ERN"; 5276 case ETB: return "ETB"; 5277 case EUR: return "EUR"; 5278 case FJD: return "FJD"; 5279 case FKP: return "FKP"; 5280 case GBP: return "GBP"; 5281 case GEL: return "GEL"; 5282 case GGP: return "GGP"; 5283 case GHS: return "GHS"; 5284 case GIP: return "GIP"; 5285 case GMD: return "GMD"; 5286 case GNF: return "GNF"; 5287 case GTQ: return "GTQ"; 5288 case GYD: return "GYD"; 5289 case HKD: return "HKD"; 5290 case HNL: return "HNL"; 5291 case HRK: return "HRK"; 5292 case HTG: return "HTG"; 5293 case HUF: return "HUF"; 5294 case IDR: return "IDR"; 5295 case ILS: return "ILS"; 5296 case IMP: return "IMP"; 5297 case INR: return "INR"; 5298 case IQD: return "IQD"; 5299 case IRR: return "IRR"; 5300 case ISK: return "ISK"; 5301 case JEP: return "JEP"; 5302 case JMD: return "JMD"; 5303 case JOD: return "JOD"; 5304 case JPY: return "JPY"; 5305 case KES: return "KES"; 5306 case KGS: return "KGS"; 5307 case KHR: return "KHR"; 5308 case KMF: return "KMF"; 5309 case KPW: return "KPW"; 5310 case KRW: return "KRW"; 5311 case KWD: return "KWD"; 5312 case KYD: return "KYD"; 5313 case KZT: return "KZT"; 5314 case LAK: return "LAK"; 5315 case LBP: return "LBP"; 5316 case LKR: return "LKR"; 5317 case LRD: return "LRD"; 5318 case LSL: return "LSL"; 5319 case LYD: return "LYD"; 5320 case MAD: return "MAD"; 5321 case MDL: return "MDL"; 5322 case MGA: return "MGA"; 5323 case MKD: return "MKD"; 5324 case MMK: return "MMK"; 5325 case MNT: return "MNT"; 5326 case MOP: return "MOP"; 5327 case MRU: return "MRU"; 5328 case MUR: return "MUR"; 5329 case MVR: return "MVR"; 5330 case MWK: return "MWK"; 5331 case MXN: return "MXN"; 5332 case MXV: return "MXV"; 5333 case MYR: return "MYR"; 5334 case MZN: return "MZN"; 5335 case NAD: return "NAD"; 5336 case NGN: return "NGN"; 5337 case NIO: return "NIO"; 5338 case NOK: return "NOK"; 5339 case NPR: return "NPR"; 5340 case NZD: return "NZD"; 5341 case OMR: return "OMR"; 5342 case PAB: return "PAB"; 5343 case PEN: return "PEN"; 5344 case PGK: return "PGK"; 5345 case PHP: return "PHP"; 5346 case PKR: return "PKR"; 5347 case PLN: return "PLN"; 5348 case PYG: return "PYG"; 5349 case QAR: return "QAR"; 5350 case RON: return "RON"; 5351 case RSD: return "RSD"; 5352 case RUB: return "RUB"; 5353 case RWF: return "RWF"; 5354 case SAR: return "SAR"; 5355 case SBD: return "SBD"; 5356 case SCR: return "SCR"; 5357 case SDG: return "SDG"; 5358 case SEK: return "SEK"; 5359 case SGD: return "SGD"; 5360 case SHP: return "SHP"; 5361 case SLL: return "SLL"; 5362 case SOS: return "SOS"; 5363 case SRD: return "SRD"; 5364 case SSP: return "SSP"; 5365 case STN: return "STN"; 5366 case SVC: return "SVC"; 5367 case SYP: return "SYP"; 5368 case SZL: return "SZL"; 5369 case THB: return "THB"; 5370 case TJS: return "TJS"; 5371 case TMT: return "TMT"; 5372 case TND: return "TND"; 5373 case TOP: return "TOP"; 5374 case TRY: return "TRY"; 5375 case TTD: return "TTD"; 5376 case TVD: return "TVD"; 5377 case TWD: return "TWD"; 5378 case TZS: return "TZS"; 5379 case UAH: return "UAH"; 5380 case UGX: return "UGX"; 5381 case USD: return "USD"; 5382 case USN: return "USN"; 5383 case UYI: return "UYI"; 5384 case UYU: return "UYU"; 5385 case UZS: return "UZS"; 5386 case VEF: return "VEF"; 5387 case VND: return "VND"; 5388 case VUV: return "VUV"; 5389 case WST: return "WST"; 5390 case XAF: return "XAF"; 5391 case XAG: return "XAG"; 5392 case XAU: return "XAU"; 5393 case XBA: return "XBA"; 5394 case XBB: return "XBB"; 5395 case XBC: return "XBC"; 5396 case XBD: return "XBD"; 5397 case XCD: return "XCD"; 5398 case XDR: return "XDR"; 5399 case XOF: return "XOF"; 5400 case XPD: return "XPD"; 5401 case XPF: return "XPF"; 5402 case XPT: return "XPT"; 5403 case XSU: return "XSU"; 5404 case XTS: return "XTS"; 5405 case XUA: return "XUA"; 5406 case XXX: return "XXX"; 5407 case YER: return "YER"; 5408 case ZAR: return "ZAR"; 5409 case ZMW: return "ZMW"; 5410 case ZWL: return "ZWL"; 5411 case NULL: return null; 5412 default: return "?"; 5413 } 5414 } 5415 public String getSystem() { 5416 switch (this) { 5417 case AED: return "urn:iso:std:iso:4217"; 5418 case AFN: return "urn:iso:std:iso:4217"; 5419 case ALL: return "urn:iso:std:iso:4217"; 5420 case AMD: return "urn:iso:std:iso:4217"; 5421 case ANG: return "urn:iso:std:iso:4217"; 5422 case AOA: return "urn:iso:std:iso:4217"; 5423 case ARS: return "urn:iso:std:iso:4217"; 5424 case AUD: return "urn:iso:std:iso:4217"; 5425 case AWG: return "urn:iso:std:iso:4217"; 5426 case AZN: return "urn:iso:std:iso:4217"; 5427 case BAM: return "urn:iso:std:iso:4217"; 5428 case BBD: return "urn:iso:std:iso:4217"; 5429 case BDT: return "urn:iso:std:iso:4217"; 5430 case BGN: return "urn:iso:std:iso:4217"; 5431 case BHD: return "urn:iso:std:iso:4217"; 5432 case BIF: return "urn:iso:std:iso:4217"; 5433 case BMD: return "urn:iso:std:iso:4217"; 5434 case BND: return "urn:iso:std:iso:4217"; 5435 case BOB: return "urn:iso:std:iso:4217"; 5436 case BOV: return "urn:iso:std:iso:4217"; 5437 case BRL: return "urn:iso:std:iso:4217"; 5438 case BSD: return "urn:iso:std:iso:4217"; 5439 case BTN: return "urn:iso:std:iso:4217"; 5440 case BWP: return "urn:iso:std:iso:4217"; 5441 case BYN: return "urn:iso:std:iso:4217"; 5442 case BZD: return "urn:iso:std:iso:4217"; 5443 case CAD: return "urn:iso:std:iso:4217"; 5444 case CDF: return "urn:iso:std:iso:4217"; 5445 case CHE: return "urn:iso:std:iso:4217"; 5446 case CHF: return "urn:iso:std:iso:4217"; 5447 case CHW: return "urn:iso:std:iso:4217"; 5448 case CLF: return "urn:iso:std:iso:4217"; 5449 case CLP: return "urn:iso:std:iso:4217"; 5450 case CNY: return "urn:iso:std:iso:4217"; 5451 case COP: return "urn:iso:std:iso:4217"; 5452 case COU: return "urn:iso:std:iso:4217"; 5453 case CRC: return "urn:iso:std:iso:4217"; 5454 case CUC: return "urn:iso:std:iso:4217"; 5455 case CUP: return "urn:iso:std:iso:4217"; 5456 case CVE: return "urn:iso:std:iso:4217"; 5457 case CZK: return "urn:iso:std:iso:4217"; 5458 case DJF: return "urn:iso:std:iso:4217"; 5459 case DKK: return "urn:iso:std:iso:4217"; 5460 case DOP: return "urn:iso:std:iso:4217"; 5461 case DZD: return "urn:iso:std:iso:4217"; 5462 case EGP: return "urn:iso:std:iso:4217"; 5463 case ERN: return "urn:iso:std:iso:4217"; 5464 case ETB: return "urn:iso:std:iso:4217"; 5465 case EUR: return "urn:iso:std:iso:4217"; 5466 case FJD: return "urn:iso:std:iso:4217"; 5467 case FKP: return "urn:iso:std:iso:4217"; 5468 case GBP: return "urn:iso:std:iso:4217"; 5469 case GEL: return "urn:iso:std:iso:4217"; 5470 case GGP: return "urn:iso:std:iso:4217"; 5471 case GHS: return "urn:iso:std:iso:4217"; 5472 case GIP: return "urn:iso:std:iso:4217"; 5473 case GMD: return "urn:iso:std:iso:4217"; 5474 case GNF: return "urn:iso:std:iso:4217"; 5475 case GTQ: return "urn:iso:std:iso:4217"; 5476 case GYD: return "urn:iso:std:iso:4217"; 5477 case HKD: return "urn:iso:std:iso:4217"; 5478 case HNL: return "urn:iso:std:iso:4217"; 5479 case HRK: return "urn:iso:std:iso:4217"; 5480 case HTG: return "urn:iso:std:iso:4217"; 5481 case HUF: return "urn:iso:std:iso:4217"; 5482 case IDR: return "urn:iso:std:iso:4217"; 5483 case ILS: return "urn:iso:std:iso:4217"; 5484 case IMP: return "urn:iso:std:iso:4217"; 5485 case INR: return "urn:iso:std:iso:4217"; 5486 case IQD: return "urn:iso:std:iso:4217"; 5487 case IRR: return "urn:iso:std:iso:4217"; 5488 case ISK: return "urn:iso:std:iso:4217"; 5489 case JEP: return "urn:iso:std:iso:4217"; 5490 case JMD: return "urn:iso:std:iso:4217"; 5491 case JOD: return "urn:iso:std:iso:4217"; 5492 case JPY: return "urn:iso:std:iso:4217"; 5493 case KES: return "urn:iso:std:iso:4217"; 5494 case KGS: return "urn:iso:std:iso:4217"; 5495 case KHR: return "urn:iso:std:iso:4217"; 5496 case KMF: return "urn:iso:std:iso:4217"; 5497 case KPW: return "urn:iso:std:iso:4217"; 5498 case KRW: return "urn:iso:std:iso:4217"; 5499 case KWD: return "urn:iso:std:iso:4217"; 5500 case KYD: return "urn:iso:std:iso:4217"; 5501 case KZT: return "urn:iso:std:iso:4217"; 5502 case LAK: return "urn:iso:std:iso:4217"; 5503 case LBP: return "urn:iso:std:iso:4217"; 5504 case LKR: return "urn:iso:std:iso:4217"; 5505 case LRD: return "urn:iso:std:iso:4217"; 5506 case LSL: return "urn:iso:std:iso:4217"; 5507 case LYD: return "urn:iso:std:iso:4217"; 5508 case MAD: return "urn:iso:std:iso:4217"; 5509 case MDL: return "urn:iso:std:iso:4217"; 5510 case MGA: return "urn:iso:std:iso:4217"; 5511 case MKD: return "urn:iso:std:iso:4217"; 5512 case MMK: return "urn:iso:std:iso:4217"; 5513 case MNT: return "urn:iso:std:iso:4217"; 5514 case MOP: return "urn:iso:std:iso:4217"; 5515 case MRU: return "urn:iso:std:iso:4217"; 5516 case MUR: return "urn:iso:std:iso:4217"; 5517 case MVR: return "urn:iso:std:iso:4217"; 5518 case MWK: return "urn:iso:std:iso:4217"; 5519 case MXN: return "urn:iso:std:iso:4217"; 5520 case MXV: return "urn:iso:std:iso:4217"; 5521 case MYR: return "urn:iso:std:iso:4217"; 5522 case MZN: return "urn:iso:std:iso:4217"; 5523 case NAD: return "urn:iso:std:iso:4217"; 5524 case NGN: return "urn:iso:std:iso:4217"; 5525 case NIO: return "urn:iso:std:iso:4217"; 5526 case NOK: return "urn:iso:std:iso:4217"; 5527 case NPR: return "urn:iso:std:iso:4217"; 5528 case NZD: return "urn:iso:std:iso:4217"; 5529 case OMR: return "urn:iso:std:iso:4217"; 5530 case PAB: return "urn:iso:std:iso:4217"; 5531 case PEN: return "urn:iso:std:iso:4217"; 5532 case PGK: return "urn:iso:std:iso:4217"; 5533 case PHP: return "urn:iso:std:iso:4217"; 5534 case PKR: return "urn:iso:std:iso:4217"; 5535 case PLN: return "urn:iso:std:iso:4217"; 5536 case PYG: return "urn:iso:std:iso:4217"; 5537 case QAR: return "urn:iso:std:iso:4217"; 5538 case RON: return "urn:iso:std:iso:4217"; 5539 case RSD: return "urn:iso:std:iso:4217"; 5540 case RUB: return "urn:iso:std:iso:4217"; 5541 case RWF: return "urn:iso:std:iso:4217"; 5542 case SAR: return "urn:iso:std:iso:4217"; 5543 case SBD: return "urn:iso:std:iso:4217"; 5544 case SCR: return "urn:iso:std:iso:4217"; 5545 case SDG: return "urn:iso:std:iso:4217"; 5546 case SEK: return "urn:iso:std:iso:4217"; 5547 case SGD: return "urn:iso:std:iso:4217"; 5548 case SHP: return "urn:iso:std:iso:4217"; 5549 case SLL: return "urn:iso:std:iso:4217"; 5550 case SOS: return "urn:iso:std:iso:4217"; 5551 case SRD: return "urn:iso:std:iso:4217"; 5552 case SSP: return "urn:iso:std:iso:4217"; 5553 case STN: return "urn:iso:std:iso:4217"; 5554 case SVC: return "urn:iso:std:iso:4217"; 5555 case SYP: return "urn:iso:std:iso:4217"; 5556 case SZL: return "urn:iso:std:iso:4217"; 5557 case THB: return "urn:iso:std:iso:4217"; 5558 case TJS: return "urn:iso:std:iso:4217"; 5559 case TMT: return "urn:iso:std:iso:4217"; 5560 case TND: return "urn:iso:std:iso:4217"; 5561 case TOP: return "urn:iso:std:iso:4217"; 5562 case TRY: return "urn:iso:std:iso:4217"; 5563 case TTD: return "urn:iso:std:iso:4217"; 5564 case TVD: return "urn:iso:std:iso:4217"; 5565 case TWD: return "urn:iso:std:iso:4217"; 5566 case TZS: return "urn:iso:std:iso:4217"; 5567 case UAH: return "urn:iso:std:iso:4217"; 5568 case UGX: return "urn:iso:std:iso:4217"; 5569 case USD: return "urn:iso:std:iso:4217"; 5570 case USN: return "urn:iso:std:iso:4217"; 5571 case UYI: return "urn:iso:std:iso:4217"; 5572 case UYU: return "urn:iso:std:iso:4217"; 5573 case UZS: return "urn:iso:std:iso:4217"; 5574 case VEF: return "urn:iso:std:iso:4217"; 5575 case VND: return "urn:iso:std:iso:4217"; 5576 case VUV: return "urn:iso:std:iso:4217"; 5577 case WST: return "urn:iso:std:iso:4217"; 5578 case XAF: return "urn:iso:std:iso:4217"; 5579 case XAG: return "urn:iso:std:iso:4217"; 5580 case XAU: return "urn:iso:std:iso:4217"; 5581 case XBA: return "urn:iso:std:iso:4217"; 5582 case XBB: return "urn:iso:std:iso:4217"; 5583 case XBC: return "urn:iso:std:iso:4217"; 5584 case XBD: return "urn:iso:std:iso:4217"; 5585 case XCD: return "urn:iso:std:iso:4217"; 5586 case XDR: return "urn:iso:std:iso:4217"; 5587 case XOF: return "urn:iso:std:iso:4217"; 5588 case XPD: return "urn:iso:std:iso:4217"; 5589 case XPF: return "urn:iso:std:iso:4217"; 5590 case XPT: return "urn:iso:std:iso:4217"; 5591 case XSU: return "urn:iso:std:iso:4217"; 5592 case XTS: return "urn:iso:std:iso:4217"; 5593 case XUA: return "urn:iso:std:iso:4217"; 5594 case XXX: return "urn:iso:std:iso:4217"; 5595 case YER: return "urn:iso:std:iso:4217"; 5596 case ZAR: return "urn:iso:std:iso:4217"; 5597 case ZMW: return "urn:iso:std:iso:4217"; 5598 case ZWL: return "urn:iso:std:iso:4217"; 5599 case NULL: return null; 5600 default: return "?"; 5601 } 5602 } 5603 public String getDefinition() { 5604 switch (this) { 5605 case AED: return ""; 5606 case AFN: return ""; 5607 case ALL: return ""; 5608 case AMD: return ""; 5609 case ANG: return ""; 5610 case AOA: return ""; 5611 case ARS: return ""; 5612 case AUD: return ""; 5613 case AWG: return ""; 5614 case AZN: return ""; 5615 case BAM: return ""; 5616 case BBD: return ""; 5617 case BDT: return ""; 5618 case BGN: return ""; 5619 case BHD: return ""; 5620 case BIF: return ""; 5621 case BMD: return ""; 5622 case BND: return ""; 5623 case BOB: return ""; 5624 case BOV: return ""; 5625 case BRL: return ""; 5626 case BSD: return ""; 5627 case BTN: return ""; 5628 case BWP: return ""; 5629 case BYN: return ""; 5630 case BZD: return ""; 5631 case CAD: return ""; 5632 case CDF: return ""; 5633 case CHE: return ""; 5634 case CHF: return ""; 5635 case CHW: return ""; 5636 case CLF: return ""; 5637 case CLP: return ""; 5638 case CNY: return ""; 5639 case COP: return ""; 5640 case COU: return ""; 5641 case CRC: return ""; 5642 case CUC: return ""; 5643 case CUP: return ""; 5644 case CVE: return ""; 5645 case CZK: return ""; 5646 case DJF: return ""; 5647 case DKK: return ""; 5648 case DOP: return ""; 5649 case DZD: return ""; 5650 case EGP: return ""; 5651 case ERN: return ""; 5652 case ETB: return ""; 5653 case EUR: return ""; 5654 case FJD: return ""; 5655 case FKP: return ""; 5656 case GBP: return ""; 5657 case GEL: return ""; 5658 case GGP: return ""; 5659 case GHS: return ""; 5660 case GIP: return ""; 5661 case GMD: return ""; 5662 case GNF: return ""; 5663 case GTQ: return ""; 5664 case GYD: return ""; 5665 case HKD: return ""; 5666 case HNL: return ""; 5667 case HRK: return ""; 5668 case HTG: return ""; 5669 case HUF: return ""; 5670 case IDR: return ""; 5671 case ILS: return ""; 5672 case IMP: return ""; 5673 case INR: return ""; 5674 case IQD: return ""; 5675 case IRR: return ""; 5676 case ISK: return ""; 5677 case JEP: return ""; 5678 case JMD: return ""; 5679 case JOD: return ""; 5680 case JPY: return ""; 5681 case KES: return ""; 5682 case KGS: return ""; 5683 case KHR: return ""; 5684 case KMF: return ""; 5685 case KPW: return ""; 5686 case KRW: return ""; 5687 case KWD: return ""; 5688 case KYD: return ""; 5689 case KZT: return ""; 5690 case LAK: return ""; 5691 case LBP: return ""; 5692 case LKR: return ""; 5693 case LRD: return ""; 5694 case LSL: return ""; 5695 case LYD: return ""; 5696 case MAD: return ""; 5697 case MDL: return ""; 5698 case MGA: return ""; 5699 case MKD: return ""; 5700 case MMK: return ""; 5701 case MNT: return ""; 5702 case MOP: return ""; 5703 case MRU: return ""; 5704 case MUR: return ""; 5705 case MVR: return ""; 5706 case MWK: return ""; 5707 case MXN: return ""; 5708 case MXV: return ""; 5709 case MYR: return ""; 5710 case MZN: return ""; 5711 case NAD: return ""; 5712 case NGN: return ""; 5713 case NIO: return ""; 5714 case NOK: return ""; 5715 case NPR: return ""; 5716 case NZD: return ""; 5717 case OMR: return ""; 5718 case PAB: return ""; 5719 case PEN: return ""; 5720 case PGK: return ""; 5721 case PHP: return ""; 5722 case PKR: return ""; 5723 case PLN: return ""; 5724 case PYG: return ""; 5725 case QAR: return ""; 5726 case RON: return ""; 5727 case RSD: return ""; 5728 case RUB: return ""; 5729 case RWF: return ""; 5730 case SAR: return ""; 5731 case SBD: return ""; 5732 case SCR: return ""; 5733 case SDG: return ""; 5734 case SEK: return ""; 5735 case SGD: return ""; 5736 case SHP: return ""; 5737 case SLL: return ""; 5738 case SOS: return ""; 5739 case SRD: return ""; 5740 case SSP: return ""; 5741 case STN: return ""; 5742 case SVC: return ""; 5743 case SYP: return ""; 5744 case SZL: return ""; 5745 case THB: return ""; 5746 case TJS: return ""; 5747 case TMT: return ""; 5748 case TND: return ""; 5749 case TOP: return ""; 5750 case TRY: return ""; 5751 case TTD: return ""; 5752 case TVD: return ""; 5753 case TWD: return ""; 5754 case TZS: return ""; 5755 case UAH: return ""; 5756 case UGX: return ""; 5757 case USD: return ""; 5758 case USN: return ""; 5759 case UYI: return ""; 5760 case UYU: return ""; 5761 case UZS: return ""; 5762 case VEF: return ""; 5763 case VND: return ""; 5764 case VUV: return ""; 5765 case WST: return ""; 5766 case XAF: return ""; 5767 case XAG: return ""; 5768 case XAU: return ""; 5769 case XBA: return ""; 5770 case XBB: return ""; 5771 case XBC: return ""; 5772 case XBD: return ""; 5773 case XCD: return ""; 5774 case XDR: return ""; 5775 case XOF: return ""; 5776 case XPD: return ""; 5777 case XPF: return ""; 5778 case XPT: return ""; 5779 case XSU: return ""; 5780 case XTS: return ""; 5781 case XUA: return ""; 5782 case XXX: return ""; 5783 case YER: return ""; 5784 case ZAR: return ""; 5785 case ZMW: return ""; 5786 case ZWL: return ""; 5787 case NULL: return null; 5788 default: return "?"; 5789 } 5790 } 5791 public String getDisplay() { 5792 switch (this) { 5793 case AED: return "United Arab Emirates dirham"; 5794 case AFN: return "Afghan afghani"; 5795 case ALL: return "Albanian lek"; 5796 case AMD: return "Armenian dram"; 5797 case ANG: return "Netherlands Antillean guilder"; 5798 case AOA: return "Angolan kwanza"; 5799 case ARS: return "Argentine peso"; 5800 case AUD: return "Australian dollar"; 5801 case AWG: return "Aruban florin"; 5802 case AZN: return "Azerbaijani manat"; 5803 case BAM: return "Bosnia and Herzegovina convertible mark"; 5804 case BBD: return "Barbados dollar"; 5805 case BDT: return "Bangladeshi taka"; 5806 case BGN: return "Bulgarian lev"; 5807 case BHD: return "Bahraini dinar"; 5808 case BIF: return "Burundian franc"; 5809 case BMD: return "Bermudian dollar"; 5810 case BND: return "Brunei dollar"; 5811 case BOB: return "Boliviano"; 5812 case BOV: return "Bolivian Mvdol (funds code)"; 5813 case BRL: return "Brazilian real"; 5814 case BSD: return "Bahamian dollar"; 5815 case BTN: return "Bhutanese ngultrum"; 5816 case BWP: return "Botswana pula"; 5817 case BYN: return "Belarusian ruble"; 5818 case BZD: return "Belize dollar"; 5819 case CAD: return "Canadian dollar"; 5820 case CDF: return "Congolese franc"; 5821 case CHE: return "WIR Euro (complementary currency)"; 5822 case CHF: return "Swiss franc"; 5823 case CHW: return "WIR Franc (complementary currency)"; 5824 case CLF: return "Unidad de Fomento (funds code)"; 5825 case CLP: return "Chilean peso"; 5826 case CNY: return "Renminbi (Chinese) yuan[8]"; 5827 case COP: return "Colombian peso"; 5828 case COU: return "Unidad de Valor Real (UVR) (funds code)[9]"; 5829 case CRC: return "Costa Rican colon"; 5830 case CUC: return "Cuban convertible peso"; 5831 case CUP: return "Cuban peso"; 5832 case CVE: return "Cape Verde escudo"; 5833 case CZK: return "Czech koruna"; 5834 case DJF: return "Djiboutian franc"; 5835 case DKK: return "Danish krone"; 5836 case DOP: return "Dominican peso"; 5837 case DZD: return "Algerian dinar"; 5838 case EGP: return "Egyptian pound"; 5839 case ERN: return "Eritrean nakfa"; 5840 case ETB: return "Ethiopian birr"; 5841 case EUR: return "Euro"; 5842 case FJD: return "Fiji dollar"; 5843 case FKP: return "Falkland Islands pound"; 5844 case GBP: return "Pound sterling"; 5845 case GEL: return "Georgian lari"; 5846 case GGP: return "Guernsey Pound"; 5847 case GHS: return "Ghanaian cedi"; 5848 case GIP: return "Gibraltar pound"; 5849 case GMD: return "Gambian dalasi"; 5850 case GNF: return "Guinean franc"; 5851 case GTQ: return "Guatemalan quetzal"; 5852 case GYD: return "Guyanese dollar"; 5853 case HKD: return "Hong Kong dollar"; 5854 case HNL: return "Honduran lempira"; 5855 case HRK: return "Croatian kuna"; 5856 case HTG: return "Haitian gourde"; 5857 case HUF: return "Hungarian forint"; 5858 case IDR: return "Indonesian rupiah"; 5859 case ILS: return "Israeli new shekel"; 5860 case IMP: return "Isle of Man Pound"; 5861 case INR: return "Indian rupee"; 5862 case IQD: return "Iraqi dinar"; 5863 case IRR: return "Iranian rial"; 5864 case ISK: return "Icelandic króna"; 5865 case JEP: return "Jersey Pound"; 5866 case JMD: return "Jamaican dollar"; 5867 case JOD: return "Jordanian dinar"; 5868 case JPY: return "Japanese yen"; 5869 case KES: return "Kenyan shilling"; 5870 case KGS: return "Kyrgyzstani som"; 5871 case KHR: return "Cambodian riel"; 5872 case KMF: return "Comoro franc"; 5873 case KPW: return "North Korean won"; 5874 case KRW: return "South Korean won"; 5875 case KWD: return "Kuwaiti dinar"; 5876 case KYD: return "Cayman Islands dollar"; 5877 case KZT: return "Kazakhstani tenge"; 5878 case LAK: return "Lao kip"; 5879 case LBP: return "Lebanese pound"; 5880 case LKR: return "Sri Lankan rupee"; 5881 case LRD: return "Liberian dollar"; 5882 case LSL: return "Lesotho loti"; 5883 case LYD: return "Libyan dinar"; 5884 case MAD: return "Moroccan dirham"; 5885 case MDL: return "Moldovan leu"; 5886 case MGA: return "Malagasy ariary"; 5887 case MKD: return "Macedonian denar"; 5888 case MMK: return "Myanmar kyat"; 5889 case MNT: return "Mongolian tögrög"; 5890 case MOP: return "Macanese pataca"; 5891 case MRU: return "Mauritanian ouguiya"; 5892 case MUR: return "Mauritian rupee"; 5893 case MVR: return "Maldivian rufiyaa"; 5894 case MWK: return "Malawian kwacha"; 5895 case MXN: return "Mexican peso"; 5896 case MXV: return "Mexican Unidad de Inversion (UDI) (funds code)"; 5897 case MYR: return "Malaysian ringgit"; 5898 case MZN: return "Mozambican metical"; 5899 case NAD: return "Namibian dollar"; 5900 case NGN: return "Nigerian naira"; 5901 case NIO: return "Nicaraguan córdoba"; 5902 case NOK: return "Norwegian krone"; 5903 case NPR: return "Nepalese rupee"; 5904 case NZD: return "New Zealand dollar"; 5905 case OMR: return "Omani rial"; 5906 case PAB: return "Panamanian balboa"; 5907 case PEN: return "Peruvian Sol"; 5908 case PGK: return "Papua New Guinean kina"; 5909 case PHP: return "Philippine piso[13]"; 5910 case PKR: return "Pakistani rupee"; 5911 case PLN: return "Polish z?oty"; 5912 case PYG: return "Paraguayan guaraní"; 5913 case QAR: return "Qatari riyal"; 5914 case RON: return "Romanian leu"; 5915 case RSD: return "Serbian dinar"; 5916 case RUB: return "Russian ruble"; 5917 case RWF: return "Rwandan franc"; 5918 case SAR: return "Saudi riyal"; 5919 case SBD: return "Solomon Islands dollar"; 5920 case SCR: return "Seychelles rupee"; 5921 case SDG: return "Sudanese pound"; 5922 case SEK: return "Swedish krona/kronor"; 5923 case SGD: return "Singapore dollar"; 5924 case SHP: return "Saint Helena pound"; 5925 case SLL: return "Sierra Leonean leone"; 5926 case SOS: return "Somali shilling"; 5927 case SRD: return "Surinamese dollar"; 5928 case SSP: return "South Sudanese pound"; 5929 case STN: return "São Tomé and Príncipe dobra"; 5930 case SVC: return "Salvadoran colón"; 5931 case SYP: return "Syrian pound"; 5932 case SZL: return "Swazi lilangeni"; 5933 case THB: return "Thai baht"; 5934 case TJS: return "Tajikistani somoni"; 5935 case TMT: return "Turkmenistan manat"; 5936 case TND: return "Tunisian dinar"; 5937 case TOP: return "Tongan pa?anga"; 5938 case TRY: return "Turkish lira"; 5939 case TTD: return "Trinidad and Tobago dollar"; 5940 case TVD: return "Tuvalu Dollar"; 5941 case TWD: return "New Taiwan dollar"; 5942 case TZS: return "Tanzanian shilling"; 5943 case UAH: return "Ukrainian hryvnia"; 5944 case UGX: return "Ugandan shilling"; 5945 case USD: return "United States dollar"; 5946 case USN: return "United States dollar (next day) (funds code)"; 5947 case UYI: return "Uruguay Peso en Unidades Indexadas (URUIURUI) (funds code)"; 5948 case UYU: return "Uruguayan peso"; 5949 case UZS: return "Uzbekistan som"; 5950 case VEF: return "Venezuelan bolívar"; 5951 case VND: return "Vietnamese ??ng"; 5952 case VUV: return "Vanuatu vatu"; 5953 case WST: return "Samoan tala"; 5954 case XAF: return "CFA franc BEAC"; 5955 case XAG: return "Silver (one troy ounce)"; 5956 case XAU: return "Gold (one troy ounce)"; 5957 case XBA: return "European Composite Unit (EURCO) (bond market unit)"; 5958 case XBB: return "European Monetary Unit (E.M.U.-6) (bond market unit)"; 5959 case XBC: return "European Unit of Account 9 (E.U.A.-9) (bond market unit)"; 5960 case XBD: return "European Unit of Account 17 (E.U.A.-17) (bond market unit)"; 5961 case XCD: return "East Caribbean dollar"; 5962 case XDR: return "Special drawing rights"; 5963 case XOF: return "CFA franc BCEAO"; 5964 case XPD: return "Palladium (one troy ounce)"; 5965 case XPF: return "CFP franc (franc Pacifique)"; 5966 case XPT: return "Platinum (one troy ounce)"; 5967 case XSU: return "SUCRE"; 5968 case XTS: return "Code reserved for testing purposes"; 5969 case XUA: return "ADB Unit of Account"; 5970 case XXX: return "No currency"; 5971 case YER: return "Yemeni rial"; 5972 case ZAR: return "South African rand"; 5973 case ZMW: return "Zambian kwacha"; 5974 case ZWL: return "Zimbabwean dollar A/10"; 5975 case NULL: return null; 5976 default: return "?"; 5977 } 5978 } 5979 } 5980 5981 public static class CurrenciesEnumFactory implements EnumFactory<Currencies> { 5982 public Currencies fromCode(String codeString) throws IllegalArgumentException { 5983 if (codeString == null || "".equals(codeString)) 5984 if (codeString == null || "".equals(codeString)) 5985 return null; 5986 if ("AED".equals(codeString)) 5987 return Currencies.AED; 5988 if ("AFN".equals(codeString)) 5989 return Currencies.AFN; 5990 if ("ALL".equals(codeString)) 5991 return Currencies.ALL; 5992 if ("AMD".equals(codeString)) 5993 return Currencies.AMD; 5994 if ("ANG".equals(codeString)) 5995 return Currencies.ANG; 5996 if ("AOA".equals(codeString)) 5997 return Currencies.AOA; 5998 if ("ARS".equals(codeString)) 5999 return Currencies.ARS; 6000 if ("AUD".equals(codeString)) 6001 return Currencies.AUD; 6002 if ("AWG".equals(codeString)) 6003 return Currencies.AWG; 6004 if ("AZN".equals(codeString)) 6005 return Currencies.AZN; 6006 if ("BAM".equals(codeString)) 6007 return Currencies.BAM; 6008 if ("BBD".equals(codeString)) 6009 return Currencies.BBD; 6010 if ("BDT".equals(codeString)) 6011 return Currencies.BDT; 6012 if ("BGN".equals(codeString)) 6013 return Currencies.BGN; 6014 if ("BHD".equals(codeString)) 6015 return Currencies.BHD; 6016 if ("BIF".equals(codeString)) 6017 return Currencies.BIF; 6018 if ("BMD".equals(codeString)) 6019 return Currencies.BMD; 6020 if ("BND".equals(codeString)) 6021 return Currencies.BND; 6022 if ("BOB".equals(codeString)) 6023 return Currencies.BOB; 6024 if ("BOV".equals(codeString)) 6025 return Currencies.BOV; 6026 if ("BRL".equals(codeString)) 6027 return Currencies.BRL; 6028 if ("BSD".equals(codeString)) 6029 return Currencies.BSD; 6030 if ("BTN".equals(codeString)) 6031 return Currencies.BTN; 6032 if ("BWP".equals(codeString)) 6033 return Currencies.BWP; 6034 if ("BYN".equals(codeString)) 6035 return Currencies.BYN; 6036 if ("BZD".equals(codeString)) 6037 return Currencies.BZD; 6038 if ("CAD".equals(codeString)) 6039 return Currencies.CAD; 6040 if ("CDF".equals(codeString)) 6041 return Currencies.CDF; 6042 if ("CHE".equals(codeString)) 6043 return Currencies.CHE; 6044 if ("CHF".equals(codeString)) 6045 return Currencies.CHF; 6046 if ("CHW".equals(codeString)) 6047 return Currencies.CHW; 6048 if ("CLF".equals(codeString)) 6049 return Currencies.CLF; 6050 if ("CLP".equals(codeString)) 6051 return Currencies.CLP; 6052 if ("CNY".equals(codeString)) 6053 return Currencies.CNY; 6054 if ("COP".equals(codeString)) 6055 return Currencies.COP; 6056 if ("COU".equals(codeString)) 6057 return Currencies.COU; 6058 if ("CRC".equals(codeString)) 6059 return Currencies.CRC; 6060 if ("CUC".equals(codeString)) 6061 return Currencies.CUC; 6062 if ("CUP".equals(codeString)) 6063 return Currencies.CUP; 6064 if ("CVE".equals(codeString)) 6065 return Currencies.CVE; 6066 if ("CZK".equals(codeString)) 6067 return Currencies.CZK; 6068 if ("DJF".equals(codeString)) 6069 return Currencies.DJF; 6070 if ("DKK".equals(codeString)) 6071 return Currencies.DKK; 6072 if ("DOP".equals(codeString)) 6073 return Currencies.DOP; 6074 if ("DZD".equals(codeString)) 6075 return Currencies.DZD; 6076 if ("EGP".equals(codeString)) 6077 return Currencies.EGP; 6078 if ("ERN".equals(codeString)) 6079 return Currencies.ERN; 6080 if ("ETB".equals(codeString)) 6081 return Currencies.ETB; 6082 if ("EUR".equals(codeString)) 6083 return Currencies.EUR; 6084 if ("FJD".equals(codeString)) 6085 return Currencies.FJD; 6086 if ("FKP".equals(codeString)) 6087 return Currencies.FKP; 6088 if ("GBP".equals(codeString)) 6089 return Currencies.GBP; 6090 if ("GEL".equals(codeString)) 6091 return Currencies.GEL; 6092 if ("GGP".equals(codeString)) 6093 return Currencies.GGP; 6094 if ("GHS".equals(codeString)) 6095 return Currencies.GHS; 6096 if ("GIP".equals(codeString)) 6097 return Currencies.GIP; 6098 if ("GMD".equals(codeString)) 6099 return Currencies.GMD; 6100 if ("GNF".equals(codeString)) 6101 return Currencies.GNF; 6102 if ("GTQ".equals(codeString)) 6103 return Currencies.GTQ; 6104 if ("GYD".equals(codeString)) 6105 return Currencies.GYD; 6106 if ("HKD".equals(codeString)) 6107 return Currencies.HKD; 6108 if ("HNL".equals(codeString)) 6109 return Currencies.HNL; 6110 if ("HRK".equals(codeString)) 6111 return Currencies.HRK; 6112 if ("HTG".equals(codeString)) 6113 return Currencies.HTG; 6114 if ("HUF".equals(codeString)) 6115 return Currencies.HUF; 6116 if ("IDR".equals(codeString)) 6117 return Currencies.IDR; 6118 if ("ILS".equals(codeString)) 6119 return Currencies.ILS; 6120 if ("IMP".equals(codeString)) 6121 return Currencies.IMP; 6122 if ("INR".equals(codeString)) 6123 return Currencies.INR; 6124 if ("IQD".equals(codeString)) 6125 return Currencies.IQD; 6126 if ("IRR".equals(codeString)) 6127 return Currencies.IRR; 6128 if ("ISK".equals(codeString)) 6129 return Currencies.ISK; 6130 if ("JEP".equals(codeString)) 6131 return Currencies.JEP; 6132 if ("JMD".equals(codeString)) 6133 return Currencies.JMD; 6134 if ("JOD".equals(codeString)) 6135 return Currencies.JOD; 6136 if ("JPY".equals(codeString)) 6137 return Currencies.JPY; 6138 if ("KES".equals(codeString)) 6139 return Currencies.KES; 6140 if ("KGS".equals(codeString)) 6141 return Currencies.KGS; 6142 if ("KHR".equals(codeString)) 6143 return Currencies.KHR; 6144 if ("KMF".equals(codeString)) 6145 return Currencies.KMF; 6146 if ("KPW".equals(codeString)) 6147 return Currencies.KPW; 6148 if ("KRW".equals(codeString)) 6149 return Currencies.KRW; 6150 if ("KWD".equals(codeString)) 6151 return Currencies.KWD; 6152 if ("KYD".equals(codeString)) 6153 return Currencies.KYD; 6154 if ("KZT".equals(codeString)) 6155 return Currencies.KZT; 6156 if ("LAK".equals(codeString)) 6157 return Currencies.LAK; 6158 if ("LBP".equals(codeString)) 6159 return Currencies.LBP; 6160 if ("LKR".equals(codeString)) 6161 return Currencies.LKR; 6162 if ("LRD".equals(codeString)) 6163 return Currencies.LRD; 6164 if ("LSL".equals(codeString)) 6165 return Currencies.LSL; 6166 if ("LYD".equals(codeString)) 6167 return Currencies.LYD; 6168 if ("MAD".equals(codeString)) 6169 return Currencies.MAD; 6170 if ("MDL".equals(codeString)) 6171 return Currencies.MDL; 6172 if ("MGA".equals(codeString)) 6173 return Currencies.MGA; 6174 if ("MKD".equals(codeString)) 6175 return Currencies.MKD; 6176 if ("MMK".equals(codeString)) 6177 return Currencies.MMK; 6178 if ("MNT".equals(codeString)) 6179 return Currencies.MNT; 6180 if ("MOP".equals(codeString)) 6181 return Currencies.MOP; 6182 if ("MRU".equals(codeString)) 6183 return Currencies.MRU; 6184 if ("MUR".equals(codeString)) 6185 return Currencies.MUR; 6186 if ("MVR".equals(codeString)) 6187 return Currencies.MVR; 6188 if ("MWK".equals(codeString)) 6189 return Currencies.MWK; 6190 if ("MXN".equals(codeString)) 6191 return Currencies.MXN; 6192 if ("MXV".equals(codeString)) 6193 return Currencies.MXV; 6194 if ("MYR".equals(codeString)) 6195 return Currencies.MYR; 6196 if ("MZN".equals(codeString)) 6197 return Currencies.MZN; 6198 if ("NAD".equals(codeString)) 6199 return Currencies.NAD; 6200 if ("NGN".equals(codeString)) 6201 return Currencies.NGN; 6202 if ("NIO".equals(codeString)) 6203 return Currencies.NIO; 6204 if ("NOK".equals(codeString)) 6205 return Currencies.NOK; 6206 if ("NPR".equals(codeString)) 6207 return Currencies.NPR; 6208 if ("NZD".equals(codeString)) 6209 return Currencies.NZD; 6210 if ("OMR".equals(codeString)) 6211 return Currencies.OMR; 6212 if ("PAB".equals(codeString)) 6213 return Currencies.PAB; 6214 if ("PEN".equals(codeString)) 6215 return Currencies.PEN; 6216 if ("PGK".equals(codeString)) 6217 return Currencies.PGK; 6218 if ("PHP".equals(codeString)) 6219 return Currencies.PHP; 6220 if ("PKR".equals(codeString)) 6221 return Currencies.PKR; 6222 if ("PLN".equals(codeString)) 6223 return Currencies.PLN; 6224 if ("PYG".equals(codeString)) 6225 return Currencies.PYG; 6226 if ("QAR".equals(codeString)) 6227 return Currencies.QAR; 6228 if ("RON".equals(codeString)) 6229 return Currencies.RON; 6230 if ("RSD".equals(codeString)) 6231 return Currencies.RSD; 6232 if ("RUB".equals(codeString)) 6233 return Currencies.RUB; 6234 if ("RWF".equals(codeString)) 6235 return Currencies.RWF; 6236 if ("SAR".equals(codeString)) 6237 return Currencies.SAR; 6238 if ("SBD".equals(codeString)) 6239 return Currencies.SBD; 6240 if ("SCR".equals(codeString)) 6241 return Currencies.SCR; 6242 if ("SDG".equals(codeString)) 6243 return Currencies.SDG; 6244 if ("SEK".equals(codeString)) 6245 return Currencies.SEK; 6246 if ("SGD".equals(codeString)) 6247 return Currencies.SGD; 6248 if ("SHP".equals(codeString)) 6249 return Currencies.SHP; 6250 if ("SLL".equals(codeString)) 6251 return Currencies.SLL; 6252 if ("SOS".equals(codeString)) 6253 return Currencies.SOS; 6254 if ("SRD".equals(codeString)) 6255 return Currencies.SRD; 6256 if ("SSP".equals(codeString)) 6257 return Currencies.SSP; 6258 if ("STN".equals(codeString)) 6259 return Currencies.STN; 6260 if ("SVC".equals(codeString)) 6261 return Currencies.SVC; 6262 if ("SYP".equals(codeString)) 6263 return Currencies.SYP; 6264 if ("SZL".equals(codeString)) 6265 return Currencies.SZL; 6266 if ("THB".equals(codeString)) 6267 return Currencies.THB; 6268 if ("TJS".equals(codeString)) 6269 return Currencies.TJS; 6270 if ("TMT".equals(codeString)) 6271 return Currencies.TMT; 6272 if ("TND".equals(codeString)) 6273 return Currencies.TND; 6274 if ("TOP".equals(codeString)) 6275 return Currencies.TOP; 6276 if ("TRY".equals(codeString)) 6277 return Currencies.TRY; 6278 if ("TTD".equals(codeString)) 6279 return Currencies.TTD; 6280 if ("TVD".equals(codeString)) 6281 return Currencies.TVD; 6282 if ("TWD".equals(codeString)) 6283 return Currencies.TWD; 6284 if ("TZS".equals(codeString)) 6285 return Currencies.TZS; 6286 if ("UAH".equals(codeString)) 6287 return Currencies.UAH; 6288 if ("UGX".equals(codeString)) 6289 return Currencies.UGX; 6290 if ("USD".equals(codeString)) 6291 return Currencies.USD; 6292 if ("USN".equals(codeString)) 6293 return Currencies.USN; 6294 if ("UYI".equals(codeString)) 6295 return Currencies.UYI; 6296 if ("UYU".equals(codeString)) 6297 return Currencies.UYU; 6298 if ("UZS".equals(codeString)) 6299 return Currencies.UZS; 6300 if ("VEF".equals(codeString)) 6301 return Currencies.VEF; 6302 if ("VND".equals(codeString)) 6303 return Currencies.VND; 6304 if ("VUV".equals(codeString)) 6305 return Currencies.VUV; 6306 if ("WST".equals(codeString)) 6307 return Currencies.WST; 6308 if ("XAF".equals(codeString)) 6309 return Currencies.XAF; 6310 if ("XAG".equals(codeString)) 6311 return Currencies.XAG; 6312 if ("XAU".equals(codeString)) 6313 return Currencies.XAU; 6314 if ("XBA".equals(codeString)) 6315 return Currencies.XBA; 6316 if ("XBB".equals(codeString)) 6317 return Currencies.XBB; 6318 if ("XBC".equals(codeString)) 6319 return Currencies.XBC; 6320 if ("XBD".equals(codeString)) 6321 return Currencies.XBD; 6322 if ("XCD".equals(codeString)) 6323 return Currencies.XCD; 6324 if ("XDR".equals(codeString)) 6325 return Currencies.XDR; 6326 if ("XOF".equals(codeString)) 6327 return Currencies.XOF; 6328 if ("XPD".equals(codeString)) 6329 return Currencies.XPD; 6330 if ("XPF".equals(codeString)) 6331 return Currencies.XPF; 6332 if ("XPT".equals(codeString)) 6333 return Currencies.XPT; 6334 if ("XSU".equals(codeString)) 6335 return Currencies.XSU; 6336 if ("XTS".equals(codeString)) 6337 return Currencies.XTS; 6338 if ("XUA".equals(codeString)) 6339 return Currencies.XUA; 6340 if ("XXX".equals(codeString)) 6341 return Currencies.XXX; 6342 if ("YER".equals(codeString)) 6343 return Currencies.YER; 6344 if ("ZAR".equals(codeString)) 6345 return Currencies.ZAR; 6346 if ("ZMW".equals(codeString)) 6347 return Currencies.ZMW; 6348 if ("ZWL".equals(codeString)) 6349 return Currencies.ZWL; 6350 throw new IllegalArgumentException("Unknown Currencies code '"+codeString+"'"); 6351 } 6352 6353 public Enumeration<Currencies> fromType(PrimitiveType<?> code) throws FHIRException { 6354 if (code == null) 6355 return null; 6356 if (code.isEmpty()) 6357 return new Enumeration<Currencies>(this, Currencies.NULL, code); 6358 String codeString = ((PrimitiveType) code).asStringValue(); 6359 if (codeString == null || "".equals(codeString)) 6360 return new Enumeration<Currencies>(this, Currencies.NULL, code); 6361 if ("AED".equals(codeString)) 6362 return new Enumeration<Currencies>(this, Currencies.AED, code); 6363 if ("AFN".equals(codeString)) 6364 return new Enumeration<Currencies>(this, Currencies.AFN, code); 6365 if ("ALL".equals(codeString)) 6366 return new Enumeration<Currencies>(this, Currencies.ALL, code); 6367 if ("AMD".equals(codeString)) 6368 return new Enumeration<Currencies>(this, Currencies.AMD, code); 6369 if ("ANG".equals(codeString)) 6370 return new Enumeration<Currencies>(this, Currencies.ANG, code); 6371 if ("AOA".equals(codeString)) 6372 return new Enumeration<Currencies>(this, Currencies.AOA, code); 6373 if ("ARS".equals(codeString)) 6374 return new Enumeration<Currencies>(this, Currencies.ARS, code); 6375 if ("AUD".equals(codeString)) 6376 return new Enumeration<Currencies>(this, Currencies.AUD, code); 6377 if ("AWG".equals(codeString)) 6378 return new Enumeration<Currencies>(this, Currencies.AWG, code); 6379 if ("AZN".equals(codeString)) 6380 return new Enumeration<Currencies>(this, Currencies.AZN, code); 6381 if ("BAM".equals(codeString)) 6382 return new Enumeration<Currencies>(this, Currencies.BAM, code); 6383 if ("BBD".equals(codeString)) 6384 return new Enumeration<Currencies>(this, Currencies.BBD, code); 6385 if ("BDT".equals(codeString)) 6386 return new Enumeration<Currencies>(this, Currencies.BDT, code); 6387 if ("BGN".equals(codeString)) 6388 return new Enumeration<Currencies>(this, Currencies.BGN, code); 6389 if ("BHD".equals(codeString)) 6390 return new Enumeration<Currencies>(this, Currencies.BHD, code); 6391 if ("BIF".equals(codeString)) 6392 return new Enumeration<Currencies>(this, Currencies.BIF, code); 6393 if ("BMD".equals(codeString)) 6394 return new Enumeration<Currencies>(this, Currencies.BMD, code); 6395 if ("BND".equals(codeString)) 6396 return new Enumeration<Currencies>(this, Currencies.BND, code); 6397 if ("BOB".equals(codeString)) 6398 return new Enumeration<Currencies>(this, Currencies.BOB, code); 6399 if ("BOV".equals(codeString)) 6400 return new Enumeration<Currencies>(this, Currencies.BOV, code); 6401 if ("BRL".equals(codeString)) 6402 return new Enumeration<Currencies>(this, Currencies.BRL, code); 6403 if ("BSD".equals(codeString)) 6404 return new Enumeration<Currencies>(this, Currencies.BSD, code); 6405 if ("BTN".equals(codeString)) 6406 return new Enumeration<Currencies>(this, Currencies.BTN, code); 6407 if ("BWP".equals(codeString)) 6408 return new Enumeration<Currencies>(this, Currencies.BWP, code); 6409 if ("BYN".equals(codeString)) 6410 return new Enumeration<Currencies>(this, Currencies.BYN, code); 6411 if ("BZD".equals(codeString)) 6412 return new Enumeration<Currencies>(this, Currencies.BZD, code); 6413 if ("CAD".equals(codeString)) 6414 return new Enumeration<Currencies>(this, Currencies.CAD, code); 6415 if ("CDF".equals(codeString)) 6416 return new Enumeration<Currencies>(this, Currencies.CDF, code); 6417 if ("CHE".equals(codeString)) 6418 return new Enumeration<Currencies>(this, Currencies.CHE, code); 6419 if ("CHF".equals(codeString)) 6420 return new Enumeration<Currencies>(this, Currencies.CHF, code); 6421 if ("CHW".equals(codeString)) 6422 return new Enumeration<Currencies>(this, Currencies.CHW, code); 6423 if ("CLF".equals(codeString)) 6424 return new Enumeration<Currencies>(this, Currencies.CLF, code); 6425 if ("CLP".equals(codeString)) 6426 return new Enumeration<Currencies>(this, Currencies.CLP, code); 6427 if ("CNY".equals(codeString)) 6428 return new Enumeration<Currencies>(this, Currencies.CNY, code); 6429 if ("COP".equals(codeString)) 6430 return new Enumeration<Currencies>(this, Currencies.COP, code); 6431 if ("COU".equals(codeString)) 6432 return new Enumeration<Currencies>(this, Currencies.COU, code); 6433 if ("CRC".equals(codeString)) 6434 return new Enumeration<Currencies>(this, Currencies.CRC, code); 6435 if ("CUC".equals(codeString)) 6436 return new Enumeration<Currencies>(this, Currencies.CUC, code); 6437 if ("CUP".equals(codeString)) 6438 return new Enumeration<Currencies>(this, Currencies.CUP, code); 6439 if ("CVE".equals(codeString)) 6440 return new Enumeration<Currencies>(this, Currencies.CVE, code); 6441 if ("CZK".equals(codeString)) 6442 return new Enumeration<Currencies>(this, Currencies.CZK, code); 6443 if ("DJF".equals(codeString)) 6444 return new Enumeration<Currencies>(this, Currencies.DJF, code); 6445 if ("DKK".equals(codeString)) 6446 return new Enumeration<Currencies>(this, Currencies.DKK, code); 6447 if ("DOP".equals(codeString)) 6448 return new Enumeration<Currencies>(this, Currencies.DOP, code); 6449 if ("DZD".equals(codeString)) 6450 return new Enumeration<Currencies>(this, Currencies.DZD, code); 6451 if ("EGP".equals(codeString)) 6452 return new Enumeration<Currencies>(this, Currencies.EGP, code); 6453 if ("ERN".equals(codeString)) 6454 return new Enumeration<Currencies>(this, Currencies.ERN, code); 6455 if ("ETB".equals(codeString)) 6456 return new Enumeration<Currencies>(this, Currencies.ETB, code); 6457 if ("EUR".equals(codeString)) 6458 return new Enumeration<Currencies>(this, Currencies.EUR, code); 6459 if ("FJD".equals(codeString)) 6460 return new Enumeration<Currencies>(this, Currencies.FJD, code); 6461 if ("FKP".equals(codeString)) 6462 return new Enumeration<Currencies>(this, Currencies.FKP, code); 6463 if ("GBP".equals(codeString)) 6464 return new Enumeration<Currencies>(this, Currencies.GBP, code); 6465 if ("GEL".equals(codeString)) 6466 return new Enumeration<Currencies>(this, Currencies.GEL, code); 6467 if ("GGP".equals(codeString)) 6468 return new Enumeration<Currencies>(this, Currencies.GGP, code); 6469 if ("GHS".equals(codeString)) 6470 return new Enumeration<Currencies>(this, Currencies.GHS, code); 6471 if ("GIP".equals(codeString)) 6472 return new Enumeration<Currencies>(this, Currencies.GIP, code); 6473 if ("GMD".equals(codeString)) 6474 return new Enumeration<Currencies>(this, Currencies.GMD, code); 6475 if ("GNF".equals(codeString)) 6476 return new Enumeration<Currencies>(this, Currencies.GNF, code); 6477 if ("GTQ".equals(codeString)) 6478 return new Enumeration<Currencies>(this, Currencies.GTQ, code); 6479 if ("GYD".equals(codeString)) 6480 return new Enumeration<Currencies>(this, Currencies.GYD, code); 6481 if ("HKD".equals(codeString)) 6482 return new Enumeration<Currencies>(this, Currencies.HKD, code); 6483 if ("HNL".equals(codeString)) 6484 return new Enumeration<Currencies>(this, Currencies.HNL, code); 6485 if ("HRK".equals(codeString)) 6486 return new Enumeration<Currencies>(this, Currencies.HRK, code); 6487 if ("HTG".equals(codeString)) 6488 return new Enumeration<Currencies>(this, Currencies.HTG, code); 6489 if ("HUF".equals(codeString)) 6490 return new Enumeration<Currencies>(this, Currencies.HUF, code); 6491 if ("IDR".equals(codeString)) 6492 return new Enumeration<Currencies>(this, Currencies.IDR, code); 6493 if ("ILS".equals(codeString)) 6494 return new Enumeration<Currencies>(this, Currencies.ILS, code); 6495 if ("IMP".equals(codeString)) 6496 return new Enumeration<Currencies>(this, Currencies.IMP, code); 6497 if ("INR".equals(codeString)) 6498 return new Enumeration<Currencies>(this, Currencies.INR, code); 6499 if ("IQD".equals(codeString)) 6500 return new Enumeration<Currencies>(this, Currencies.IQD, code); 6501 if ("IRR".equals(codeString)) 6502 return new Enumeration<Currencies>(this, Currencies.IRR, code); 6503 if ("ISK".equals(codeString)) 6504 return new Enumeration<Currencies>(this, Currencies.ISK, code); 6505 if ("JEP".equals(codeString)) 6506 return new Enumeration<Currencies>(this, Currencies.JEP, code); 6507 if ("JMD".equals(codeString)) 6508 return new Enumeration<Currencies>(this, Currencies.JMD, code); 6509 if ("JOD".equals(codeString)) 6510 return new Enumeration<Currencies>(this, Currencies.JOD, code); 6511 if ("JPY".equals(codeString)) 6512 return new Enumeration<Currencies>(this, Currencies.JPY, code); 6513 if ("KES".equals(codeString)) 6514 return new Enumeration<Currencies>(this, Currencies.KES, code); 6515 if ("KGS".equals(codeString)) 6516 return new Enumeration<Currencies>(this, Currencies.KGS, code); 6517 if ("KHR".equals(codeString)) 6518 return new Enumeration<Currencies>(this, Currencies.KHR, code); 6519 if ("KMF".equals(codeString)) 6520 return new Enumeration<Currencies>(this, Currencies.KMF, code); 6521 if ("KPW".equals(codeString)) 6522 return new Enumeration<Currencies>(this, Currencies.KPW, code); 6523 if ("KRW".equals(codeString)) 6524 return new Enumeration<Currencies>(this, Currencies.KRW, code); 6525 if ("KWD".equals(codeString)) 6526 return new Enumeration<Currencies>(this, Currencies.KWD, code); 6527 if ("KYD".equals(codeString)) 6528 return new Enumeration<Currencies>(this, Currencies.KYD, code); 6529 if ("KZT".equals(codeString)) 6530 return new Enumeration<Currencies>(this, Currencies.KZT, code); 6531 if ("LAK".equals(codeString)) 6532 return new Enumeration<Currencies>(this, Currencies.LAK, code); 6533 if ("LBP".equals(codeString)) 6534 return new Enumeration<Currencies>(this, Currencies.LBP, code); 6535 if ("LKR".equals(codeString)) 6536 return new Enumeration<Currencies>(this, Currencies.LKR, code); 6537 if ("LRD".equals(codeString)) 6538 return new Enumeration<Currencies>(this, Currencies.LRD, code); 6539 if ("LSL".equals(codeString)) 6540 return new Enumeration<Currencies>(this, Currencies.LSL, code); 6541 if ("LYD".equals(codeString)) 6542 return new Enumeration<Currencies>(this, Currencies.LYD, code); 6543 if ("MAD".equals(codeString)) 6544 return new Enumeration<Currencies>(this, Currencies.MAD, code); 6545 if ("MDL".equals(codeString)) 6546 return new Enumeration<Currencies>(this, Currencies.MDL, code); 6547 if ("MGA".equals(codeString)) 6548 return new Enumeration<Currencies>(this, Currencies.MGA, code); 6549 if ("MKD".equals(codeString)) 6550 return new Enumeration<Currencies>(this, Currencies.MKD, code); 6551 if ("MMK".equals(codeString)) 6552 return new Enumeration<Currencies>(this, Currencies.MMK, code); 6553 if ("MNT".equals(codeString)) 6554 return new Enumeration<Currencies>(this, Currencies.MNT, code); 6555 if ("MOP".equals(codeString)) 6556 return new Enumeration<Currencies>(this, Currencies.MOP, code); 6557 if ("MRU".equals(codeString)) 6558 return new Enumeration<Currencies>(this, Currencies.MRU, code); 6559 if ("MUR".equals(codeString)) 6560 return new Enumeration<Currencies>(this, Currencies.MUR, code); 6561 if ("MVR".equals(codeString)) 6562 return new Enumeration<Currencies>(this, Currencies.MVR, code); 6563 if ("MWK".equals(codeString)) 6564 return new Enumeration<Currencies>(this, Currencies.MWK, code); 6565 if ("MXN".equals(codeString)) 6566 return new Enumeration<Currencies>(this, Currencies.MXN, code); 6567 if ("MXV".equals(codeString)) 6568 return new Enumeration<Currencies>(this, Currencies.MXV, code); 6569 if ("MYR".equals(codeString)) 6570 return new Enumeration<Currencies>(this, Currencies.MYR, code); 6571 if ("MZN".equals(codeString)) 6572 return new Enumeration<Currencies>(this, Currencies.MZN, code); 6573 if ("NAD".equals(codeString)) 6574 return new Enumeration<Currencies>(this, Currencies.NAD, code); 6575 if ("NGN".equals(codeString)) 6576 return new Enumeration<Currencies>(this, Currencies.NGN, code); 6577 if ("NIO".equals(codeString)) 6578 return new Enumeration<Currencies>(this, Currencies.NIO, code); 6579 if ("NOK".equals(codeString)) 6580 return new Enumeration<Currencies>(this, Currencies.NOK, code); 6581 if ("NPR".equals(codeString)) 6582 return new Enumeration<Currencies>(this, Currencies.NPR, code); 6583 if ("NZD".equals(codeString)) 6584 return new Enumeration<Currencies>(this, Currencies.NZD, code); 6585 if ("OMR".equals(codeString)) 6586 return new Enumeration<Currencies>(this, Currencies.OMR, code); 6587 if ("PAB".equals(codeString)) 6588 return new Enumeration<Currencies>(this, Currencies.PAB, code); 6589 if ("PEN".equals(codeString)) 6590 return new Enumeration<Currencies>(this, Currencies.PEN, code); 6591 if ("PGK".equals(codeString)) 6592 return new Enumeration<Currencies>(this, Currencies.PGK, code); 6593 if ("PHP".equals(codeString)) 6594 return new Enumeration<Currencies>(this, Currencies.PHP, code); 6595 if ("PKR".equals(codeString)) 6596 return new Enumeration<Currencies>(this, Currencies.PKR, code); 6597 if ("PLN".equals(codeString)) 6598 return new Enumeration<Currencies>(this, Currencies.PLN, code); 6599 if ("PYG".equals(codeString)) 6600 return new Enumeration<Currencies>(this, Currencies.PYG, code); 6601 if ("QAR".equals(codeString)) 6602 return new Enumeration<Currencies>(this, Currencies.QAR, code); 6603 if ("RON".equals(codeString)) 6604 return new Enumeration<Currencies>(this, Currencies.RON, code); 6605 if ("RSD".equals(codeString)) 6606 return new Enumeration<Currencies>(this, Currencies.RSD, code); 6607 if ("RUB".equals(codeString)) 6608 return new Enumeration<Currencies>(this, Currencies.RUB, code); 6609 if ("RWF".equals(codeString)) 6610 return new Enumeration<Currencies>(this, Currencies.RWF, code); 6611 if ("SAR".equals(codeString)) 6612 return new Enumeration<Currencies>(this, Currencies.SAR, code); 6613 if ("SBD".equals(codeString)) 6614 return new Enumeration<Currencies>(this, Currencies.SBD, code); 6615 if ("SCR".equals(codeString)) 6616 return new Enumeration<Currencies>(this, Currencies.SCR, code); 6617 if ("SDG".equals(codeString)) 6618 return new Enumeration<Currencies>(this, Currencies.SDG, code); 6619 if ("SEK".equals(codeString)) 6620 return new Enumeration<Currencies>(this, Currencies.SEK, code); 6621 if ("SGD".equals(codeString)) 6622 return new Enumeration<Currencies>(this, Currencies.SGD, code); 6623 if ("SHP".equals(codeString)) 6624 return new Enumeration<Currencies>(this, Currencies.SHP, code); 6625 if ("SLL".equals(codeString)) 6626 return new Enumeration<Currencies>(this, Currencies.SLL, code); 6627 if ("SOS".equals(codeString)) 6628 return new Enumeration<Currencies>(this, Currencies.SOS, code); 6629 if ("SRD".equals(codeString)) 6630 return new Enumeration<Currencies>(this, Currencies.SRD, code); 6631 if ("SSP".equals(codeString)) 6632 return new Enumeration<Currencies>(this, Currencies.SSP, code); 6633 if ("STN".equals(codeString)) 6634 return new Enumeration<Currencies>(this, Currencies.STN, code); 6635 if ("SVC".equals(codeString)) 6636 return new Enumeration<Currencies>(this, Currencies.SVC, code); 6637 if ("SYP".equals(codeString)) 6638 return new Enumeration<Currencies>(this, Currencies.SYP, code); 6639 if ("SZL".equals(codeString)) 6640 return new Enumeration<Currencies>(this, Currencies.SZL, code); 6641 if ("THB".equals(codeString)) 6642 return new Enumeration<Currencies>(this, Currencies.THB, code); 6643 if ("TJS".equals(codeString)) 6644 return new Enumeration<Currencies>(this, Currencies.TJS, code); 6645 if ("TMT".equals(codeString)) 6646 return new Enumeration<Currencies>(this, Currencies.TMT, code); 6647 if ("TND".equals(codeString)) 6648 return new Enumeration<Currencies>(this, Currencies.TND, code); 6649 if ("TOP".equals(codeString)) 6650 return new Enumeration<Currencies>(this, Currencies.TOP, code); 6651 if ("TRY".equals(codeString)) 6652 return new Enumeration<Currencies>(this, Currencies.TRY, code); 6653 if ("TTD".equals(codeString)) 6654 return new Enumeration<Currencies>(this, Currencies.TTD, code); 6655 if ("TVD".equals(codeString)) 6656 return new Enumeration<Currencies>(this, Currencies.TVD, code); 6657 if ("TWD".equals(codeString)) 6658 return new Enumeration<Currencies>(this, Currencies.TWD, code); 6659 if ("TZS".equals(codeString)) 6660 return new Enumeration<Currencies>(this, Currencies.TZS, code); 6661 if ("UAH".equals(codeString)) 6662 return new Enumeration<Currencies>(this, Currencies.UAH, code); 6663 if ("UGX".equals(codeString)) 6664 return new Enumeration<Currencies>(this, Currencies.UGX, code); 6665 if ("USD".equals(codeString)) 6666 return new Enumeration<Currencies>(this, Currencies.USD, code); 6667 if ("USN".equals(codeString)) 6668 return new Enumeration<Currencies>(this, Currencies.USN, code); 6669 if ("UYI".equals(codeString)) 6670 return new Enumeration<Currencies>(this, Currencies.UYI, code); 6671 if ("UYU".equals(codeString)) 6672 return new Enumeration<Currencies>(this, Currencies.UYU, code); 6673 if ("UZS".equals(codeString)) 6674 return new Enumeration<Currencies>(this, Currencies.UZS, code); 6675 if ("VEF".equals(codeString)) 6676 return new Enumeration<Currencies>(this, Currencies.VEF, code); 6677 if ("VND".equals(codeString)) 6678 return new Enumeration<Currencies>(this, Currencies.VND, code); 6679 if ("VUV".equals(codeString)) 6680 return new Enumeration<Currencies>(this, Currencies.VUV, code); 6681 if ("WST".equals(codeString)) 6682 return new Enumeration<Currencies>(this, Currencies.WST, code); 6683 if ("XAF".equals(codeString)) 6684 return new Enumeration<Currencies>(this, Currencies.XAF, code); 6685 if ("XAG".equals(codeString)) 6686 return new Enumeration<Currencies>(this, Currencies.XAG, code); 6687 if ("XAU".equals(codeString)) 6688 return new Enumeration<Currencies>(this, Currencies.XAU, code); 6689 if ("XBA".equals(codeString)) 6690 return new Enumeration<Currencies>(this, Currencies.XBA, code); 6691 if ("XBB".equals(codeString)) 6692 return new Enumeration<Currencies>(this, Currencies.XBB, code); 6693 if ("XBC".equals(codeString)) 6694 return new Enumeration<Currencies>(this, Currencies.XBC, code); 6695 if ("XBD".equals(codeString)) 6696 return new Enumeration<Currencies>(this, Currencies.XBD, code); 6697 if ("XCD".equals(codeString)) 6698 return new Enumeration<Currencies>(this, Currencies.XCD, code); 6699 if ("XDR".equals(codeString)) 6700 return new Enumeration<Currencies>(this, Currencies.XDR, code); 6701 if ("XOF".equals(codeString)) 6702 return new Enumeration<Currencies>(this, Currencies.XOF, code); 6703 if ("XPD".equals(codeString)) 6704 return new Enumeration<Currencies>(this, Currencies.XPD, code); 6705 if ("XPF".equals(codeString)) 6706 return new Enumeration<Currencies>(this, Currencies.XPF, code); 6707 if ("XPT".equals(codeString)) 6708 return new Enumeration<Currencies>(this, Currencies.XPT, code); 6709 if ("XSU".equals(codeString)) 6710 return new Enumeration<Currencies>(this, Currencies.XSU, code); 6711 if ("XTS".equals(codeString)) 6712 return new Enumeration<Currencies>(this, Currencies.XTS, code); 6713 if ("XUA".equals(codeString)) 6714 return new Enumeration<Currencies>(this, Currencies.XUA, code); 6715 if ("XXX".equals(codeString)) 6716 return new Enumeration<Currencies>(this, Currencies.XXX, code); 6717 if ("YER".equals(codeString)) 6718 return new Enumeration<Currencies>(this, Currencies.YER, code); 6719 if ("ZAR".equals(codeString)) 6720 return new Enumeration<Currencies>(this, Currencies.ZAR, code); 6721 if ("ZMW".equals(codeString)) 6722 return new Enumeration<Currencies>(this, Currencies.ZMW, code); 6723 if ("ZWL".equals(codeString)) 6724 return new Enumeration<Currencies>(this, Currencies.ZWL, code); 6725 throw new FHIRException("Unknown Currencies code '"+codeString+"'"); 6726 } 6727 public String toCode(Currencies code) { 6728 if (code == Currencies.AED) 6729 return "AED"; 6730 if (code == Currencies.AFN) 6731 return "AFN"; 6732 if (code == Currencies.ALL) 6733 return "ALL"; 6734 if (code == Currencies.AMD) 6735 return "AMD"; 6736 if (code == Currencies.ANG) 6737 return "ANG"; 6738 if (code == Currencies.AOA) 6739 return "AOA"; 6740 if (code == Currencies.ARS) 6741 return "ARS"; 6742 if (code == Currencies.AUD) 6743 return "AUD"; 6744 if (code == Currencies.AWG) 6745 return "AWG"; 6746 if (code == Currencies.AZN) 6747 return "AZN"; 6748 if (code == Currencies.BAM) 6749 return "BAM"; 6750 if (code == Currencies.BBD) 6751 return "BBD"; 6752 if (code == Currencies.BDT) 6753 return "BDT"; 6754 if (code == Currencies.BGN) 6755 return "BGN"; 6756 if (code == Currencies.BHD) 6757 return "BHD"; 6758 if (code == Currencies.BIF) 6759 return "BIF"; 6760 if (code == Currencies.BMD) 6761 return "BMD"; 6762 if (code == Currencies.BND) 6763 return "BND"; 6764 if (code == Currencies.BOB) 6765 return "BOB"; 6766 if (code == Currencies.BOV) 6767 return "BOV"; 6768 if (code == Currencies.BRL) 6769 return "BRL"; 6770 if (code == Currencies.BSD) 6771 return "BSD"; 6772 if (code == Currencies.BTN) 6773 return "BTN"; 6774 if (code == Currencies.BWP) 6775 return "BWP"; 6776 if (code == Currencies.BYN) 6777 return "BYN"; 6778 if (code == Currencies.BZD) 6779 return "BZD"; 6780 if (code == Currencies.CAD) 6781 return "CAD"; 6782 if (code == Currencies.CDF) 6783 return "CDF"; 6784 if (code == Currencies.CHE) 6785 return "CHE"; 6786 if (code == Currencies.CHF) 6787 return "CHF"; 6788 if (code == Currencies.CHW) 6789 return "CHW"; 6790 if (code == Currencies.CLF) 6791 return "CLF"; 6792 if (code == Currencies.CLP) 6793 return "CLP"; 6794 if (code == Currencies.CNY) 6795 return "CNY"; 6796 if (code == Currencies.COP) 6797 return "COP"; 6798 if (code == Currencies.COU) 6799 return "COU"; 6800 if (code == Currencies.CRC) 6801 return "CRC"; 6802 if (code == Currencies.CUC) 6803 return "CUC"; 6804 if (code == Currencies.CUP) 6805 return "CUP"; 6806 if (code == Currencies.CVE) 6807 return "CVE"; 6808 if (code == Currencies.CZK) 6809 return "CZK"; 6810 if (code == Currencies.DJF) 6811 return "DJF"; 6812 if (code == Currencies.DKK) 6813 return "DKK"; 6814 if (code == Currencies.DOP) 6815 return "DOP"; 6816 if (code == Currencies.DZD) 6817 return "DZD"; 6818 if (code == Currencies.EGP) 6819 return "EGP"; 6820 if (code == Currencies.ERN) 6821 return "ERN"; 6822 if (code == Currencies.ETB) 6823 return "ETB"; 6824 if (code == Currencies.EUR) 6825 return "EUR"; 6826 if (code == Currencies.FJD) 6827 return "FJD"; 6828 if (code == Currencies.FKP) 6829 return "FKP"; 6830 if (code == Currencies.GBP) 6831 return "GBP"; 6832 if (code == Currencies.GEL) 6833 return "GEL"; 6834 if (code == Currencies.GGP) 6835 return "GGP"; 6836 if (code == Currencies.GHS) 6837 return "GHS"; 6838 if (code == Currencies.GIP) 6839 return "GIP"; 6840 if (code == Currencies.GMD) 6841 return "GMD"; 6842 if (code == Currencies.GNF) 6843 return "GNF"; 6844 if (code == Currencies.GTQ) 6845 return "GTQ"; 6846 if (code == Currencies.GYD) 6847 return "GYD"; 6848 if (code == Currencies.HKD) 6849 return "HKD"; 6850 if (code == Currencies.HNL) 6851 return "HNL"; 6852 if (code == Currencies.HRK) 6853 return "HRK"; 6854 if (code == Currencies.HTG) 6855 return "HTG"; 6856 if (code == Currencies.HUF) 6857 return "HUF"; 6858 if (code == Currencies.IDR) 6859 return "IDR"; 6860 if (code == Currencies.ILS) 6861 return "ILS"; 6862 if (code == Currencies.IMP) 6863 return "IMP"; 6864 if (code == Currencies.INR) 6865 return "INR"; 6866 if (code == Currencies.IQD) 6867 return "IQD"; 6868 if (code == Currencies.IRR) 6869 return "IRR"; 6870 if (code == Currencies.ISK) 6871 return "ISK"; 6872 if (code == Currencies.JEP) 6873 return "JEP"; 6874 if (code == Currencies.JMD) 6875 return "JMD"; 6876 if (code == Currencies.JOD) 6877 return "JOD"; 6878 if (code == Currencies.JPY) 6879 return "JPY"; 6880 if (code == Currencies.KES) 6881 return "KES"; 6882 if (code == Currencies.KGS) 6883 return "KGS"; 6884 if (code == Currencies.KHR) 6885 return "KHR"; 6886 if (code == Currencies.KMF) 6887 return "KMF"; 6888 if (code == Currencies.KPW) 6889 return "KPW"; 6890 if (code == Currencies.KRW) 6891 return "KRW"; 6892 if (code == Currencies.KWD) 6893 return "KWD"; 6894 if (code == Currencies.KYD) 6895 return "KYD"; 6896 if (code == Currencies.KZT) 6897 return "KZT"; 6898 if (code == Currencies.LAK) 6899 return "LAK"; 6900 if (code == Currencies.LBP) 6901 return "LBP"; 6902 if (code == Currencies.LKR) 6903 return "LKR"; 6904 if (code == Currencies.LRD) 6905 return "LRD"; 6906 if (code == Currencies.LSL) 6907 return "LSL"; 6908 if (code == Currencies.LYD) 6909 return "LYD"; 6910 if (code == Currencies.MAD) 6911 return "MAD"; 6912 if (code == Currencies.MDL) 6913 return "MDL"; 6914 if (code == Currencies.MGA) 6915 return "MGA"; 6916 if (code == Currencies.MKD) 6917 return "MKD"; 6918 if (code == Currencies.MMK) 6919 return "MMK"; 6920 if (code == Currencies.MNT) 6921 return "MNT"; 6922 if (code == Currencies.MOP) 6923 return "MOP"; 6924 if (code == Currencies.MRU) 6925 return "MRU"; 6926 if (code == Currencies.MUR) 6927 return "MUR"; 6928 if (code == Currencies.MVR) 6929 return "MVR"; 6930 if (code == Currencies.MWK) 6931 return "MWK"; 6932 if (code == Currencies.MXN) 6933 return "MXN"; 6934 if (code == Currencies.MXV) 6935 return "MXV"; 6936 if (code == Currencies.MYR) 6937 return "MYR"; 6938 if (code == Currencies.MZN) 6939 return "MZN"; 6940 if (code == Currencies.NAD) 6941 return "NAD"; 6942 if (code == Currencies.NGN) 6943 return "NGN"; 6944 if (code == Currencies.NIO) 6945 return "NIO"; 6946 if (code == Currencies.NOK) 6947 return "NOK"; 6948 if (code == Currencies.NPR) 6949 return "NPR"; 6950 if (code == Currencies.NZD) 6951 return "NZD"; 6952 if (code == Currencies.OMR) 6953 return "OMR"; 6954 if (code == Currencies.PAB) 6955 return "PAB"; 6956 if (code == Currencies.PEN) 6957 return "PEN"; 6958 if (code == Currencies.PGK) 6959 return "PGK"; 6960 if (code == Currencies.PHP) 6961 return "PHP"; 6962 if (code == Currencies.PKR) 6963 return "PKR"; 6964 if (code == Currencies.PLN) 6965 return "PLN"; 6966 if (code == Currencies.PYG) 6967 return "PYG"; 6968 if (code == Currencies.QAR) 6969 return "QAR"; 6970 if (code == Currencies.RON) 6971 return "RON"; 6972 if (code == Currencies.RSD) 6973 return "RSD"; 6974 if (code == Currencies.RUB) 6975 return "RUB"; 6976 if (code == Currencies.RWF) 6977 return "RWF"; 6978 if (code == Currencies.SAR) 6979 return "SAR"; 6980 if (code == Currencies.SBD) 6981 return "SBD"; 6982 if (code == Currencies.SCR) 6983 return "SCR"; 6984 if (code == Currencies.SDG) 6985 return "SDG"; 6986 if (code == Currencies.SEK) 6987 return "SEK"; 6988 if (code == Currencies.SGD) 6989 return "SGD"; 6990 if (code == Currencies.SHP) 6991 return "SHP"; 6992 if (code == Currencies.SLL) 6993 return "SLL"; 6994 if (code == Currencies.SOS) 6995 return "SOS"; 6996 if (code == Currencies.SRD) 6997 return "SRD"; 6998 if (code == Currencies.SSP) 6999 return "SSP"; 7000 if (code == Currencies.STN) 7001 return "STN"; 7002 if (code == Currencies.SVC) 7003 return "SVC"; 7004 if (code == Currencies.SYP) 7005 return "SYP"; 7006 if (code == Currencies.SZL) 7007 return "SZL"; 7008 if (code == Currencies.THB) 7009 return "THB"; 7010 if (code == Currencies.TJS) 7011 return "TJS"; 7012 if (code == Currencies.TMT) 7013 return "TMT"; 7014 if (code == Currencies.TND) 7015 return "TND"; 7016 if (code == Currencies.TOP) 7017 return "TOP"; 7018 if (code == Currencies.TRY) 7019 return "TRY"; 7020 if (code == Currencies.TTD) 7021 return "TTD"; 7022 if (code == Currencies.TVD) 7023 return "TVD"; 7024 if (code == Currencies.TWD) 7025 return "TWD"; 7026 if (code == Currencies.TZS) 7027 return "TZS"; 7028 if (code == Currencies.UAH) 7029 return "UAH"; 7030 if (code == Currencies.UGX) 7031 return "UGX"; 7032 if (code == Currencies.USD) 7033 return "USD"; 7034 if (code == Currencies.USN) 7035 return "USN"; 7036 if (code == Currencies.UYI) 7037 return "UYI"; 7038 if (code == Currencies.UYU) 7039 return "UYU"; 7040 if (code == Currencies.UZS) 7041 return "UZS"; 7042 if (code == Currencies.VEF) 7043 return "VEF"; 7044 if (code == Currencies.VND) 7045 return "VND"; 7046 if (code == Currencies.VUV) 7047 return "VUV"; 7048 if (code == Currencies.WST) 7049 return "WST"; 7050 if (code == Currencies.XAF) 7051 return "XAF"; 7052 if (code == Currencies.XAG) 7053 return "XAG"; 7054 if (code == Currencies.XAU) 7055 return "XAU"; 7056 if (code == Currencies.XBA) 7057 return "XBA"; 7058 if (code == Currencies.XBB) 7059 return "XBB"; 7060 if (code == Currencies.XBC) 7061 return "XBC"; 7062 if (code == Currencies.XBD) 7063 return "XBD"; 7064 if (code == Currencies.XCD) 7065 return "XCD"; 7066 if (code == Currencies.XDR) 7067 return "XDR"; 7068 if (code == Currencies.XOF) 7069 return "XOF"; 7070 if (code == Currencies.XPD) 7071 return "XPD"; 7072 if (code == Currencies.XPF) 7073 return "XPF"; 7074 if (code == Currencies.XPT) 7075 return "XPT"; 7076 if (code == Currencies.XSU) 7077 return "XSU"; 7078 if (code == Currencies.XTS) 7079 return "XTS"; 7080 if (code == Currencies.XUA) 7081 return "XUA"; 7082 if (code == Currencies.XXX) 7083 return "XXX"; 7084 if (code == Currencies.YER) 7085 return "YER"; 7086 if (code == Currencies.ZAR) 7087 return "ZAR"; 7088 if (code == Currencies.ZMW) 7089 return "ZMW"; 7090 if (code == Currencies.ZWL) 7091 return "ZWL"; 7092 return "?"; 7093 } 7094 public String toSystem(Currencies code) { 7095 return code.getSystem(); 7096 } 7097 } 7098 7099 public enum DaysOfWeek { 7100 /** 7101 * Monday. 7102 */ 7103 MON, 7104 /** 7105 * Tuesday. 7106 */ 7107 TUE, 7108 /** 7109 * Wednesday. 7110 */ 7111 WED, 7112 /** 7113 * Thursday. 7114 */ 7115 THU, 7116 /** 7117 * Friday. 7118 */ 7119 FRI, 7120 /** 7121 * Saturday. 7122 */ 7123 SAT, 7124 /** 7125 * Sunday. 7126 */ 7127 SUN, 7128 /** 7129 * added to help the parsers 7130 */ 7131 NULL; 7132 public static DaysOfWeek fromCode(String codeString) throws FHIRException { 7133 if (codeString == null || "".equals(codeString)) 7134 return null; 7135 if ("mon".equals(codeString)) 7136 return MON; 7137 if ("tue".equals(codeString)) 7138 return TUE; 7139 if ("wed".equals(codeString)) 7140 return WED; 7141 if ("thu".equals(codeString)) 7142 return THU; 7143 if ("fri".equals(codeString)) 7144 return FRI; 7145 if ("sat".equals(codeString)) 7146 return SAT; 7147 if ("sun".equals(codeString)) 7148 return SUN; 7149 throw new FHIRException("Unknown DaysOfWeek code '"+codeString+"'"); 7150 } 7151 public static boolean isValidCode(String codeString) { 7152 if (codeString == null || "".equals(codeString)) 7153 return false; 7154 return Utilities.existsInList(codeString, "mon", "tue", "wed", "thu", "fri", "sat", "sun"); 7155 } 7156 public String toCode() { 7157 switch (this) { 7158 case MON: return "mon"; 7159 case TUE: return "tue"; 7160 case WED: return "wed"; 7161 case THU: return "thu"; 7162 case FRI: return "fri"; 7163 case SAT: return "sat"; 7164 case SUN: return "sun"; 7165 case NULL: return null; 7166 default: return "?"; 7167 } 7168 } 7169 public String getSystem() { 7170 switch (this) { 7171 case MON: return "http://hl7.org/fhir/days-of-week"; 7172 case TUE: return "http://hl7.org/fhir/days-of-week"; 7173 case WED: return "http://hl7.org/fhir/days-of-week"; 7174 case THU: return "http://hl7.org/fhir/days-of-week"; 7175 case FRI: return "http://hl7.org/fhir/days-of-week"; 7176 case SAT: return "http://hl7.org/fhir/days-of-week"; 7177 case SUN: return "http://hl7.org/fhir/days-of-week"; 7178 case NULL: return null; 7179 default: return "?"; 7180 } 7181 } 7182 public String getDefinition() { 7183 switch (this) { 7184 case MON: return "Monday."; 7185 case TUE: return "Tuesday."; 7186 case WED: return "Wednesday."; 7187 case THU: return "Thursday."; 7188 case FRI: return "Friday."; 7189 case SAT: return "Saturday."; 7190 case SUN: return "Sunday."; 7191 case NULL: return null; 7192 default: return "?"; 7193 } 7194 } 7195 public String getDisplay() { 7196 switch (this) { 7197 case MON: return "Monday"; 7198 case TUE: return "Tuesday"; 7199 case WED: return "Wednesday"; 7200 case THU: return "Thursday"; 7201 case FRI: return "Friday"; 7202 case SAT: return "Saturday"; 7203 case SUN: return "Sunday"; 7204 case NULL: return null; 7205 default: return "?"; 7206 } 7207 } 7208 } 7209 7210 public static class DaysOfWeekEnumFactory implements EnumFactory<DaysOfWeek> { 7211 public DaysOfWeek fromCode(String codeString) throws IllegalArgumentException { 7212 if (codeString == null || "".equals(codeString)) 7213 if (codeString == null || "".equals(codeString)) 7214 return null; 7215 if ("mon".equals(codeString)) 7216 return DaysOfWeek.MON; 7217 if ("tue".equals(codeString)) 7218 return DaysOfWeek.TUE; 7219 if ("wed".equals(codeString)) 7220 return DaysOfWeek.WED; 7221 if ("thu".equals(codeString)) 7222 return DaysOfWeek.THU; 7223 if ("fri".equals(codeString)) 7224 return DaysOfWeek.FRI; 7225 if ("sat".equals(codeString)) 7226 return DaysOfWeek.SAT; 7227 if ("sun".equals(codeString)) 7228 return DaysOfWeek.SUN; 7229 throw new IllegalArgumentException("Unknown DaysOfWeek code '"+codeString+"'"); 7230 } 7231 7232 public Enumeration<DaysOfWeek> fromType(PrimitiveType<?> code) throws FHIRException { 7233 if (code == null) 7234 return null; 7235 if (code.isEmpty()) 7236 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.NULL, code); 7237 String codeString = ((PrimitiveType) code).asStringValue(); 7238 if (codeString == null || "".equals(codeString)) 7239 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.NULL, code); 7240 if ("mon".equals(codeString)) 7241 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.MON, code); 7242 if ("tue".equals(codeString)) 7243 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.TUE, code); 7244 if ("wed".equals(codeString)) 7245 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.WED, code); 7246 if ("thu".equals(codeString)) 7247 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.THU, code); 7248 if ("fri".equals(codeString)) 7249 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.FRI, code); 7250 if ("sat".equals(codeString)) 7251 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.SAT, code); 7252 if ("sun".equals(codeString)) 7253 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.SUN, code); 7254 throw new FHIRException("Unknown DaysOfWeek code '"+codeString+"'"); 7255 } 7256 public String toCode(DaysOfWeek code) { 7257 if (code == DaysOfWeek.MON) 7258 return "mon"; 7259 if (code == DaysOfWeek.TUE) 7260 return "tue"; 7261 if (code == DaysOfWeek.WED) 7262 return "wed"; 7263 if (code == DaysOfWeek.THU) 7264 return "thu"; 7265 if (code == DaysOfWeek.FRI) 7266 return "fri"; 7267 if (code == DaysOfWeek.SAT) 7268 return "sat"; 7269 if (code == DaysOfWeek.SUN) 7270 return "sun"; 7271 return "?"; 7272 } 7273 public String toSystem(DaysOfWeek code) { 7274 return code.getSystem(); 7275 } 7276 } 7277 7278 public enum DeviceNameType { 7279 /** 7280 * 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. 7281 */ 7282 REGISTEREDNAME, 7283 /** 7284 * 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. 7285 */ 7286 USERFRIENDLYNAME, 7287 /** 7288 * 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. 7289 */ 7290 PATIENTREPORTEDNAME, 7291 /** 7292 * added to help the parsers 7293 */ 7294 NULL; 7295 public static DeviceNameType fromCode(String codeString) throws FHIRException { 7296 if (codeString == null || "".equals(codeString)) 7297 return null; 7298 if ("registered-name".equals(codeString)) 7299 return REGISTEREDNAME; 7300 if ("user-friendly-name".equals(codeString)) 7301 return USERFRIENDLYNAME; 7302 if ("patient-reported-name".equals(codeString)) 7303 return PATIENTREPORTEDNAME; 7304 throw new FHIRException("Unknown DeviceNameType code '"+codeString+"'"); 7305 } 7306 public static boolean isValidCode(String codeString) { 7307 if (codeString == null || "".equals(codeString)) 7308 return false; 7309 return Utilities.existsInList(codeString, "registered-name", "user-friendly-name", "patient-reported-name"); 7310 } 7311 public String toCode() { 7312 switch (this) { 7313 case REGISTEREDNAME: return "registered-name"; 7314 case USERFRIENDLYNAME: return "user-friendly-name"; 7315 case PATIENTREPORTEDNAME: return "patient-reported-name"; 7316 case NULL: return null; 7317 default: return "?"; 7318 } 7319 } 7320 public String getSystem() { 7321 switch (this) { 7322 case REGISTEREDNAME: return "http://hl7.org/fhir/device-nametype"; 7323 case USERFRIENDLYNAME: return "http://hl7.org/fhir/device-nametype"; 7324 case PATIENTREPORTEDNAME: return "http://hl7.org/fhir/device-nametype"; 7325 case NULL: return null; 7326 default: return "?"; 7327 } 7328 } 7329 public String getDefinition() { 7330 switch (this) { 7331 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."; 7332 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."; 7333 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."; 7334 case NULL: return null; 7335 default: return "?"; 7336 } 7337 } 7338 public String getDisplay() { 7339 switch (this) { 7340 case REGISTEREDNAME: return "Registered name"; 7341 case USERFRIENDLYNAME: return "User Friendly name"; 7342 case PATIENTREPORTEDNAME: return "Patient Reported name"; 7343 case NULL: return null; 7344 default: return "?"; 7345 } 7346 } 7347 } 7348 7349 public static class DeviceNameTypeEnumFactory implements EnumFactory<DeviceNameType> { 7350 public DeviceNameType fromCode(String codeString) throws IllegalArgumentException { 7351 if (codeString == null || "".equals(codeString)) 7352 if (codeString == null || "".equals(codeString)) 7353 return null; 7354 if ("registered-name".equals(codeString)) 7355 return DeviceNameType.REGISTEREDNAME; 7356 if ("user-friendly-name".equals(codeString)) 7357 return DeviceNameType.USERFRIENDLYNAME; 7358 if ("patient-reported-name".equals(codeString)) 7359 return DeviceNameType.PATIENTREPORTEDNAME; 7360 throw new IllegalArgumentException("Unknown DeviceNameType code '"+codeString+"'"); 7361 } 7362 7363 public Enumeration<DeviceNameType> fromType(PrimitiveType<?> code) throws FHIRException { 7364 if (code == null) 7365 return null; 7366 if (code.isEmpty()) 7367 return new Enumeration<DeviceNameType>(this, DeviceNameType.NULL, code); 7368 String codeString = ((PrimitiveType) code).asStringValue(); 7369 if (codeString == null || "".equals(codeString)) 7370 return new Enumeration<DeviceNameType>(this, DeviceNameType.NULL, code); 7371 if ("registered-name".equals(codeString)) 7372 return new Enumeration<DeviceNameType>(this, DeviceNameType.REGISTEREDNAME, code); 7373 if ("user-friendly-name".equals(codeString)) 7374 return new Enumeration<DeviceNameType>(this, DeviceNameType.USERFRIENDLYNAME, code); 7375 if ("patient-reported-name".equals(codeString)) 7376 return new Enumeration<DeviceNameType>(this, DeviceNameType.PATIENTREPORTEDNAME, code); 7377 throw new FHIRException("Unknown DeviceNameType code '"+codeString+"'"); 7378 } 7379 public String toCode(DeviceNameType code) { 7380 if (code == DeviceNameType.REGISTEREDNAME) 7381 return "registered-name"; 7382 if (code == DeviceNameType.USERFRIENDLYNAME) 7383 return "user-friendly-name"; 7384 if (code == DeviceNameType.PATIENTREPORTEDNAME) 7385 return "patient-reported-name"; 7386 return "?"; 7387 } 7388 public String toSystem(DeviceNameType code) { 7389 return code.getSystem(); 7390 } 7391 } 7392 7393 public enum EncounterStatus { 7394 /** 7395 * The Encounter has not yet started. 7396 */ 7397 PLANNED, 7398 /** 7399 * The Encounter has begun and the patient is present / the practitioner and the patient are meeting. 7400 */ 7401 INPROGRESS, 7402 /** 7403 * The Encounter has begun, but is currently on hold, e.g. because the patient is temporarily on leave. 7404 */ 7405 ONHOLD, 7406 /** 7407 * 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. 7408 */ 7409 DISCHARGED, 7410 /** 7411 * The Encounter has ended. 7412 */ 7413 COMPLETED, 7414 /** 7415 * The Encounter has ended before it has begun. 7416 */ 7417 CANCELLED, 7418 /** 7419 * 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. 7420 */ 7421 DISCONTINUED, 7422 /** 7423 * This instance should not have been part of this patient's medical record. 7424 */ 7425 ENTEREDINERROR, 7426 /** 7427 * 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". 7428 */ 7429 UNKNOWN, 7430 /** 7431 * added to help the parsers 7432 */ 7433 NULL; 7434 public static EncounterStatus fromCode(String codeString) throws FHIRException { 7435 if (codeString == null || "".equals(codeString)) 7436 return null; 7437 if ("planned".equals(codeString)) 7438 return PLANNED; 7439 if ("in-progress".equals(codeString)) 7440 return INPROGRESS; 7441 if ("on-hold".equals(codeString)) 7442 return ONHOLD; 7443 if ("discharged".equals(codeString)) 7444 return DISCHARGED; 7445 if ("completed".equals(codeString)) 7446 return COMPLETED; 7447 if ("cancelled".equals(codeString)) 7448 return CANCELLED; 7449 if ("discontinued".equals(codeString)) 7450 return DISCONTINUED; 7451 if ("entered-in-error".equals(codeString)) 7452 return ENTEREDINERROR; 7453 if ("unknown".equals(codeString)) 7454 return UNKNOWN; 7455 throw new FHIRException("Unknown EncounterStatus code '"+codeString+"'"); 7456 } 7457 public static boolean isValidCode(String codeString) { 7458 if (codeString == null || "".equals(codeString)) 7459 return false; 7460 return Utilities.existsInList(codeString, "planned", "in-progress", "on-hold", "discharged", "completed", "cancelled", "discontinued", "entered-in-error", "unknown"); 7461 } 7462 public String toCode() { 7463 switch (this) { 7464 case PLANNED: return "planned"; 7465 case INPROGRESS: return "in-progress"; 7466 case ONHOLD: return "on-hold"; 7467 case DISCHARGED: return "discharged"; 7468 case COMPLETED: return "completed"; 7469 case CANCELLED: return "cancelled"; 7470 case DISCONTINUED: return "discontinued"; 7471 case ENTEREDINERROR: return "entered-in-error"; 7472 case UNKNOWN: return "unknown"; 7473 case NULL: return null; 7474 default: return "?"; 7475 } 7476 } 7477 public String getSystem() { 7478 switch (this) { 7479 case PLANNED: return "http://hl7.org/fhir/encounter-status"; 7480 case INPROGRESS: return "http://hl7.org/fhir/encounter-status"; 7481 case ONHOLD: return "http://hl7.org/fhir/encounter-status"; 7482 case DISCHARGED: return "http://hl7.org/fhir/encounter-status"; 7483 case COMPLETED: return "http://hl7.org/fhir/encounter-status"; 7484 case CANCELLED: return "http://hl7.org/fhir/encounter-status"; 7485 case DISCONTINUED: return "http://hl7.org/fhir/encounter-status"; 7486 case ENTEREDINERROR: return "http://hl7.org/fhir/encounter-status"; 7487 case UNKNOWN: return "http://hl7.org/fhir/encounter-status"; 7488 case NULL: return null; 7489 default: return "?"; 7490 } 7491 } 7492 public String getDefinition() { 7493 switch (this) { 7494 case PLANNED: return "The Encounter has not yet started."; 7495 case INPROGRESS: return "The Encounter has begun and the patient is present / the practitioner and the patient are meeting."; 7496 case ONHOLD: return "The Encounter has begun, but is currently on hold, e.g. because the patient is temporarily on leave."; 7497 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."; 7498 case COMPLETED: return "The Encounter has ended."; 7499 case CANCELLED: return "The Encounter has ended before it has begun."; 7500 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."; 7501 case ENTEREDINERROR: return "This instance should not have been part of this patient's medical record."; 7502 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\"."; 7503 case NULL: return null; 7504 default: return "?"; 7505 } 7506 } 7507 public String getDisplay() { 7508 switch (this) { 7509 case PLANNED: return "Planned"; 7510 case INPROGRESS: return "In Progress"; 7511 case ONHOLD: return "On Hold"; 7512 case DISCHARGED: return "Discharged"; 7513 case COMPLETED: return "Completed"; 7514 case CANCELLED: return "Cancelled"; 7515 case DISCONTINUED: return "Discontinued"; 7516 case ENTEREDINERROR: return "Entered in Error"; 7517 case UNKNOWN: return "Unknown"; 7518 case NULL: return null; 7519 default: return "?"; 7520 } 7521 } 7522 } 7523 7524 public static class EncounterStatusEnumFactory implements EnumFactory<EncounterStatus> { 7525 public EncounterStatus fromCode(String codeString) throws IllegalArgumentException { 7526 if (codeString == null || "".equals(codeString)) 7527 if (codeString == null || "".equals(codeString)) 7528 return null; 7529 if ("planned".equals(codeString)) 7530 return EncounterStatus.PLANNED; 7531 if ("in-progress".equals(codeString)) 7532 return EncounterStatus.INPROGRESS; 7533 if ("on-hold".equals(codeString)) 7534 return EncounterStatus.ONHOLD; 7535 if ("discharged".equals(codeString)) 7536 return EncounterStatus.DISCHARGED; 7537 if ("completed".equals(codeString)) 7538 return EncounterStatus.COMPLETED; 7539 if ("cancelled".equals(codeString)) 7540 return EncounterStatus.CANCELLED; 7541 if ("discontinued".equals(codeString)) 7542 return EncounterStatus.DISCONTINUED; 7543 if ("entered-in-error".equals(codeString)) 7544 return EncounterStatus.ENTEREDINERROR; 7545 if ("unknown".equals(codeString)) 7546 return EncounterStatus.UNKNOWN; 7547 throw new IllegalArgumentException("Unknown EncounterStatus code '"+codeString+"'"); 7548 } 7549 7550 public Enumeration<EncounterStatus> fromType(PrimitiveType<?> code) throws FHIRException { 7551 if (code == null) 7552 return null; 7553 if (code.isEmpty()) 7554 return new Enumeration<EncounterStatus>(this, EncounterStatus.NULL, code); 7555 String codeString = ((PrimitiveType) code).asStringValue(); 7556 if (codeString == null || "".equals(codeString)) 7557 return new Enumeration<EncounterStatus>(this, EncounterStatus.NULL, code); 7558 if ("planned".equals(codeString)) 7559 return new Enumeration<EncounterStatus>(this, EncounterStatus.PLANNED, code); 7560 if ("in-progress".equals(codeString)) 7561 return new Enumeration<EncounterStatus>(this, EncounterStatus.INPROGRESS, code); 7562 if ("on-hold".equals(codeString)) 7563 return new Enumeration<EncounterStatus>(this, EncounterStatus.ONHOLD, code); 7564 if ("discharged".equals(codeString)) 7565 return new Enumeration<EncounterStatus>(this, EncounterStatus.DISCHARGED, code); 7566 if ("completed".equals(codeString)) 7567 return new Enumeration<EncounterStatus>(this, EncounterStatus.COMPLETED, code); 7568 if ("cancelled".equals(codeString)) 7569 return new Enumeration<EncounterStatus>(this, EncounterStatus.CANCELLED, code); 7570 if ("discontinued".equals(codeString)) 7571 return new Enumeration<EncounterStatus>(this, EncounterStatus.DISCONTINUED, code); 7572 if ("entered-in-error".equals(codeString)) 7573 return new Enumeration<EncounterStatus>(this, EncounterStatus.ENTEREDINERROR, code); 7574 if ("unknown".equals(codeString)) 7575 return new Enumeration<EncounterStatus>(this, EncounterStatus.UNKNOWN, code); 7576 throw new FHIRException("Unknown EncounterStatus code '"+codeString+"'"); 7577 } 7578 public String toCode(EncounterStatus code) { 7579 if (code == EncounterStatus.PLANNED) 7580 return "planned"; 7581 if (code == EncounterStatus.INPROGRESS) 7582 return "in-progress"; 7583 if (code == EncounterStatus.ONHOLD) 7584 return "on-hold"; 7585 if (code == EncounterStatus.DISCHARGED) 7586 return "discharged"; 7587 if (code == EncounterStatus.COMPLETED) 7588 return "completed"; 7589 if (code == EncounterStatus.CANCELLED) 7590 return "cancelled"; 7591 if (code == EncounterStatus.DISCONTINUED) 7592 return "discontinued"; 7593 if (code == EncounterStatus.ENTEREDINERROR) 7594 return "entered-in-error"; 7595 if (code == EncounterStatus.UNKNOWN) 7596 return "unknown"; 7597 return "?"; 7598 } 7599 public String toSystem(EncounterStatus code) { 7600 return code.getSystem(); 7601 } 7602 } 7603 7604 public enum EventStatus { 7605 /** 7606 * 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. 7607 */ 7608 PREPARATION, 7609 /** 7610 * The event is currently occurring. 7611 */ 7612 INPROGRESS, 7613 /** 7614 * 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. 7615 */ 7616 NOTDONE, 7617 /** 7618 * The event has been temporarily stopped but is expected to resume in the future. 7619 */ 7620 ONHOLD, 7621 /** 7622 * 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. 7623 */ 7624 STOPPED, 7625 /** 7626 * The event has now concluded. 7627 */ 7628 COMPLETED, 7629 /** 7630 * 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".). 7631 */ 7632 ENTEREDINERROR, 7633 /** 7634 * 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. 7635 */ 7636 UNKNOWN, 7637 /** 7638 * added to help the parsers 7639 */ 7640 NULL; 7641 public static EventStatus fromCode(String codeString) throws FHIRException { 7642 if (codeString == null || "".equals(codeString)) 7643 return null; 7644 if ("preparation".equals(codeString)) 7645 return PREPARATION; 7646 if ("in-progress".equals(codeString)) 7647 return INPROGRESS; 7648 if ("not-done".equals(codeString)) 7649 return NOTDONE; 7650 if ("on-hold".equals(codeString)) 7651 return ONHOLD; 7652 if ("stopped".equals(codeString)) 7653 return STOPPED; 7654 if ("completed".equals(codeString)) 7655 return COMPLETED; 7656 if ("entered-in-error".equals(codeString)) 7657 return ENTEREDINERROR; 7658 if ("unknown".equals(codeString)) 7659 return UNKNOWN; 7660 throw new FHIRException("Unknown EventStatus code '"+codeString+"'"); 7661 } 7662 public static boolean isValidCode(String codeString) { 7663 if (codeString == null || "".equals(codeString)) 7664 return false; 7665 return Utilities.existsInList(codeString, "preparation", "in-progress", "not-done", "on-hold", "stopped", "completed", "entered-in-error", "unknown"); 7666 } 7667 public String toCode() { 7668 switch (this) { 7669 case PREPARATION: return "preparation"; 7670 case INPROGRESS: return "in-progress"; 7671 case NOTDONE: return "not-done"; 7672 case ONHOLD: return "on-hold"; 7673 case STOPPED: return "stopped"; 7674 case COMPLETED: return "completed"; 7675 case ENTEREDINERROR: return "entered-in-error"; 7676 case UNKNOWN: return "unknown"; 7677 case NULL: return null; 7678 default: return "?"; 7679 } 7680 } 7681 public String getSystem() { 7682 switch (this) { 7683 case PREPARATION: return "http://hl7.org/fhir/event-status"; 7684 case INPROGRESS: return "http://hl7.org/fhir/event-status"; 7685 case NOTDONE: return "http://hl7.org/fhir/event-status"; 7686 case ONHOLD: return "http://hl7.org/fhir/event-status"; 7687 case STOPPED: return "http://hl7.org/fhir/event-status"; 7688 case COMPLETED: return "http://hl7.org/fhir/event-status"; 7689 case ENTEREDINERROR: return "http://hl7.org/fhir/event-status"; 7690 case UNKNOWN: return "http://hl7.org/fhir/event-status"; 7691 case NULL: return null; 7692 default: return "?"; 7693 } 7694 } 7695 public String getDefinition() { 7696 switch (this) { 7697 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."; 7698 case INPROGRESS: return "The event is currently occurring."; 7699 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."; 7700 case ONHOLD: return "The event has been temporarily stopped but is expected to resume in the future."; 7701 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."; 7702 case COMPLETED: return "The event has now concluded."; 7703 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\".)."; 7704 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."; 7705 case NULL: return null; 7706 default: return "?"; 7707 } 7708 } 7709 public String getDisplay() { 7710 switch (this) { 7711 case PREPARATION: return "Preparation"; 7712 case INPROGRESS: return "In Progress"; 7713 case NOTDONE: return "Not Done"; 7714 case ONHOLD: return "On Hold"; 7715 case STOPPED: return "Stopped"; 7716 case COMPLETED: return "Completed"; 7717 case ENTEREDINERROR: return "Entered in Error"; 7718 case UNKNOWN: return "Unknown"; 7719 case NULL: return null; 7720 default: return "?"; 7721 } 7722 } 7723 } 7724 7725 public static class EventStatusEnumFactory implements EnumFactory<EventStatus> { 7726 public EventStatus fromCode(String codeString) throws IllegalArgumentException { 7727 if (codeString == null || "".equals(codeString)) 7728 if (codeString == null || "".equals(codeString)) 7729 return null; 7730 if ("preparation".equals(codeString)) 7731 return EventStatus.PREPARATION; 7732 if ("in-progress".equals(codeString)) 7733 return EventStatus.INPROGRESS; 7734 if ("not-done".equals(codeString)) 7735 return EventStatus.NOTDONE; 7736 if ("on-hold".equals(codeString)) 7737 return EventStatus.ONHOLD; 7738 if ("stopped".equals(codeString)) 7739 return EventStatus.STOPPED; 7740 if ("completed".equals(codeString)) 7741 return EventStatus.COMPLETED; 7742 if ("entered-in-error".equals(codeString)) 7743 return EventStatus.ENTEREDINERROR; 7744 if ("unknown".equals(codeString)) 7745 return EventStatus.UNKNOWN; 7746 throw new IllegalArgumentException("Unknown EventStatus code '"+codeString+"'"); 7747 } 7748 7749 public Enumeration<EventStatus> fromType(PrimitiveType<?> code) throws FHIRException { 7750 if (code == null) 7751 return null; 7752 if (code.isEmpty()) 7753 return new Enumeration<EventStatus>(this, EventStatus.NULL, code); 7754 String codeString = ((PrimitiveType) code).asStringValue(); 7755 if (codeString == null || "".equals(codeString)) 7756 return new Enumeration<EventStatus>(this, EventStatus.NULL, code); 7757 if ("preparation".equals(codeString)) 7758 return new Enumeration<EventStatus>(this, EventStatus.PREPARATION, code); 7759 if ("in-progress".equals(codeString)) 7760 return new Enumeration<EventStatus>(this, EventStatus.INPROGRESS, code); 7761 if ("not-done".equals(codeString)) 7762 return new Enumeration<EventStatus>(this, EventStatus.NOTDONE, code); 7763 if ("on-hold".equals(codeString)) 7764 return new Enumeration<EventStatus>(this, EventStatus.ONHOLD, code); 7765 if ("stopped".equals(codeString)) 7766 return new Enumeration<EventStatus>(this, EventStatus.STOPPED, code); 7767 if ("completed".equals(codeString)) 7768 return new Enumeration<EventStatus>(this, EventStatus.COMPLETED, code); 7769 if ("entered-in-error".equals(codeString)) 7770 return new Enumeration<EventStatus>(this, EventStatus.ENTEREDINERROR, code); 7771 if ("unknown".equals(codeString)) 7772 return new Enumeration<EventStatus>(this, EventStatus.UNKNOWN, code); 7773 throw new FHIRException("Unknown EventStatus code '"+codeString+"'"); 7774 } 7775 public String toCode(EventStatus code) { 7776 if (code == EventStatus.PREPARATION) 7777 return "preparation"; 7778 if (code == EventStatus.INPROGRESS) 7779 return "in-progress"; 7780 if (code == EventStatus.NOTDONE) 7781 return "not-done"; 7782 if (code == EventStatus.ONHOLD) 7783 return "on-hold"; 7784 if (code == EventStatus.STOPPED) 7785 return "stopped"; 7786 if (code == EventStatus.COMPLETED) 7787 return "completed"; 7788 if (code == EventStatus.ENTEREDINERROR) 7789 return "entered-in-error"; 7790 if (code == EventStatus.UNKNOWN) 7791 return "unknown"; 7792 return "?"; 7793 } 7794 public String toSystem(EventStatus code) { 7795 return code.getSystem(); 7796 } 7797 } 7798 7799 public enum EvidenceVariableHandling { 7800 /** 7801 * 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). 7802 */ 7803 CONTINUOUS, 7804 /** 7805 * 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). 7806 */ 7807 DICHOTOMOUS, 7808 /** 7809 * 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). 7810 */ 7811 ORDINAL, 7812 /** 7813 * 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. 7814 */ 7815 POLYCHOTOMOUS, 7816 /** 7817 * added to help the parsers 7818 */ 7819 NULL; 7820 public static EvidenceVariableHandling fromCode(String codeString) throws FHIRException { 7821 if (codeString == null || "".equals(codeString)) 7822 return null; 7823 if ("continuous".equals(codeString)) 7824 return CONTINUOUS; 7825 if ("dichotomous".equals(codeString)) 7826 return DICHOTOMOUS; 7827 if ("ordinal".equals(codeString)) 7828 return ORDINAL; 7829 if ("polychotomous".equals(codeString)) 7830 return POLYCHOTOMOUS; 7831 throw new FHIRException("Unknown EvidenceVariableHandling code '"+codeString+"'"); 7832 } 7833 public static boolean isValidCode(String codeString) { 7834 if (codeString == null || "".equals(codeString)) 7835 return false; 7836 return Utilities.existsInList(codeString, "continuous", "dichotomous", "ordinal", "polychotomous"); 7837 } 7838 public String toCode() { 7839 switch (this) { 7840 case CONTINUOUS: return "continuous"; 7841 case DICHOTOMOUS: return "dichotomous"; 7842 case ORDINAL: return "ordinal"; 7843 case POLYCHOTOMOUS: return "polychotomous"; 7844 case NULL: return null; 7845 default: return "?"; 7846 } 7847 } 7848 public String getSystem() { 7849 switch (this) { 7850 case CONTINUOUS: return "http://hl7.org/fhir/variable-handling"; 7851 case DICHOTOMOUS: return "http://hl7.org/fhir/variable-handling"; 7852 case ORDINAL: return "http://hl7.org/fhir/variable-handling"; 7853 case POLYCHOTOMOUS: return "http://hl7.org/fhir/variable-handling"; 7854 case NULL: return null; 7855 default: return "?"; 7856 } 7857 } 7858 public String getDefinition() { 7859 switch (this) { 7860 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)."; 7861 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)."; 7862 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)."; 7863 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."; 7864 case NULL: return null; 7865 default: return "?"; 7866 } 7867 } 7868 public String getDisplay() { 7869 switch (this) { 7870 case CONTINUOUS: return "continuous variable"; 7871 case DICHOTOMOUS: return "dichotomous variable"; 7872 case ORDINAL: return "ordinal variable"; 7873 case POLYCHOTOMOUS: return "polychotomous variable"; 7874 case NULL: return null; 7875 default: return "?"; 7876 } 7877 } 7878 } 7879 7880 public static class EvidenceVariableHandlingEnumFactory implements EnumFactory<EvidenceVariableHandling> { 7881 public EvidenceVariableHandling fromCode(String codeString) throws IllegalArgumentException { 7882 if (codeString == null || "".equals(codeString)) 7883 if (codeString == null || "".equals(codeString)) 7884 return null; 7885 if ("continuous".equals(codeString)) 7886 return EvidenceVariableHandling.CONTINUOUS; 7887 if ("dichotomous".equals(codeString)) 7888 return EvidenceVariableHandling.DICHOTOMOUS; 7889 if ("ordinal".equals(codeString)) 7890 return EvidenceVariableHandling.ORDINAL; 7891 if ("polychotomous".equals(codeString)) 7892 return EvidenceVariableHandling.POLYCHOTOMOUS; 7893 throw new IllegalArgumentException("Unknown EvidenceVariableHandling code '"+codeString+"'"); 7894 } 7895 7896 public Enumeration<EvidenceVariableHandling> fromType(PrimitiveType<?> code) throws FHIRException { 7897 if (code == null) 7898 return null; 7899 if (code.isEmpty()) 7900 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.NULL, code); 7901 String codeString = ((PrimitiveType) code).asStringValue(); 7902 if (codeString == null || "".equals(codeString)) 7903 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.NULL, code); 7904 if ("continuous".equals(codeString)) 7905 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.CONTINUOUS, code); 7906 if ("dichotomous".equals(codeString)) 7907 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.DICHOTOMOUS, code); 7908 if ("ordinal".equals(codeString)) 7909 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.ORDINAL, code); 7910 if ("polychotomous".equals(codeString)) 7911 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.POLYCHOTOMOUS, code); 7912 throw new FHIRException("Unknown EvidenceVariableHandling code '"+codeString+"'"); 7913 } 7914 public String toCode(EvidenceVariableHandling code) { 7915 if (code == EvidenceVariableHandling.CONTINUOUS) 7916 return "continuous"; 7917 if (code == EvidenceVariableHandling.DICHOTOMOUS) 7918 return "dichotomous"; 7919 if (code == EvidenceVariableHandling.ORDINAL) 7920 return "ordinal"; 7921 if (code == EvidenceVariableHandling.POLYCHOTOMOUS) 7922 return "polychotomous"; 7923 return "?"; 7924 } 7925 public String toSystem(EvidenceVariableHandling code) { 7926 return code.getSystem(); 7927 } 7928 } 7929 7930 public enum ExampleScenarioActorType { 7931 /** 7932 * A human actor 7933 */ 7934 PERSON, 7935 /** 7936 * A software application or other system 7937 */ 7938 SYSTEM, 7939 /** 7940 * added to help the parsers 7941 */ 7942 NULL; 7943 public static ExampleScenarioActorType fromCode(String codeString) throws FHIRException { 7944 if (codeString == null || "".equals(codeString)) 7945 return null; 7946 if ("person".equals(codeString)) 7947 return PERSON; 7948 if ("system".equals(codeString)) 7949 return SYSTEM; 7950 throw new FHIRException("Unknown ExampleScenarioActorType code '"+codeString+"'"); 7951 } 7952 public static boolean isValidCode(String codeString) { 7953 if (codeString == null || "".equals(codeString)) 7954 return false; 7955 return Utilities.existsInList(codeString, "person", "system"); 7956 } 7957 public String toCode() { 7958 switch (this) { 7959 case PERSON: return "person"; 7960 case SYSTEM: return "system"; 7961 case NULL: return null; 7962 default: return "?"; 7963 } 7964 } 7965 public String getSystem() { 7966 switch (this) { 7967 case PERSON: return "http://hl7.org/fhir/examplescenario-actor-type"; 7968 case SYSTEM: return "http://hl7.org/fhir/examplescenario-actor-type"; 7969 case NULL: return null; 7970 default: return "?"; 7971 } 7972 } 7973 public String getDefinition() { 7974 switch (this) { 7975 case PERSON: return "A human actor"; 7976 case SYSTEM: return "A software application or other system"; 7977 case NULL: return null; 7978 default: return "?"; 7979 } 7980 } 7981 public String getDisplay() { 7982 switch (this) { 7983 case PERSON: return "Person"; 7984 case SYSTEM: return "System"; 7985 case NULL: return null; 7986 default: return "?"; 7987 } 7988 } 7989 } 7990 7991 public static class ExampleScenarioActorTypeEnumFactory implements EnumFactory<ExampleScenarioActorType> { 7992 public ExampleScenarioActorType fromCode(String codeString) throws IllegalArgumentException { 7993 if (codeString == null || "".equals(codeString)) 7994 if (codeString == null || "".equals(codeString)) 7995 return null; 7996 if ("person".equals(codeString)) 7997 return ExampleScenarioActorType.PERSON; 7998 if ("system".equals(codeString)) 7999 return ExampleScenarioActorType.SYSTEM; 8000 throw new IllegalArgumentException("Unknown ExampleScenarioActorType code '"+codeString+"'"); 8001 } 8002 8003 public Enumeration<ExampleScenarioActorType> fromType(PrimitiveType<?> code) throws FHIRException { 8004 if (code == null) 8005 return null; 8006 if (code.isEmpty()) 8007 return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.NULL, code); 8008 String codeString = ((PrimitiveType) code).asStringValue(); 8009 if (codeString == null || "".equals(codeString)) 8010 return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.NULL, code); 8011 if ("person".equals(codeString)) 8012 return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.PERSON, code); 8013 if ("system".equals(codeString)) 8014 return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.SYSTEM, code); 8015 throw new FHIRException("Unknown ExampleScenarioActorType code '"+codeString+"'"); 8016 } 8017 public String toCode(ExampleScenarioActorType code) { 8018 if (code == ExampleScenarioActorType.PERSON) 8019 return "person"; 8020 if (code == ExampleScenarioActorType.SYSTEM) 8021 return "system"; 8022 return "?"; 8023 } 8024 public String toSystem(ExampleScenarioActorType code) { 8025 return code.getSystem(); 8026 } 8027 } 8028 8029 public enum FHIRTypes { 8030 /** 8031 * Base Type: Base definition for all types defined in FHIR type system. 8032 */ 8033 BASE, 8034 /** 8035 * Element Type: Base definition for all elements in a resource. 8036 */ 8037 ELEMENT, 8038 /** 8039 * BackboneElement Type: Base definition for all elements that are defined inside a resource - but not those in a data type. 8040 */ 8041 BACKBONEELEMENT, 8042 /** 8043 * DataType Type: The base class for all re-useable types defined as part of the FHIR Specification. 8044 */ 8045 DATATYPE, 8046 /** 8047 * 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. 8048The ISO21090-codedString may be used to provide a coded representation of the contents of strings in an Address. 8049 */ 8050 ADDRESS, 8051 /** 8052 * Annotation Type: A text note which also contains information about who made the statement and when. 8053 */ 8054 ANNOTATION, 8055 /** 8056 * Attachment Type: For referring to data content defined in other formats. 8057 */ 8058 ATTACHMENT, 8059 /** 8060 * Availability Type: Availability data for an {item}. 8061 */ 8062 AVAILABILITY, 8063 /** 8064 * BackboneType Type: Base definition for the few data types that are allowed to carry modifier extensions. 8065 */ 8066 BACKBONETYPE, 8067 /** 8068 * Dosage Type: Indicates how the medication is/was taken or should be taken by the patient. 8069 */ 8070 DOSAGE, 8071 /** 8072 * ElementDefinition Type: Captures constraints on each element within the resource, profile, or extension. 8073 */ 8074 ELEMENTDEFINITION, 8075 /** 8076 * 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. 8077 */ 8078 MARKETINGSTATUS, 8079 /** 8080 * ProductShelfLife Type: The shelf-life and storage information for a medicinal product item or container can be described using this class. 8081 */ 8082 PRODUCTSHELFLIFE, 8083 /** 8084 * 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. 8085 */ 8086 TIMING, 8087 /** 8088 * CodeableConcept Type: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text. 8089 */ 8090 CODEABLECONCEPT, 8091 /** 8092 * CodeableReference Type: A reference to a resource (by instance), or instead, a reference to a concept defined in a terminology or ontology (by class). 8093 */ 8094 CODEABLEREFERENCE, 8095 /** 8096 * Coding Type: A reference to a code defined by a terminology system. 8097 */ 8098 CODING, 8099 /** 8100 * ContactDetail Type: Specifies contact information for a person or organization. 8101 */ 8102 CONTACTDETAIL, 8103 /** 8104 * ContactPoint Type: Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc. 8105 */ 8106 CONTACTPOINT, 8107 /** 8108 * Contributor Type: A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers. 8109 */ 8110 CONTRIBUTOR, 8111 /** 8112 * 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. 8113 */ 8114 DATAREQUIREMENT, 8115 /** 8116 * 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. 8117 */ 8118 EXPRESSION, 8119 /** 8120 * 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. 8121 */ 8122 EXTENDEDCONTACTDETAIL, 8123 /** 8124 * Extension Type: Optional Extension Element - found in all resources. 8125 */ 8126 EXTENSION, 8127 /** 8128 * 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. 8129 */ 8130 HUMANNAME, 8131 /** 8132 * Identifier Type: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers. 8133 */ 8134 IDENTIFIER, 8135 /** 8136 * 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. 8137 */ 8138 META, 8139 /** 8140 * MonetaryComponent Type: Availability data for an {item}. 8141 */ 8142 MONETARYCOMPONENT, 8143 /** 8144 * Money Type: An amount of economic utility in some recognized currency. 8145 */ 8146 MONEY, 8147 /** 8148 * Narrative Type: A human-readable summary of the resource conveying the essential clinical and business information for the resource. 8149 */ 8150 NARRATIVE, 8151 /** 8152 * 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. 8153 */ 8154 PARAMETERDEFINITION, 8155 /** 8156 * Period Type: A time period defined by a start and end date and optionally time. 8157 */ 8158 PERIOD, 8159 /** 8160 * PrimitiveType Type: The base type for all re-useable types defined that have a simple property. 8161 */ 8162 PRIMITIVETYPE, 8163 /** 8164 * base64Binary Type: A stream of bytes 8165 */ 8166 BASE64BINARY, 8167 /** 8168 * boolean Type: Value of "true" or "false" 8169 */ 8170 BOOLEAN, 8171 /** 8172 * 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. 8173 */ 8174 DATE, 8175 /** 8176 * 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. 8177 */ 8178 DATETIME, 8179 /** 8180 * decimal Type: A rational number with implicit precision 8181 */ 8182 DECIMAL, 8183 /** 8184 * instant Type: An instant in time - known at least to the second 8185 */ 8186 INSTANT, 8187 /** 8188 * integer Type: A whole number 8189 */ 8190 INTEGER, 8191 /** 8192 * positiveInt type: An integer with a value that is positive (e.g. >0) 8193 */ 8194 POSITIVEINT, 8195 /** 8196 * unsignedInt type: An integer with a value that is not negative (e.g. >= 0) 8197 */ 8198 UNSIGNEDINT, 8199 /** 8200 * integer64 Type: A very large whole number 8201 */ 8202 INTEGER64, 8203 /** 8204 * string Type: A sequence of Unicode characters 8205 */ 8206 STRING, 8207 /** 8208 * 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 8209 */ 8210 CODE, 8211 /** 8212 * 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. 8213 */ 8214 ID, 8215 /** 8216 * markdown type: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine 8217 */ 8218 MARKDOWN, 8219 /** 8220 * time Type: A time during the day, with no date specified 8221 */ 8222 TIME, 8223 /** 8224 * uri Type: String of characters used to identify a name or a resource 8225 */ 8226 URI, 8227 /** 8228 * canonical type: A URI that is a reference to a canonical URL on a FHIR resource 8229 */ 8230 CANONICAL, 8231 /** 8232 * oid type: An OID represented as a URI 8233 */ 8234 OID, 8235 /** 8236 * url type: A URI that is a literal reference 8237 */ 8238 URL, 8239 /** 8240 * uuid type: A UUID, represented as a URI 8241 */ 8242 UUID, 8243 /** 8244 * 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. 8245 */ 8246 QUANTITY, 8247 /** 8248 * Age Type: A duration of time during which an organism (or a process) has existed. 8249 */ 8250 AGE, 8251 /** 8252 * 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. 8253 */ 8254 COUNT, 8255 /** 8256 * Distance Type: A length - a value with a unit that is a physical distance. 8257 */ 8258 DISTANCE, 8259 /** 8260 * Duration Type: A length of time. 8261 */ 8262 DURATION, 8263 /** 8264 * Range Type: A set of ordered Quantities defined by a low and high limit. 8265 */ 8266 RANGE, 8267 /** 8268 * Ratio Type: A relationship of two Quantity values - expressed as a numerator and a denominator. 8269 */ 8270 RATIO, 8271 /** 8272 * RatioRange Type: A range of ratios expressed as a low and high numerator and a denominator. 8273 */ 8274 RATIORANGE, 8275 /** 8276 * Reference Type: A reference from one resource to another. 8277 */ 8278 REFERENCE, 8279 /** 8280 * RelatedArtifact Type: Related artifacts such as additional documentation, justification, or bibliographic references. 8281 */ 8282 RELATEDARTIFACT, 8283 /** 8284 * 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. 8285 */ 8286 SAMPLEDDATA, 8287 /** 8288 * 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. 8289 */ 8290 SIGNATURE, 8291 /** 8292 * TriggerDefinition Type: A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element. 8293 */ 8294 TRIGGERDEFINITION, 8295 /** 8296 * 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). 8297 */ 8298 USAGECONTEXT, 8299 /** 8300 * VirtualServiceDetail Type: Virtual Service Contact Details. 8301 */ 8302 VIRTUALSERVICEDETAIL, 8303 /** 8304 * xhtml Type definition 8305 */ 8306 XHTML, 8307 /** 8308 * This is the base resource type for everything. 8309 */ 8310 RESOURCE, 8311 /** 8312 * 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. 8313 */ 8314 BINARY, 8315 /** 8316 * A container for a collection of resources. 8317 */ 8318 BUNDLE, 8319 /** 8320 * A resource that includes narrative, extensions, and contained resources. 8321 */ 8322 DOMAINRESOURCE, 8323 /** 8324 * 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. 8325 */ 8326 ACCOUNT, 8327 /** 8328 * This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context. 8329 */ 8330 ACTIVITYDEFINITION, 8331 /** 8332 * 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. 8333 */ 8334 ACTORDEFINITION, 8335 /** 8336 * 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). 8337 */ 8338 ADMINISTRABLEPRODUCTDEFINITION, 8339 /** 8340 * 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. 8341 */ 8342 ADVERSEEVENT, 8343 /** 8344 * Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance. 8345 */ 8346 ALLERGYINTOLERANCE, 8347 /** 8348 * 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). 8349 */ 8350 APPOINTMENT, 8351 /** 8352 * A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection. 8353 */ 8354 APPOINTMENTRESPONSE, 8355 /** 8356 * This Resource provides one or more comments, classifiers or ratings about a Resource and supports attribution and rights management metadata for the added content. 8357 */ 8358 ARTIFACTASSESSMENT, 8359 /** 8360 * A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis. 8361 */ 8362 AUDITEVENT, 8363 /** 8364 * 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. 8365 */ 8366 BASIC, 8367 /** 8368 * A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity. 8369 */ 8370 BIOLOGICALLYDERIVEDPRODUCT, 8371 /** 8372 * A record of dispensation of a biologically derived product. 8373 */ 8374 BIOLOGICALLYDERIVEDPRODUCTDISPENSE, 8375 /** 8376 * 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. 8377 */ 8378 BODYSTRUCTURE, 8379 /** 8380 * Common Interface declaration for conformance and knowledge artifact resources. 8381 */ 8382 CANONICALRESOURCE, 8383 /** 8384 * 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. 8385 */ 8386 CAPABILITYSTATEMENT, 8387 /** 8388 * 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. 8389 */ 8390 CAREPLAN, 8391 /** 8392 * The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care. 8393 */ 8394 CARETEAM, 8395 /** 8396 * 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. 8397 */ 8398 CHARGEITEM, 8399 /** 8400 * 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. 8401 */ 8402 CHARGEITEMDEFINITION, 8403 /** 8404 * 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. 8405 */ 8406 CITATION, 8407 /** 8408 * 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. 8409 */ 8410 CLAIM, 8411 /** 8412 * This resource provides the adjudication details from the processing of a Claim resource. 8413 */ 8414 CLAIMRESPONSE, 8415 /** 8416 * 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. 8417 */ 8418 CLINICALIMPRESSION, 8419 /** 8420 * A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure. 8421 */ 8422 CLINICALUSEDEFINITION, 8423 /** 8424 * 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. 8425 */ 8426 CODESYSTEM, 8427 /** 8428 * 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. 8429 */ 8430 COMMUNICATION, 8431 /** 8432 * 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. 8433 */ 8434 COMMUNICATIONREQUEST, 8435 /** 8436 * A compartment definition that defines how resources are accessed on a server. 8437 */ 8438 COMPARTMENTDEFINITION, 8439 /** 8440 * 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.). 8441 */ 8442 COMPOSITION, 8443 /** 8444 * 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. 8445 */ 8446 CONCEPTMAP, 8447 /** 8448 * A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern. 8449 */ 8450 CONDITION, 8451 /** 8452 * A definition of a condition and information relevant to managing it. 8453 */ 8454 CONDITIONDEFINITION, 8455 /** 8456 * 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. 8457 */ 8458 CONSENT, 8459 /** 8460 * Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement. 8461 */ 8462 CONTRACT, 8463 /** 8464 * Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment. 8465 */ 8466 COVERAGE, 8467 /** 8468 * 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. 8469 */ 8470 COVERAGEELIGIBILITYREQUEST, 8471 /** 8472 * This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource. 8473 */ 8474 COVERAGEELIGIBILITYRESPONSE, 8475 /** 8476 * 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. 8477 */ 8478 DETECTEDISSUE, 8479 /** 8480 * 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. 8481 */ 8482 DEVICE, 8483 /** 8484 * A record of association of a device. 8485 */ 8486 DEVICEASSOCIATION, 8487 /** 8488 * This is a specialized resource that defines the characteristics and capabilities of a device. 8489 */ 8490 DEVICEDEFINITION, 8491 /** 8492 * 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. 8493 */ 8494 DEVICEDISPENSE, 8495 /** 8496 * 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. 8497 */ 8498 DEVICEMETRIC, 8499 /** 8500 * 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. 8501 */ 8502 DEVICEREQUEST, 8503 /** 8504 * 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. 8505 */ 8506 DEVICEUSAGE, 8507 /** 8508 * 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. 8509 */ 8510 DIAGNOSTICREPORT, 8511 /** 8512 * 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. 8513 */ 8514 DOCUMENTREFERENCE, 8515 /** 8516 * 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). 8517 */ 8518 ENCOUNTER, 8519 /** 8520 * A record of significant events/milestones key data throughout the history of an Encounter 8521 */ 8522 ENCOUNTERHISTORY, 8523 /** 8524 * 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. 8525 */ 8526 ENDPOINT, 8527 /** 8528 * This resource provides the insurance enrollment details to the insurer regarding a specified coverage. 8529 */ 8530 ENROLLMENTREQUEST, 8531 /** 8532 * This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource. 8533 */ 8534 ENROLLMENTRESPONSE, 8535 /** 8536 * 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. 8537 */ 8538 EPISODEOFCARE, 8539 /** 8540 * The EventDefinition resource provides a reusable description of when a particular event can occur. 8541 */ 8542 EVENTDEFINITION, 8543 /** 8544 * 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. 8545 */ 8546 EVIDENCE, 8547 /** 8548 * 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. 8549 */ 8550 EVIDENCEREPORT, 8551 /** 8552 * The EvidenceVariable resource describes an element that knowledge (Evidence) is about. 8553 */ 8554 EVIDENCEVARIABLE, 8555 /** 8556 * A walkthrough of a workflow showing the interaction between systems and the instances shared, possibly including the evolution of instances over time. 8557 */ 8558 EXAMPLESCENARIO, 8559 /** 8560 * 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. 8561 */ 8562 EXPLANATIONOFBENEFIT, 8563 /** 8564 * Significant health conditions for a person related to the patient relevant in the context of care for the patient. 8565 */ 8566 FAMILYMEMBERHISTORY, 8567 /** 8568 * Prospective warnings of potential issues when providing care to the patient. 8569 */ 8570 FLAG, 8571 /** 8572 * 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. 8573 */ 8574 FORMULARYITEM, 8575 /** 8576 * A set of analyses performed to analyze and generate genomic data. 8577 */ 8578 GENOMICSTUDY, 8579 /** 8580 * 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. 8581 */ 8582 GOAL, 8583 /** 8584 * 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. 8585 */ 8586 GRAPHDEFINITION, 8587 /** 8588 * 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. 8589 */ 8590 GROUP, 8591 /** 8592 * 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. 8593 */ 8594 GUIDANCERESPONSE, 8595 /** 8596 * 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. 8597 */ 8598 HEALTHCARESERVICE, 8599 /** 8600 * 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. 8601 */ 8602 IMAGINGSELECTION, 8603 /** 8604 * 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. 8605 */ 8606 IMAGINGSTUDY, 8607 /** 8608 * 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. 8609 */ 8610 IMMUNIZATION, 8611 /** 8612 * Describes a comparison of an immunization event against published recommendations to determine if the administration is "valid" in relation to those recommendations. 8613 */ 8614 IMMUNIZATIONEVALUATION, 8615 /** 8616 * A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification. 8617 */ 8618 IMMUNIZATIONRECOMMENDATION, 8619 /** 8620 * 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. 8621 */ 8622 IMPLEMENTATIONGUIDE, 8623 /** 8624 * An ingredient of a manufactured item or pharmaceutical product. 8625 */ 8626 INGREDIENT, 8627 /** 8628 * Details of a Health Insurance product/plan provided by an organization. 8629 */ 8630 INSURANCEPLAN, 8631 /** 8632 * functional description of an inventory item used in inventory and supply-related workflows. 8633 */ 8634 INVENTORYITEM, 8635 /** 8636 * A report of inventory or stock items. 8637 */ 8638 INVENTORYREPORT, 8639 /** 8640 * Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose. 8641 */ 8642 INVOICE, 8643 /** 8644 * 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. 8645 */ 8646 LIBRARY, 8647 /** 8648 * Identifies two or more records (resource instances) that refer to the same real-world "occurrence". 8649 */ 8650 LINKAGE, 8651 /** 8652 * A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc. 8653 */ 8654 LIST, 8655 /** 8656 * Details and position information for a place where services are provided and resources and participants may be stored, found, contained, or accommodated. 8657 */ 8658 LOCATION, 8659 /** 8660 * The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product. 8661 */ 8662 MANUFACTUREDITEMDEFINITION, 8663 /** 8664 * The Measure resource provides the definition of a quality measure. 8665 */ 8666 MEASURE, 8667 /** 8668 * The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation. 8669 */ 8670 MEASUREREPORT, 8671 /** 8672 * 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. 8673 */ 8674 MEDICATION, 8675 /** 8676 * 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. 8677 */ 8678 MEDICATIONADMINISTRATION, 8679 /** 8680 * 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. 8681 */ 8682 MEDICATIONDISPENSE, 8683 /** 8684 * Information about a medication that is used to support knowledge. 8685 */ 8686 MEDICATIONKNOWLEDGE, 8687 /** 8688 * 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. 8689 */ 8690 MEDICATIONREQUEST, 8691 /** 8692 * 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. 8693 8694The 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. 8695 */ 8696 MEDICATIONSTATEMENT, 8697 /** 8698 * 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.). 8699 */ 8700 MEDICINALPRODUCTDEFINITION, 8701 /** 8702 * 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. 8703 */ 8704 MESSAGEDEFINITION, 8705 /** 8706 * 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. 8707 */ 8708 MESSAGEHEADER, 8709 /** 8710 * Common Interface declaration for conformance and knowledge artifact resources. 8711 */ 8712 METADATARESOURCE, 8713 /** 8714 * Representation of a molecular sequence. 8715 */ 8716 MOLECULARSEQUENCE, 8717 /** 8718 * 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. 8719 */ 8720 NAMINGSYSTEM, 8721 /** 8722 * 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. 8723 */ 8724 NUTRITIONINTAKE, 8725 /** 8726 * A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident. 8727 */ 8728 NUTRITIONORDER, 8729 /** 8730 * A food or supplement that is consumed by patients. 8731 */ 8732 NUTRITIONPRODUCT, 8733 /** 8734 * Measurements and simple assertions made about a patient, device or other subject. 8735 */ 8736 OBSERVATION, 8737 /** 8738 * Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service. 8739 */ 8740 OBSERVATIONDEFINITION, 8741 /** 8742 * A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction). 8743 */ 8744 OPERATIONDEFINITION, 8745 /** 8746 * A collection of error, warning, or information messages that result from a system action. 8747 */ 8748 OPERATIONOUTCOME, 8749 /** 8750 * 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. 8751 */ 8752 ORGANIZATION, 8753 /** 8754 * Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship. 8755 */ 8756 ORGANIZATIONAFFILIATION, 8757 /** 8758 * A medically related item or items, in a container or package. 8759 */ 8760 PACKAGEDPRODUCTDEFINITION, 8761 /** 8762 * Demographics and other administrative information about an individual or animal receiving care or other health-related services. 8763 */ 8764 PATIENT, 8765 /** 8766 * This resource provides the status of the payment for goods and services rendered, and the request and response resource references. 8767 */ 8768 PAYMENTNOTICE, 8769 /** 8770 * This resource provides the details including amount of a payment and allocates the payment items being paid. 8771 */ 8772 PAYMENTRECONCILIATION, 8773 /** 8774 * Permission resource holds access rules for a given data and context. 8775 */ 8776 PERMISSION, 8777 /** 8778 * Demographics and administrative information about a person independent of a specific health-related context. 8779 */ 8780 PERSON, 8781 /** 8782 * 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. 8783 */ 8784 PLANDEFINITION, 8785 /** 8786 * A person who is directly or indirectly involved in the provisioning of healthcare or related services. 8787 */ 8788 PRACTITIONER, 8789 /** 8790 * A specific set of Roles/Locations/specialties/services that a practitioner may perform, or has performed at an organization during a period of time. 8791 */ 8792 PRACTITIONERROLE, 8793 /** 8794 * 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. 8795 */ 8796 PROCEDURE, 8797 /** 8798 * 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. 8799 */ 8800 PROVENANCE, 8801 /** 8802 * 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. 8803 */ 8804 QUESTIONNAIRE, 8805 /** 8806 * 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. 8807 */ 8808 QUESTIONNAIRERESPONSE, 8809 /** 8810 * 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. 8811 */ 8812 REGULATEDAUTHORIZATION, 8813 /** 8814 * 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. 8815 */ 8816 RELATEDPERSON, 8817 /** 8818 * 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". 8819 */ 8820 REQUESTORCHESTRATION, 8821 /** 8822 * 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. 8823 */ 8824 REQUIREMENTS, 8825 /** 8826 * 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. 8827 */ 8828 RESEARCHSTUDY, 8829 /** 8830 * A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study. 8831 */ 8832 RESEARCHSUBJECT, 8833 /** 8834 * An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome. 8835 */ 8836 RISKASSESSMENT, 8837 /** 8838 * A container for slots of time that may be available for booking appointments. 8839 */ 8840 SCHEDULE, 8841 /** 8842 * A search parameter that defines a named search item that can be used to search/filter on a resource. 8843 */ 8844 SEARCHPARAMETER, 8845 /** 8846 * A record of a request for service such as diagnostic investigations, treatments, or operations to be performed. 8847 */ 8848 SERVICEREQUEST, 8849 /** 8850 * A slot of time on a schedule that may be available for booking appointments. 8851 */ 8852 SLOT, 8853 /** 8854 * A sample to be used for analysis. 8855 */ 8856 SPECIMEN, 8857 /** 8858 * A kind of specimen with associated set of requirements. 8859 */ 8860 SPECIMENDEFINITION, 8861 /** 8862 * 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. 8863 */ 8864 STRUCTUREDEFINITION, 8865 /** 8866 * A Map of relationships between 2 structures that can be used to transform data. 8867 */ 8868 STRUCTUREMAP, 8869 /** 8870 * The subscription resource describes a particular client's request to be notified about a SubscriptionTopic. 8871 */ 8872 SUBSCRIPTION, 8873 /** 8874 * The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted. 8875 */ 8876 SUBSCRIPTIONSTATUS, 8877 /** 8878 * Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic. 8879 */ 8880 SUBSCRIPTIONTOPIC, 8881 /** 8882 * A homogeneous material with a definite composition. 8883 */ 8884 SUBSTANCE, 8885 /** 8886 * The detailed description of a substance, typically at a level beyond what is used for prescribing. 8887 */ 8888 SUBSTANCEDEFINITION, 8889 /** 8890 * 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. 8891 */ 8892 SUBSTANCENUCLEICACID, 8893 /** 8894 * Properties of a substance specific to it being a polymer. 8895 */ 8896 SUBSTANCEPOLYMER, 8897 /** 8898 * 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. 8899 */ 8900 SUBSTANCEPROTEIN, 8901 /** 8902 * Todo. 8903 */ 8904 SUBSTANCEREFERENCEINFORMATION, 8905 /** 8906 * 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. 8907 */ 8908 SUBSTANCESOURCEMATERIAL, 8909 /** 8910 * Record of delivery of what is supplied. 8911 */ 8912 SUPPLYDELIVERY, 8913 /** 8914 * 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. 8915 */ 8916 SUPPLYREQUEST, 8917 /** 8918 * A task to be performed. 8919 */ 8920 TASK, 8921 /** 8922 * 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. 8923 */ 8924 TERMINOLOGYCAPABILITIES, 8925 /** 8926 * A plan for executing testing on an artifact or specifications 8927 */ 8928 TESTPLAN, 8929 /** 8930 * A summary of information based on the results of executing a TestScript. 8931 */ 8932 TESTREPORT, 8933 /** 8934 * A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification. 8935 */ 8936 TESTSCRIPT, 8937 /** 8938 * Record of transport. 8939 */ 8940 TRANSPORT, 8941 /** 8942 * 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). 8943 */ 8944 VALUESET, 8945 /** 8946 * Describes validation requirements, source(s), status and dates for one or more elements. 8947 */ 8948 VERIFICATIONRESULT, 8949 /** 8950 * An authorization for the provision of glasses and/or contact lenses to a patient. 8951 */ 8952 VISIONPRESCRIPTION, 8953 /** 8954 * 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. 8955 */ 8956 PARAMETERS, 8957 /** 8958 * added to help the parsers 8959 */ 8960 NULL; 8961 public static FHIRTypes fromCode(String codeString) throws FHIRException { 8962 if (codeString == null || "".equals(codeString)) 8963 return null; 8964 if ("Base".equals(codeString)) 8965 return BASE; 8966 if ("Element".equals(codeString)) 8967 return ELEMENT; 8968 if ("BackboneElement".equals(codeString)) 8969 return BACKBONEELEMENT; 8970 if ("DataType".equals(codeString)) 8971 return DATATYPE; 8972 if ("Address".equals(codeString)) 8973 return ADDRESS; 8974 if ("Annotation".equals(codeString)) 8975 return ANNOTATION; 8976 if ("Attachment".equals(codeString)) 8977 return ATTACHMENT; 8978 if ("Availability".equals(codeString)) 8979 return AVAILABILITY; 8980 if ("BackboneType".equals(codeString)) 8981 return BACKBONETYPE; 8982 if ("Dosage".equals(codeString)) 8983 return DOSAGE; 8984 if ("ElementDefinition".equals(codeString)) 8985 return ELEMENTDEFINITION; 8986 if ("MarketingStatus".equals(codeString)) 8987 return MARKETINGSTATUS; 8988 if ("ProductShelfLife".equals(codeString)) 8989 return PRODUCTSHELFLIFE; 8990 if ("Timing".equals(codeString)) 8991 return TIMING; 8992 if ("CodeableConcept".equals(codeString)) 8993 return CODEABLECONCEPT; 8994 if ("CodeableReference".equals(codeString)) 8995 return CODEABLEREFERENCE; 8996 if ("Coding".equals(codeString)) 8997 return CODING; 8998 if ("ContactDetail".equals(codeString)) 8999 return CONTACTDETAIL; 9000 if ("ContactPoint".equals(codeString)) 9001 return CONTACTPOINT; 9002 if ("Contributor".equals(codeString)) 9003 return CONTRIBUTOR; 9004 if ("DataRequirement".equals(codeString)) 9005 return DATAREQUIREMENT; 9006 if ("Expression".equals(codeString)) 9007 return EXPRESSION; 9008 if ("ExtendedContactDetail".equals(codeString)) 9009 return EXTENDEDCONTACTDETAIL; 9010 if ("Extension".equals(codeString)) 9011 return EXTENSION; 9012 if ("HumanName".equals(codeString)) 9013 return HUMANNAME; 9014 if ("Identifier".equals(codeString)) 9015 return IDENTIFIER; 9016 if ("Meta".equals(codeString)) 9017 return META; 9018 if ("MonetaryComponent".equals(codeString)) 9019 return MONETARYCOMPONENT; 9020 if ("Money".equals(codeString)) 9021 return MONEY; 9022 if ("Narrative".equals(codeString)) 9023 return NARRATIVE; 9024 if ("ParameterDefinition".equals(codeString)) 9025 return PARAMETERDEFINITION; 9026 if ("Period".equals(codeString)) 9027 return PERIOD; 9028 if ("PrimitiveType".equals(codeString)) 9029 return PRIMITIVETYPE; 9030 if ("base64Binary".equals(codeString)) 9031 return BASE64BINARY; 9032 if ("boolean".equals(codeString)) 9033 return BOOLEAN; 9034 if ("date".equals(codeString)) 9035 return DATE; 9036 if ("dateTime".equals(codeString)) 9037 return DATETIME; 9038 if ("decimal".equals(codeString)) 9039 return DECIMAL; 9040 if ("instant".equals(codeString)) 9041 return INSTANT; 9042 if ("integer".equals(codeString)) 9043 return INTEGER; 9044 if ("positiveInt".equals(codeString)) 9045 return POSITIVEINT; 9046 if ("unsignedInt".equals(codeString)) 9047 return UNSIGNEDINT; 9048 if ("integer64".equals(codeString)) 9049 return INTEGER64; 9050 if ("string".equals(codeString)) 9051 return STRING; 9052 if ("code".equals(codeString)) 9053 return CODE; 9054 if ("id".equals(codeString)) 9055 return ID; 9056 if ("markdown".equals(codeString)) 9057 return MARKDOWN; 9058 if ("time".equals(codeString)) 9059 return TIME; 9060 if ("uri".equals(codeString)) 9061 return URI; 9062 if ("canonical".equals(codeString)) 9063 return CANONICAL; 9064 if ("oid".equals(codeString)) 9065 return OID; 9066 if ("url".equals(codeString)) 9067 return URL; 9068 if ("uuid".equals(codeString)) 9069 return UUID; 9070 if ("Quantity".equals(codeString)) 9071 return QUANTITY; 9072 if ("Age".equals(codeString)) 9073 return AGE; 9074 if ("Count".equals(codeString)) 9075 return COUNT; 9076 if ("Distance".equals(codeString)) 9077 return DISTANCE; 9078 if ("Duration".equals(codeString)) 9079 return DURATION; 9080 if ("Range".equals(codeString)) 9081 return RANGE; 9082 if ("Ratio".equals(codeString)) 9083 return RATIO; 9084 if ("RatioRange".equals(codeString)) 9085 return RATIORANGE; 9086 if ("Reference".equals(codeString)) 9087 return REFERENCE; 9088 if ("RelatedArtifact".equals(codeString)) 9089 return RELATEDARTIFACT; 9090 if ("SampledData".equals(codeString)) 9091 return SAMPLEDDATA; 9092 if ("Signature".equals(codeString)) 9093 return SIGNATURE; 9094 if ("TriggerDefinition".equals(codeString)) 9095 return TRIGGERDEFINITION; 9096 if ("UsageContext".equals(codeString)) 9097 return USAGECONTEXT; 9098 if ("VirtualServiceDetail".equals(codeString)) 9099 return VIRTUALSERVICEDETAIL; 9100 if ("xhtml".equals(codeString)) 9101 return XHTML; 9102 if ("Resource".equals(codeString) || "Any".equals(codeString)) 9103 return RESOURCE; 9104 if ("Binary".equals(codeString)) 9105 return BINARY; 9106 if ("Bundle".equals(codeString)) 9107 return BUNDLE; 9108 if ("DomainResource".equals(codeString)) 9109 return DOMAINRESOURCE; 9110 if ("Account".equals(codeString)) 9111 return ACCOUNT; 9112 if ("ActivityDefinition".equals(codeString)) 9113 return ACTIVITYDEFINITION; 9114 if ("ActorDefinition".equals(codeString)) 9115 return ACTORDEFINITION; 9116 if ("AdministrableProductDefinition".equals(codeString)) 9117 return ADMINISTRABLEPRODUCTDEFINITION; 9118 if ("AdverseEvent".equals(codeString)) 9119 return ADVERSEEVENT; 9120 if ("AllergyIntolerance".equals(codeString)) 9121 return ALLERGYINTOLERANCE; 9122 if ("Appointment".equals(codeString)) 9123 return APPOINTMENT; 9124 if ("AppointmentResponse".equals(codeString)) 9125 return APPOINTMENTRESPONSE; 9126 if ("ArtifactAssessment".equals(codeString)) 9127 return ARTIFACTASSESSMENT; 9128 if ("AuditEvent".equals(codeString)) 9129 return AUDITEVENT; 9130 if ("Basic".equals(codeString)) 9131 return BASIC; 9132 if ("BiologicallyDerivedProduct".equals(codeString)) 9133 return BIOLOGICALLYDERIVEDPRODUCT; 9134 if ("BiologicallyDerivedProductDispense".equals(codeString)) 9135 return BIOLOGICALLYDERIVEDPRODUCTDISPENSE; 9136 if ("BodyStructure".equals(codeString)) 9137 return BODYSTRUCTURE; 9138 if ("CanonicalResource".equals(codeString)) 9139 return CANONICALRESOURCE; 9140 if ("CapabilityStatement".equals(codeString)) 9141 return CAPABILITYSTATEMENT; 9142 if ("CarePlan".equals(codeString)) 9143 return CAREPLAN; 9144 if ("CareTeam".equals(codeString)) 9145 return CARETEAM; 9146 if ("ChargeItem".equals(codeString)) 9147 return CHARGEITEM; 9148 if ("ChargeItemDefinition".equals(codeString)) 9149 return CHARGEITEMDEFINITION; 9150 if ("Citation".equals(codeString)) 9151 return CITATION; 9152 if ("Claim".equals(codeString)) 9153 return CLAIM; 9154 if ("ClaimResponse".equals(codeString)) 9155 return CLAIMRESPONSE; 9156 if ("ClinicalImpression".equals(codeString)) 9157 return CLINICALIMPRESSION; 9158 if ("ClinicalUseDefinition".equals(codeString)) 9159 return CLINICALUSEDEFINITION; 9160 if ("CodeSystem".equals(codeString)) 9161 return CODESYSTEM; 9162 if ("Communication".equals(codeString)) 9163 return COMMUNICATION; 9164 if ("CommunicationRequest".equals(codeString)) 9165 return COMMUNICATIONREQUEST; 9166 if ("CompartmentDefinition".equals(codeString)) 9167 return COMPARTMENTDEFINITION; 9168 if ("Composition".equals(codeString)) 9169 return COMPOSITION; 9170 if ("ConceptMap".equals(codeString)) 9171 return CONCEPTMAP; 9172 if ("Condition".equals(codeString)) 9173 return CONDITION; 9174 if ("ConditionDefinition".equals(codeString)) 9175 return CONDITIONDEFINITION; 9176 if ("Consent".equals(codeString)) 9177 return CONSENT; 9178 if ("Contract".equals(codeString)) 9179 return CONTRACT; 9180 if ("Coverage".equals(codeString)) 9181 return COVERAGE; 9182 if ("CoverageEligibilityRequest".equals(codeString)) 9183 return COVERAGEELIGIBILITYREQUEST; 9184 if ("CoverageEligibilityResponse".equals(codeString)) 9185 return COVERAGEELIGIBILITYRESPONSE; 9186 if ("DetectedIssue".equals(codeString)) 9187 return DETECTEDISSUE; 9188 if ("Device".equals(codeString)) 9189 return DEVICE; 9190 if ("DeviceAssociation".equals(codeString)) 9191 return DEVICEASSOCIATION; 9192 if ("DeviceDefinition".equals(codeString)) 9193 return DEVICEDEFINITION; 9194 if ("DeviceDispense".equals(codeString)) 9195 return DEVICEDISPENSE; 9196 if ("DeviceMetric".equals(codeString)) 9197 return DEVICEMETRIC; 9198 if ("DeviceRequest".equals(codeString)) 9199 return DEVICEREQUEST; 9200 if ("DeviceUsage".equals(codeString)) 9201 return DEVICEUSAGE; 9202 if ("DiagnosticReport".equals(codeString)) 9203 return DIAGNOSTICREPORT; 9204 if ("DocumentReference".equals(codeString)) 9205 return DOCUMENTREFERENCE; 9206 if ("Encounter".equals(codeString)) 9207 return ENCOUNTER; 9208 if ("EncounterHistory".equals(codeString)) 9209 return ENCOUNTERHISTORY; 9210 if ("Endpoint".equals(codeString)) 9211 return ENDPOINT; 9212 if ("EnrollmentRequest".equals(codeString)) 9213 return ENROLLMENTREQUEST; 9214 if ("EnrollmentResponse".equals(codeString)) 9215 return ENROLLMENTRESPONSE; 9216 if ("EpisodeOfCare".equals(codeString)) 9217 return EPISODEOFCARE; 9218 if ("EventDefinition".equals(codeString)) 9219 return EVENTDEFINITION; 9220 if ("Evidence".equals(codeString)) 9221 return EVIDENCE; 9222 if ("EvidenceReport".equals(codeString)) 9223 return EVIDENCEREPORT; 9224 if ("EvidenceVariable".equals(codeString)) 9225 return EVIDENCEVARIABLE; 9226 if ("ExampleScenario".equals(codeString)) 9227 return EXAMPLESCENARIO; 9228 if ("ExplanationOfBenefit".equals(codeString)) 9229 return EXPLANATIONOFBENEFIT; 9230 if ("FamilyMemberHistory".equals(codeString)) 9231 return FAMILYMEMBERHISTORY; 9232 if ("Flag".equals(codeString)) 9233 return FLAG; 9234 if ("FormularyItem".equals(codeString)) 9235 return FORMULARYITEM; 9236 if ("GenomicStudy".equals(codeString)) 9237 return GENOMICSTUDY; 9238 if ("Goal".equals(codeString)) 9239 return GOAL; 9240 if ("GraphDefinition".equals(codeString)) 9241 return GRAPHDEFINITION; 9242 if ("Group".equals(codeString)) 9243 return GROUP; 9244 if ("GuidanceResponse".equals(codeString)) 9245 return GUIDANCERESPONSE; 9246 if ("HealthcareService".equals(codeString)) 9247 return HEALTHCARESERVICE; 9248 if ("ImagingSelection".equals(codeString)) 9249 return IMAGINGSELECTION; 9250 if ("ImagingStudy".equals(codeString)) 9251 return IMAGINGSTUDY; 9252 if ("Immunization".equals(codeString)) 9253 return IMMUNIZATION; 9254 if ("ImmunizationEvaluation".equals(codeString)) 9255 return IMMUNIZATIONEVALUATION; 9256 if ("ImmunizationRecommendation".equals(codeString)) 9257 return IMMUNIZATIONRECOMMENDATION; 9258 if ("ImplementationGuide".equals(codeString)) 9259 return IMPLEMENTATIONGUIDE; 9260 if ("Ingredient".equals(codeString)) 9261 return INGREDIENT; 9262 if ("InsurancePlan".equals(codeString)) 9263 return INSURANCEPLAN; 9264 if ("InventoryItem".equals(codeString)) 9265 return INVENTORYITEM; 9266 if ("InventoryReport".equals(codeString)) 9267 return INVENTORYREPORT; 9268 if ("Invoice".equals(codeString)) 9269 return INVOICE; 9270 if ("Library".equals(codeString)) 9271 return LIBRARY; 9272 if ("Linkage".equals(codeString)) 9273 return LINKAGE; 9274 if ("List".equals(codeString)) 9275 return LIST; 9276 if ("Location".equals(codeString)) 9277 return LOCATION; 9278 if ("ManufacturedItemDefinition".equals(codeString)) 9279 return MANUFACTUREDITEMDEFINITION; 9280 if ("Measure".equals(codeString)) 9281 return MEASURE; 9282 if ("MeasureReport".equals(codeString)) 9283 return MEASUREREPORT; 9284 if ("Medication".equals(codeString)) 9285 return MEDICATION; 9286 if ("MedicationAdministration".equals(codeString)) 9287 return MEDICATIONADMINISTRATION; 9288 if ("MedicationDispense".equals(codeString)) 9289 return MEDICATIONDISPENSE; 9290 if ("MedicationKnowledge".equals(codeString)) 9291 return MEDICATIONKNOWLEDGE; 9292 if ("MedicationRequest".equals(codeString)) 9293 return MEDICATIONREQUEST; 9294 if ("MedicationStatement".equals(codeString)) 9295 return MEDICATIONSTATEMENT; 9296 if ("MedicinalProductDefinition".equals(codeString)) 9297 return MEDICINALPRODUCTDEFINITION; 9298 if ("MessageDefinition".equals(codeString)) 9299 return MESSAGEDEFINITION; 9300 if ("MessageHeader".equals(codeString)) 9301 return MESSAGEHEADER; 9302 if ("MetadataResource".equals(codeString)) 9303 return METADATARESOURCE; 9304 if ("MolecularSequence".equals(codeString)) 9305 return MOLECULARSEQUENCE; 9306 if ("NamingSystem".equals(codeString)) 9307 return NAMINGSYSTEM; 9308 if ("NutritionIntake".equals(codeString)) 9309 return NUTRITIONINTAKE; 9310 if ("NutritionOrder".equals(codeString)) 9311 return NUTRITIONORDER; 9312 if ("NutritionProduct".equals(codeString)) 9313 return NUTRITIONPRODUCT; 9314 if ("Observation".equals(codeString)) 9315 return OBSERVATION; 9316 if ("ObservationDefinition".equals(codeString)) 9317 return OBSERVATIONDEFINITION; 9318 if ("OperationDefinition".equals(codeString)) 9319 return OPERATIONDEFINITION; 9320 if ("OperationOutcome".equals(codeString)) 9321 return OPERATIONOUTCOME; 9322 if ("Organization".equals(codeString)) 9323 return ORGANIZATION; 9324 if ("OrganizationAffiliation".equals(codeString)) 9325 return ORGANIZATIONAFFILIATION; 9326 if ("PackagedProductDefinition".equals(codeString)) 9327 return PACKAGEDPRODUCTDEFINITION; 9328 if ("Patient".equals(codeString)) 9329 return PATIENT; 9330 if ("PaymentNotice".equals(codeString)) 9331 return PAYMENTNOTICE; 9332 if ("PaymentReconciliation".equals(codeString)) 9333 return PAYMENTRECONCILIATION; 9334 if ("Permission".equals(codeString)) 9335 return PERMISSION; 9336 if ("Person".equals(codeString)) 9337 return PERSON; 9338 if ("PlanDefinition".equals(codeString)) 9339 return PLANDEFINITION; 9340 if ("Practitioner".equals(codeString)) 9341 return PRACTITIONER; 9342 if ("PractitionerRole".equals(codeString)) 9343 return PRACTITIONERROLE; 9344 if ("Procedure".equals(codeString)) 9345 return PROCEDURE; 9346 if ("Provenance".equals(codeString)) 9347 return PROVENANCE; 9348 if ("Questionnaire".equals(codeString)) 9349 return QUESTIONNAIRE; 9350 if ("QuestionnaireResponse".equals(codeString)) 9351 return QUESTIONNAIRERESPONSE; 9352 if ("RegulatedAuthorization".equals(codeString)) 9353 return REGULATEDAUTHORIZATION; 9354 if ("RelatedPerson".equals(codeString)) 9355 return RELATEDPERSON; 9356 if ("RequestOrchestration".equals(codeString)) 9357 return REQUESTORCHESTRATION; 9358 if ("Requirements".equals(codeString)) 9359 return REQUIREMENTS; 9360 if ("ResearchStudy".equals(codeString)) 9361 return RESEARCHSTUDY; 9362 if ("ResearchSubject".equals(codeString)) 9363 return RESEARCHSUBJECT; 9364 if ("RiskAssessment".equals(codeString)) 9365 return RISKASSESSMENT; 9366 if ("Schedule".equals(codeString)) 9367 return SCHEDULE; 9368 if ("SearchParameter".equals(codeString)) 9369 return SEARCHPARAMETER; 9370 if ("ServiceRequest".equals(codeString)) 9371 return SERVICEREQUEST; 9372 if ("Slot".equals(codeString)) 9373 return SLOT; 9374 if ("Specimen".equals(codeString)) 9375 return SPECIMEN; 9376 if ("SpecimenDefinition".equals(codeString)) 9377 return SPECIMENDEFINITION; 9378 if ("StructureDefinition".equals(codeString)) 9379 return STRUCTUREDEFINITION; 9380 if ("StructureMap".equals(codeString)) 9381 return STRUCTUREMAP; 9382 if ("Subscription".equals(codeString)) 9383 return SUBSCRIPTION; 9384 if ("SubscriptionStatus".equals(codeString)) 9385 return SUBSCRIPTIONSTATUS; 9386 if ("SubscriptionTopic".equals(codeString)) 9387 return SUBSCRIPTIONTOPIC; 9388 if ("Substance".equals(codeString)) 9389 return SUBSTANCE; 9390 if ("SubstanceDefinition".equals(codeString)) 9391 return SUBSTANCEDEFINITION; 9392 if ("SubstanceNucleicAcid".equals(codeString)) 9393 return SUBSTANCENUCLEICACID; 9394 if ("SubstancePolymer".equals(codeString)) 9395 return SUBSTANCEPOLYMER; 9396 if ("SubstanceProtein".equals(codeString)) 9397 return SUBSTANCEPROTEIN; 9398 if ("SubstanceReferenceInformation".equals(codeString)) 9399 return SUBSTANCEREFERENCEINFORMATION; 9400 if ("SubstanceSourceMaterial".equals(codeString)) 9401 return SUBSTANCESOURCEMATERIAL; 9402 if ("SupplyDelivery".equals(codeString)) 9403 return SUPPLYDELIVERY; 9404 if ("SupplyRequest".equals(codeString)) 9405 return SUPPLYREQUEST; 9406 if ("Task".equals(codeString)) 9407 return TASK; 9408 if ("TerminologyCapabilities".equals(codeString)) 9409 return TERMINOLOGYCAPABILITIES; 9410 if ("TestPlan".equals(codeString)) 9411 return TESTPLAN; 9412 if ("TestReport".equals(codeString)) 9413 return TESTREPORT; 9414 if ("TestScript".equals(codeString)) 9415 return TESTSCRIPT; 9416 if ("Transport".equals(codeString)) 9417 return TRANSPORT; 9418 if ("ValueSet".equals(codeString)) 9419 return VALUESET; 9420 if ("VerificationResult".equals(codeString)) 9421 return VERIFICATIONRESULT; 9422 if ("VisionPrescription".equals(codeString)) 9423 return VISIONPRESCRIPTION; 9424 if ("Parameters".equals(codeString)) 9425 return PARAMETERS; 9426 throw new FHIRException("Unknown FHIRTypes code '"+codeString+"'"); 9427 } 9428 public static boolean isValidCode(String codeString) { 9429 if (codeString == null || "".equals(codeString)) 9430 return false; 9431 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"); 9432 } 9433 public String toCode() { 9434 switch (this) { 9435 case BASE: return "Base"; 9436 case ELEMENT: return "Element"; 9437 case BACKBONEELEMENT: return "BackboneElement"; 9438 case DATATYPE: return "DataType"; 9439 case ADDRESS: return "Address"; 9440 case ANNOTATION: return "Annotation"; 9441 case ATTACHMENT: return "Attachment"; 9442 case AVAILABILITY: return "Availability"; 9443 case BACKBONETYPE: return "BackboneType"; 9444 case DOSAGE: return "Dosage"; 9445 case ELEMENTDEFINITION: return "ElementDefinition"; 9446 case MARKETINGSTATUS: return "MarketingStatus"; 9447 case PRODUCTSHELFLIFE: return "ProductShelfLife"; 9448 case TIMING: return "Timing"; 9449 case CODEABLECONCEPT: return "CodeableConcept"; 9450 case CODEABLEREFERENCE: return "CodeableReference"; 9451 case CODING: return "Coding"; 9452 case CONTACTDETAIL: return "ContactDetail"; 9453 case CONTACTPOINT: return "ContactPoint"; 9454 case CONTRIBUTOR: return "Contributor"; 9455 case DATAREQUIREMENT: return "DataRequirement"; 9456 case EXPRESSION: return "Expression"; 9457 case EXTENDEDCONTACTDETAIL: return "ExtendedContactDetail"; 9458 case EXTENSION: return "Extension"; 9459 case HUMANNAME: return "HumanName"; 9460 case IDENTIFIER: return "Identifier"; 9461 case META: return "Meta"; 9462 case MONETARYCOMPONENT: return "MonetaryComponent"; 9463 case MONEY: return "Money"; 9464 case NARRATIVE: return "Narrative"; 9465 case PARAMETERDEFINITION: return "ParameterDefinition"; 9466 case PERIOD: return "Period"; 9467 case PRIMITIVETYPE: return "PrimitiveType"; 9468 case BASE64BINARY: return "base64Binary"; 9469 case BOOLEAN: return "boolean"; 9470 case DATE: return "date"; 9471 case DATETIME: return "dateTime"; 9472 case DECIMAL: return "decimal"; 9473 case INSTANT: return "instant"; 9474 case INTEGER: return "integer"; 9475 case POSITIVEINT: return "positiveInt"; 9476 case UNSIGNEDINT: return "unsignedInt"; 9477 case INTEGER64: return "integer64"; 9478 case STRING: return "string"; 9479 case CODE: return "code"; 9480 case ID: return "id"; 9481 case MARKDOWN: return "markdown"; 9482 case TIME: return "time"; 9483 case URI: return "uri"; 9484 case CANONICAL: return "canonical"; 9485 case OID: return "oid"; 9486 case URL: return "url"; 9487 case UUID: return "uuid"; 9488 case QUANTITY: return "Quantity"; 9489 case AGE: return "Age"; 9490 case COUNT: return "Count"; 9491 case DISTANCE: return "Distance"; 9492 case DURATION: return "Duration"; 9493 case RANGE: return "Range"; 9494 case RATIO: return "Ratio"; 9495 case RATIORANGE: return "RatioRange"; 9496 case REFERENCE: return "Reference"; 9497 case RELATEDARTIFACT: return "RelatedArtifact"; 9498 case SAMPLEDDATA: return "SampledData"; 9499 case SIGNATURE: return "Signature"; 9500 case TRIGGERDEFINITION: return "TriggerDefinition"; 9501 case USAGECONTEXT: return "UsageContext"; 9502 case VIRTUALSERVICEDETAIL: return "VirtualServiceDetail"; 9503 case XHTML: return "xhtml"; 9504 case RESOURCE: return "Resource"; 9505 case BINARY: return "Binary"; 9506 case BUNDLE: return "Bundle"; 9507 case DOMAINRESOURCE: return "DomainResource"; 9508 case ACCOUNT: return "Account"; 9509 case ACTIVITYDEFINITION: return "ActivityDefinition"; 9510 case ACTORDEFINITION: return "ActorDefinition"; 9511 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 9512 case ADVERSEEVENT: return "AdverseEvent"; 9513 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 9514 case APPOINTMENT: return "Appointment"; 9515 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 9516 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 9517 case AUDITEVENT: return "AuditEvent"; 9518 case BASIC: return "Basic"; 9519 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 9520 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "BiologicallyDerivedProductDispense"; 9521 case BODYSTRUCTURE: return "BodyStructure"; 9522 case CANONICALRESOURCE: return "CanonicalResource"; 9523 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 9524 case CAREPLAN: return "CarePlan"; 9525 case CARETEAM: return "CareTeam"; 9526 case CHARGEITEM: return "ChargeItem"; 9527 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 9528 case CITATION: return "Citation"; 9529 case CLAIM: return "Claim"; 9530 case CLAIMRESPONSE: return "ClaimResponse"; 9531 case CLINICALIMPRESSION: return "ClinicalImpression"; 9532 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 9533 case CODESYSTEM: return "CodeSystem"; 9534 case COMMUNICATION: return "Communication"; 9535 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 9536 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 9537 case COMPOSITION: return "Composition"; 9538 case CONCEPTMAP: return "ConceptMap"; 9539 case CONDITION: return "Condition"; 9540 case CONDITIONDEFINITION: return "ConditionDefinition"; 9541 case CONSENT: return "Consent"; 9542 case CONTRACT: return "Contract"; 9543 case COVERAGE: return "Coverage"; 9544 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 9545 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 9546 case DETECTEDISSUE: return "DetectedIssue"; 9547 case DEVICE: return "Device"; 9548 case DEVICEASSOCIATION: return "DeviceAssociation"; 9549 case DEVICEDEFINITION: return "DeviceDefinition"; 9550 case DEVICEDISPENSE: return "DeviceDispense"; 9551 case DEVICEMETRIC: return "DeviceMetric"; 9552 case DEVICEREQUEST: return "DeviceRequest"; 9553 case DEVICEUSAGE: return "DeviceUsage"; 9554 case DIAGNOSTICREPORT: return "DiagnosticReport"; 9555 case DOCUMENTREFERENCE: return "DocumentReference"; 9556 case ENCOUNTER: return "Encounter"; 9557 case ENCOUNTERHISTORY: return "EncounterHistory"; 9558 case ENDPOINT: return "Endpoint"; 9559 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 9560 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 9561 case EPISODEOFCARE: return "EpisodeOfCare"; 9562 case EVENTDEFINITION: return "EventDefinition"; 9563 case EVIDENCE: return "Evidence"; 9564 case EVIDENCEREPORT: return "EvidenceReport"; 9565 case EVIDENCEVARIABLE: return "EvidenceVariable"; 9566 case EXAMPLESCENARIO: return "ExampleScenario"; 9567 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 9568 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 9569 case FLAG: return "Flag"; 9570 case FORMULARYITEM: return "FormularyItem"; 9571 case GENOMICSTUDY: return "GenomicStudy"; 9572 case GOAL: return "Goal"; 9573 case GRAPHDEFINITION: return "GraphDefinition"; 9574 case GROUP: return "Group"; 9575 case GUIDANCERESPONSE: return "GuidanceResponse"; 9576 case HEALTHCARESERVICE: return "HealthcareService"; 9577 case IMAGINGSELECTION: return "ImagingSelection"; 9578 case IMAGINGSTUDY: return "ImagingStudy"; 9579 case IMMUNIZATION: return "Immunization"; 9580 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 9581 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 9582 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 9583 case INGREDIENT: return "Ingredient"; 9584 case INSURANCEPLAN: return "InsurancePlan"; 9585 case INVENTORYITEM: return "InventoryItem"; 9586 case INVENTORYREPORT: return "InventoryReport"; 9587 case INVOICE: return "Invoice"; 9588 case LIBRARY: return "Library"; 9589 case LINKAGE: return "Linkage"; 9590 case LIST: return "List"; 9591 case LOCATION: return "Location"; 9592 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 9593 case MEASURE: return "Measure"; 9594 case MEASUREREPORT: return "MeasureReport"; 9595 case MEDICATION: return "Medication"; 9596 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 9597 case MEDICATIONDISPENSE: return "MedicationDispense"; 9598 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 9599 case MEDICATIONREQUEST: return "MedicationRequest"; 9600 case MEDICATIONSTATEMENT: return "MedicationStatement"; 9601 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 9602 case MESSAGEDEFINITION: return "MessageDefinition"; 9603 case MESSAGEHEADER: return "MessageHeader"; 9604 case METADATARESOURCE: return "MetadataResource"; 9605 case MOLECULARSEQUENCE: return "MolecularSequence"; 9606 case NAMINGSYSTEM: return "NamingSystem"; 9607 case NUTRITIONINTAKE: return "NutritionIntake"; 9608 case NUTRITIONORDER: return "NutritionOrder"; 9609 case NUTRITIONPRODUCT: return "NutritionProduct"; 9610 case OBSERVATION: return "Observation"; 9611 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 9612 case OPERATIONDEFINITION: return "OperationDefinition"; 9613 case OPERATIONOUTCOME: return "OperationOutcome"; 9614 case ORGANIZATION: return "Organization"; 9615 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 9616 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 9617 case PATIENT: return "Patient"; 9618 case PAYMENTNOTICE: return "PaymentNotice"; 9619 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 9620 case PERMISSION: return "Permission"; 9621 case PERSON: return "Person"; 9622 case PLANDEFINITION: return "PlanDefinition"; 9623 case PRACTITIONER: return "Practitioner"; 9624 case PRACTITIONERROLE: return "PractitionerRole"; 9625 case PROCEDURE: return "Procedure"; 9626 case PROVENANCE: return "Provenance"; 9627 case QUESTIONNAIRE: return "Questionnaire"; 9628 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 9629 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 9630 case RELATEDPERSON: return "RelatedPerson"; 9631 case REQUESTORCHESTRATION: return "RequestOrchestration"; 9632 case REQUIREMENTS: return "Requirements"; 9633 case RESEARCHSTUDY: return "ResearchStudy"; 9634 case RESEARCHSUBJECT: return "ResearchSubject"; 9635 case RISKASSESSMENT: return "RiskAssessment"; 9636 case SCHEDULE: return "Schedule"; 9637 case SEARCHPARAMETER: return "SearchParameter"; 9638 case SERVICEREQUEST: return "ServiceRequest"; 9639 case SLOT: return "Slot"; 9640 case SPECIMEN: return "Specimen"; 9641 case SPECIMENDEFINITION: return "SpecimenDefinition"; 9642 case STRUCTUREDEFINITION: return "StructureDefinition"; 9643 case STRUCTUREMAP: return "StructureMap"; 9644 case SUBSCRIPTION: return "Subscription"; 9645 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 9646 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 9647 case SUBSTANCE: return "Substance"; 9648 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 9649 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 9650 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 9651 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 9652 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 9653 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 9654 case SUPPLYDELIVERY: return "SupplyDelivery"; 9655 case SUPPLYREQUEST: return "SupplyRequest"; 9656 case TASK: return "Task"; 9657 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 9658 case TESTPLAN: return "TestPlan"; 9659 case TESTREPORT: return "TestReport"; 9660 case TESTSCRIPT: return "TestScript"; 9661 case TRANSPORT: return "Transport"; 9662 case VALUESET: return "ValueSet"; 9663 case VERIFICATIONRESULT: return "VerificationResult"; 9664 case VISIONPRESCRIPTION: return "VisionPrescription"; 9665 case PARAMETERS: return "Parameters"; 9666 case NULL: return null; 9667 default: return "?"; 9668 } 9669 } 9670 public String getSystem() { 9671 switch (this) { 9672 case BASE: return "http://hl7.org/fhir/fhir-types"; 9673 case ELEMENT: return "http://hl7.org/fhir/fhir-types"; 9674 case BACKBONEELEMENT: return "http://hl7.org/fhir/fhir-types"; 9675 case DATATYPE: return "http://hl7.org/fhir/fhir-types"; 9676 case ADDRESS: return "http://hl7.org/fhir/fhir-types"; 9677 case ANNOTATION: return "http://hl7.org/fhir/fhir-types"; 9678 case ATTACHMENT: return "http://hl7.org/fhir/fhir-types"; 9679 case AVAILABILITY: return "http://hl7.org/fhir/fhir-types"; 9680 case BACKBONETYPE: return "http://hl7.org/fhir/fhir-types"; 9681 case DOSAGE: return "http://hl7.org/fhir/fhir-types"; 9682 case ELEMENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9683 case MARKETINGSTATUS: return "http://hl7.org/fhir/fhir-types"; 9684 case PRODUCTSHELFLIFE: return "http://hl7.org/fhir/fhir-types"; 9685 case TIMING: return "http://hl7.org/fhir/fhir-types"; 9686 case CODEABLECONCEPT: return "http://hl7.org/fhir/fhir-types"; 9687 case CODEABLEREFERENCE: return "http://hl7.org/fhir/fhir-types"; 9688 case CODING: return "http://hl7.org/fhir/fhir-types"; 9689 case CONTACTDETAIL: return "http://hl7.org/fhir/fhir-types"; 9690 case CONTACTPOINT: return "http://hl7.org/fhir/fhir-types"; 9691 case CONTRIBUTOR: return "http://hl7.org/fhir/fhir-types"; 9692 case DATAREQUIREMENT: return "http://hl7.org/fhir/fhir-types"; 9693 case EXPRESSION: return "http://hl7.org/fhir/fhir-types"; 9694 case EXTENDEDCONTACTDETAIL: return "http://hl7.org/fhir/fhir-types"; 9695 case EXTENSION: return "http://hl7.org/fhir/fhir-types"; 9696 case HUMANNAME: return "http://hl7.org/fhir/fhir-types"; 9697 case IDENTIFIER: return "http://hl7.org/fhir/fhir-types"; 9698 case META: return "http://hl7.org/fhir/fhir-types"; 9699 case MONETARYCOMPONENT: return "http://hl7.org/fhir/fhir-types"; 9700 case MONEY: return "http://hl7.org/fhir/fhir-types"; 9701 case NARRATIVE: return "http://hl7.org/fhir/fhir-types"; 9702 case PARAMETERDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9703 case PERIOD: return "http://hl7.org/fhir/fhir-types"; 9704 case PRIMITIVETYPE: return "http://hl7.org/fhir/fhir-types"; 9705 case BASE64BINARY: return "http://hl7.org/fhir/fhir-types"; 9706 case BOOLEAN: return "http://hl7.org/fhir/fhir-types"; 9707 case DATE: return "http://hl7.org/fhir/fhir-types"; 9708 case DATETIME: return "http://hl7.org/fhir/fhir-types"; 9709 case DECIMAL: return "http://hl7.org/fhir/fhir-types"; 9710 case INSTANT: return "http://hl7.org/fhir/fhir-types"; 9711 case INTEGER: return "http://hl7.org/fhir/fhir-types"; 9712 case POSITIVEINT: return "http://hl7.org/fhir/fhir-types"; 9713 case UNSIGNEDINT: return "http://hl7.org/fhir/fhir-types"; 9714 case INTEGER64: return "http://hl7.org/fhir/fhir-types"; 9715 case STRING: return "http://hl7.org/fhir/fhir-types"; 9716 case CODE: return "http://hl7.org/fhir/fhir-types"; 9717 case ID: return "http://hl7.org/fhir/fhir-types"; 9718 case MARKDOWN: return "http://hl7.org/fhir/fhir-types"; 9719 case TIME: return "http://hl7.org/fhir/fhir-types"; 9720 case URI: return "http://hl7.org/fhir/fhir-types"; 9721 case CANONICAL: return "http://hl7.org/fhir/fhir-types"; 9722 case OID: return "http://hl7.org/fhir/fhir-types"; 9723 case URL: return "http://hl7.org/fhir/fhir-types"; 9724 case UUID: return "http://hl7.org/fhir/fhir-types"; 9725 case QUANTITY: return "http://hl7.org/fhir/fhir-types"; 9726 case AGE: return "http://hl7.org/fhir/fhir-types"; 9727 case COUNT: return "http://hl7.org/fhir/fhir-types"; 9728 case DISTANCE: return "http://hl7.org/fhir/fhir-types"; 9729 case DURATION: return "http://hl7.org/fhir/fhir-types"; 9730 case RANGE: return "http://hl7.org/fhir/fhir-types"; 9731 case RATIO: return "http://hl7.org/fhir/fhir-types"; 9732 case RATIORANGE: return "http://hl7.org/fhir/fhir-types"; 9733 case REFERENCE: return "http://hl7.org/fhir/fhir-types"; 9734 case RELATEDARTIFACT: return "http://hl7.org/fhir/fhir-types"; 9735 case SAMPLEDDATA: return "http://hl7.org/fhir/fhir-types"; 9736 case SIGNATURE: return "http://hl7.org/fhir/fhir-types"; 9737 case TRIGGERDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9738 case USAGECONTEXT: return "http://hl7.org/fhir/fhir-types"; 9739 case VIRTUALSERVICEDETAIL: return "http://hl7.org/fhir/fhir-types"; 9740 case XHTML: return "http://hl7.org/fhir/fhir-types"; 9741 case RESOURCE: return "http://hl7.org/fhir/fhir-types"; 9742 case BINARY: return "http://hl7.org/fhir/fhir-types"; 9743 case BUNDLE: return "http://hl7.org/fhir/fhir-types"; 9744 case DOMAINRESOURCE: return "http://hl7.org/fhir/fhir-types"; 9745 case ACCOUNT: return "http://hl7.org/fhir/fhir-types"; 9746 case ACTIVITYDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9747 case ACTORDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9748 case ADMINISTRABLEPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9749 case ADVERSEEVENT: return "http://hl7.org/fhir/fhir-types"; 9750 case ALLERGYINTOLERANCE: return "http://hl7.org/fhir/fhir-types"; 9751 case APPOINTMENT: return "http://hl7.org/fhir/fhir-types"; 9752 case APPOINTMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 9753 case ARTIFACTASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 9754 case AUDITEVENT: return "http://hl7.org/fhir/fhir-types"; 9755 case BASIC: return "http://hl7.org/fhir/fhir-types"; 9756 case BIOLOGICALLYDERIVEDPRODUCT: return "http://hl7.org/fhir/fhir-types"; 9757 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "http://hl7.org/fhir/fhir-types"; 9758 case BODYSTRUCTURE: return "http://hl7.org/fhir/fhir-types"; 9759 case CANONICALRESOURCE: return "http://hl7.org/fhir/fhir-types"; 9760 case CAPABILITYSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 9761 case CAREPLAN: return "http://hl7.org/fhir/fhir-types"; 9762 case CARETEAM: return "http://hl7.org/fhir/fhir-types"; 9763 case CHARGEITEM: return "http://hl7.org/fhir/fhir-types"; 9764 case CHARGEITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9765 case CITATION: return "http://hl7.org/fhir/fhir-types"; 9766 case CLAIM: return "http://hl7.org/fhir/fhir-types"; 9767 case CLAIMRESPONSE: return "http://hl7.org/fhir/fhir-types"; 9768 case CLINICALIMPRESSION: return "http://hl7.org/fhir/fhir-types"; 9769 case CLINICALUSEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9770 case CODESYSTEM: return "http://hl7.org/fhir/fhir-types"; 9771 case COMMUNICATION: return "http://hl7.org/fhir/fhir-types"; 9772 case COMMUNICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 9773 case COMPARTMENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9774 case COMPOSITION: return "http://hl7.org/fhir/fhir-types"; 9775 case CONCEPTMAP: return "http://hl7.org/fhir/fhir-types"; 9776 case CONDITION: return "http://hl7.org/fhir/fhir-types"; 9777 case CONDITIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9778 case CONSENT: return "http://hl7.org/fhir/fhir-types"; 9779 case CONTRACT: return "http://hl7.org/fhir/fhir-types"; 9780 case COVERAGE: return "http://hl7.org/fhir/fhir-types"; 9781 case COVERAGEELIGIBILITYREQUEST: return "http://hl7.org/fhir/fhir-types"; 9782 case COVERAGEELIGIBILITYRESPONSE: return "http://hl7.org/fhir/fhir-types"; 9783 case DETECTEDISSUE: return "http://hl7.org/fhir/fhir-types"; 9784 case DEVICE: return "http://hl7.org/fhir/fhir-types"; 9785 case DEVICEASSOCIATION: return "http://hl7.org/fhir/fhir-types"; 9786 case DEVICEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9787 case DEVICEDISPENSE: return "http://hl7.org/fhir/fhir-types"; 9788 case DEVICEMETRIC: return "http://hl7.org/fhir/fhir-types"; 9789 case DEVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 9790 case DEVICEUSAGE: return "http://hl7.org/fhir/fhir-types"; 9791 case DIAGNOSTICREPORT: return "http://hl7.org/fhir/fhir-types"; 9792 case DOCUMENTREFERENCE: return "http://hl7.org/fhir/fhir-types"; 9793 case ENCOUNTER: return "http://hl7.org/fhir/fhir-types"; 9794 case ENCOUNTERHISTORY: return "http://hl7.org/fhir/fhir-types"; 9795 case ENDPOINT: return "http://hl7.org/fhir/fhir-types"; 9796 case ENROLLMENTREQUEST: return "http://hl7.org/fhir/fhir-types"; 9797 case ENROLLMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 9798 case EPISODEOFCARE: return "http://hl7.org/fhir/fhir-types"; 9799 case EVENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9800 case EVIDENCE: return "http://hl7.org/fhir/fhir-types"; 9801 case EVIDENCEREPORT: return "http://hl7.org/fhir/fhir-types"; 9802 case EVIDENCEVARIABLE: return "http://hl7.org/fhir/fhir-types"; 9803 case EXAMPLESCENARIO: return "http://hl7.org/fhir/fhir-types"; 9804 case EXPLANATIONOFBENEFIT: return "http://hl7.org/fhir/fhir-types"; 9805 case FAMILYMEMBERHISTORY: return "http://hl7.org/fhir/fhir-types"; 9806 case FLAG: return "http://hl7.org/fhir/fhir-types"; 9807 case FORMULARYITEM: return "http://hl7.org/fhir/fhir-types"; 9808 case GENOMICSTUDY: return "http://hl7.org/fhir/fhir-types"; 9809 case GOAL: return "http://hl7.org/fhir/fhir-types"; 9810 case GRAPHDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9811 case GROUP: return "http://hl7.org/fhir/fhir-types"; 9812 case GUIDANCERESPONSE: return "http://hl7.org/fhir/fhir-types"; 9813 case HEALTHCARESERVICE: return "http://hl7.org/fhir/fhir-types"; 9814 case IMAGINGSELECTION: return "http://hl7.org/fhir/fhir-types"; 9815 case IMAGINGSTUDY: return "http://hl7.org/fhir/fhir-types"; 9816 case IMMUNIZATION: return "http://hl7.org/fhir/fhir-types"; 9817 case IMMUNIZATIONEVALUATION: return "http://hl7.org/fhir/fhir-types"; 9818 case IMMUNIZATIONRECOMMENDATION: return "http://hl7.org/fhir/fhir-types"; 9819 case IMPLEMENTATIONGUIDE: return "http://hl7.org/fhir/fhir-types"; 9820 case INGREDIENT: return "http://hl7.org/fhir/fhir-types"; 9821 case INSURANCEPLAN: return "http://hl7.org/fhir/fhir-types"; 9822 case INVENTORYITEM: return "http://hl7.org/fhir/fhir-types"; 9823 case INVENTORYREPORT: return "http://hl7.org/fhir/fhir-types"; 9824 case INVOICE: return "http://hl7.org/fhir/fhir-types"; 9825 case LIBRARY: return "http://hl7.org/fhir/fhir-types"; 9826 case LINKAGE: return "http://hl7.org/fhir/fhir-types"; 9827 case LIST: return "http://hl7.org/fhir/fhir-types"; 9828 case LOCATION: return "http://hl7.org/fhir/fhir-types"; 9829 case MANUFACTUREDITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9830 case MEASURE: return "http://hl7.org/fhir/fhir-types"; 9831 case MEASUREREPORT: return "http://hl7.org/fhir/fhir-types"; 9832 case MEDICATION: return "http://hl7.org/fhir/fhir-types"; 9833 case MEDICATIONADMINISTRATION: return "http://hl7.org/fhir/fhir-types"; 9834 case MEDICATIONDISPENSE: return "http://hl7.org/fhir/fhir-types"; 9835 case MEDICATIONKNOWLEDGE: return "http://hl7.org/fhir/fhir-types"; 9836 case MEDICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 9837 case MEDICATIONSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 9838 case MEDICINALPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9839 case MESSAGEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9840 case MESSAGEHEADER: return "http://hl7.org/fhir/fhir-types"; 9841 case METADATARESOURCE: return "http://hl7.org/fhir/fhir-types"; 9842 case MOLECULARSEQUENCE: return "http://hl7.org/fhir/fhir-types"; 9843 case NAMINGSYSTEM: return "http://hl7.org/fhir/fhir-types"; 9844 case NUTRITIONINTAKE: return "http://hl7.org/fhir/fhir-types"; 9845 case NUTRITIONORDER: return "http://hl7.org/fhir/fhir-types"; 9846 case NUTRITIONPRODUCT: return "http://hl7.org/fhir/fhir-types"; 9847 case OBSERVATION: return "http://hl7.org/fhir/fhir-types"; 9848 case OBSERVATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9849 case OPERATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9850 case OPERATIONOUTCOME: return "http://hl7.org/fhir/fhir-types"; 9851 case ORGANIZATION: return "http://hl7.org/fhir/fhir-types"; 9852 case ORGANIZATIONAFFILIATION: return "http://hl7.org/fhir/fhir-types"; 9853 case PACKAGEDPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9854 case PATIENT: return "http://hl7.org/fhir/fhir-types"; 9855 case PAYMENTNOTICE: return "http://hl7.org/fhir/fhir-types"; 9856 case PAYMENTRECONCILIATION: return "http://hl7.org/fhir/fhir-types"; 9857 case PERMISSION: return "http://hl7.org/fhir/fhir-types"; 9858 case PERSON: return "http://hl7.org/fhir/fhir-types"; 9859 case PLANDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9860 case PRACTITIONER: return "http://hl7.org/fhir/fhir-types"; 9861 case PRACTITIONERROLE: return "http://hl7.org/fhir/fhir-types"; 9862 case PROCEDURE: return "http://hl7.org/fhir/fhir-types"; 9863 case PROVENANCE: return "http://hl7.org/fhir/fhir-types"; 9864 case QUESTIONNAIRE: return "http://hl7.org/fhir/fhir-types"; 9865 case QUESTIONNAIRERESPONSE: return "http://hl7.org/fhir/fhir-types"; 9866 case REGULATEDAUTHORIZATION: return "http://hl7.org/fhir/fhir-types"; 9867 case RELATEDPERSON: return "http://hl7.org/fhir/fhir-types"; 9868 case REQUESTORCHESTRATION: return "http://hl7.org/fhir/fhir-types"; 9869 case REQUIREMENTS: return "http://hl7.org/fhir/fhir-types"; 9870 case RESEARCHSTUDY: return "http://hl7.org/fhir/fhir-types"; 9871 case RESEARCHSUBJECT: return "http://hl7.org/fhir/fhir-types"; 9872 case RISKASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 9873 case SCHEDULE: return "http://hl7.org/fhir/fhir-types"; 9874 case SEARCHPARAMETER: return "http://hl7.org/fhir/fhir-types"; 9875 case SERVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 9876 case SLOT: return "http://hl7.org/fhir/fhir-types"; 9877 case SPECIMEN: return "http://hl7.org/fhir/fhir-types"; 9878 case SPECIMENDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9879 case STRUCTUREDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9880 case STRUCTUREMAP: return "http://hl7.org/fhir/fhir-types"; 9881 case SUBSCRIPTION: return "http://hl7.org/fhir/fhir-types"; 9882 case SUBSCRIPTIONSTATUS: return "http://hl7.org/fhir/fhir-types"; 9883 case SUBSCRIPTIONTOPIC: return "http://hl7.org/fhir/fhir-types"; 9884 case SUBSTANCE: return "http://hl7.org/fhir/fhir-types"; 9885 case SUBSTANCEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 9886 case SUBSTANCENUCLEICACID: return "http://hl7.org/fhir/fhir-types"; 9887 case SUBSTANCEPOLYMER: return "http://hl7.org/fhir/fhir-types"; 9888 case SUBSTANCEPROTEIN: return "http://hl7.org/fhir/fhir-types"; 9889 case SUBSTANCEREFERENCEINFORMATION: return "http://hl7.org/fhir/fhir-types"; 9890 case SUBSTANCESOURCEMATERIAL: return "http://hl7.org/fhir/fhir-types"; 9891 case SUPPLYDELIVERY: return "http://hl7.org/fhir/fhir-types"; 9892 case SUPPLYREQUEST: return "http://hl7.org/fhir/fhir-types"; 9893 case TASK: return "http://hl7.org/fhir/fhir-types"; 9894 case TERMINOLOGYCAPABILITIES: return "http://hl7.org/fhir/fhir-types"; 9895 case TESTPLAN: return "http://hl7.org/fhir/fhir-types"; 9896 case TESTREPORT: return "http://hl7.org/fhir/fhir-types"; 9897 case TESTSCRIPT: return "http://hl7.org/fhir/fhir-types"; 9898 case TRANSPORT: return "http://hl7.org/fhir/fhir-types"; 9899 case VALUESET: return "http://hl7.org/fhir/fhir-types"; 9900 case VERIFICATIONRESULT: return "http://hl7.org/fhir/fhir-types"; 9901 case VISIONPRESCRIPTION: return "http://hl7.org/fhir/fhir-types"; 9902 case PARAMETERS: return "http://hl7.org/fhir/fhir-types"; 9903 case NULL: return null; 9904 default: return "?"; 9905 } 9906 } 9907 public String getDefinition() { 9908 switch (this) { 9909 case BASE: return "Base Type: Base definition for all types defined in FHIR type system."; 9910 case ELEMENT: return "Element Type: Base definition for all elements in a resource."; 9911 case BACKBONEELEMENT: return "BackboneElement Type: Base definition for all elements that are defined inside a resource - but not those in a data type."; 9912 case DATATYPE: return "DataType Type: The base class for all re-useable types defined as part of the FHIR Specification."; 9913 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."; 9914 case ANNOTATION: return "Annotation Type: A text note which also contains information about who made the statement and when."; 9915 case ATTACHMENT: return "Attachment Type: For referring to data content defined in other formats."; 9916 case AVAILABILITY: return "Availability Type: Availability data for an {item}."; 9917 case BACKBONETYPE: return "BackboneType Type: Base definition for the few data types that are allowed to carry modifier extensions."; 9918 case DOSAGE: return "Dosage Type: Indicates how the medication is/was taken or should be taken by the patient."; 9919 case ELEMENTDEFINITION: return "ElementDefinition Type: Captures constraints on each element within the resource, profile, or extension."; 9920 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."; 9921 case PRODUCTSHELFLIFE: return "ProductShelfLife Type: The shelf-life and storage information for a medicinal product item or container can be described using this class."; 9922 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."; 9923 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."; 9924 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)."; 9925 case CODING: return "Coding Type: A reference to a code defined by a terminology system."; 9926 case CONTACTDETAIL: return "ContactDetail Type: Specifies contact information for a person or organization."; 9927 case CONTACTPOINT: return "ContactPoint Type: Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc."; 9928 case CONTRIBUTOR: return "Contributor Type: A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers."; 9929 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."; 9930 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."; 9931 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."; 9932 case EXTENSION: return "Extension Type: Optional Extension Element - found in all resources."; 9933 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."; 9934 case IDENTIFIER: return "Identifier Type: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers."; 9935 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."; 9936 case MONETARYCOMPONENT: return "MonetaryComponent Type: Availability data for an {item}."; 9937 case MONEY: return "Money Type: An amount of economic utility in some recognized currency."; 9938 case NARRATIVE: return "Narrative Type: A human-readable summary of the resource conveying the essential clinical and business information for the resource."; 9939 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."; 9940 case PERIOD: return "Period Type: A time period defined by a start and end date and optionally time."; 9941 case PRIMITIVETYPE: return "PrimitiveType Type: The base type for all re-useable types defined that have a simple property."; 9942 case BASE64BINARY: return "base64Binary Type: A stream of bytes"; 9943 case BOOLEAN: return "boolean Type: Value of \"true\" or \"false\""; 9944 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."; 9945 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."; 9946 case DECIMAL: return "decimal Type: A rational number with implicit precision"; 9947 case INSTANT: return "instant Type: An instant in time - known at least to the second"; 9948 case INTEGER: return "integer Type: A whole number"; 9949 case POSITIVEINT: return "positiveInt type: An integer with a value that is positive (e.g. >0)"; 9950 case UNSIGNEDINT: return "unsignedInt type: An integer with a value that is not negative (e.g. >= 0)"; 9951 case INTEGER64: return "integer64 Type: A very large whole number"; 9952 case STRING: return "string Type: A sequence of Unicode characters"; 9953 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"; 9954 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."; 9955 case MARKDOWN: return "markdown type: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine"; 9956 case TIME: return "time Type: A time during the day, with no date specified"; 9957 case URI: return "uri Type: String of characters used to identify a name or a resource"; 9958 case CANONICAL: return "canonical type: A URI that is a reference to a canonical URL on a FHIR resource"; 9959 case OID: return "oid type: An OID represented as a URI"; 9960 case URL: return "url type: A URI that is a literal reference"; 9961 case UUID: return "uuid type: A UUID, represented as a URI"; 9962 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."; 9963 case AGE: return "Age Type: A duration of time during which an organism (or a process) has existed."; 9964 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."; 9965 case DISTANCE: return "Distance Type: A length - a value with a unit that is a physical distance."; 9966 case DURATION: return "Duration Type: A length of time."; 9967 case RANGE: return "Range Type: A set of ordered Quantities defined by a low and high limit."; 9968 case RATIO: return "Ratio Type: A relationship of two Quantity values - expressed as a numerator and a denominator."; 9969 case RATIORANGE: return "RatioRange Type: A range of ratios expressed as a low and high numerator and a denominator."; 9970 case REFERENCE: return "Reference Type: A reference from one resource to another."; 9971 case RELATEDARTIFACT: return "RelatedArtifact Type: Related artifacts such as additional documentation, justification, or bibliographic references."; 9972 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."; 9973 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."; 9974 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."; 9975 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)."; 9976 case VIRTUALSERVICEDETAIL: return "VirtualServiceDetail Type: Virtual Service Contact Details."; 9977 case XHTML: return "xhtml Type definition"; 9978 case RESOURCE: return "This is the base resource type for everything."; 9979 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."; 9980 case BUNDLE: return "A container for a collection of resources."; 9981 case DOMAINRESOURCE: return "A resource that includes narrative, extensions, and contained resources."; 9982 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."; 9983 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."; 9984 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."; 9985 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)."; 9986 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."; 9987 case ALLERGYINTOLERANCE: return "Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance."; 9988 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)."; 9989 case APPOINTMENTRESPONSE: return "A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection."; 9990 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."; 9991 case AUDITEVENT: return "A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis."; 9992 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."; 9993 case BIOLOGICALLYDERIVEDPRODUCT: return "A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity."; 9994 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "A record of dispensation of a biologically derived product."; 9995 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."; 9996 case CANONICALRESOURCE: return "Common Interface declaration for conformance and knowledge artifact resources."; 9997 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."; 9998 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."; 9999 case CARETEAM: return "The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care."; 10000 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."; 10001 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."; 10002 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."; 10003 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."; 10004 case CLAIMRESPONSE: return "This resource provides the adjudication details from the processing of a Claim resource."; 10005 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."; 10006 case CLINICALUSEDEFINITION: return "A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure."; 10007 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."; 10008 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."; 10009 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."; 10010 case COMPARTMENTDEFINITION: return "A compartment definition that defines how resources are accessed on a server."; 10011 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.)."; 10012 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."; 10013 case CONDITION: return "A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern."; 10014 case CONDITIONDEFINITION: return "A definition of a condition and information relevant to managing it."; 10015 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."; 10016 case CONTRACT: return "Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement."; 10017 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."; 10018 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."; 10019 case COVERAGEELIGIBILITYRESPONSE: return "This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource."; 10020 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."; 10021 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."; 10022 case DEVICEASSOCIATION: return "A record of association of a device."; 10023 case DEVICEDEFINITION: return "This is a specialized resource that defines the characteristics and capabilities of a device."; 10024 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."; 10025 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. "; 10026 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."; 10027 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."; 10028 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."; 10029 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."; 10030 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)."; 10031 case ENCOUNTERHISTORY: return "A record of significant events/milestones key data throughout the history of an Encounter"; 10032 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."; 10033 case ENROLLMENTREQUEST: return "This resource provides the insurance enrollment details to the insurer regarding a specified coverage."; 10034 case ENROLLMENTRESPONSE: return "This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource."; 10035 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."; 10036 case EVENTDEFINITION: return "The EventDefinition resource provides a reusable description of when a particular event can occur."; 10037 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."; 10038 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."; 10039 case EVIDENCEVARIABLE: return "The EvidenceVariable resource describes an element that knowledge (Evidence) is about."; 10040 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."; 10041 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."; 10042 case FAMILYMEMBERHISTORY: return "Significant health conditions for a person related to the patient relevant in the context of care for the patient."; 10043 case FLAG: return "Prospective warnings of potential issues when providing care to the patient."; 10044 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."; 10045 case GENOMICSTUDY: return "A set of analyses performed to analyze and generate genomic data."; 10046 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."; 10047 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."; 10048 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."; 10049 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."; 10050 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."; 10051 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."; 10052 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."; 10053 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."; 10054 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."; 10055 case IMMUNIZATIONRECOMMENDATION: return "A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification."; 10056 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."; 10057 case INGREDIENT: return "An ingredient of a manufactured item or pharmaceutical product."; 10058 case INSURANCEPLAN: return "Details of a Health Insurance product/plan provided by an organization."; 10059 case INVENTORYITEM: return "functional description of an inventory item used in inventory and supply-related workflows."; 10060 case INVENTORYREPORT: return "A report of inventory or stock items."; 10061 case INVOICE: return "Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose."; 10062 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."; 10063 case LINKAGE: return "Identifies two or more records (resource instances) that refer to the same real-world \"occurrence\"."; 10064 case LIST: return "A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc."; 10065 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."; 10066 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."; 10067 case MEASURE: return "The Measure resource provides the definition of a quality measure."; 10068 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."; 10069 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."; 10070 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."; 10071 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."; 10072 case MEDICATIONKNOWLEDGE: return "Information about a medication that is used to support knowledge."; 10073 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."; 10074 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."; 10075 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.)."; 10076 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."; 10077 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."; 10078 case METADATARESOURCE: return "Common Interface declaration for conformance and knowledge artifact resources."; 10079 case MOLECULARSEQUENCE: return "Representation of a molecular sequence."; 10080 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."; 10081 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."; 10082 case NUTRITIONORDER: return "A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident."; 10083 case NUTRITIONPRODUCT: return "A food or supplement that is consumed by patients."; 10084 case OBSERVATION: return "Measurements and simple assertions made about a patient, device or other subject."; 10085 case OBSERVATIONDEFINITION: return "Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service."; 10086 case OPERATIONDEFINITION: return "A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction)."; 10087 case OPERATIONOUTCOME: return "A collection of error, warning, or information messages that result from a system action."; 10088 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."; 10089 case ORGANIZATIONAFFILIATION: return "Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship."; 10090 case PACKAGEDPRODUCTDEFINITION: return "A medically related item or items, in a container or package."; 10091 case PATIENT: return "Demographics and other administrative information about an individual or animal receiving care or other health-related services."; 10092 case PAYMENTNOTICE: return "This resource provides the status of the payment for goods and services rendered, and the request and response resource references."; 10093 case PAYMENTRECONCILIATION: return "This resource provides the details including amount of a payment and allocates the payment items being paid."; 10094 case PERMISSION: return "Permission resource holds access rules for a given data and context."; 10095 case PERSON: return "Demographics and administrative information about a person independent of a specific health-related context."; 10096 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."; 10097 case PRACTITIONER: return "A person who is directly or indirectly involved in the provisioning of healthcare or related services."; 10098 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."; 10099 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."; 10100 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."; 10101 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."; 10102 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."; 10103 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."; 10104 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."; 10105 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\"."; 10106 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."; 10107 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."; 10108 case RESEARCHSUBJECT: return "A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study."; 10109 case RISKASSESSMENT: return "An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome."; 10110 case SCHEDULE: return "A container for slots of time that may be available for booking appointments."; 10111 case SEARCHPARAMETER: return "A search parameter that defines a named search item that can be used to search/filter on a resource."; 10112 case SERVICEREQUEST: return "A record of a request for service such as diagnostic investigations, treatments, or operations to be performed."; 10113 case SLOT: return "A slot of time on a schedule that may be available for booking appointments."; 10114 case SPECIMEN: return "A sample to be used for analysis."; 10115 case SPECIMENDEFINITION: return "A kind of specimen with associated set of requirements."; 10116 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."; 10117 case STRUCTUREMAP: return "A Map of relationships between 2 structures that can be used to transform data."; 10118 case SUBSCRIPTION: return "The subscription resource describes a particular client's request to be notified about a SubscriptionTopic."; 10119 case SUBSCRIPTIONSTATUS: return "The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted."; 10120 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."; 10121 case SUBSTANCE: return "A homogeneous material with a definite composition."; 10122 case SUBSTANCEDEFINITION: return "The detailed description of a substance, typically at a level beyond what is used for prescribing."; 10123 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."; 10124 case SUBSTANCEPOLYMER: return "Properties of a substance specific to it being a polymer."; 10125 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."; 10126 case SUBSTANCEREFERENCEINFORMATION: return "Todo."; 10127 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."; 10128 case SUPPLYDELIVERY: return "Record of delivery of what is supplied."; 10129 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."; 10130 case TASK: return "A task to be performed."; 10131 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."; 10132 case TESTPLAN: return "A plan for executing testing on an artifact or specifications"; 10133 case TESTREPORT: return "A summary of information based on the results of executing a TestScript."; 10134 case TESTSCRIPT: return "A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification."; 10135 case TRANSPORT: return "Record of transport."; 10136 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)."; 10137 case VERIFICATIONRESULT: return "Describes validation requirements, source(s), status and dates for one or more elements."; 10138 case VISIONPRESCRIPTION: return "An authorization for the provision of glasses and/or contact lenses to a patient."; 10139 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."; 10140 case NULL: return null; 10141 default: return "?"; 10142 } 10143 } 10144 public String getDisplay() { 10145 switch (this) { 10146 case BASE: return "Base"; 10147 case ELEMENT: return "Element"; 10148 case BACKBONEELEMENT: return "BackboneElement"; 10149 case DATATYPE: return "DataType"; 10150 case ADDRESS: return "Address"; 10151 case ANNOTATION: return "Annotation"; 10152 case ATTACHMENT: return "Attachment"; 10153 case AVAILABILITY: return "Availability"; 10154 case BACKBONETYPE: return "BackboneType"; 10155 case DOSAGE: return "Dosage"; 10156 case ELEMENTDEFINITION: return "ElementDefinition"; 10157 case MARKETINGSTATUS: return "MarketingStatus"; 10158 case PRODUCTSHELFLIFE: return "ProductShelfLife"; 10159 case TIMING: return "Timing"; 10160 case CODEABLECONCEPT: return "CodeableConcept"; 10161 case CODEABLEREFERENCE: return "CodeableReference"; 10162 case CODING: return "Coding"; 10163 case CONTACTDETAIL: return "ContactDetail"; 10164 case CONTACTPOINT: return "ContactPoint"; 10165 case CONTRIBUTOR: return "Contributor"; 10166 case DATAREQUIREMENT: return "DataRequirement"; 10167 case EXPRESSION: return "Expression"; 10168 case EXTENDEDCONTACTDETAIL: return "ExtendedContactDetail"; 10169 case EXTENSION: return "Extension"; 10170 case HUMANNAME: return "HumanName"; 10171 case IDENTIFIER: return "Identifier"; 10172 case META: return "Meta"; 10173 case MONETARYCOMPONENT: return "MonetaryComponent"; 10174 case MONEY: return "Money"; 10175 case NARRATIVE: return "Narrative"; 10176 case PARAMETERDEFINITION: return "ParameterDefinition"; 10177 case PERIOD: return "Period"; 10178 case PRIMITIVETYPE: return "PrimitiveType"; 10179 case BASE64BINARY: return "base64Binary"; 10180 case BOOLEAN: return "boolean"; 10181 case DATE: return "date"; 10182 case DATETIME: return "dateTime"; 10183 case DECIMAL: return "decimal"; 10184 case INSTANT: return "instant"; 10185 case INTEGER: return "integer"; 10186 case POSITIVEINT: return "positiveInt"; 10187 case UNSIGNEDINT: return "unsignedInt"; 10188 case INTEGER64: return "integer64"; 10189 case STRING: return "string"; 10190 case CODE: return "code"; 10191 case ID: return "id"; 10192 case MARKDOWN: return "markdown"; 10193 case TIME: return "time"; 10194 case URI: return "uri"; 10195 case CANONICAL: return "canonical"; 10196 case OID: return "oid"; 10197 case URL: return "url"; 10198 case UUID: return "uuid"; 10199 case QUANTITY: return "Quantity"; 10200 case AGE: return "Age"; 10201 case COUNT: return "Count"; 10202 case DISTANCE: return "Distance"; 10203 case DURATION: return "Duration"; 10204 case RANGE: return "Range"; 10205 case RATIO: return "Ratio"; 10206 case RATIORANGE: return "RatioRange"; 10207 case REFERENCE: return "Reference"; 10208 case RELATEDARTIFACT: return "RelatedArtifact"; 10209 case SAMPLEDDATA: return "SampledData"; 10210 case SIGNATURE: return "Signature"; 10211 case TRIGGERDEFINITION: return "TriggerDefinition"; 10212 case USAGECONTEXT: return "UsageContext"; 10213 case VIRTUALSERVICEDETAIL: return "VirtualServiceDetail"; 10214 case XHTML: return "xhtml"; 10215 case RESOURCE: return "Resource"; 10216 case BINARY: return "Binary"; 10217 case BUNDLE: return "Bundle"; 10218 case DOMAINRESOURCE: return "DomainResource"; 10219 case ACCOUNT: return "Account"; 10220 case ACTIVITYDEFINITION: return "ActivityDefinition"; 10221 case ACTORDEFINITION: return "ActorDefinition"; 10222 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 10223 case ADVERSEEVENT: return "AdverseEvent"; 10224 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 10225 case APPOINTMENT: return "Appointment"; 10226 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 10227 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 10228 case AUDITEVENT: return "AuditEvent"; 10229 case BASIC: return "Basic"; 10230 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 10231 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "BiologicallyDerivedProductDispense"; 10232 case BODYSTRUCTURE: return "BodyStructure"; 10233 case CANONICALRESOURCE: return "CanonicalResource"; 10234 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 10235 case CAREPLAN: return "CarePlan"; 10236 case CARETEAM: return "CareTeam"; 10237 case CHARGEITEM: return "ChargeItem"; 10238 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 10239 case CITATION: return "Citation"; 10240 case CLAIM: return "Claim"; 10241 case CLAIMRESPONSE: return "ClaimResponse"; 10242 case CLINICALIMPRESSION: return "ClinicalImpression"; 10243 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 10244 case CODESYSTEM: return "CodeSystem"; 10245 case COMMUNICATION: return "Communication"; 10246 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 10247 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 10248 case COMPOSITION: return "Composition"; 10249 case CONCEPTMAP: return "ConceptMap"; 10250 case CONDITION: return "Condition"; 10251 case CONDITIONDEFINITION: return "ConditionDefinition"; 10252 case CONSENT: return "Consent"; 10253 case CONTRACT: return "Contract"; 10254 case COVERAGE: return "Coverage"; 10255 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 10256 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 10257 case DETECTEDISSUE: return "DetectedIssue"; 10258 case DEVICE: return "Device"; 10259 case DEVICEASSOCIATION: return "DeviceAssociation"; 10260 case DEVICEDEFINITION: return "DeviceDefinition"; 10261 case DEVICEDISPENSE: return "DeviceDispense"; 10262 case DEVICEMETRIC: return "DeviceMetric"; 10263 case DEVICEREQUEST: return "DeviceRequest"; 10264 case DEVICEUSAGE: return "DeviceUsage"; 10265 case DIAGNOSTICREPORT: return "DiagnosticReport"; 10266 case DOCUMENTREFERENCE: return "DocumentReference"; 10267 case ENCOUNTER: return "Encounter"; 10268 case ENCOUNTERHISTORY: return "EncounterHistory"; 10269 case ENDPOINT: return "Endpoint"; 10270 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 10271 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 10272 case EPISODEOFCARE: return "EpisodeOfCare"; 10273 case EVENTDEFINITION: return "EventDefinition"; 10274 case EVIDENCE: return "Evidence"; 10275 case EVIDENCEREPORT: return "EvidenceReport"; 10276 case EVIDENCEVARIABLE: return "EvidenceVariable"; 10277 case EXAMPLESCENARIO: return "ExampleScenario"; 10278 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 10279 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 10280 case FLAG: return "Flag"; 10281 case FORMULARYITEM: return "FormularyItem"; 10282 case GENOMICSTUDY: return "GenomicStudy"; 10283 case GOAL: return "Goal"; 10284 case GRAPHDEFINITION: return "GraphDefinition"; 10285 case GROUP: return "Group"; 10286 case GUIDANCERESPONSE: return "GuidanceResponse"; 10287 case HEALTHCARESERVICE: return "HealthcareService"; 10288 case IMAGINGSELECTION: return "ImagingSelection"; 10289 case IMAGINGSTUDY: return "ImagingStudy"; 10290 case IMMUNIZATION: return "Immunization"; 10291 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 10292 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 10293 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 10294 case INGREDIENT: return "Ingredient"; 10295 case INSURANCEPLAN: return "InsurancePlan"; 10296 case INVENTORYITEM: return "InventoryItem"; 10297 case INVENTORYREPORT: return "InventoryReport"; 10298 case INVOICE: return "Invoice"; 10299 case LIBRARY: return "Library"; 10300 case LINKAGE: return "Linkage"; 10301 case LIST: return "List"; 10302 case LOCATION: return "Location"; 10303 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 10304 case MEASURE: return "Measure"; 10305 case MEASUREREPORT: return "MeasureReport"; 10306 case MEDICATION: return "Medication"; 10307 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 10308 case MEDICATIONDISPENSE: return "MedicationDispense"; 10309 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 10310 case MEDICATIONREQUEST: return "MedicationRequest"; 10311 case MEDICATIONSTATEMENT: return "MedicationStatement"; 10312 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 10313 case MESSAGEDEFINITION: return "MessageDefinition"; 10314 case MESSAGEHEADER: return "MessageHeader"; 10315 case METADATARESOURCE: return "MetadataResource"; 10316 case MOLECULARSEQUENCE: return "MolecularSequence"; 10317 case NAMINGSYSTEM: return "NamingSystem"; 10318 case NUTRITIONINTAKE: return "NutritionIntake"; 10319 case NUTRITIONORDER: return "NutritionOrder"; 10320 case NUTRITIONPRODUCT: return "NutritionProduct"; 10321 case OBSERVATION: return "Observation"; 10322 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 10323 case OPERATIONDEFINITION: return "OperationDefinition"; 10324 case OPERATIONOUTCOME: return "OperationOutcome"; 10325 case ORGANIZATION: return "Organization"; 10326 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 10327 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 10328 case PATIENT: return "Patient"; 10329 case PAYMENTNOTICE: return "PaymentNotice"; 10330 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 10331 case PERMISSION: return "Permission"; 10332 case PERSON: return "Person"; 10333 case PLANDEFINITION: return "PlanDefinition"; 10334 case PRACTITIONER: return "Practitioner"; 10335 case PRACTITIONERROLE: return "PractitionerRole"; 10336 case PROCEDURE: return "Procedure"; 10337 case PROVENANCE: return "Provenance"; 10338 case QUESTIONNAIRE: return "Questionnaire"; 10339 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 10340 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 10341 case RELATEDPERSON: return "RelatedPerson"; 10342 case REQUESTORCHESTRATION: return "RequestOrchestration"; 10343 case REQUIREMENTS: return "Requirements"; 10344 case RESEARCHSTUDY: return "ResearchStudy"; 10345 case RESEARCHSUBJECT: return "ResearchSubject"; 10346 case RISKASSESSMENT: return "RiskAssessment"; 10347 case SCHEDULE: return "Schedule"; 10348 case SEARCHPARAMETER: return "SearchParameter"; 10349 case SERVICEREQUEST: return "ServiceRequest"; 10350 case SLOT: return "Slot"; 10351 case SPECIMEN: return "Specimen"; 10352 case SPECIMENDEFINITION: return "SpecimenDefinition"; 10353 case STRUCTUREDEFINITION: return "StructureDefinition"; 10354 case STRUCTUREMAP: return "StructureMap"; 10355 case SUBSCRIPTION: return "Subscription"; 10356 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 10357 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 10358 case SUBSTANCE: return "Substance"; 10359 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 10360 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 10361 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 10362 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 10363 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 10364 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 10365 case SUPPLYDELIVERY: return "SupplyDelivery"; 10366 case SUPPLYREQUEST: return "SupplyRequest"; 10367 case TASK: return "Task"; 10368 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 10369 case TESTPLAN: return "TestPlan"; 10370 case TESTREPORT: return "TestReport"; 10371 case TESTSCRIPT: return "TestScript"; 10372 case TRANSPORT: return "Transport"; 10373 case VALUESET: return "ValueSet"; 10374 case VERIFICATIONRESULT: return "VerificationResult"; 10375 case VISIONPRESCRIPTION: return "VisionPrescription"; 10376 case PARAMETERS: return "Parameters"; 10377 case NULL: return null; 10378 default: return "?"; 10379 } 10380 } 10381 } 10382 10383 public static class FHIRTypesEnumFactory implements EnumFactory<FHIRTypes> { 10384 public FHIRTypes fromCode(String codeString) throws IllegalArgumentException { 10385 if (codeString == null || "".equals(codeString)) 10386 if (codeString == null || "".equals(codeString)) 10387 return null; 10388 if ("Base".equals(codeString)) 10389 return FHIRTypes.BASE; 10390 if ("Element".equals(codeString)) 10391 return FHIRTypes.ELEMENT; 10392 if ("BackboneElement".equals(codeString)) 10393 return FHIRTypes.BACKBONEELEMENT; 10394 if ("DataType".equals(codeString)) 10395 return FHIRTypes.DATATYPE; 10396 if ("Address".equals(codeString)) 10397 return FHIRTypes.ADDRESS; 10398 if ("Annotation".equals(codeString)) 10399 return FHIRTypes.ANNOTATION; 10400 if ("Attachment".equals(codeString)) 10401 return FHIRTypes.ATTACHMENT; 10402 if ("Availability".equals(codeString)) 10403 return FHIRTypes.AVAILABILITY; 10404 if ("BackboneType".equals(codeString)) 10405 return FHIRTypes.BACKBONETYPE; 10406 if ("Dosage".equals(codeString)) 10407 return FHIRTypes.DOSAGE; 10408 if ("ElementDefinition".equals(codeString)) 10409 return FHIRTypes.ELEMENTDEFINITION; 10410 if ("MarketingStatus".equals(codeString)) 10411 return FHIRTypes.MARKETINGSTATUS; 10412 if ("ProductShelfLife".equals(codeString)) 10413 return FHIRTypes.PRODUCTSHELFLIFE; 10414 if ("Timing".equals(codeString)) 10415 return FHIRTypes.TIMING; 10416 if ("CodeableConcept".equals(codeString)) 10417 return FHIRTypes.CODEABLECONCEPT; 10418 if ("CodeableReference".equals(codeString)) 10419 return FHIRTypes.CODEABLEREFERENCE; 10420 if ("Coding".equals(codeString)) 10421 return FHIRTypes.CODING; 10422 if ("ContactDetail".equals(codeString)) 10423 return FHIRTypes.CONTACTDETAIL; 10424 if ("ContactPoint".equals(codeString)) 10425 return FHIRTypes.CONTACTPOINT; 10426 if ("Contributor".equals(codeString)) 10427 return FHIRTypes.CONTRIBUTOR; 10428 if ("DataRequirement".equals(codeString)) 10429 return FHIRTypes.DATAREQUIREMENT; 10430 if ("Expression".equals(codeString)) 10431 return FHIRTypes.EXPRESSION; 10432 if ("ExtendedContactDetail".equals(codeString)) 10433 return FHIRTypes.EXTENDEDCONTACTDETAIL; 10434 if ("Extension".equals(codeString)) 10435 return FHIRTypes.EXTENSION; 10436 if ("HumanName".equals(codeString)) 10437 return FHIRTypes.HUMANNAME; 10438 if ("Identifier".equals(codeString)) 10439 return FHIRTypes.IDENTIFIER; 10440 if ("Meta".equals(codeString)) 10441 return FHIRTypes.META; 10442 if ("MonetaryComponent".equals(codeString)) 10443 return FHIRTypes.MONETARYCOMPONENT; 10444 if ("Money".equals(codeString)) 10445 return FHIRTypes.MONEY; 10446 if ("Narrative".equals(codeString)) 10447 return FHIRTypes.NARRATIVE; 10448 if ("ParameterDefinition".equals(codeString)) 10449 return FHIRTypes.PARAMETERDEFINITION; 10450 if ("Period".equals(codeString)) 10451 return FHIRTypes.PERIOD; 10452 if ("PrimitiveType".equals(codeString)) 10453 return FHIRTypes.PRIMITIVETYPE; 10454 if ("base64Binary".equals(codeString)) 10455 return FHIRTypes.BASE64BINARY; 10456 if ("boolean".equals(codeString)) 10457 return FHIRTypes.BOOLEAN; 10458 if ("date".equals(codeString)) 10459 return FHIRTypes.DATE; 10460 if ("dateTime".equals(codeString)) 10461 return FHIRTypes.DATETIME; 10462 if ("decimal".equals(codeString)) 10463 return FHIRTypes.DECIMAL; 10464 if ("instant".equals(codeString)) 10465 return FHIRTypes.INSTANT; 10466 if ("integer".equals(codeString)) 10467 return FHIRTypes.INTEGER; 10468 if ("positiveInt".equals(codeString)) 10469 return FHIRTypes.POSITIVEINT; 10470 if ("unsignedInt".equals(codeString)) 10471 return FHIRTypes.UNSIGNEDINT; 10472 if ("integer64".equals(codeString)) 10473 return FHIRTypes.INTEGER64; 10474 if ("string".equals(codeString)) 10475 return FHIRTypes.STRING; 10476 if ("code".equals(codeString)) 10477 return FHIRTypes.CODE; 10478 if ("id".equals(codeString)) 10479 return FHIRTypes.ID; 10480 if ("markdown".equals(codeString)) 10481 return FHIRTypes.MARKDOWN; 10482 if ("time".equals(codeString)) 10483 return FHIRTypes.TIME; 10484 if ("uri".equals(codeString)) 10485 return FHIRTypes.URI; 10486 if ("canonical".equals(codeString)) 10487 return FHIRTypes.CANONICAL; 10488 if ("oid".equals(codeString)) 10489 return FHIRTypes.OID; 10490 if ("url".equals(codeString)) 10491 return FHIRTypes.URL; 10492 if ("uuid".equals(codeString)) 10493 return FHIRTypes.UUID; 10494 if ("Quantity".equals(codeString)) 10495 return FHIRTypes.QUANTITY; 10496 if ("Age".equals(codeString)) 10497 return FHIRTypes.AGE; 10498 if ("Count".equals(codeString)) 10499 return FHIRTypes.COUNT; 10500 if ("Distance".equals(codeString)) 10501 return FHIRTypes.DISTANCE; 10502 if ("Duration".equals(codeString)) 10503 return FHIRTypes.DURATION; 10504 if ("Range".equals(codeString)) 10505 return FHIRTypes.RANGE; 10506 if ("Ratio".equals(codeString)) 10507 return FHIRTypes.RATIO; 10508 if ("RatioRange".equals(codeString)) 10509 return FHIRTypes.RATIORANGE; 10510 if ("Reference".equals(codeString)) 10511 return FHIRTypes.REFERENCE; 10512 if ("RelatedArtifact".equals(codeString)) 10513 return FHIRTypes.RELATEDARTIFACT; 10514 if ("SampledData".equals(codeString)) 10515 return FHIRTypes.SAMPLEDDATA; 10516 if ("Signature".equals(codeString)) 10517 return FHIRTypes.SIGNATURE; 10518 if ("TriggerDefinition".equals(codeString)) 10519 return FHIRTypes.TRIGGERDEFINITION; 10520 if ("UsageContext".equals(codeString)) 10521 return FHIRTypes.USAGECONTEXT; 10522 if ("VirtualServiceDetail".equals(codeString)) 10523 return FHIRTypes.VIRTUALSERVICEDETAIL; 10524 if ("xhtml".equals(codeString)) 10525 return FHIRTypes.XHTML; 10526 if ("Resource".equals(codeString)) 10527 return FHIRTypes.RESOURCE; 10528 if ("Binary".equals(codeString)) 10529 return FHIRTypes.BINARY; 10530 if ("Bundle".equals(codeString)) 10531 return FHIRTypes.BUNDLE; 10532 if ("DomainResource".equals(codeString)) 10533 return FHIRTypes.DOMAINRESOURCE; 10534 if ("Account".equals(codeString)) 10535 return FHIRTypes.ACCOUNT; 10536 if ("ActivityDefinition".equals(codeString)) 10537 return FHIRTypes.ACTIVITYDEFINITION; 10538 if ("ActorDefinition".equals(codeString)) 10539 return FHIRTypes.ACTORDEFINITION; 10540 if ("AdministrableProductDefinition".equals(codeString)) 10541 return FHIRTypes.ADMINISTRABLEPRODUCTDEFINITION; 10542 if ("AdverseEvent".equals(codeString)) 10543 return FHIRTypes.ADVERSEEVENT; 10544 if ("AllergyIntolerance".equals(codeString)) 10545 return FHIRTypes.ALLERGYINTOLERANCE; 10546 if ("Appointment".equals(codeString)) 10547 return FHIRTypes.APPOINTMENT; 10548 if ("AppointmentResponse".equals(codeString)) 10549 return FHIRTypes.APPOINTMENTRESPONSE; 10550 if ("ArtifactAssessment".equals(codeString)) 10551 return FHIRTypes.ARTIFACTASSESSMENT; 10552 if ("AuditEvent".equals(codeString)) 10553 return FHIRTypes.AUDITEVENT; 10554 if ("Basic".equals(codeString)) 10555 return FHIRTypes.BASIC; 10556 if ("BiologicallyDerivedProduct".equals(codeString)) 10557 return FHIRTypes.BIOLOGICALLYDERIVEDPRODUCT; 10558 if ("BiologicallyDerivedProductDispense".equals(codeString)) 10559 return FHIRTypes.BIOLOGICALLYDERIVEDPRODUCTDISPENSE; 10560 if ("BodyStructure".equals(codeString)) 10561 return FHIRTypes.BODYSTRUCTURE; 10562 if ("CanonicalResource".equals(codeString)) 10563 return FHIRTypes.CANONICALRESOURCE; 10564 if ("CapabilityStatement".equals(codeString)) 10565 return FHIRTypes.CAPABILITYSTATEMENT; 10566 if ("CarePlan".equals(codeString)) 10567 return FHIRTypes.CAREPLAN; 10568 if ("CareTeam".equals(codeString)) 10569 return FHIRTypes.CARETEAM; 10570 if ("ChargeItem".equals(codeString)) 10571 return FHIRTypes.CHARGEITEM; 10572 if ("ChargeItemDefinition".equals(codeString)) 10573 return FHIRTypes.CHARGEITEMDEFINITION; 10574 if ("Citation".equals(codeString)) 10575 return FHIRTypes.CITATION; 10576 if ("Claim".equals(codeString)) 10577 return FHIRTypes.CLAIM; 10578 if ("ClaimResponse".equals(codeString)) 10579 return FHIRTypes.CLAIMRESPONSE; 10580 if ("ClinicalImpression".equals(codeString)) 10581 return FHIRTypes.CLINICALIMPRESSION; 10582 if ("ClinicalUseDefinition".equals(codeString)) 10583 return FHIRTypes.CLINICALUSEDEFINITION; 10584 if ("CodeSystem".equals(codeString)) 10585 return FHIRTypes.CODESYSTEM; 10586 if ("Communication".equals(codeString)) 10587 return FHIRTypes.COMMUNICATION; 10588 if ("CommunicationRequest".equals(codeString)) 10589 return FHIRTypes.COMMUNICATIONREQUEST; 10590 if ("CompartmentDefinition".equals(codeString)) 10591 return FHIRTypes.COMPARTMENTDEFINITION; 10592 if ("Composition".equals(codeString)) 10593 return FHIRTypes.COMPOSITION; 10594 if ("ConceptMap".equals(codeString)) 10595 return FHIRTypes.CONCEPTMAP; 10596 if ("Condition".equals(codeString)) 10597 return FHIRTypes.CONDITION; 10598 if ("ConditionDefinition".equals(codeString)) 10599 return FHIRTypes.CONDITIONDEFINITION; 10600 if ("Consent".equals(codeString)) 10601 return FHIRTypes.CONSENT; 10602 if ("Contract".equals(codeString)) 10603 return FHIRTypes.CONTRACT; 10604 if ("Coverage".equals(codeString)) 10605 return FHIRTypes.COVERAGE; 10606 if ("CoverageEligibilityRequest".equals(codeString)) 10607 return FHIRTypes.COVERAGEELIGIBILITYREQUEST; 10608 if ("CoverageEligibilityResponse".equals(codeString)) 10609 return FHIRTypes.COVERAGEELIGIBILITYRESPONSE; 10610 if ("DetectedIssue".equals(codeString)) 10611 return FHIRTypes.DETECTEDISSUE; 10612 if ("Device".equals(codeString)) 10613 return FHIRTypes.DEVICE; 10614 if ("DeviceAssociation".equals(codeString)) 10615 return FHIRTypes.DEVICEASSOCIATION; 10616 if ("DeviceDefinition".equals(codeString)) 10617 return FHIRTypes.DEVICEDEFINITION; 10618 if ("DeviceDispense".equals(codeString)) 10619 return FHIRTypes.DEVICEDISPENSE; 10620 if ("DeviceMetric".equals(codeString)) 10621 return FHIRTypes.DEVICEMETRIC; 10622 if ("DeviceRequest".equals(codeString)) 10623 return FHIRTypes.DEVICEREQUEST; 10624 if ("DeviceUsage".equals(codeString)) 10625 return FHIRTypes.DEVICEUSAGE; 10626 if ("DiagnosticReport".equals(codeString)) 10627 return FHIRTypes.DIAGNOSTICREPORT; 10628 if ("DocumentReference".equals(codeString)) 10629 return FHIRTypes.DOCUMENTREFERENCE; 10630 if ("Encounter".equals(codeString)) 10631 return FHIRTypes.ENCOUNTER; 10632 if ("EncounterHistory".equals(codeString)) 10633 return FHIRTypes.ENCOUNTERHISTORY; 10634 if ("Endpoint".equals(codeString)) 10635 return FHIRTypes.ENDPOINT; 10636 if ("EnrollmentRequest".equals(codeString)) 10637 return FHIRTypes.ENROLLMENTREQUEST; 10638 if ("EnrollmentResponse".equals(codeString)) 10639 return FHIRTypes.ENROLLMENTRESPONSE; 10640 if ("EpisodeOfCare".equals(codeString)) 10641 return FHIRTypes.EPISODEOFCARE; 10642 if ("EventDefinition".equals(codeString)) 10643 return FHIRTypes.EVENTDEFINITION; 10644 if ("Evidence".equals(codeString)) 10645 return FHIRTypes.EVIDENCE; 10646 if ("EvidenceReport".equals(codeString)) 10647 return FHIRTypes.EVIDENCEREPORT; 10648 if ("EvidenceVariable".equals(codeString)) 10649 return FHIRTypes.EVIDENCEVARIABLE; 10650 if ("ExampleScenario".equals(codeString)) 10651 return FHIRTypes.EXAMPLESCENARIO; 10652 if ("ExplanationOfBenefit".equals(codeString)) 10653 return FHIRTypes.EXPLANATIONOFBENEFIT; 10654 if ("FamilyMemberHistory".equals(codeString)) 10655 return FHIRTypes.FAMILYMEMBERHISTORY; 10656 if ("Flag".equals(codeString)) 10657 return FHIRTypes.FLAG; 10658 if ("FormularyItem".equals(codeString)) 10659 return FHIRTypes.FORMULARYITEM; 10660 if ("GenomicStudy".equals(codeString)) 10661 return FHIRTypes.GENOMICSTUDY; 10662 if ("Goal".equals(codeString)) 10663 return FHIRTypes.GOAL; 10664 if ("GraphDefinition".equals(codeString)) 10665 return FHIRTypes.GRAPHDEFINITION; 10666 if ("Group".equals(codeString)) 10667 return FHIRTypes.GROUP; 10668 if ("GuidanceResponse".equals(codeString)) 10669 return FHIRTypes.GUIDANCERESPONSE; 10670 if ("HealthcareService".equals(codeString)) 10671 return FHIRTypes.HEALTHCARESERVICE; 10672 if ("ImagingSelection".equals(codeString)) 10673 return FHIRTypes.IMAGINGSELECTION; 10674 if ("ImagingStudy".equals(codeString)) 10675 return FHIRTypes.IMAGINGSTUDY; 10676 if ("Immunization".equals(codeString)) 10677 return FHIRTypes.IMMUNIZATION; 10678 if ("ImmunizationEvaluation".equals(codeString)) 10679 return FHIRTypes.IMMUNIZATIONEVALUATION; 10680 if ("ImmunizationRecommendation".equals(codeString)) 10681 return FHIRTypes.IMMUNIZATIONRECOMMENDATION; 10682 if ("ImplementationGuide".equals(codeString)) 10683 return FHIRTypes.IMPLEMENTATIONGUIDE; 10684 if ("Ingredient".equals(codeString)) 10685 return FHIRTypes.INGREDIENT; 10686 if ("InsurancePlan".equals(codeString)) 10687 return FHIRTypes.INSURANCEPLAN; 10688 if ("InventoryItem".equals(codeString)) 10689 return FHIRTypes.INVENTORYITEM; 10690 if ("InventoryReport".equals(codeString)) 10691 return FHIRTypes.INVENTORYREPORT; 10692 if ("Invoice".equals(codeString)) 10693 return FHIRTypes.INVOICE; 10694 if ("Library".equals(codeString)) 10695 return FHIRTypes.LIBRARY; 10696 if ("Linkage".equals(codeString)) 10697 return FHIRTypes.LINKAGE; 10698 if ("List".equals(codeString)) 10699 return FHIRTypes.LIST; 10700 if ("Location".equals(codeString)) 10701 return FHIRTypes.LOCATION; 10702 if ("ManufacturedItemDefinition".equals(codeString)) 10703 return FHIRTypes.MANUFACTUREDITEMDEFINITION; 10704 if ("Measure".equals(codeString)) 10705 return FHIRTypes.MEASURE; 10706 if ("MeasureReport".equals(codeString)) 10707 return FHIRTypes.MEASUREREPORT; 10708 if ("Medication".equals(codeString)) 10709 return FHIRTypes.MEDICATION; 10710 if ("MedicationAdministration".equals(codeString)) 10711 return FHIRTypes.MEDICATIONADMINISTRATION; 10712 if ("MedicationDispense".equals(codeString)) 10713 return FHIRTypes.MEDICATIONDISPENSE; 10714 if ("MedicationKnowledge".equals(codeString)) 10715 return FHIRTypes.MEDICATIONKNOWLEDGE; 10716 if ("MedicationRequest".equals(codeString)) 10717 return FHIRTypes.MEDICATIONREQUEST; 10718 if ("MedicationStatement".equals(codeString)) 10719 return FHIRTypes.MEDICATIONSTATEMENT; 10720 if ("MedicinalProductDefinition".equals(codeString)) 10721 return FHIRTypes.MEDICINALPRODUCTDEFINITION; 10722 if ("MessageDefinition".equals(codeString)) 10723 return FHIRTypes.MESSAGEDEFINITION; 10724 if ("MessageHeader".equals(codeString)) 10725 return FHIRTypes.MESSAGEHEADER; 10726 if ("MetadataResource".equals(codeString)) 10727 return FHIRTypes.METADATARESOURCE; 10728 if ("MolecularSequence".equals(codeString)) 10729 return FHIRTypes.MOLECULARSEQUENCE; 10730 if ("NamingSystem".equals(codeString)) 10731 return FHIRTypes.NAMINGSYSTEM; 10732 if ("NutritionIntake".equals(codeString)) 10733 return FHIRTypes.NUTRITIONINTAKE; 10734 if ("NutritionOrder".equals(codeString)) 10735 return FHIRTypes.NUTRITIONORDER; 10736 if ("NutritionProduct".equals(codeString)) 10737 return FHIRTypes.NUTRITIONPRODUCT; 10738 if ("Observation".equals(codeString)) 10739 return FHIRTypes.OBSERVATION; 10740 if ("ObservationDefinition".equals(codeString)) 10741 return FHIRTypes.OBSERVATIONDEFINITION; 10742 if ("OperationDefinition".equals(codeString)) 10743 return FHIRTypes.OPERATIONDEFINITION; 10744 if ("OperationOutcome".equals(codeString)) 10745 return FHIRTypes.OPERATIONOUTCOME; 10746 if ("Organization".equals(codeString)) 10747 return FHIRTypes.ORGANIZATION; 10748 if ("OrganizationAffiliation".equals(codeString)) 10749 return FHIRTypes.ORGANIZATIONAFFILIATION; 10750 if ("PackagedProductDefinition".equals(codeString)) 10751 return FHIRTypes.PACKAGEDPRODUCTDEFINITION; 10752 if ("Patient".equals(codeString)) 10753 return FHIRTypes.PATIENT; 10754 if ("PaymentNotice".equals(codeString)) 10755 return FHIRTypes.PAYMENTNOTICE; 10756 if ("PaymentReconciliation".equals(codeString)) 10757 return FHIRTypes.PAYMENTRECONCILIATION; 10758 if ("Permission".equals(codeString)) 10759 return FHIRTypes.PERMISSION; 10760 if ("Person".equals(codeString)) 10761 return FHIRTypes.PERSON; 10762 if ("PlanDefinition".equals(codeString)) 10763 return FHIRTypes.PLANDEFINITION; 10764 if ("Practitioner".equals(codeString)) 10765 return FHIRTypes.PRACTITIONER; 10766 if ("PractitionerRole".equals(codeString)) 10767 return FHIRTypes.PRACTITIONERROLE; 10768 if ("Procedure".equals(codeString)) 10769 return FHIRTypes.PROCEDURE; 10770 if ("Provenance".equals(codeString)) 10771 return FHIRTypes.PROVENANCE; 10772 if ("Questionnaire".equals(codeString)) 10773 return FHIRTypes.QUESTIONNAIRE; 10774 if ("QuestionnaireResponse".equals(codeString)) 10775 return FHIRTypes.QUESTIONNAIRERESPONSE; 10776 if ("RegulatedAuthorization".equals(codeString)) 10777 return FHIRTypes.REGULATEDAUTHORIZATION; 10778 if ("RelatedPerson".equals(codeString)) 10779 return FHIRTypes.RELATEDPERSON; 10780 if ("RequestOrchestration".equals(codeString)) 10781 return FHIRTypes.REQUESTORCHESTRATION; 10782 if ("Requirements".equals(codeString)) 10783 return FHIRTypes.REQUIREMENTS; 10784 if ("ResearchStudy".equals(codeString)) 10785 return FHIRTypes.RESEARCHSTUDY; 10786 if ("ResearchSubject".equals(codeString)) 10787 return FHIRTypes.RESEARCHSUBJECT; 10788 if ("RiskAssessment".equals(codeString)) 10789 return FHIRTypes.RISKASSESSMENT; 10790 if ("Schedule".equals(codeString)) 10791 return FHIRTypes.SCHEDULE; 10792 if ("SearchParameter".equals(codeString)) 10793 return FHIRTypes.SEARCHPARAMETER; 10794 if ("ServiceRequest".equals(codeString)) 10795 return FHIRTypes.SERVICEREQUEST; 10796 if ("Slot".equals(codeString)) 10797 return FHIRTypes.SLOT; 10798 if ("Specimen".equals(codeString)) 10799 return FHIRTypes.SPECIMEN; 10800 if ("SpecimenDefinition".equals(codeString)) 10801 return FHIRTypes.SPECIMENDEFINITION; 10802 if ("StructureDefinition".equals(codeString)) 10803 return FHIRTypes.STRUCTUREDEFINITION; 10804 if ("StructureMap".equals(codeString)) 10805 return FHIRTypes.STRUCTUREMAP; 10806 if ("Subscription".equals(codeString)) 10807 return FHIRTypes.SUBSCRIPTION; 10808 if ("SubscriptionStatus".equals(codeString)) 10809 return FHIRTypes.SUBSCRIPTIONSTATUS; 10810 if ("SubscriptionTopic".equals(codeString)) 10811 return FHIRTypes.SUBSCRIPTIONTOPIC; 10812 if ("Substance".equals(codeString)) 10813 return FHIRTypes.SUBSTANCE; 10814 if ("SubstanceDefinition".equals(codeString)) 10815 return FHIRTypes.SUBSTANCEDEFINITION; 10816 if ("SubstanceNucleicAcid".equals(codeString)) 10817 return FHIRTypes.SUBSTANCENUCLEICACID; 10818 if ("SubstancePolymer".equals(codeString)) 10819 return FHIRTypes.SUBSTANCEPOLYMER; 10820 if ("SubstanceProtein".equals(codeString)) 10821 return FHIRTypes.SUBSTANCEPROTEIN; 10822 if ("SubstanceReferenceInformation".equals(codeString)) 10823 return FHIRTypes.SUBSTANCEREFERENCEINFORMATION; 10824 if ("SubstanceSourceMaterial".equals(codeString)) 10825 return FHIRTypes.SUBSTANCESOURCEMATERIAL; 10826 if ("SupplyDelivery".equals(codeString)) 10827 return FHIRTypes.SUPPLYDELIVERY; 10828 if ("SupplyRequest".equals(codeString)) 10829 return FHIRTypes.SUPPLYREQUEST; 10830 if ("Task".equals(codeString)) 10831 return FHIRTypes.TASK; 10832 if ("TerminologyCapabilities".equals(codeString)) 10833 return FHIRTypes.TERMINOLOGYCAPABILITIES; 10834 if ("TestPlan".equals(codeString)) 10835 return FHIRTypes.TESTPLAN; 10836 if ("TestReport".equals(codeString)) 10837 return FHIRTypes.TESTREPORT; 10838 if ("TestScript".equals(codeString)) 10839 return FHIRTypes.TESTSCRIPT; 10840 if ("Transport".equals(codeString)) 10841 return FHIRTypes.TRANSPORT; 10842 if ("ValueSet".equals(codeString)) 10843 return FHIRTypes.VALUESET; 10844 if ("VerificationResult".equals(codeString)) 10845 return FHIRTypes.VERIFICATIONRESULT; 10846 if ("VisionPrescription".equals(codeString)) 10847 return FHIRTypes.VISIONPRESCRIPTION; 10848 if ("Parameters".equals(codeString)) 10849 return FHIRTypes.PARAMETERS; 10850 throw new IllegalArgumentException("Unknown FHIRTypes code '"+codeString+"'"); 10851 } 10852 10853 public Enumeration<FHIRTypes> fromType(PrimitiveType<?> code) throws FHIRException { 10854 if (code == null) 10855 return null; 10856 if (code.isEmpty()) 10857 return new Enumeration<FHIRTypes>(this, FHIRTypes.NULL, code); 10858 String codeString = ((PrimitiveType) code).asStringValue(); 10859 if (codeString == null || "".equals(codeString)) 10860 return new Enumeration<FHIRTypes>(this, FHIRTypes.NULL, code); 10861 if ("Base".equals(codeString)) 10862 return new Enumeration<FHIRTypes>(this, FHIRTypes.BASE, code); 10863 if ("Element".equals(codeString)) 10864 return new Enumeration<FHIRTypes>(this, FHIRTypes.ELEMENT, code); 10865 if ("BackboneElement".equals(codeString)) 10866 return new Enumeration<FHIRTypes>(this, FHIRTypes.BACKBONEELEMENT, code); 10867 if ("DataType".equals(codeString)) 10868 return new Enumeration<FHIRTypes>(this, FHIRTypes.DATATYPE, code); 10869 if ("Address".equals(codeString)) 10870 return new Enumeration<FHIRTypes>(this, FHIRTypes.ADDRESS, code); 10871 if ("Annotation".equals(codeString)) 10872 return new Enumeration<FHIRTypes>(this, FHIRTypes.ANNOTATION, code); 10873 if ("Attachment".equals(codeString)) 10874 return new Enumeration<FHIRTypes>(this, FHIRTypes.ATTACHMENT, code); 10875 if ("Availability".equals(codeString)) 10876 return new Enumeration<FHIRTypes>(this, FHIRTypes.AVAILABILITY, code); 10877 if ("BackboneType".equals(codeString)) 10878 return new Enumeration<FHIRTypes>(this, FHIRTypes.BACKBONETYPE, code); 10879 if ("Dosage".equals(codeString)) 10880 return new Enumeration<FHIRTypes>(this, FHIRTypes.DOSAGE, code); 10881 if ("ElementDefinition".equals(codeString)) 10882 return new Enumeration<FHIRTypes>(this, FHIRTypes.ELEMENTDEFINITION, code); 10883 if ("MarketingStatus".equals(codeString)) 10884 return new Enumeration<FHIRTypes>(this, FHIRTypes.MARKETINGSTATUS, code); 10885 if ("ProductShelfLife".equals(codeString)) 10886 return new Enumeration<FHIRTypes>(this, FHIRTypes.PRODUCTSHELFLIFE, code); 10887 if ("Timing".equals(codeString)) 10888 return new Enumeration<FHIRTypes>(this, FHIRTypes.TIMING, code); 10889 if ("CodeableConcept".equals(codeString)) 10890 return new Enumeration<FHIRTypes>(this, FHIRTypes.CODEABLECONCEPT, code); 10891 if ("CodeableReference".equals(codeString)) 10892 return new Enumeration<FHIRTypes>(this, FHIRTypes.CODEABLEREFERENCE, code); 10893 if ("Coding".equals(codeString)) 10894 return new Enumeration<FHIRTypes>(this, FHIRTypes.CODING, code); 10895 if ("ContactDetail".equals(codeString)) 10896 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONTACTDETAIL, code); 10897 if ("ContactPoint".equals(codeString)) 10898 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONTACTPOINT, code); 10899 if ("Contributor".equals(codeString)) 10900 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONTRIBUTOR, code); 10901 if ("DataRequirement".equals(codeString)) 10902 return new Enumeration<FHIRTypes>(this, FHIRTypes.DATAREQUIREMENT, code); 10903 if ("Expression".equals(codeString)) 10904 return new Enumeration<FHIRTypes>(this, FHIRTypes.EXPRESSION, code); 10905 if ("ExtendedContactDetail".equals(codeString)) 10906 return new Enumeration<FHIRTypes>(this, FHIRTypes.EXTENDEDCONTACTDETAIL, code); 10907 if ("Extension".equals(codeString)) 10908 return new Enumeration<FHIRTypes>(this, FHIRTypes.EXTENSION, code); 10909 if ("HumanName".equals(codeString)) 10910 return new Enumeration<FHIRTypes>(this, FHIRTypes.HUMANNAME, code); 10911 if ("Identifier".equals(codeString)) 10912 return new Enumeration<FHIRTypes>(this, FHIRTypes.IDENTIFIER, code); 10913 if ("Meta".equals(codeString)) 10914 return new Enumeration<FHIRTypes>(this, FHIRTypes.META, code); 10915 if ("MonetaryComponent".equals(codeString)) 10916 return new Enumeration<FHIRTypes>(this, FHIRTypes.MONETARYCOMPONENT, code); 10917 if ("Money".equals(codeString)) 10918 return new Enumeration<FHIRTypes>(this, FHIRTypes.MONEY, code); 10919 if ("Narrative".equals(codeString)) 10920 return new Enumeration<FHIRTypes>(this, FHIRTypes.NARRATIVE, code); 10921 if ("ParameterDefinition".equals(codeString)) 10922 return new Enumeration<FHIRTypes>(this, FHIRTypes.PARAMETERDEFINITION, code); 10923 if ("Period".equals(codeString)) 10924 return new Enumeration<FHIRTypes>(this, FHIRTypes.PERIOD, code); 10925 if ("PrimitiveType".equals(codeString)) 10926 return new Enumeration<FHIRTypes>(this, FHIRTypes.PRIMITIVETYPE, code); 10927 if ("base64Binary".equals(codeString)) 10928 return new Enumeration<FHIRTypes>(this, FHIRTypes.BASE64BINARY, code); 10929 if ("boolean".equals(codeString)) 10930 return new Enumeration<FHIRTypes>(this, FHIRTypes.BOOLEAN, code); 10931 if ("date".equals(codeString)) 10932 return new Enumeration<FHIRTypes>(this, FHIRTypes.DATE, code); 10933 if ("dateTime".equals(codeString)) 10934 return new Enumeration<FHIRTypes>(this, FHIRTypes.DATETIME, code); 10935 if ("decimal".equals(codeString)) 10936 return new Enumeration<FHIRTypes>(this, FHIRTypes.DECIMAL, code); 10937 if ("instant".equals(codeString)) 10938 return new Enumeration<FHIRTypes>(this, FHIRTypes.INSTANT, code); 10939 if ("integer".equals(codeString)) 10940 return new Enumeration<FHIRTypes>(this, FHIRTypes.INTEGER, code); 10941 if ("positiveInt".equals(codeString)) 10942 return new Enumeration<FHIRTypes>(this, FHIRTypes.POSITIVEINT, code); 10943 if ("unsignedInt".equals(codeString)) 10944 return new Enumeration<FHIRTypes>(this, FHIRTypes.UNSIGNEDINT, code); 10945 if ("integer64".equals(codeString)) 10946 return new Enumeration<FHIRTypes>(this, FHIRTypes.INTEGER64, code); 10947 if ("string".equals(codeString)) 10948 return new Enumeration<FHIRTypes>(this, FHIRTypes.STRING, code); 10949 if ("code".equals(codeString)) 10950 return new Enumeration<FHIRTypes>(this, FHIRTypes.CODE, code); 10951 if ("id".equals(codeString)) 10952 return new Enumeration<FHIRTypes>(this, FHIRTypes.ID, code); 10953 if ("markdown".equals(codeString)) 10954 return new Enumeration<FHIRTypes>(this, FHIRTypes.MARKDOWN, code); 10955 if ("time".equals(codeString)) 10956 return new Enumeration<FHIRTypes>(this, FHIRTypes.TIME, code); 10957 if ("uri".equals(codeString)) 10958 return new Enumeration<FHIRTypes>(this, FHIRTypes.URI, code); 10959 if ("canonical".equals(codeString)) 10960 return new Enumeration<FHIRTypes>(this, FHIRTypes.CANONICAL, code); 10961 if ("oid".equals(codeString)) 10962 return new Enumeration<FHIRTypes>(this, FHIRTypes.OID, code); 10963 if ("url".equals(codeString)) 10964 return new Enumeration<FHIRTypes>(this, FHIRTypes.URL, code); 10965 if ("uuid".equals(codeString)) 10966 return new Enumeration<FHIRTypes>(this, FHIRTypes.UUID, code); 10967 if ("Quantity".equals(codeString)) 10968 return new Enumeration<FHIRTypes>(this, FHIRTypes.QUANTITY, code); 10969 if ("Age".equals(codeString)) 10970 return new Enumeration<FHIRTypes>(this, FHIRTypes.AGE, code); 10971 if ("Count".equals(codeString)) 10972 return new Enumeration<FHIRTypes>(this, FHIRTypes.COUNT, code); 10973 if ("Distance".equals(codeString)) 10974 return new Enumeration<FHIRTypes>(this, FHIRTypes.DISTANCE, code); 10975 if ("Duration".equals(codeString)) 10976 return new Enumeration<FHIRTypes>(this, FHIRTypes.DURATION, code); 10977 if ("Range".equals(codeString)) 10978 return new Enumeration<FHIRTypes>(this, FHIRTypes.RANGE, code); 10979 if ("Ratio".equals(codeString)) 10980 return new Enumeration<FHIRTypes>(this, FHIRTypes.RATIO, code); 10981 if ("RatioRange".equals(codeString)) 10982 return new Enumeration<FHIRTypes>(this, FHIRTypes.RATIORANGE, code); 10983 if ("Reference".equals(codeString)) 10984 return new Enumeration<FHIRTypes>(this, FHIRTypes.REFERENCE, code); 10985 if ("RelatedArtifact".equals(codeString)) 10986 return new Enumeration<FHIRTypes>(this, FHIRTypes.RELATEDARTIFACT, code); 10987 if ("SampledData".equals(codeString)) 10988 return new Enumeration<FHIRTypes>(this, FHIRTypes.SAMPLEDDATA, code); 10989 if ("Signature".equals(codeString)) 10990 return new Enumeration<FHIRTypes>(this, FHIRTypes.SIGNATURE, code); 10991 if ("TriggerDefinition".equals(codeString)) 10992 return new Enumeration<FHIRTypes>(this, FHIRTypes.TRIGGERDEFINITION, code); 10993 if ("UsageContext".equals(codeString)) 10994 return new Enumeration<FHIRTypes>(this, FHIRTypes.USAGECONTEXT, code); 10995 if ("VirtualServiceDetail".equals(codeString)) 10996 return new Enumeration<FHIRTypes>(this, FHIRTypes.VIRTUALSERVICEDETAIL, code); 10997 if ("xhtml".equals(codeString)) 10998 return new Enumeration<FHIRTypes>(this, FHIRTypes.XHTML, code); 10999 if ("Resource".equals(codeString)) 11000 return new Enumeration<FHIRTypes>(this, FHIRTypes.RESOURCE, code); 11001 if ("Binary".equals(codeString)) 11002 return new Enumeration<FHIRTypes>(this, FHIRTypes.BINARY, code); 11003 if ("Bundle".equals(codeString)) 11004 return new Enumeration<FHIRTypes>(this, FHIRTypes.BUNDLE, code); 11005 if ("DomainResource".equals(codeString)) 11006 return new Enumeration<FHIRTypes>(this, FHIRTypes.DOMAINRESOURCE, code); 11007 if ("Account".equals(codeString)) 11008 return new Enumeration<FHIRTypes>(this, FHIRTypes.ACCOUNT, code); 11009 if ("ActivityDefinition".equals(codeString)) 11010 return new Enumeration<FHIRTypes>(this, FHIRTypes.ACTIVITYDEFINITION, code); 11011 if ("ActorDefinition".equals(codeString)) 11012 return new Enumeration<FHIRTypes>(this, FHIRTypes.ACTORDEFINITION, code); 11013 if ("AdministrableProductDefinition".equals(codeString)) 11014 return new Enumeration<FHIRTypes>(this, FHIRTypes.ADMINISTRABLEPRODUCTDEFINITION, code); 11015 if ("AdverseEvent".equals(codeString)) 11016 return new Enumeration<FHIRTypes>(this, FHIRTypes.ADVERSEEVENT, code); 11017 if ("AllergyIntolerance".equals(codeString)) 11018 return new Enumeration<FHIRTypes>(this, FHIRTypes.ALLERGYINTOLERANCE, code); 11019 if ("Appointment".equals(codeString)) 11020 return new Enumeration<FHIRTypes>(this, FHIRTypes.APPOINTMENT, code); 11021 if ("AppointmentResponse".equals(codeString)) 11022 return new Enumeration<FHIRTypes>(this, FHIRTypes.APPOINTMENTRESPONSE, code); 11023 if ("ArtifactAssessment".equals(codeString)) 11024 return new Enumeration<FHIRTypes>(this, FHIRTypes.ARTIFACTASSESSMENT, code); 11025 if ("AuditEvent".equals(codeString)) 11026 return new Enumeration<FHIRTypes>(this, FHIRTypes.AUDITEVENT, code); 11027 if ("Basic".equals(codeString)) 11028 return new Enumeration<FHIRTypes>(this, FHIRTypes.BASIC, code); 11029 if ("BiologicallyDerivedProduct".equals(codeString)) 11030 return new Enumeration<FHIRTypes>(this, FHIRTypes.BIOLOGICALLYDERIVEDPRODUCT, code); 11031 if ("BiologicallyDerivedProductDispense".equals(codeString)) 11032 return new Enumeration<FHIRTypes>(this, FHIRTypes.BIOLOGICALLYDERIVEDPRODUCTDISPENSE, code); 11033 if ("BodyStructure".equals(codeString)) 11034 return new Enumeration<FHIRTypes>(this, FHIRTypes.BODYSTRUCTURE, code); 11035 if ("CanonicalResource".equals(codeString)) 11036 return new Enumeration<FHIRTypes>(this, FHIRTypes.CANONICALRESOURCE, code); 11037 if ("CapabilityStatement".equals(codeString)) 11038 return new Enumeration<FHIRTypes>(this, FHIRTypes.CAPABILITYSTATEMENT, code); 11039 if ("CarePlan".equals(codeString)) 11040 return new Enumeration<FHIRTypes>(this, FHIRTypes.CAREPLAN, code); 11041 if ("CareTeam".equals(codeString)) 11042 return new Enumeration<FHIRTypes>(this, FHIRTypes.CARETEAM, code); 11043 if ("ChargeItem".equals(codeString)) 11044 return new Enumeration<FHIRTypes>(this, FHIRTypes.CHARGEITEM, code); 11045 if ("ChargeItemDefinition".equals(codeString)) 11046 return new Enumeration<FHIRTypes>(this, FHIRTypes.CHARGEITEMDEFINITION, code); 11047 if ("Citation".equals(codeString)) 11048 return new Enumeration<FHIRTypes>(this, FHIRTypes.CITATION, code); 11049 if ("Claim".equals(codeString)) 11050 return new Enumeration<FHIRTypes>(this, FHIRTypes.CLAIM, code); 11051 if ("ClaimResponse".equals(codeString)) 11052 return new Enumeration<FHIRTypes>(this, FHIRTypes.CLAIMRESPONSE, code); 11053 if ("ClinicalImpression".equals(codeString)) 11054 return new Enumeration<FHIRTypes>(this, FHIRTypes.CLINICALIMPRESSION, code); 11055 if ("ClinicalUseDefinition".equals(codeString)) 11056 return new Enumeration<FHIRTypes>(this, FHIRTypes.CLINICALUSEDEFINITION, code); 11057 if ("CodeSystem".equals(codeString)) 11058 return new Enumeration<FHIRTypes>(this, FHIRTypes.CODESYSTEM, code); 11059 if ("Communication".equals(codeString)) 11060 return new Enumeration<FHIRTypes>(this, FHIRTypes.COMMUNICATION, code); 11061 if ("CommunicationRequest".equals(codeString)) 11062 return new Enumeration<FHIRTypes>(this, FHIRTypes.COMMUNICATIONREQUEST, code); 11063 if ("CompartmentDefinition".equals(codeString)) 11064 return new Enumeration<FHIRTypes>(this, FHIRTypes.COMPARTMENTDEFINITION, code); 11065 if ("Composition".equals(codeString)) 11066 return new Enumeration<FHIRTypes>(this, FHIRTypes.COMPOSITION, code); 11067 if ("ConceptMap".equals(codeString)) 11068 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONCEPTMAP, code); 11069 if ("Condition".equals(codeString)) 11070 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONDITION, code); 11071 if ("ConditionDefinition".equals(codeString)) 11072 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONDITIONDEFINITION, code); 11073 if ("Consent".equals(codeString)) 11074 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONSENT, code); 11075 if ("Contract".equals(codeString)) 11076 return new Enumeration<FHIRTypes>(this, FHIRTypes.CONTRACT, code); 11077 if ("Coverage".equals(codeString)) 11078 return new Enumeration<FHIRTypes>(this, FHIRTypes.COVERAGE, code); 11079 if ("CoverageEligibilityRequest".equals(codeString)) 11080 return new Enumeration<FHIRTypes>(this, FHIRTypes.COVERAGEELIGIBILITYREQUEST, code); 11081 if ("CoverageEligibilityResponse".equals(codeString)) 11082 return new Enumeration<FHIRTypes>(this, FHIRTypes.COVERAGEELIGIBILITYRESPONSE, code); 11083 if ("DetectedIssue".equals(codeString)) 11084 return new Enumeration<FHIRTypes>(this, FHIRTypes.DETECTEDISSUE, code); 11085 if ("Device".equals(codeString)) 11086 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICE, code); 11087 if ("DeviceAssociation".equals(codeString)) 11088 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICEASSOCIATION, code); 11089 if ("DeviceDefinition".equals(codeString)) 11090 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICEDEFINITION, code); 11091 if ("DeviceDispense".equals(codeString)) 11092 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICEDISPENSE, code); 11093 if ("DeviceMetric".equals(codeString)) 11094 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICEMETRIC, code); 11095 if ("DeviceRequest".equals(codeString)) 11096 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICEREQUEST, code); 11097 if ("DeviceUsage".equals(codeString)) 11098 return new Enumeration<FHIRTypes>(this, FHIRTypes.DEVICEUSAGE, code); 11099 if ("DiagnosticReport".equals(codeString)) 11100 return new Enumeration<FHIRTypes>(this, FHIRTypes.DIAGNOSTICREPORT, code); 11101 if ("DocumentReference".equals(codeString)) 11102 return new Enumeration<FHIRTypes>(this, FHIRTypes.DOCUMENTREFERENCE, code); 11103 if ("Encounter".equals(codeString)) 11104 return new Enumeration<FHIRTypes>(this, FHIRTypes.ENCOUNTER, code); 11105 if ("EncounterHistory".equals(codeString)) 11106 return new Enumeration<FHIRTypes>(this, FHIRTypes.ENCOUNTERHISTORY, code); 11107 if ("Endpoint".equals(codeString)) 11108 return new Enumeration<FHIRTypes>(this, FHIRTypes.ENDPOINT, code); 11109 if ("EnrollmentRequest".equals(codeString)) 11110 return new Enumeration<FHIRTypes>(this, FHIRTypes.ENROLLMENTREQUEST, code); 11111 if ("EnrollmentResponse".equals(codeString)) 11112 return new Enumeration<FHIRTypes>(this, FHIRTypes.ENROLLMENTRESPONSE, code); 11113 if ("EpisodeOfCare".equals(codeString)) 11114 return new Enumeration<FHIRTypes>(this, FHIRTypes.EPISODEOFCARE, code); 11115 if ("EventDefinition".equals(codeString)) 11116 return new Enumeration<FHIRTypes>(this, FHIRTypes.EVENTDEFINITION, code); 11117 if ("Evidence".equals(codeString)) 11118 return new Enumeration<FHIRTypes>(this, FHIRTypes.EVIDENCE, code); 11119 if ("EvidenceReport".equals(codeString)) 11120 return new Enumeration<FHIRTypes>(this, FHIRTypes.EVIDENCEREPORT, code); 11121 if ("EvidenceVariable".equals(codeString)) 11122 return new Enumeration<FHIRTypes>(this, FHIRTypes.EVIDENCEVARIABLE, code); 11123 if ("ExampleScenario".equals(codeString)) 11124 return new Enumeration<FHIRTypes>(this, FHIRTypes.EXAMPLESCENARIO, code); 11125 if ("ExplanationOfBenefit".equals(codeString)) 11126 return new Enumeration<FHIRTypes>(this, FHIRTypes.EXPLANATIONOFBENEFIT, code); 11127 if ("FamilyMemberHistory".equals(codeString)) 11128 return new Enumeration<FHIRTypes>(this, FHIRTypes.FAMILYMEMBERHISTORY, code); 11129 if ("Flag".equals(codeString)) 11130 return new Enumeration<FHIRTypes>(this, FHIRTypes.FLAG, code); 11131 if ("FormularyItem".equals(codeString)) 11132 return new Enumeration<FHIRTypes>(this, FHIRTypes.FORMULARYITEM, code); 11133 if ("GenomicStudy".equals(codeString)) 11134 return new Enumeration<FHIRTypes>(this, FHIRTypes.GENOMICSTUDY, code); 11135 if ("Goal".equals(codeString)) 11136 return new Enumeration<FHIRTypes>(this, FHIRTypes.GOAL, code); 11137 if ("GraphDefinition".equals(codeString)) 11138 return new Enumeration<FHIRTypes>(this, FHIRTypes.GRAPHDEFINITION, code); 11139 if ("Group".equals(codeString)) 11140 return new Enumeration<FHIRTypes>(this, FHIRTypes.GROUP, code); 11141 if ("GuidanceResponse".equals(codeString)) 11142 return new Enumeration<FHIRTypes>(this, FHIRTypes.GUIDANCERESPONSE, code); 11143 if ("HealthcareService".equals(codeString)) 11144 return new Enumeration<FHIRTypes>(this, FHIRTypes.HEALTHCARESERVICE, code); 11145 if ("ImagingSelection".equals(codeString)) 11146 return new Enumeration<FHIRTypes>(this, FHIRTypes.IMAGINGSELECTION, code); 11147 if ("ImagingStudy".equals(codeString)) 11148 return new Enumeration<FHIRTypes>(this, FHIRTypes.IMAGINGSTUDY, code); 11149 if ("Immunization".equals(codeString)) 11150 return new Enumeration<FHIRTypes>(this, FHIRTypes.IMMUNIZATION, code); 11151 if ("ImmunizationEvaluation".equals(codeString)) 11152 return new Enumeration<FHIRTypes>(this, FHIRTypes.IMMUNIZATIONEVALUATION, code); 11153 if ("ImmunizationRecommendation".equals(codeString)) 11154 return new Enumeration<FHIRTypes>(this, FHIRTypes.IMMUNIZATIONRECOMMENDATION, code); 11155 if ("ImplementationGuide".equals(codeString)) 11156 return new Enumeration<FHIRTypes>(this, FHIRTypes.IMPLEMENTATIONGUIDE, code); 11157 if ("Ingredient".equals(codeString)) 11158 return new Enumeration<FHIRTypes>(this, FHIRTypes.INGREDIENT, code); 11159 if ("InsurancePlan".equals(codeString)) 11160 return new Enumeration<FHIRTypes>(this, FHIRTypes.INSURANCEPLAN, code); 11161 if ("InventoryItem".equals(codeString)) 11162 return new Enumeration<FHIRTypes>(this, FHIRTypes.INVENTORYITEM, code); 11163 if ("InventoryReport".equals(codeString)) 11164 return new Enumeration<FHIRTypes>(this, FHIRTypes.INVENTORYREPORT, code); 11165 if ("Invoice".equals(codeString)) 11166 return new Enumeration<FHIRTypes>(this, FHIRTypes.INVOICE, code); 11167 if ("Library".equals(codeString)) 11168 return new Enumeration<FHIRTypes>(this, FHIRTypes.LIBRARY, code); 11169 if ("Linkage".equals(codeString)) 11170 return new Enumeration<FHIRTypes>(this, FHIRTypes.LINKAGE, code); 11171 if ("List".equals(codeString)) 11172 return new Enumeration<FHIRTypes>(this, FHIRTypes.LIST, code); 11173 if ("Location".equals(codeString)) 11174 return new Enumeration<FHIRTypes>(this, FHIRTypes.LOCATION, code); 11175 if ("ManufacturedItemDefinition".equals(codeString)) 11176 return new Enumeration<FHIRTypes>(this, FHIRTypes.MANUFACTUREDITEMDEFINITION, code); 11177 if ("Measure".equals(codeString)) 11178 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEASURE, code); 11179 if ("MeasureReport".equals(codeString)) 11180 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEASUREREPORT, code); 11181 if ("Medication".equals(codeString)) 11182 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICATION, code); 11183 if ("MedicationAdministration".equals(codeString)) 11184 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICATIONADMINISTRATION, code); 11185 if ("MedicationDispense".equals(codeString)) 11186 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICATIONDISPENSE, code); 11187 if ("MedicationKnowledge".equals(codeString)) 11188 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICATIONKNOWLEDGE, code); 11189 if ("MedicationRequest".equals(codeString)) 11190 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICATIONREQUEST, code); 11191 if ("MedicationStatement".equals(codeString)) 11192 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICATIONSTATEMENT, code); 11193 if ("MedicinalProductDefinition".equals(codeString)) 11194 return new Enumeration<FHIRTypes>(this, FHIRTypes.MEDICINALPRODUCTDEFINITION, code); 11195 if ("MessageDefinition".equals(codeString)) 11196 return new Enumeration<FHIRTypes>(this, FHIRTypes.MESSAGEDEFINITION, code); 11197 if ("MessageHeader".equals(codeString)) 11198 return new Enumeration<FHIRTypes>(this, FHIRTypes.MESSAGEHEADER, code); 11199 if ("MetadataResource".equals(codeString)) 11200 return new Enumeration<FHIRTypes>(this, FHIRTypes.METADATARESOURCE, code); 11201 if ("MolecularSequence".equals(codeString)) 11202 return new Enumeration<FHIRTypes>(this, FHIRTypes.MOLECULARSEQUENCE, code); 11203 if ("NamingSystem".equals(codeString)) 11204 return new Enumeration<FHIRTypes>(this, FHIRTypes.NAMINGSYSTEM, code); 11205 if ("NutritionIntake".equals(codeString)) 11206 return new Enumeration<FHIRTypes>(this, FHIRTypes.NUTRITIONINTAKE, code); 11207 if ("NutritionOrder".equals(codeString)) 11208 return new Enumeration<FHIRTypes>(this, FHIRTypes.NUTRITIONORDER, code); 11209 if ("NutritionProduct".equals(codeString)) 11210 return new Enumeration<FHIRTypes>(this, FHIRTypes.NUTRITIONPRODUCT, code); 11211 if ("Observation".equals(codeString)) 11212 return new Enumeration<FHIRTypes>(this, FHIRTypes.OBSERVATION, code); 11213 if ("ObservationDefinition".equals(codeString)) 11214 return new Enumeration<FHIRTypes>(this, FHIRTypes.OBSERVATIONDEFINITION, code); 11215 if ("OperationDefinition".equals(codeString)) 11216 return new Enumeration<FHIRTypes>(this, FHIRTypes.OPERATIONDEFINITION, code); 11217 if ("OperationOutcome".equals(codeString)) 11218 return new Enumeration<FHIRTypes>(this, FHIRTypes.OPERATIONOUTCOME, code); 11219 if ("Organization".equals(codeString)) 11220 return new Enumeration<FHIRTypes>(this, FHIRTypes.ORGANIZATION, code); 11221 if ("OrganizationAffiliation".equals(codeString)) 11222 return new Enumeration<FHIRTypes>(this, FHIRTypes.ORGANIZATIONAFFILIATION, code); 11223 if ("PackagedProductDefinition".equals(codeString)) 11224 return new Enumeration<FHIRTypes>(this, FHIRTypes.PACKAGEDPRODUCTDEFINITION, code); 11225 if ("Patient".equals(codeString)) 11226 return new Enumeration<FHIRTypes>(this, FHIRTypes.PATIENT, code); 11227 if ("PaymentNotice".equals(codeString)) 11228 return new Enumeration<FHIRTypes>(this, FHIRTypes.PAYMENTNOTICE, code); 11229 if ("PaymentReconciliation".equals(codeString)) 11230 return new Enumeration<FHIRTypes>(this, FHIRTypes.PAYMENTRECONCILIATION, code); 11231 if ("Permission".equals(codeString)) 11232 return new Enumeration<FHIRTypes>(this, FHIRTypes.PERMISSION, code); 11233 if ("Person".equals(codeString)) 11234 return new Enumeration<FHIRTypes>(this, FHIRTypes.PERSON, code); 11235 if ("PlanDefinition".equals(codeString)) 11236 return new Enumeration<FHIRTypes>(this, FHIRTypes.PLANDEFINITION, code); 11237 if ("Practitioner".equals(codeString)) 11238 return new Enumeration<FHIRTypes>(this, FHIRTypes.PRACTITIONER, code); 11239 if ("PractitionerRole".equals(codeString)) 11240 return new Enumeration<FHIRTypes>(this, FHIRTypes.PRACTITIONERROLE, code); 11241 if ("Procedure".equals(codeString)) 11242 return new Enumeration<FHIRTypes>(this, FHIRTypes.PROCEDURE, code); 11243 if ("Provenance".equals(codeString)) 11244 return new Enumeration<FHIRTypes>(this, FHIRTypes.PROVENANCE, code); 11245 if ("Questionnaire".equals(codeString)) 11246 return new Enumeration<FHIRTypes>(this, FHIRTypes.QUESTIONNAIRE, code); 11247 if ("QuestionnaireResponse".equals(codeString)) 11248 return new Enumeration<FHIRTypes>(this, FHIRTypes.QUESTIONNAIRERESPONSE, code); 11249 if ("RegulatedAuthorization".equals(codeString)) 11250 return new Enumeration<FHIRTypes>(this, FHIRTypes.REGULATEDAUTHORIZATION, code); 11251 if ("RelatedPerson".equals(codeString)) 11252 return new Enumeration<FHIRTypes>(this, FHIRTypes.RELATEDPERSON, code); 11253 if ("RequestOrchestration".equals(codeString)) 11254 return new Enumeration<FHIRTypes>(this, FHIRTypes.REQUESTORCHESTRATION, code); 11255 if ("Requirements".equals(codeString)) 11256 return new Enumeration<FHIRTypes>(this, FHIRTypes.REQUIREMENTS, code); 11257 if ("ResearchStudy".equals(codeString)) 11258 return new Enumeration<FHIRTypes>(this, FHIRTypes.RESEARCHSTUDY, code); 11259 if ("ResearchSubject".equals(codeString)) 11260 return new Enumeration<FHIRTypes>(this, FHIRTypes.RESEARCHSUBJECT, code); 11261 if ("RiskAssessment".equals(codeString)) 11262 return new Enumeration<FHIRTypes>(this, FHIRTypes.RISKASSESSMENT, code); 11263 if ("Schedule".equals(codeString)) 11264 return new Enumeration<FHIRTypes>(this, FHIRTypes.SCHEDULE, code); 11265 if ("SearchParameter".equals(codeString)) 11266 return new Enumeration<FHIRTypes>(this, FHIRTypes.SEARCHPARAMETER, code); 11267 if ("ServiceRequest".equals(codeString)) 11268 return new Enumeration<FHIRTypes>(this, FHIRTypes.SERVICEREQUEST, code); 11269 if ("Slot".equals(codeString)) 11270 return new Enumeration<FHIRTypes>(this, FHIRTypes.SLOT, code); 11271 if ("Specimen".equals(codeString)) 11272 return new Enumeration<FHIRTypes>(this, FHIRTypes.SPECIMEN, code); 11273 if ("SpecimenDefinition".equals(codeString)) 11274 return new Enumeration<FHIRTypes>(this, FHIRTypes.SPECIMENDEFINITION, code); 11275 if ("StructureDefinition".equals(codeString)) 11276 return new Enumeration<FHIRTypes>(this, FHIRTypes.STRUCTUREDEFINITION, code); 11277 if ("StructureMap".equals(codeString)) 11278 return new Enumeration<FHIRTypes>(this, FHIRTypes.STRUCTUREMAP, code); 11279 if ("Subscription".equals(codeString)) 11280 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSCRIPTION, code); 11281 if ("SubscriptionStatus".equals(codeString)) 11282 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSCRIPTIONSTATUS, code); 11283 if ("SubscriptionTopic".equals(codeString)) 11284 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSCRIPTIONTOPIC, code); 11285 if ("Substance".equals(codeString)) 11286 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCE, code); 11287 if ("SubstanceDefinition".equals(codeString)) 11288 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCEDEFINITION, code); 11289 if ("SubstanceNucleicAcid".equals(codeString)) 11290 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCENUCLEICACID, code); 11291 if ("SubstancePolymer".equals(codeString)) 11292 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCEPOLYMER, code); 11293 if ("SubstanceProtein".equals(codeString)) 11294 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCEPROTEIN, code); 11295 if ("SubstanceReferenceInformation".equals(codeString)) 11296 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCEREFERENCEINFORMATION, code); 11297 if ("SubstanceSourceMaterial".equals(codeString)) 11298 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUBSTANCESOURCEMATERIAL, code); 11299 if ("SupplyDelivery".equals(codeString)) 11300 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUPPLYDELIVERY, code); 11301 if ("SupplyRequest".equals(codeString)) 11302 return new Enumeration<FHIRTypes>(this, FHIRTypes.SUPPLYREQUEST, code); 11303 if ("Task".equals(codeString)) 11304 return new Enumeration<FHIRTypes>(this, FHIRTypes.TASK, code); 11305 if ("TerminologyCapabilities".equals(codeString)) 11306 return new Enumeration<FHIRTypes>(this, FHIRTypes.TERMINOLOGYCAPABILITIES, code); 11307 if ("TestPlan".equals(codeString)) 11308 return new Enumeration<FHIRTypes>(this, FHIRTypes.TESTPLAN, code); 11309 if ("TestReport".equals(codeString)) 11310 return new Enumeration<FHIRTypes>(this, FHIRTypes.TESTREPORT, code); 11311 if ("TestScript".equals(codeString)) 11312 return new Enumeration<FHIRTypes>(this, FHIRTypes.TESTSCRIPT, code); 11313 if ("Transport".equals(codeString)) 11314 return new Enumeration<FHIRTypes>(this, FHIRTypes.TRANSPORT, code); 11315 if ("ValueSet".equals(codeString)) 11316 return new Enumeration<FHIRTypes>(this, FHIRTypes.VALUESET, code); 11317 if ("VerificationResult".equals(codeString)) 11318 return new Enumeration<FHIRTypes>(this, FHIRTypes.VERIFICATIONRESULT, code); 11319 if ("VisionPrescription".equals(codeString)) 11320 return new Enumeration<FHIRTypes>(this, FHIRTypes.VISIONPRESCRIPTION, code); 11321 if ("Parameters".equals(codeString)) 11322 return new Enumeration<FHIRTypes>(this, FHIRTypes.PARAMETERS, code); 11323 throw new FHIRException("Unknown FHIRTypes code '"+codeString+"'"); 11324 } 11325 public String toCode(FHIRTypes code) { 11326 if (code == FHIRTypes.BASE) 11327 return "Base"; 11328 if (code == FHIRTypes.ELEMENT) 11329 return "Element"; 11330 if (code == FHIRTypes.BACKBONEELEMENT) 11331 return "BackboneElement"; 11332 if (code == FHIRTypes.DATATYPE) 11333 return "DataType"; 11334 if (code == FHIRTypes.ADDRESS) 11335 return "Address"; 11336 if (code == FHIRTypes.ANNOTATION) 11337 return "Annotation"; 11338 if (code == FHIRTypes.ATTACHMENT) 11339 return "Attachment"; 11340 if (code == FHIRTypes.AVAILABILITY) 11341 return "Availability"; 11342 if (code == FHIRTypes.BACKBONETYPE) 11343 return "BackboneType"; 11344 if (code == FHIRTypes.DOSAGE) 11345 return "Dosage"; 11346 if (code == FHIRTypes.ELEMENTDEFINITION) 11347 return "ElementDefinition"; 11348 if (code == FHIRTypes.MARKETINGSTATUS) 11349 return "MarketingStatus"; 11350 if (code == FHIRTypes.PRODUCTSHELFLIFE) 11351 return "ProductShelfLife"; 11352 if (code == FHIRTypes.TIMING) 11353 return "Timing"; 11354 if (code == FHIRTypes.CODEABLECONCEPT) 11355 return "CodeableConcept"; 11356 if (code == FHIRTypes.CODEABLEREFERENCE) 11357 return "CodeableReference"; 11358 if (code == FHIRTypes.CODING) 11359 return "Coding"; 11360 if (code == FHIRTypes.CONTACTDETAIL) 11361 return "ContactDetail"; 11362 if (code == FHIRTypes.CONTACTPOINT) 11363 return "ContactPoint"; 11364 if (code == FHIRTypes.CONTRIBUTOR) 11365 return "Contributor"; 11366 if (code == FHIRTypes.DATAREQUIREMENT) 11367 return "DataRequirement"; 11368 if (code == FHIRTypes.EXPRESSION) 11369 return "Expression"; 11370 if (code == FHIRTypes.EXTENDEDCONTACTDETAIL) 11371 return "ExtendedContactDetail"; 11372 if (code == FHIRTypes.EXTENSION) 11373 return "Extension"; 11374 if (code == FHIRTypes.HUMANNAME) 11375 return "HumanName"; 11376 if (code == FHIRTypes.IDENTIFIER) 11377 return "Identifier"; 11378 if (code == FHIRTypes.META) 11379 return "Meta"; 11380 if (code == FHIRTypes.MONETARYCOMPONENT) 11381 return "MonetaryComponent"; 11382 if (code == FHIRTypes.MONEY) 11383 return "Money"; 11384 if (code == FHIRTypes.NARRATIVE) 11385 return "Narrative"; 11386 if (code == FHIRTypes.PARAMETERDEFINITION) 11387 return "ParameterDefinition"; 11388 if (code == FHIRTypes.PERIOD) 11389 return "Period"; 11390 if (code == FHIRTypes.PRIMITIVETYPE) 11391 return "PrimitiveType"; 11392 if (code == FHIRTypes.BASE64BINARY) 11393 return "base64Binary"; 11394 if (code == FHIRTypes.BOOLEAN) 11395 return "boolean"; 11396 if (code == FHIRTypes.DATE) 11397 return "date"; 11398 if (code == FHIRTypes.DATETIME) 11399 return "dateTime"; 11400 if (code == FHIRTypes.DECIMAL) 11401 return "decimal"; 11402 if (code == FHIRTypes.INSTANT) 11403 return "instant"; 11404 if (code == FHIRTypes.INTEGER) 11405 return "integer"; 11406 if (code == FHIRTypes.POSITIVEINT) 11407 return "positiveInt"; 11408 if (code == FHIRTypes.UNSIGNEDINT) 11409 return "unsignedInt"; 11410 if (code == FHIRTypes.INTEGER64) 11411 return "integer64"; 11412 if (code == FHIRTypes.STRING) 11413 return "string"; 11414 if (code == FHIRTypes.CODE) 11415 return "code"; 11416 if (code == FHIRTypes.ID) 11417 return "id"; 11418 if (code == FHIRTypes.MARKDOWN) 11419 return "markdown"; 11420 if (code == FHIRTypes.TIME) 11421 return "time"; 11422 if (code == FHIRTypes.URI) 11423 return "uri"; 11424 if (code == FHIRTypes.CANONICAL) 11425 return "canonical"; 11426 if (code == FHIRTypes.OID) 11427 return "oid"; 11428 if (code == FHIRTypes.URL) 11429 return "url"; 11430 if (code == FHIRTypes.UUID) 11431 return "uuid"; 11432 if (code == FHIRTypes.QUANTITY) 11433 return "Quantity"; 11434 if (code == FHIRTypes.AGE) 11435 return "Age"; 11436 if (code == FHIRTypes.COUNT) 11437 return "Count"; 11438 if (code == FHIRTypes.DISTANCE) 11439 return "Distance"; 11440 if (code == FHIRTypes.DURATION) 11441 return "Duration"; 11442 if (code == FHIRTypes.RANGE) 11443 return "Range"; 11444 if (code == FHIRTypes.RATIO) 11445 return "Ratio"; 11446 if (code == FHIRTypes.RATIORANGE) 11447 return "RatioRange"; 11448 if (code == FHIRTypes.REFERENCE) 11449 return "Reference"; 11450 if (code == FHIRTypes.RELATEDARTIFACT) 11451 return "RelatedArtifact"; 11452 if (code == FHIRTypes.SAMPLEDDATA) 11453 return "SampledData"; 11454 if (code == FHIRTypes.SIGNATURE) 11455 return "Signature"; 11456 if (code == FHIRTypes.TRIGGERDEFINITION) 11457 return "TriggerDefinition"; 11458 if (code == FHIRTypes.USAGECONTEXT) 11459 return "UsageContext"; 11460 if (code == FHIRTypes.VIRTUALSERVICEDETAIL) 11461 return "VirtualServiceDetail"; 11462 if (code == FHIRTypes.XHTML) 11463 return "xhtml"; 11464 if (code == FHIRTypes.RESOURCE) 11465 return "Resource"; 11466 if (code == FHIRTypes.BINARY) 11467 return "Binary"; 11468 if (code == FHIRTypes.BUNDLE) 11469 return "Bundle"; 11470 if (code == FHIRTypes.DOMAINRESOURCE) 11471 return "DomainResource"; 11472 if (code == FHIRTypes.ACCOUNT) 11473 return "Account"; 11474 if (code == FHIRTypes.ACTIVITYDEFINITION) 11475 return "ActivityDefinition"; 11476 if (code == FHIRTypes.ACTORDEFINITION) 11477 return "ActorDefinition"; 11478 if (code == FHIRTypes.ADMINISTRABLEPRODUCTDEFINITION) 11479 return "AdministrableProductDefinition"; 11480 if (code == FHIRTypes.ADVERSEEVENT) 11481 return "AdverseEvent"; 11482 if (code == FHIRTypes.ALLERGYINTOLERANCE) 11483 return "AllergyIntolerance"; 11484 if (code == FHIRTypes.APPOINTMENT) 11485 return "Appointment"; 11486 if (code == FHIRTypes.APPOINTMENTRESPONSE) 11487 return "AppointmentResponse"; 11488 if (code == FHIRTypes.ARTIFACTASSESSMENT) 11489 return "ArtifactAssessment"; 11490 if (code == FHIRTypes.AUDITEVENT) 11491 return "AuditEvent"; 11492 if (code == FHIRTypes.BASIC) 11493 return "Basic"; 11494 if (code == FHIRTypes.BIOLOGICALLYDERIVEDPRODUCT) 11495 return "BiologicallyDerivedProduct"; 11496 if (code == FHIRTypes.BIOLOGICALLYDERIVEDPRODUCTDISPENSE) 11497 return "BiologicallyDerivedProductDispense"; 11498 if (code == FHIRTypes.BODYSTRUCTURE) 11499 return "BodyStructure"; 11500 if (code == FHIRTypes.CANONICALRESOURCE) 11501 return "CanonicalResource"; 11502 if (code == FHIRTypes.CAPABILITYSTATEMENT) 11503 return "CapabilityStatement"; 11504 if (code == FHIRTypes.CAREPLAN) 11505 return "CarePlan"; 11506 if (code == FHIRTypes.CARETEAM) 11507 return "CareTeam"; 11508 if (code == FHIRTypes.CHARGEITEM) 11509 return "ChargeItem"; 11510 if (code == FHIRTypes.CHARGEITEMDEFINITION) 11511 return "ChargeItemDefinition"; 11512 if (code == FHIRTypes.CITATION) 11513 return "Citation"; 11514 if (code == FHIRTypes.CLAIM) 11515 return "Claim"; 11516 if (code == FHIRTypes.CLAIMRESPONSE) 11517 return "ClaimResponse"; 11518 if (code == FHIRTypes.CLINICALIMPRESSION) 11519 return "ClinicalImpression"; 11520 if (code == FHIRTypes.CLINICALUSEDEFINITION) 11521 return "ClinicalUseDefinition"; 11522 if (code == FHIRTypes.CODESYSTEM) 11523 return "CodeSystem"; 11524 if (code == FHIRTypes.COMMUNICATION) 11525 return "Communication"; 11526 if (code == FHIRTypes.COMMUNICATIONREQUEST) 11527 return "CommunicationRequest"; 11528 if (code == FHIRTypes.COMPARTMENTDEFINITION) 11529 return "CompartmentDefinition"; 11530 if (code == FHIRTypes.COMPOSITION) 11531 return "Composition"; 11532 if (code == FHIRTypes.CONCEPTMAP) 11533 return "ConceptMap"; 11534 if (code == FHIRTypes.CONDITION) 11535 return "Condition"; 11536 if (code == FHIRTypes.CONDITIONDEFINITION) 11537 return "ConditionDefinition"; 11538 if (code == FHIRTypes.CONSENT) 11539 return "Consent"; 11540 if (code == FHIRTypes.CONTRACT) 11541 return "Contract"; 11542 if (code == FHIRTypes.COVERAGE) 11543 return "Coverage"; 11544 if (code == FHIRTypes.COVERAGEELIGIBILITYREQUEST) 11545 return "CoverageEligibilityRequest"; 11546 if (code == FHIRTypes.COVERAGEELIGIBILITYRESPONSE) 11547 return "CoverageEligibilityResponse"; 11548 if (code == FHIRTypes.DETECTEDISSUE) 11549 return "DetectedIssue"; 11550 if (code == FHIRTypes.DEVICE) 11551 return "Device"; 11552 if (code == FHIRTypes.DEVICEASSOCIATION) 11553 return "DeviceAssociation"; 11554 if (code == FHIRTypes.DEVICEDEFINITION) 11555 return "DeviceDefinition"; 11556 if (code == FHIRTypes.DEVICEDISPENSE) 11557 return "DeviceDispense"; 11558 if (code == FHIRTypes.DEVICEMETRIC) 11559 return "DeviceMetric"; 11560 if (code == FHIRTypes.DEVICEREQUEST) 11561 return "DeviceRequest"; 11562 if (code == FHIRTypes.DEVICEUSAGE) 11563 return "DeviceUsage"; 11564 if (code == FHIRTypes.DIAGNOSTICREPORT) 11565 return "DiagnosticReport"; 11566 if (code == FHIRTypes.DOCUMENTREFERENCE) 11567 return "DocumentReference"; 11568 if (code == FHIRTypes.ENCOUNTER) 11569 return "Encounter"; 11570 if (code == FHIRTypes.ENCOUNTERHISTORY) 11571 return "EncounterHistory"; 11572 if (code == FHIRTypes.ENDPOINT) 11573 return "Endpoint"; 11574 if (code == FHIRTypes.ENROLLMENTREQUEST) 11575 return "EnrollmentRequest"; 11576 if (code == FHIRTypes.ENROLLMENTRESPONSE) 11577 return "EnrollmentResponse"; 11578 if (code == FHIRTypes.EPISODEOFCARE) 11579 return "EpisodeOfCare"; 11580 if (code == FHIRTypes.EVENTDEFINITION) 11581 return "EventDefinition"; 11582 if (code == FHIRTypes.EVIDENCE) 11583 return "Evidence"; 11584 if (code == FHIRTypes.EVIDENCEREPORT) 11585 return "EvidenceReport"; 11586 if (code == FHIRTypes.EVIDENCEVARIABLE) 11587 return "EvidenceVariable"; 11588 if (code == FHIRTypes.EXAMPLESCENARIO) 11589 return "ExampleScenario"; 11590 if (code == FHIRTypes.EXPLANATIONOFBENEFIT) 11591 return "ExplanationOfBenefit"; 11592 if (code == FHIRTypes.FAMILYMEMBERHISTORY) 11593 return "FamilyMemberHistory"; 11594 if (code == FHIRTypes.FLAG) 11595 return "Flag"; 11596 if (code == FHIRTypes.FORMULARYITEM) 11597 return "FormularyItem"; 11598 if (code == FHIRTypes.GENOMICSTUDY) 11599 return "GenomicStudy"; 11600 if (code == FHIRTypes.GOAL) 11601 return "Goal"; 11602 if (code == FHIRTypes.GRAPHDEFINITION) 11603 return "GraphDefinition"; 11604 if (code == FHIRTypes.GROUP) 11605 return "Group"; 11606 if (code == FHIRTypes.GUIDANCERESPONSE) 11607 return "GuidanceResponse"; 11608 if (code == FHIRTypes.HEALTHCARESERVICE) 11609 return "HealthcareService"; 11610 if (code == FHIRTypes.IMAGINGSELECTION) 11611 return "ImagingSelection"; 11612 if (code == FHIRTypes.IMAGINGSTUDY) 11613 return "ImagingStudy"; 11614 if (code == FHIRTypes.IMMUNIZATION) 11615 return "Immunization"; 11616 if (code == FHIRTypes.IMMUNIZATIONEVALUATION) 11617 return "ImmunizationEvaluation"; 11618 if (code == FHIRTypes.IMMUNIZATIONRECOMMENDATION) 11619 return "ImmunizationRecommendation"; 11620 if (code == FHIRTypes.IMPLEMENTATIONGUIDE) 11621 return "ImplementationGuide"; 11622 if (code == FHIRTypes.INGREDIENT) 11623 return "Ingredient"; 11624 if (code == FHIRTypes.INSURANCEPLAN) 11625 return "InsurancePlan"; 11626 if (code == FHIRTypes.INVENTORYITEM) 11627 return "InventoryItem"; 11628 if (code == FHIRTypes.INVENTORYREPORT) 11629 return "InventoryReport"; 11630 if (code == FHIRTypes.INVOICE) 11631 return "Invoice"; 11632 if (code == FHIRTypes.LIBRARY) 11633 return "Library"; 11634 if (code == FHIRTypes.LINKAGE) 11635 return "Linkage"; 11636 if (code == FHIRTypes.LIST) 11637 return "List"; 11638 if (code == FHIRTypes.LOCATION) 11639 return "Location"; 11640 if (code == FHIRTypes.MANUFACTUREDITEMDEFINITION) 11641 return "ManufacturedItemDefinition"; 11642 if (code == FHIRTypes.MEASURE) 11643 return "Measure"; 11644 if (code == FHIRTypes.MEASUREREPORT) 11645 return "MeasureReport"; 11646 if (code == FHIRTypes.MEDICATION) 11647 return "Medication"; 11648 if (code == FHIRTypes.MEDICATIONADMINISTRATION) 11649 return "MedicationAdministration"; 11650 if (code == FHIRTypes.MEDICATIONDISPENSE) 11651 return "MedicationDispense"; 11652 if (code == FHIRTypes.MEDICATIONKNOWLEDGE) 11653 return "MedicationKnowledge"; 11654 if (code == FHIRTypes.MEDICATIONREQUEST) 11655 return "MedicationRequest"; 11656 if (code == FHIRTypes.MEDICATIONSTATEMENT) 11657 return "MedicationStatement"; 11658 if (code == FHIRTypes.MEDICINALPRODUCTDEFINITION) 11659 return "MedicinalProductDefinition"; 11660 if (code == FHIRTypes.MESSAGEDEFINITION) 11661 return "MessageDefinition"; 11662 if (code == FHIRTypes.MESSAGEHEADER) 11663 return "MessageHeader"; 11664 if (code == FHIRTypes.METADATARESOURCE) 11665 return "MetadataResource"; 11666 if (code == FHIRTypes.MOLECULARSEQUENCE) 11667 return "MolecularSequence"; 11668 if (code == FHIRTypes.NAMINGSYSTEM) 11669 return "NamingSystem"; 11670 if (code == FHIRTypes.NUTRITIONINTAKE) 11671 return "NutritionIntake"; 11672 if (code == FHIRTypes.NUTRITIONORDER) 11673 return "NutritionOrder"; 11674 if (code == FHIRTypes.NUTRITIONPRODUCT) 11675 return "NutritionProduct"; 11676 if (code == FHIRTypes.OBSERVATION) 11677 return "Observation"; 11678 if (code == FHIRTypes.OBSERVATIONDEFINITION) 11679 return "ObservationDefinition"; 11680 if (code == FHIRTypes.OPERATIONDEFINITION) 11681 return "OperationDefinition"; 11682 if (code == FHIRTypes.OPERATIONOUTCOME) 11683 return "OperationOutcome"; 11684 if (code == FHIRTypes.ORGANIZATION) 11685 return "Organization"; 11686 if (code == FHIRTypes.ORGANIZATIONAFFILIATION) 11687 return "OrganizationAffiliation"; 11688 if (code == FHIRTypes.PACKAGEDPRODUCTDEFINITION) 11689 return "PackagedProductDefinition"; 11690 if (code == FHIRTypes.PATIENT) 11691 return "Patient"; 11692 if (code == FHIRTypes.PAYMENTNOTICE) 11693 return "PaymentNotice"; 11694 if (code == FHIRTypes.PAYMENTRECONCILIATION) 11695 return "PaymentReconciliation"; 11696 if (code == FHIRTypes.PERMISSION) 11697 return "Permission"; 11698 if (code == FHIRTypes.PERSON) 11699 return "Person"; 11700 if (code == FHIRTypes.PLANDEFINITION) 11701 return "PlanDefinition"; 11702 if (code == FHIRTypes.PRACTITIONER) 11703 return "Practitioner"; 11704 if (code == FHIRTypes.PRACTITIONERROLE) 11705 return "PractitionerRole"; 11706 if (code == FHIRTypes.PROCEDURE) 11707 return "Procedure"; 11708 if (code == FHIRTypes.PROVENANCE) 11709 return "Provenance"; 11710 if (code == FHIRTypes.QUESTIONNAIRE) 11711 return "Questionnaire"; 11712 if (code == FHIRTypes.QUESTIONNAIRERESPONSE) 11713 return "QuestionnaireResponse"; 11714 if (code == FHIRTypes.REGULATEDAUTHORIZATION) 11715 return "RegulatedAuthorization"; 11716 if (code == FHIRTypes.RELATEDPERSON) 11717 return "RelatedPerson"; 11718 if (code == FHIRTypes.REQUESTORCHESTRATION) 11719 return "RequestOrchestration"; 11720 if (code == FHIRTypes.REQUIREMENTS) 11721 return "Requirements"; 11722 if (code == FHIRTypes.RESEARCHSTUDY) 11723 return "ResearchStudy"; 11724 if (code == FHIRTypes.RESEARCHSUBJECT) 11725 return "ResearchSubject"; 11726 if (code == FHIRTypes.RISKASSESSMENT) 11727 return "RiskAssessment"; 11728 if (code == FHIRTypes.SCHEDULE) 11729 return "Schedule"; 11730 if (code == FHIRTypes.SEARCHPARAMETER) 11731 return "SearchParameter"; 11732 if (code == FHIRTypes.SERVICEREQUEST) 11733 return "ServiceRequest"; 11734 if (code == FHIRTypes.SLOT) 11735 return "Slot"; 11736 if (code == FHIRTypes.SPECIMEN) 11737 return "Specimen"; 11738 if (code == FHIRTypes.SPECIMENDEFINITION) 11739 return "SpecimenDefinition"; 11740 if (code == FHIRTypes.STRUCTUREDEFINITION) 11741 return "StructureDefinition"; 11742 if (code == FHIRTypes.STRUCTUREMAP) 11743 return "StructureMap"; 11744 if (code == FHIRTypes.SUBSCRIPTION) 11745 return "Subscription"; 11746 if (code == FHIRTypes.SUBSCRIPTIONSTATUS) 11747 return "SubscriptionStatus"; 11748 if (code == FHIRTypes.SUBSCRIPTIONTOPIC) 11749 return "SubscriptionTopic"; 11750 if (code == FHIRTypes.SUBSTANCE) 11751 return "Substance"; 11752 if (code == FHIRTypes.SUBSTANCEDEFINITION) 11753 return "SubstanceDefinition"; 11754 if (code == FHIRTypes.SUBSTANCENUCLEICACID) 11755 return "SubstanceNucleicAcid"; 11756 if (code == FHIRTypes.SUBSTANCEPOLYMER) 11757 return "SubstancePolymer"; 11758 if (code == FHIRTypes.SUBSTANCEPROTEIN) 11759 return "SubstanceProtein"; 11760 if (code == FHIRTypes.SUBSTANCEREFERENCEINFORMATION) 11761 return "SubstanceReferenceInformation"; 11762 if (code == FHIRTypes.SUBSTANCESOURCEMATERIAL) 11763 return "SubstanceSourceMaterial"; 11764 if (code == FHIRTypes.SUPPLYDELIVERY) 11765 return "SupplyDelivery"; 11766 if (code == FHIRTypes.SUPPLYREQUEST) 11767 return "SupplyRequest"; 11768 if (code == FHIRTypes.TASK) 11769 return "Task"; 11770 if (code == FHIRTypes.TERMINOLOGYCAPABILITIES) 11771 return "TerminologyCapabilities"; 11772 if (code == FHIRTypes.TESTPLAN) 11773 return "TestPlan"; 11774 if (code == FHIRTypes.TESTREPORT) 11775 return "TestReport"; 11776 if (code == FHIRTypes.TESTSCRIPT) 11777 return "TestScript"; 11778 if (code == FHIRTypes.TRANSPORT) 11779 return "Transport"; 11780 if (code == FHIRTypes.VALUESET) 11781 return "ValueSet"; 11782 if (code == FHIRTypes.VERIFICATIONRESULT) 11783 return "VerificationResult"; 11784 if (code == FHIRTypes.VISIONPRESCRIPTION) 11785 return "VisionPrescription"; 11786 if (code == FHIRTypes.PARAMETERS) 11787 return "Parameters"; 11788 return "?"; 11789 } 11790 public String toSystem(FHIRTypes code) { 11791 return code.getSystem(); 11792 } 11793 } 11794 11795 public enum FHIRVersion { 11796 /** 11797 * Oldest archived version of FHIR. 11798 */ 11799 _0_01, 11800 /** 11801 * 1st Draft for Comment (Sept 2012 Ballot). 11802 */ 11803 _0_05, 11804 /** 11805 * 2nd Draft for Comment (January 2013 Ballot). 11806 */ 11807 _0_06, 11808 /** 11809 * DSTU 1 Ballot version. 11810 */ 11811 _0_11, 11812 /** 11813 * DSTU 1 version. 11814 */ 11815 _0_0, 11816 /** 11817 * DSTU 1 Official version. 11818 */ 11819 _0_0_80, 11820 /** 11821 * DSTU 1 Official version Technical Errata #1. 11822 */ 11823 _0_0_81, 11824 /** 11825 * DSTU 1 Official version Technical Errata #2. 11826 */ 11827 _0_0_82, 11828 /** 11829 * January 2015 Ballot. 11830 */ 11831 _0_4, 11832 /** 11833 * Draft For Comment (January 2015 Ballot). 11834 */ 11835 _0_4_0, 11836 /** 11837 * May 2015 Ballot. 11838 */ 11839 _0_5, 11840 /** 11841 * DSTU 2 Ballot version (May 2015 Ballot). 11842 */ 11843 _0_5_0, 11844 /** 11845 * DSTU 2 version. 11846 */ 11847 _1_0, 11848 /** 11849 * DSTU 2 QA Preview + CQIF Ballot (Sep 2015). 11850 */ 11851 _1_0_0, 11852 /** 11853 * DSTU 2 (Official version). 11854 */ 11855 _1_0_1, 11856 /** 11857 * DSTU 2 (Official version) with 1 technical errata. 11858 */ 11859 _1_0_2, 11860 /** 11861 * GAO Ballot version. 11862 */ 11863 _1_1, 11864 /** 11865 * GAO Ballot + draft changes to main FHIR standard. 11866 */ 11867 _1_1_0, 11868 /** 11869 * Connectathon 12 (Montreal) version. 11870 */ 11871 _1_4, 11872 /** 11873 * CQF on FHIR Ballot + Connectathon 12 (Montreal). 11874 */ 11875 _1_4_0, 11876 /** 11877 * Connectathon 13 (Baltimore) version. 11878 */ 11879 _1_6, 11880 /** 11881 * FHIR STU3 Ballot + Connectathon 13 (Baltimore). 11882 */ 11883 _1_6_0, 11884 /** 11885 * Connectathon 14 (San Antonio) version. 11886 */ 11887 _1_8, 11888 /** 11889 * FHIR STU3 Candidate + Connectathon 14 (San Antonio). 11890 */ 11891 _1_8_0, 11892 /** 11893 * STU3 version. 11894 */ 11895 _3_0, 11896 /** 11897 * FHIR Release 3 (STU). 11898 */ 11899 _3_0_0, 11900 /** 11901 * FHIR Release 3 (STU) with 1 technical errata. 11902 */ 11903 _3_0_1, 11904 /** 11905 * FHIR Release 3 (STU) with 2 technical errata. 11906 */ 11907 _3_0_2, 11908 /** 11909 * R4 Ballot #1 version. 11910 */ 11911 _3_3, 11912 /** 11913 * R4 Ballot #1 + Connectaton 18 (Cologne). 11914 */ 11915 _3_3_0, 11916 /** 11917 * R4 Ballot #2 version. 11918 */ 11919 _3_5, 11920 /** 11921 * R4 Ballot #2 + Connectathon 19 (Baltimore). 11922 */ 11923 _3_5_0, 11924 /** 11925 * R4 version. 11926 */ 11927 _4_0, 11928 /** 11929 * FHIR Release 4 (Normative + STU). 11930 */ 11931 _4_0_0, 11932 /** 11933 * FHIR Release 4 (Normative + STU) with 1 technical errata. 11934 */ 11935 _4_0_1, 11936 /** 11937 * R4B Ballot #1 version. 11938 */ 11939 _4_1, 11940 /** 11941 * R4B Ballot #1 + Connectathon 27 (Virtual). 11942 */ 11943 _4_1_0, 11944 /** 11945 * R5 Preview #1 version. 11946 */ 11947 _4_2, 11948 /** 11949 * R5 Preview #1 + Connectathon 23 (Sydney). 11950 */ 11951 _4_2_0, 11952 /** 11953 * R4B version. 11954 */ 11955 _4_3, 11956 /** 11957 * FHIR Release 4B (Normative + STU). 11958 */ 11959 _4_3_0, 11960 /** 11961 * FHIR Release 4B CI-Builld. 11962 */ 11963 _4_3_0CIBUILD, 11964 /** 11965 * FHIR Release 4B Snapshot #1. 11966 */ 11967 _4_3_0SNAPSHOT1, 11968 /** 11969 * R5 Preview #2 version. 11970 */ 11971 _4_4, 11972 /** 11973 * R5 Preview #2 + Connectathon 24 (Virtual). 11974 */ 11975 _4_4_0, 11976 /** 11977 * R5 Preview #3 version. 11978 */ 11979 _4_5, 11980 /** 11981 * R5 Preview #3 + Connectathon 25 (Virtual). 11982 */ 11983 _4_5_0, 11984 /** 11985 * R5 Draft Ballot version. 11986 */ 11987 _4_6, 11988 /** 11989 * R5 Draft Ballot + Connectathon 27 (Virtual). 11990 */ 11991 _4_6_0, 11992 /** 11993 * R5 Versions. 11994 */ 11995 _5_0, 11996 /** 11997 * R5 Final Version. 11998 */ 11999 _5_0_0, 12000 /** 12001 * R5 Rolling ci-build. 12002 */ 12003 _5_0_0CIBUILD, 12004 /** 12005 * R5 Preview #2. 12006 */ 12007 _5_0_0SNAPSHOT1, 12008 /** 12009 * R5 Interim tooling stage. 12010 */ 12011 _5_0_0SNAPSHOT2, 12012 /** 12013 * R5 Ballot. 12014 */ 12015 _5_0_0BALLOT, 12016 /** 12017 * R5 January 2023 Staging Release + Connectathon 32. 12018 */ 12019 _5_0_0SNAPSHOT3, 12020 /** 12021 * R5 Final QA. 12022 */ 12023 _5_0_0DRAFTFINAL, 12024 /** 12025 * R6 Rolling ci-build. 12026 */ 12027 _6_0_0CIBUILD, 12028 /** 12029 * R6 Formal version (does not exist yet) 12030 */ 12031 _6_0_0, 12032 /** 12033 * added to help the parsers 12034 */ 12035 NULL; 12036 public static FHIRVersion fromCode(String codeString) throws FHIRException { 12037 if (codeString == null || "".equals(codeString)) 12038 return null; 12039 if ("0.01".equals(codeString)) 12040 return _0_01; 12041 if ("0.05".equals(codeString)) 12042 return _0_05; 12043 if ("0.06".equals(codeString)) 12044 return _0_06; 12045 if ("0.11".equals(codeString)) 12046 return _0_11; 12047 if ("0.0".equals(codeString)) 12048 return _0_0; 12049 if ("0.0.80".equals(codeString)) 12050 return _0_0_80; 12051 if ("0.0.81".equals(codeString)) 12052 return _0_0_81; 12053 if ("0.0.82".equals(codeString)) 12054 return _0_0_82; 12055 if ("0.4".equals(codeString)) 12056 return _0_4; 12057 if ("0.4.0".equals(codeString)) 12058 return _0_4_0; 12059 if ("0.5".equals(codeString)) 12060 return _0_5; 12061 if ("0.5.0".equals(codeString)) 12062 return _0_5_0; 12063 if ("1.0".equals(codeString)) 12064 return _1_0; 12065 if ("1.0.0".equals(codeString)) 12066 return _1_0_0; 12067 if ("1.0.1".equals(codeString)) 12068 return _1_0_1; 12069 if ("1.0.2".equals(codeString)) 12070 return _1_0_2; 12071 if ("1.1".equals(codeString)) 12072 return _1_1; 12073 if ("1.1.0".equals(codeString)) 12074 return _1_1_0; 12075 if ("1.4".equals(codeString)) 12076 return _1_4; 12077 if ("1.4.0".equals(codeString)) 12078 return _1_4_0; 12079 if ("1.6".equals(codeString)) 12080 return _1_6; 12081 if ("1.6.0".equals(codeString)) 12082 return _1_6_0; 12083 if ("1.8".equals(codeString)) 12084 return _1_8; 12085 if ("1.8.0".equals(codeString)) 12086 return _1_8_0; 12087 if ("3.0".equals(codeString)) 12088 return _3_0; 12089 if ("3.0.0".equals(codeString)) 12090 return _3_0_0; 12091 if ("3.0.1".equals(codeString)) 12092 return _3_0_1; 12093 if ("3.0.2".equals(codeString)) 12094 return _3_0_2; 12095 if ("3.3".equals(codeString)) 12096 return _3_3; 12097 if ("3.3.0".equals(codeString)) 12098 return _3_3_0; 12099 if ("3.5".equals(codeString)) 12100 return _3_5; 12101 if ("3.5.0".equals(codeString)) 12102 return _3_5_0; 12103 if ("4.0".equals(codeString)) 12104 return _4_0; 12105 if ("4.0.0".equals(codeString)) 12106 return _4_0_0; 12107 if ("4.0.1".equals(codeString)) 12108 return _4_0_1; 12109 if ("4.1".equals(codeString)) 12110 return _4_1; 12111 if ("4.1.0".equals(codeString)) 12112 return _4_1_0; 12113 if ("4.2".equals(codeString)) 12114 return _4_2; 12115 if ("4.2.0".equals(codeString)) 12116 return _4_2_0; 12117 if ("4.3".equals(codeString)) 12118 return _4_3; 12119 if ("4.3.0".equals(codeString)) 12120 return _4_3_0; 12121 if ("4.3.0-cibuild".equals(codeString)) 12122 return _4_3_0CIBUILD; 12123 if ("4.3.0-snapshot1".equals(codeString)) 12124 return _4_3_0SNAPSHOT1; 12125 if ("4.4".equals(codeString)) 12126 return _4_4; 12127 if ("4.4.0".equals(codeString)) 12128 return _4_4_0; 12129 if ("4.5".equals(codeString)) 12130 return _4_5; 12131 if ("4.5.0".equals(codeString)) 12132 return _4_5_0; 12133 if ("4.6".equals(codeString)) 12134 return _4_6; 12135 if ("4.6.0".equals(codeString)) 12136 return _4_6_0; 12137 if ("5.0".equals(codeString)) 12138 return _5_0; 12139 if ("5.0.0".equals(codeString)) 12140 return _5_0_0; 12141 if ("5.0.0-cibuild".equals(codeString)) 12142 return _5_0_0CIBUILD; 12143 if ("5.0.0-snapshot1".equals(codeString)) 12144 return _5_0_0SNAPSHOT1; 12145 if ("5.0.0-snapshot2".equals(codeString)) 12146 return _5_0_0SNAPSHOT2; 12147 if ("5.0.0-ballot".equals(codeString)) 12148 return _5_0_0BALLOT; 12149 if ("5.0.0-snapshot3".equals(codeString)) 12150 return _5_0_0SNAPSHOT3; 12151 if ("5.0.0-draft-final".equals(codeString)) 12152 return _5_0_0DRAFTFINAL; 12153 if ("6.0.0-cibuild".equals(codeString)) 12154 return _6_0_0CIBUILD; 12155 if ("6.0.0".equals(codeString)) 12156 return _6_0_0; 12157 throw new FHIRException("Unknown FHIRVersion code '"+codeString+"'"); 12158 } 12159 public static boolean isValidCode(String codeString) { 12160 if (codeString == null || "".equals(codeString)) 12161 return false; 12162 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"); 12163 } 12164 public String toCode() { 12165 switch (this) { 12166 case _0_01: return "0.01"; 12167 case _0_05: return "0.05"; 12168 case _0_06: return "0.06"; 12169 case _0_11: return "0.11"; 12170 case _0_0: return "0.0"; 12171 case _0_0_80: return "0.0.80"; 12172 case _0_0_81: return "0.0.81"; 12173 case _0_0_82: return "0.0.82"; 12174 case _0_4: return "0.4"; 12175 case _0_4_0: return "0.4.0"; 12176 case _0_5: return "0.5"; 12177 case _0_5_0: return "0.5.0"; 12178 case _1_0: return "1.0"; 12179 case _1_0_0: return "1.0.0"; 12180 case _1_0_1: return "1.0.1"; 12181 case _1_0_2: return "1.0.2"; 12182 case _1_1: return "1.1"; 12183 case _1_1_0: return "1.1.0"; 12184 case _1_4: return "1.4"; 12185 case _1_4_0: return "1.4.0"; 12186 case _1_6: return "1.6"; 12187 case _1_6_0: return "1.6.0"; 12188 case _1_8: return "1.8"; 12189 case _1_8_0: return "1.8.0"; 12190 case _3_0: return "3.0"; 12191 case _3_0_0: return "3.0.0"; 12192 case _3_0_1: return "3.0.1"; 12193 case _3_0_2: return "3.0.2"; 12194 case _3_3: return "3.3"; 12195 case _3_3_0: return "3.3.0"; 12196 case _3_5: return "3.5"; 12197 case _3_5_0: return "3.5.0"; 12198 case _4_0: return "4.0"; 12199 case _4_0_0: return "4.0.0"; 12200 case _4_0_1: return "4.0.1"; 12201 case _4_1: return "4.1"; 12202 case _4_1_0: return "4.1.0"; 12203 case _4_2: return "4.2"; 12204 case _4_2_0: return "4.2.0"; 12205 case _4_3: return "4.3"; 12206 case _4_3_0: return "4.3.0"; 12207 case _4_3_0CIBUILD: return "4.3.0-cibuild"; 12208 case _4_3_0SNAPSHOT1: return "4.3.0-snapshot1"; 12209 case _4_4: return "4.4"; 12210 case _4_4_0: return "4.4.0"; 12211 case _4_5: return "4.5"; 12212 case _4_5_0: return "4.5.0"; 12213 case _4_6: return "4.6"; 12214 case _4_6_0: return "4.6.0"; 12215 case _5_0: return "5.0"; 12216 case _5_0_0: return "5.0.0"; 12217 case _5_0_0CIBUILD: return "5.0.0-cibuild"; 12218 case _5_0_0SNAPSHOT1: return "5.0.0-snapshot1"; 12219 case _5_0_0SNAPSHOT2: return "5.0.0-snapshot2"; 12220 case _5_0_0BALLOT: return "5.0.0-ballot"; 12221 case _5_0_0SNAPSHOT3: return "5.0.0-snapshot3"; 12222 case _5_0_0DRAFTFINAL: return "5.0.0-draft-final"; 12223 case _6_0_0CIBUILD: return "6.0.0-cibuild"; 12224 case _6_0_0: return "6.0.0"; 12225 case NULL: return null; 12226 default: return "?"; 12227 } 12228 } 12229 public String getSystem() { 12230 switch (this) { 12231 case _0_01: return "http://hl7.org/fhir/FHIR-version"; 12232 case _0_05: return "http://hl7.org/fhir/FHIR-version"; 12233 case _0_06: return "http://hl7.org/fhir/FHIR-version"; 12234 case _0_11: return "http://hl7.org/fhir/FHIR-version"; 12235 case _0_0: return "http://hl7.org/fhir/FHIR-version"; 12236 case _0_0_80: return "http://hl7.org/fhir/FHIR-version"; 12237 case _0_0_81: return "http://hl7.org/fhir/FHIR-version"; 12238 case _0_0_82: return "http://hl7.org/fhir/FHIR-version"; 12239 case _0_4: return "http://hl7.org/fhir/FHIR-version"; 12240 case _0_4_0: return "http://hl7.org/fhir/FHIR-version"; 12241 case _0_5: return "http://hl7.org/fhir/FHIR-version"; 12242 case _0_5_0: return "http://hl7.org/fhir/FHIR-version"; 12243 case _1_0: return "http://hl7.org/fhir/FHIR-version"; 12244 case _1_0_0: return "http://hl7.org/fhir/FHIR-version"; 12245 case _1_0_1: return "http://hl7.org/fhir/FHIR-version"; 12246 case _1_0_2: return "http://hl7.org/fhir/FHIR-version"; 12247 case _1_1: return "http://hl7.org/fhir/FHIR-version"; 12248 case _1_1_0: return "http://hl7.org/fhir/FHIR-version"; 12249 case _1_4: return "http://hl7.org/fhir/FHIR-version"; 12250 case _1_4_0: return "http://hl7.org/fhir/FHIR-version"; 12251 case _1_6: return "http://hl7.org/fhir/FHIR-version"; 12252 case _1_6_0: return "http://hl7.org/fhir/FHIR-version"; 12253 case _1_8: return "http://hl7.org/fhir/FHIR-version"; 12254 case _1_8_0: return "http://hl7.org/fhir/FHIR-version"; 12255 case _3_0: return "http://hl7.org/fhir/FHIR-version"; 12256 case _3_0_0: return "http://hl7.org/fhir/FHIR-version"; 12257 case _3_0_1: return "http://hl7.org/fhir/FHIR-version"; 12258 case _3_0_2: return "http://hl7.org/fhir/FHIR-version"; 12259 case _3_3: return "http://hl7.org/fhir/FHIR-version"; 12260 case _3_3_0: return "http://hl7.org/fhir/FHIR-version"; 12261 case _3_5: return "http://hl7.org/fhir/FHIR-version"; 12262 case _3_5_0: return "http://hl7.org/fhir/FHIR-version"; 12263 case _4_0: return "http://hl7.org/fhir/FHIR-version"; 12264 case _4_0_0: return "http://hl7.org/fhir/FHIR-version"; 12265 case _4_0_1: return "http://hl7.org/fhir/FHIR-version"; 12266 case _4_1: return "http://hl7.org/fhir/FHIR-version"; 12267 case _4_1_0: return "http://hl7.org/fhir/FHIR-version"; 12268 case _4_2: return "http://hl7.org/fhir/FHIR-version"; 12269 case _4_2_0: return "http://hl7.org/fhir/FHIR-version"; 12270 case _4_3: return "http://hl7.org/fhir/FHIR-version"; 12271 case _4_3_0: return "http://hl7.org/fhir/FHIR-version"; 12272 case _4_3_0CIBUILD: return "http://hl7.org/fhir/FHIR-version"; 12273 case _4_3_0SNAPSHOT1: return "http://hl7.org/fhir/FHIR-version"; 12274 case _4_4: return "http://hl7.org/fhir/FHIR-version"; 12275 case _4_4_0: return "http://hl7.org/fhir/FHIR-version"; 12276 case _4_5: return "http://hl7.org/fhir/FHIR-version"; 12277 case _4_5_0: return "http://hl7.org/fhir/FHIR-version"; 12278 case _4_6: return "http://hl7.org/fhir/FHIR-version"; 12279 case _4_6_0: return "http://hl7.org/fhir/FHIR-version"; 12280 case _5_0: return "http://hl7.org/fhir/FHIR-version"; 12281 case _5_0_0: return "http://hl7.org/fhir/FHIR-version"; 12282 case _5_0_0CIBUILD: return "http://hl7.org/fhir/FHIR-version"; 12283 case _5_0_0SNAPSHOT1: return "http://hl7.org/fhir/FHIR-version"; 12284 case _5_0_0SNAPSHOT2: return "http://hl7.org/fhir/FHIR-version"; 12285 case _5_0_0BALLOT: return "http://hl7.org/fhir/FHIR-version"; 12286 case _5_0_0SNAPSHOT3: return "http://hl7.org/fhir/FHIR-version"; 12287 case _5_0_0DRAFTFINAL: return "http://hl7.org/fhir/FHIR-version"; 12288 case _6_0_0CIBUILD: return "http://hl7.org/fhir/FHIR-version"; 12289 case _6_0_0: return "http://hl7.org/fhir/FHIR-version"; 12290 case NULL: return null; 12291 default: return "?"; 12292 } 12293 } 12294 public String getDefinition() { 12295 switch (this) { 12296 case _0_01: return "Oldest archived version of FHIR."; 12297 case _0_05: return "1st Draft for Comment (Sept 2012 Ballot)."; 12298 case _0_06: return "2nd Draft for Comment (January 2013 Ballot)."; 12299 case _0_11: return "DSTU 1 Ballot version."; 12300 case _0_0: return "DSTU 1 version."; 12301 case _0_0_80: return "DSTU 1 Official version."; 12302 case _0_0_81: return "DSTU 1 Official version Technical Errata #1."; 12303 case _0_0_82: return "DSTU 1 Official version Technical Errata #2."; 12304 case _0_4: return "January 2015 Ballot."; 12305 case _0_4_0: return "Draft For Comment (January 2015 Ballot)."; 12306 case _0_5: return "May 2015 Ballot."; 12307 case _0_5_0: return "DSTU 2 Ballot version (May 2015 Ballot)."; 12308 case _1_0: return "DSTU 2 version."; 12309 case _1_0_0: return "DSTU 2 QA Preview + CQIF Ballot (Sep 2015)."; 12310 case _1_0_1: return "DSTU 2 (Official version)."; 12311 case _1_0_2: return "DSTU 2 (Official version) with 1 technical errata."; 12312 case _1_1: return "GAO Ballot version."; 12313 case _1_1_0: return "GAO Ballot + draft changes to main FHIR standard."; 12314 case _1_4: return "Connectathon 12 (Montreal) version."; 12315 case _1_4_0: return "CQF on FHIR Ballot + Connectathon 12 (Montreal)."; 12316 case _1_6: return "Connectathon 13 (Baltimore) version."; 12317 case _1_6_0: return "FHIR STU3 Ballot + Connectathon 13 (Baltimore)."; 12318 case _1_8: return "Connectathon 14 (San Antonio) version."; 12319 case _1_8_0: return "FHIR STU3 Candidate + Connectathon 14 (San Antonio)."; 12320 case _3_0: return "STU3 version."; 12321 case _3_0_0: return "FHIR Release 3 (STU)."; 12322 case _3_0_1: return "FHIR Release 3 (STU) with 1 technical errata."; 12323 case _3_0_2: return "FHIR Release 3 (STU) with 2 technical errata."; 12324 case _3_3: return "R4 Ballot #1 version."; 12325 case _3_3_0: return "R4 Ballot #1 + Connectaton 18 (Cologne)."; 12326 case _3_5: return "R4 Ballot #2 version."; 12327 case _3_5_0: return "R4 Ballot #2 + Connectathon 19 (Baltimore)."; 12328 case _4_0: return "R4 version."; 12329 case _4_0_0: return "FHIR Release 4 (Normative + STU)."; 12330 case _4_0_1: return "FHIR Release 4 (Normative + STU) with 1 technical errata."; 12331 case _4_1: return "R4B Ballot #1 version."; 12332 case _4_1_0: return "R4B Ballot #1 + Connectathon 27 (Virtual)."; 12333 case _4_2: return "R5 Preview #1 version."; 12334 case _4_2_0: return "R5 Preview #1 + Connectathon 23 (Sydney)."; 12335 case _4_3: return "R4B version."; 12336 case _4_3_0: return "FHIR Release 4B (Normative + STU)."; 12337 case _4_3_0CIBUILD: return "FHIR Release 4B CI-Builld."; 12338 case _4_3_0SNAPSHOT1: return "FHIR Release 4B Snapshot #1."; 12339 case _4_4: return "R5 Preview #2 version."; 12340 case _4_4_0: return "R5 Preview #2 + Connectathon 24 (Virtual)."; 12341 case _4_5: return "R5 Preview #3 version."; 12342 case _4_5_0: return "R5 Preview #3 + Connectathon 25 (Virtual)."; 12343 case _4_6: return "R5 Draft Ballot version."; 12344 case _4_6_0: return "R5 Draft Ballot + Connectathon 27 (Virtual)."; 12345 case _5_0: return "R5 Versions."; 12346 case _5_0_0: return "R5 Final Version."; 12347 case _5_0_0CIBUILD: return "R5 Rolling ci-build."; 12348 case _5_0_0SNAPSHOT1: return "R5 Preview #2."; 12349 case _5_0_0SNAPSHOT2: return "R5 Interim tooling stage."; 12350 case _5_0_0BALLOT: return "R5 Ballot."; 12351 case _5_0_0SNAPSHOT3: return "R5 January 2023 Staging Release + Connectathon 32."; 12352 case _5_0_0DRAFTFINAL: return "R5 Final QA."; 12353 case _6_0_0CIBUILD: return "R6 Rolling ci-build."; 12354 case _6_0_0: return "R6 Final Version."; 12355 case NULL: return null; 12356 default: return "?"; 12357 } 12358 } 12359 public String getDisplay() { 12360 switch (this) { 12361 case _0_01: return "0.01"; 12362 case _0_05: return "0.05"; 12363 case _0_06: return "0.06"; 12364 case _0_11: return "0.11"; 12365 case _0_0: return "0.0"; 12366 case _0_0_80: return "0.0.80"; 12367 case _0_0_81: return "0.0.81"; 12368 case _0_0_82: return "0.0.82"; 12369 case _0_4: return "0.4"; 12370 case _0_4_0: return "0.4.0"; 12371 case _0_5: return "0.5"; 12372 case _0_5_0: return "0.5.0"; 12373 case _1_0: return "1.0"; 12374 case _1_0_0: return "1.0.0"; 12375 case _1_0_1: return "1.0.1"; 12376 case _1_0_2: return "1.0.2"; 12377 case _1_1: return "1.1"; 12378 case _1_1_0: return "1.1.0"; 12379 case _1_4: return "1.4"; 12380 case _1_4_0: return "1.4.0"; 12381 case _1_6: return "1.6"; 12382 case _1_6_0: return "1.6.0"; 12383 case _1_8: return "1.8"; 12384 case _1_8_0: return "1.8.0"; 12385 case _3_0: return "3.0"; 12386 case _3_0_0: return "3.0.0"; 12387 case _3_0_1: return "3.0.1"; 12388 case _3_0_2: return "3.0.2"; 12389 case _3_3: return "3.3"; 12390 case _3_3_0: return "3.3.0"; 12391 case _3_5: return "3.5"; 12392 case _3_5_0: return "3.5.0"; 12393 case _4_0: return "4.0"; 12394 case _4_0_0: return "4.0.0"; 12395 case _4_0_1: return "4.0.1"; 12396 case _4_1: return "4.1"; 12397 case _4_1_0: return "4.1.0"; 12398 case _4_2: return "4.2"; 12399 case _4_2_0: return "4.2.0"; 12400 case _4_3: return "4.3"; 12401 case _4_3_0: return "4.3.0"; 12402 case _4_3_0CIBUILD: return "4.3.0-cibuild"; 12403 case _4_3_0SNAPSHOT1: return "4.3.0-snapshot1"; 12404 case _4_4: return "4.4"; 12405 case _4_4_0: return "4.4.0"; 12406 case _4_5: return "4.5"; 12407 case _4_5_0: return "4.5.0"; 12408 case _4_6: return "4.6"; 12409 case _4_6_0: return "4.6.0"; 12410 case _5_0: return "5.0"; 12411 case _5_0_0: return "5.0.0"; 12412 case _5_0_0CIBUILD: return "5.0.0-cibuild"; 12413 case _5_0_0SNAPSHOT1: return "5.0.0-snapshot1"; 12414 case _5_0_0SNAPSHOT2: return "5.0.0-snapshot2"; 12415 case _5_0_0BALLOT: return "5.0.0-ballot"; 12416 case _5_0_0SNAPSHOT3: return "5.0.0-snapshot3"; 12417 case _5_0_0DRAFTFINAL: return "5.0.0-draft-final"; 12418 case _6_0_0CIBUILD: return "6.0.0-cibuild"; 12419 case _6_0_0: return "6.0.0"; 12420 case NULL: return null; 12421 default: return "?"; 12422 } 12423 } 12424// manual code from configuration.txt: 12425//public String toCode(int len) { 12426// return toCode().substring(0, len); 12427// } 12428// 12429// 12430// @Override 12431// public String toString() { 12432// return toCode(); 12433// } 12434// 12435// 12436// public boolean isR4B() { 12437// return toCode().startsWith("4.1"); 12438// } 12439// 12440// end addition 12441 } 12442 12443 public static class FHIRVersionEnumFactory implements EnumFactory<FHIRVersion> { 12444 public FHIRVersion fromCode(String codeString) throws IllegalArgumentException { 12445 if (codeString == null || "".equals(codeString)) 12446 if (codeString == null || "".equals(codeString)) 12447 return null; 12448 if ("0.01".equals(codeString)) 12449 return FHIRVersion._0_01; 12450 if ("0.05".equals(codeString)) 12451 return FHIRVersion._0_05; 12452 if ("0.06".equals(codeString)) 12453 return FHIRVersion._0_06; 12454 if ("0.11".equals(codeString)) 12455 return FHIRVersion._0_11; 12456 if ("0.0".equals(codeString)) 12457 return FHIRVersion._0_0; 12458 if ("0.0.80".equals(codeString)) 12459 return FHIRVersion._0_0_80; 12460 if ("0.0.81".equals(codeString)) 12461 return FHIRVersion._0_0_81; 12462 if ("0.0.82".equals(codeString)) 12463 return FHIRVersion._0_0_82; 12464 if ("0.4".equals(codeString)) 12465 return FHIRVersion._0_4; 12466 if ("0.4.0".equals(codeString)) 12467 return FHIRVersion._0_4_0; 12468 if ("0.5".equals(codeString)) 12469 return FHIRVersion._0_5; 12470 if ("0.5.0".equals(codeString)) 12471 return FHIRVersion._0_5_0; 12472 if ("1.0".equals(codeString)) 12473 return FHIRVersion._1_0; 12474 if ("1.0.0".equals(codeString)) 12475 return FHIRVersion._1_0_0; 12476 if ("1.0.1".equals(codeString)) 12477 return FHIRVersion._1_0_1; 12478 if ("1.0.2".equals(codeString)) 12479 return FHIRVersion._1_0_2; 12480 if ("1.1".equals(codeString)) 12481 return FHIRVersion._1_1; 12482 if ("1.1.0".equals(codeString)) 12483 return FHIRVersion._1_1_0; 12484 if ("1.4".equals(codeString)) 12485 return FHIRVersion._1_4; 12486 if ("1.4.0".equals(codeString)) 12487 return FHIRVersion._1_4_0; 12488 if ("1.6".equals(codeString)) 12489 return FHIRVersion._1_6; 12490 if ("1.6.0".equals(codeString)) 12491 return FHIRVersion._1_6_0; 12492 if ("1.8".equals(codeString)) 12493 return FHIRVersion._1_8; 12494 if ("1.8.0".equals(codeString)) 12495 return FHIRVersion._1_8_0; 12496 if ("3.0".equals(codeString)) 12497 return FHIRVersion._3_0; 12498 if ("3.0.0".equals(codeString)) 12499 return FHIRVersion._3_0_0; 12500 if ("3.0.1".equals(codeString)) 12501 return FHIRVersion._3_0_1; 12502 if ("3.0.2".equals(codeString)) 12503 return FHIRVersion._3_0_2; 12504 if ("3.3".equals(codeString)) 12505 return FHIRVersion._3_3; 12506 if ("3.3.0".equals(codeString)) 12507 return FHIRVersion._3_3_0; 12508 if ("3.5".equals(codeString)) 12509 return FHIRVersion._3_5; 12510 if ("3.5.0".equals(codeString)) 12511 return FHIRVersion._3_5_0; 12512 if ("4.0".equals(codeString)) 12513 return FHIRVersion._4_0; 12514 if ("4.0.0".equals(codeString)) 12515 return FHIRVersion._4_0_0; 12516 if ("4.0.1".equals(codeString)) 12517 return FHIRVersion._4_0_1; 12518 if ("4.1".equals(codeString)) 12519 return FHIRVersion._4_1; 12520 if ("4.1.0".equals(codeString)) 12521 return FHIRVersion._4_1_0; 12522 if ("4.2".equals(codeString)) 12523 return FHIRVersion._4_2; 12524 if ("4.2.0".equals(codeString)) 12525 return FHIRVersion._4_2_0; 12526 if ("4.3".equals(codeString)) 12527 return FHIRVersion._4_3; 12528 if ("4.3.0".equals(codeString)) 12529 return FHIRVersion._4_3_0; 12530 if ("4.3.0-cibuild".equals(codeString)) 12531 return FHIRVersion._4_3_0CIBUILD; 12532 if ("4.3.0-snapshot1".equals(codeString)) 12533 return FHIRVersion._4_3_0SNAPSHOT1; 12534 if ("4.4".equals(codeString)) 12535 return FHIRVersion._4_4; 12536 if ("4.4.0".equals(codeString)) 12537 return FHIRVersion._4_4_0; 12538 if ("4.5".equals(codeString)) 12539 return FHIRVersion._4_5; 12540 if ("4.5.0".equals(codeString)) 12541 return FHIRVersion._4_5_0; 12542 if ("4.6".equals(codeString)) 12543 return FHIRVersion._4_6; 12544 if ("4.6.0".equals(codeString)) 12545 return FHIRVersion._4_6_0; 12546 if ("5.0".equals(codeString)) 12547 return FHIRVersion._5_0; 12548 if ("5.0.0".equals(codeString)) 12549 return FHIRVersion._5_0_0; 12550 if ("5.0.0-cibuild".equals(codeString)) 12551 return FHIRVersion._5_0_0CIBUILD; 12552 if ("5.0.0-snapshot1".equals(codeString)) 12553 return FHIRVersion._5_0_0SNAPSHOT1; 12554 if ("5.0.0-snapshot2".equals(codeString)) 12555 return FHIRVersion._5_0_0SNAPSHOT2; 12556 if ("5.0.0-ballot".equals(codeString)) 12557 return FHIRVersion._5_0_0BALLOT; 12558 if ("5.0.0-snapshot3".equals(codeString)) 12559 return FHIRVersion._5_0_0SNAPSHOT3; 12560 if ("5.0.0-draft-final".equals(codeString)) 12561 return FHIRVersion._5_0_0DRAFTFINAL; 12562 if ("6.0.0-cibuild".equals(codeString)) 12563 return FHIRVersion._6_0_0CIBUILD; 12564 if ("6.0.0".equals(codeString)) 12565 return FHIRVersion._6_0_0; 12566 throw new IllegalArgumentException("Unknown FHIRVersion code '"+codeString+"'"); 12567 } 12568 12569 public Enumeration<FHIRVersion> fromType(PrimitiveType<?> code) throws FHIRException { 12570 if (code == null) 12571 return null; 12572 if (code.isEmpty()) 12573 return new Enumeration<FHIRVersion>(this, FHIRVersion.NULL, code); 12574 String codeString = ((PrimitiveType) code).asStringValue(); 12575 if (codeString == null || "".equals(codeString)) 12576 return new Enumeration<FHIRVersion>(this, FHIRVersion.NULL, code); 12577 if ("0.01".equals(codeString)) 12578 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_01, code); 12579 if ("0.05".equals(codeString)) 12580 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_05, code); 12581 if ("0.06".equals(codeString)) 12582 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_06, code); 12583 if ("0.11".equals(codeString)) 12584 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_11, code); 12585 if ("0.0".equals(codeString)) 12586 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_0, code); 12587 if ("0.0.80".equals(codeString)) 12588 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_0_80, code); 12589 if ("0.0.81".equals(codeString)) 12590 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_0_81, code); 12591 if ("0.0.82".equals(codeString)) 12592 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_0_82, code); 12593 if ("0.4".equals(codeString)) 12594 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_4, code); 12595 if ("0.4.0".equals(codeString)) 12596 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_4_0, code); 12597 if ("0.5".equals(codeString)) 12598 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_5, code); 12599 if ("0.5.0".equals(codeString)) 12600 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_5_0, code); 12601 if ("1.0".equals(codeString)) 12602 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_0, code); 12603 if ("1.0.0".equals(codeString)) 12604 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_0_0, code); 12605 if ("1.0.1".equals(codeString)) 12606 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_0_1, code); 12607 if ("1.0.2".equals(codeString)) 12608 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_0_2, code); 12609 if ("1.1".equals(codeString)) 12610 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_1, code); 12611 if ("1.1.0".equals(codeString)) 12612 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_1_0, code); 12613 if ("1.4".equals(codeString)) 12614 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_4, code); 12615 if ("1.4.0".equals(codeString)) 12616 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_4_0, code); 12617 if ("1.6".equals(codeString)) 12618 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_6, code); 12619 if ("1.6.0".equals(codeString)) 12620 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_6_0, code); 12621 if ("1.8".equals(codeString)) 12622 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_8, code); 12623 if ("1.8.0".equals(codeString)) 12624 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_8_0, code); 12625 if ("3.0".equals(codeString)) 12626 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_0, code); 12627 if ("3.0.0".equals(codeString)) 12628 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_0_0, code); 12629 if ("3.0.1".equals(codeString)) 12630 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_0_1, code); 12631 if ("3.0.2".equals(codeString)) 12632 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_0_2, code); 12633 if ("3.3".equals(codeString)) 12634 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_3, code); 12635 if ("3.3.0".equals(codeString)) 12636 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_3_0, code); 12637 if ("3.5".equals(codeString)) 12638 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_5, code); 12639 if ("3.5.0".equals(codeString)) 12640 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_5_0, code); 12641 if ("4.0".equals(codeString)) 12642 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_0, code); 12643 if ("4.0.0".equals(codeString)) 12644 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_0_0, code); 12645 if ("4.0.1".equals(codeString)) 12646 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_0_1, code); 12647 if ("4.1".equals(codeString)) 12648 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_1, code); 12649 if ("4.1.0".equals(codeString)) 12650 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_1_0, code); 12651 if ("4.2".equals(codeString)) 12652 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_2, code); 12653 if ("4.2.0".equals(codeString)) 12654 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_2_0, code); 12655 if ("4.3".equals(codeString)) 12656 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_3, code); 12657 if ("4.3.0".equals(codeString)) 12658 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_3_0, code); 12659 if ("4.3.0-cibuild".equals(codeString)) 12660 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_3_0CIBUILD, code); 12661 if ("4.3.0-snapshot1".equals(codeString)) 12662 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_3_0SNAPSHOT1, code); 12663 if ("4.4".equals(codeString)) 12664 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_4, code); 12665 if ("4.4.0".equals(codeString)) 12666 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_4_0, code); 12667 if ("4.5".equals(codeString)) 12668 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_5, code); 12669 if ("4.5.0".equals(codeString)) 12670 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_5_0, code); 12671 if ("4.6".equals(codeString)) 12672 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_6, code); 12673 if ("4.6.0".equals(codeString)) 12674 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_6_0, code); 12675 if ("5.0".equals(codeString)) 12676 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0, code); 12677 if ("5.0.0".equals(codeString)) 12678 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0, code); 12679 if ("5.0.0-cibuild".equals(codeString)) 12680 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0CIBUILD, code); 12681 if ("5.0.0-snapshot1".equals(codeString)) 12682 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0SNAPSHOT1, code); 12683 if ("5.0.0-snapshot2".equals(codeString)) 12684 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0SNAPSHOT2, code); 12685 if ("5.0.0-ballot".equals(codeString)) 12686 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0BALLOT, code); 12687 if ("5.0.0-snapshot3".equals(codeString)) 12688 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0SNAPSHOT3, code); 12689 if ("5.0.0-draft-final".equals(codeString)) 12690 return new Enumeration<FHIRVersion>(this, FHIRVersion._5_0_0DRAFTFINAL, code); 12691 if ("6.0.0-cibuild".equals(codeString)) 12692 return new Enumeration<FHIRVersion>(this, FHIRVersion._6_0_0CIBUILD, code); 12693 if ("6.0.0".equals(codeString)) 12694 return new Enumeration<FHIRVersion>(this, FHIRVersion._6_0_0, code); 12695 throw new FHIRException("Unknown FHIRVersion code '"+codeString+"'"); 12696 } 12697 public String toCode(FHIRVersion code) { 12698 if (code == FHIRVersion._0_01) 12699 return "0.01"; 12700 if (code == FHIRVersion._0_05) 12701 return "0.05"; 12702 if (code == FHIRVersion._0_06) 12703 return "0.06"; 12704 if (code == FHIRVersion._0_11) 12705 return "0.11"; 12706 if (code == FHIRVersion._0_0) 12707 return "0.0"; 12708 if (code == FHIRVersion._0_0_80) 12709 return "0.0.80"; 12710 if (code == FHIRVersion._0_0_81) 12711 return "0.0.81"; 12712 if (code == FHIRVersion._0_0_82) 12713 return "0.0.82"; 12714 if (code == FHIRVersion._0_4) 12715 return "0.4"; 12716 if (code == FHIRVersion._0_4_0) 12717 return "0.4.0"; 12718 if (code == FHIRVersion._0_5) 12719 return "0.5"; 12720 if (code == FHIRVersion._0_5_0) 12721 return "0.5.0"; 12722 if (code == FHIRVersion._1_0) 12723 return "1.0"; 12724 if (code == FHIRVersion._1_0_0) 12725 return "1.0.0"; 12726 if (code == FHIRVersion._1_0_1) 12727 return "1.0.1"; 12728 if (code == FHIRVersion._1_0_2) 12729 return "1.0.2"; 12730 if (code == FHIRVersion._1_1) 12731 return "1.1"; 12732 if (code == FHIRVersion._1_1_0) 12733 return "1.1.0"; 12734 if (code == FHIRVersion._1_4) 12735 return "1.4"; 12736 if (code == FHIRVersion._1_4_0) 12737 return "1.4.0"; 12738 if (code == FHIRVersion._1_6) 12739 return "1.6"; 12740 if (code == FHIRVersion._1_6_0) 12741 return "1.6.0"; 12742 if (code == FHIRVersion._1_8) 12743 return "1.8"; 12744 if (code == FHIRVersion._1_8_0) 12745 return "1.8.0"; 12746 if (code == FHIRVersion._3_0) 12747 return "3.0"; 12748 if (code == FHIRVersion._3_0_0) 12749 return "3.0.0"; 12750 if (code == FHIRVersion._3_0_1) 12751 return "3.0.1"; 12752 if (code == FHIRVersion._3_0_2) 12753 return "3.0.2"; 12754 if (code == FHIRVersion._3_3) 12755 return "3.3"; 12756 if (code == FHIRVersion._3_3_0) 12757 return "3.3.0"; 12758 if (code == FHIRVersion._3_5) 12759 return "3.5"; 12760 if (code == FHIRVersion._3_5_0) 12761 return "3.5.0"; 12762 if (code == FHIRVersion._4_0) 12763 return "4.0"; 12764 if (code == FHIRVersion._4_0_0) 12765 return "4.0.0"; 12766 if (code == FHIRVersion._4_0_1) 12767 return "4.0.1"; 12768 if (code == FHIRVersion._4_1) 12769 return "4.1"; 12770 if (code == FHIRVersion._4_1_0) 12771 return "4.1.0"; 12772 if (code == FHIRVersion._4_2) 12773 return "4.2"; 12774 if (code == FHIRVersion._4_2_0) 12775 return "4.2.0"; 12776 if (code == FHIRVersion._4_3) 12777 return "4.3"; 12778 if (code == FHIRVersion._4_3_0) 12779 return "4.3.0"; 12780 if (code == FHIRVersion._4_3_0CIBUILD) 12781 return "4.3.0-cibuild"; 12782 if (code == FHIRVersion._4_3_0SNAPSHOT1) 12783 return "4.3.0-snapshot1"; 12784 if (code == FHIRVersion._4_4) 12785 return "4.4"; 12786 if (code == FHIRVersion._4_4_0) 12787 return "4.4.0"; 12788 if (code == FHIRVersion._4_5) 12789 return "4.5"; 12790 if (code == FHIRVersion._4_5_0) 12791 return "4.5.0"; 12792 if (code == FHIRVersion._4_6) 12793 return "4.6"; 12794 if (code == FHIRVersion._4_6_0) 12795 return "4.6.0"; 12796 if (code == FHIRVersion._5_0) 12797 return "5.0"; 12798 if (code == FHIRVersion._5_0_0) 12799 return "5.0.0"; 12800 if (code == FHIRVersion._5_0_0CIBUILD) 12801 return "5.0.0-cibuild"; 12802 if (code == FHIRVersion._5_0_0SNAPSHOT1) 12803 return "5.0.0-snapshot1"; 12804 if (code == FHIRVersion._5_0_0SNAPSHOT2) 12805 return "5.0.0-snapshot2"; 12806 if (code == FHIRVersion._5_0_0BALLOT) 12807 return "5.0.0-ballot"; 12808 if (code == FHIRVersion._5_0_0SNAPSHOT3) 12809 return "5.0.0-snapshot3"; 12810 if (code == FHIRVersion._5_0_0DRAFTFINAL) 12811 return "5.0.0-draft-final"; 12812 if (code == FHIRVersion._6_0_0CIBUILD) 12813 return "6.0.0-cibuild"; 12814 if (code == FHIRVersion._6_0_0) 12815 return "6.0.0"; 12816 return "?"; 12817 } 12818 public String toSystem(FHIRVersion code) { 12819 return code.getSystem(); 12820 } 12821 } 12822 12823 public enum FilterOperator { 12824 /** 12825 * The specified property of the code equals the provided value. 12826 */ 12827 EQUAL, 12828 /** 12829 * 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). 12830 */ 12831 ISA, 12832 /** 12833 * 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). 12834 */ 12835 DESCENDENTOF, 12836 /** 12837 * The specified property of the code does not have an is-a relationship with the provided value. 12838 */ 12839 ISNOTA, 12840 /** 12841 * The specified property of the code matches the regex specified in the provided value. 12842 */ 12843 REGEX, 12844 /** 12845 * The specified property of the code is in the set of codes or concepts specified in the provided value (comma-separated list). 12846 */ 12847 IN, 12848 /** 12849 * The specified property of the code is not in the set of codes or concepts specified in the provided value (comma-separated list). 12850 */ 12851 NOTIN, 12852 /** 12853 * 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). 12854 */ 12855 GENERALIZES, 12856 /** 12857 * 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. 12858 */ 12859 CHILDOF, 12860 /** 12861 * 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. 12862 */ 12863 DESCENDENTLEAF, 12864 /** 12865 * 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). 12866 */ 12867 EXISTS, 12868 /** 12869 * added to help the parsers 12870 */ 12871 NULL; 12872 public static FilterOperator fromCode(String codeString) throws FHIRException { 12873 if (codeString == null || "".equals(codeString)) 12874 return null; 12875 if ("=".equals(codeString)) 12876 return EQUAL; 12877 if ("is-a".equals(codeString)) 12878 return ISA; 12879 if ("descendent-of".equals(codeString)) 12880 return DESCENDENTOF; 12881 if ("is-not-a".equals(codeString)) 12882 return ISNOTA; 12883 if ("regex".equals(codeString)) 12884 return REGEX; 12885 if ("in".equals(codeString)) 12886 return IN; 12887 if ("not-in".equals(codeString)) 12888 return NOTIN; 12889 if ("generalizes".equals(codeString)) 12890 return GENERALIZES; 12891 if ("child-of".equals(codeString)) 12892 return CHILDOF; 12893 if ("descendent-leaf".equals(codeString)) 12894 return DESCENDENTLEAF; 12895 if ("exists".equals(codeString)) 12896 return EXISTS; 12897 throw new FHIRException("Unknown FilterOperator code '"+codeString+"'"); 12898 } 12899 public static boolean isValidCode(String codeString) { 12900 if (codeString == null || "".equals(codeString)) 12901 return false; 12902 return Utilities.existsInList(codeString, "=", "is-a", "descendent-of", "is-not-a", "regex", "in", "not-in", "generalizes", "child-of", "descendent-leaf", "exists"); 12903 } 12904 public String toCode() { 12905 switch (this) { 12906 case EQUAL: return "="; 12907 case ISA: return "is-a"; 12908 case DESCENDENTOF: return "descendent-of"; 12909 case ISNOTA: return "is-not-a"; 12910 case REGEX: return "regex"; 12911 case IN: return "in"; 12912 case NOTIN: return "not-in"; 12913 case GENERALIZES: return "generalizes"; 12914 case CHILDOF: return "child-of"; 12915 case DESCENDENTLEAF: return "descendent-leaf"; 12916 case EXISTS: return "exists"; 12917 case NULL: return null; 12918 default: return "?"; 12919 } 12920 } 12921 public String getSystem() { 12922 switch (this) { 12923 case EQUAL: return "http://hl7.org/fhir/filter-operator"; 12924 case ISA: return "http://hl7.org/fhir/filter-operator"; 12925 case DESCENDENTOF: return "http://hl7.org/fhir/filter-operator"; 12926 case ISNOTA: return "http://hl7.org/fhir/filter-operator"; 12927 case REGEX: return "http://hl7.org/fhir/filter-operator"; 12928 case IN: return "http://hl7.org/fhir/filter-operator"; 12929 case NOTIN: return "http://hl7.org/fhir/filter-operator"; 12930 case GENERALIZES: return "http://hl7.org/fhir/filter-operator"; 12931 case CHILDOF: return "http://hl7.org/fhir/filter-operator"; 12932 case DESCENDENTLEAF: return "http://hl7.org/fhir/filter-operator"; 12933 case EXISTS: return "http://hl7.org/fhir/filter-operator"; 12934 case NULL: return null; 12935 default: return "?"; 12936 } 12937 } 12938 public String getDefinition() { 12939 switch (this) { 12940 case EQUAL: return "The specified property of the code equals the provided value."; 12941 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)."; 12942 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)."; 12943 case ISNOTA: return "The specified property of the code does not have an is-a relationship with the provided value."; 12944 case REGEX: return "The specified property of the code matches the regex specified in the provided value."; 12945 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)."; 12946 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)."; 12947 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)."; 12948 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."; 12949 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."; 12950 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)."; 12951 case NULL: return null; 12952 default: return "?"; 12953 } 12954 } 12955 public String getDisplay() { 12956 switch (this) { 12957 case EQUAL: return "Equals"; 12958 case ISA: return "Is A (by subsumption)"; 12959 case DESCENDENTOF: return "Descendent Of (by subsumption)"; 12960 case ISNOTA: return "Not (Is A) (by subsumption)"; 12961 case REGEX: return "Regular Expression"; 12962 case IN: return "In Set"; 12963 case NOTIN: return "Not in Set"; 12964 case GENERALIZES: return "Generalizes (by Subsumption)"; 12965 case CHILDOF: return "Child Of"; 12966 case DESCENDENTLEAF: return "Descendent Leaf"; 12967 case EXISTS: return "Exists"; 12968 case NULL: return null; 12969 default: return "?"; 12970 } 12971 } 12972 } 12973 12974 public static class FilterOperatorEnumFactory implements EnumFactory<FilterOperator> { 12975 public FilterOperator fromCode(String codeString) throws IllegalArgumentException { 12976 if (codeString == null || "".equals(codeString)) 12977 if (codeString == null || "".equals(codeString)) 12978 return null; 12979 if ("=".equals(codeString)) 12980 return FilterOperator.EQUAL; 12981 if ("is-a".equals(codeString)) 12982 return FilterOperator.ISA; 12983 if ("descendent-of".equals(codeString)) 12984 return FilterOperator.DESCENDENTOF; 12985 if ("is-not-a".equals(codeString)) 12986 return FilterOperator.ISNOTA; 12987 if ("regex".equals(codeString)) 12988 return FilterOperator.REGEX; 12989 if ("in".equals(codeString)) 12990 return FilterOperator.IN; 12991 if ("not-in".equals(codeString)) 12992 return FilterOperator.NOTIN; 12993 if ("generalizes".equals(codeString)) 12994 return FilterOperator.GENERALIZES; 12995 if ("child-of".equals(codeString)) 12996 return FilterOperator.CHILDOF; 12997 if ("descendent-leaf".equals(codeString)) 12998 return FilterOperator.DESCENDENTLEAF; 12999 if ("exists".equals(codeString)) 13000 return FilterOperator.EXISTS; 13001 throw new IllegalArgumentException("Unknown FilterOperator code '"+codeString+"'"); 13002 } 13003 13004 public Enumeration<FilterOperator> fromType(PrimitiveType<?> code) throws FHIRException { 13005 if (code == null) 13006 return null; 13007 if (code.isEmpty()) 13008 return new Enumeration<FilterOperator>(this, FilterOperator.NULL, code); 13009 String codeString = ((PrimitiveType) code).asStringValue(); 13010 if (codeString == null || "".equals(codeString)) 13011 return new Enumeration<FilterOperator>(this, FilterOperator.NULL, code); 13012 if ("=".equals(codeString)) 13013 return new Enumeration<FilterOperator>(this, FilterOperator.EQUAL, code); 13014 if ("is-a".equals(codeString)) 13015 return new Enumeration<FilterOperator>(this, FilterOperator.ISA, code); 13016 if ("descendent-of".equals(codeString)) 13017 return new Enumeration<FilterOperator>(this, FilterOperator.DESCENDENTOF, code); 13018 if ("is-not-a".equals(codeString)) 13019 return new Enumeration<FilterOperator>(this, FilterOperator.ISNOTA, code); 13020 if ("regex".equals(codeString)) 13021 return new Enumeration<FilterOperator>(this, FilterOperator.REGEX, code); 13022 if ("in".equals(codeString)) 13023 return new Enumeration<FilterOperator>(this, FilterOperator.IN, code); 13024 if ("not-in".equals(codeString)) 13025 return new Enumeration<FilterOperator>(this, FilterOperator.NOTIN, code); 13026 if ("generalizes".equals(codeString)) 13027 return new Enumeration<FilterOperator>(this, FilterOperator.GENERALIZES, code); 13028 if ("child-of".equals(codeString)) 13029 return new Enumeration<FilterOperator>(this, FilterOperator.CHILDOF, code); 13030 if ("descendent-leaf".equals(codeString)) 13031 return new Enumeration<FilterOperator>(this, FilterOperator.DESCENDENTLEAF, code); 13032 if ("exists".equals(codeString)) 13033 return new Enumeration<FilterOperator>(this, FilterOperator.EXISTS, code); 13034 throw new FHIRException("Unknown FilterOperator code '"+codeString+"'"); 13035 } 13036 public String toCode(FilterOperator code) { 13037 if (code == FilterOperator.EQUAL) 13038 return "="; 13039 if (code == FilterOperator.ISA) 13040 return "is-a"; 13041 if (code == FilterOperator.DESCENDENTOF) 13042 return "descendent-of"; 13043 if (code == FilterOperator.ISNOTA) 13044 return "is-not-a"; 13045 if (code == FilterOperator.REGEX) 13046 return "regex"; 13047 if (code == FilterOperator.IN) 13048 return "in"; 13049 if (code == FilterOperator.NOTIN) 13050 return "not-in"; 13051 if (code == FilterOperator.GENERALIZES) 13052 return "generalizes"; 13053 if (code == FilterOperator.CHILDOF) 13054 return "child-of"; 13055 if (code == FilterOperator.DESCENDENTLEAF) 13056 return "descendent-leaf"; 13057 if (code == FilterOperator.EXISTS) 13058 return "exists"; 13059 return "?"; 13060 } 13061 public String toSystem(FilterOperator code) { 13062 return code.getSystem(); 13063 } 13064 } 13065 13066 public enum FinancialResourceStatusCodes { 13067 /** 13068 * The instance is currently in-force. 13069 */ 13070 ACTIVE, 13071 /** 13072 * The instance is withdrawn, rescinded or reversed. 13073 */ 13074 CANCELLED, 13075 /** 13076 * A new instance the contents of which is not complete. 13077 */ 13078 DRAFT, 13079 /** 13080 * The instance was entered in error. 13081 */ 13082 ENTEREDINERROR, 13083 /** 13084 * added to help the parsers 13085 */ 13086 NULL; 13087 public static FinancialResourceStatusCodes fromCode(String codeString) throws FHIRException { 13088 if (codeString == null || "".equals(codeString)) 13089 return null; 13090 if ("active".equals(codeString)) 13091 return ACTIVE; 13092 if ("cancelled".equals(codeString)) 13093 return CANCELLED; 13094 if ("draft".equals(codeString)) 13095 return DRAFT; 13096 if ("entered-in-error".equals(codeString)) 13097 return ENTEREDINERROR; 13098 throw new FHIRException("Unknown FinancialResourceStatusCodes code '"+codeString+"'"); 13099 } 13100 public static boolean isValidCode(String codeString) { 13101 if (codeString == null || "".equals(codeString)) 13102 return false; 13103 return Utilities.existsInList(codeString, "active", "cancelled", "draft", "entered-in-error"); 13104 } 13105 public String toCode() { 13106 switch (this) { 13107 case ACTIVE: return "active"; 13108 case CANCELLED: return "cancelled"; 13109 case DRAFT: return "draft"; 13110 case ENTEREDINERROR: return "entered-in-error"; 13111 case NULL: return null; 13112 default: return "?"; 13113 } 13114 } 13115 public String getSystem() { 13116 switch (this) { 13117 case ACTIVE: return "http://hl7.org/fhir/fm-status"; 13118 case CANCELLED: return "http://hl7.org/fhir/fm-status"; 13119 case DRAFT: return "http://hl7.org/fhir/fm-status"; 13120 case ENTEREDINERROR: return "http://hl7.org/fhir/fm-status"; 13121 case NULL: return null; 13122 default: return "?"; 13123 } 13124 } 13125 public String getDefinition() { 13126 switch (this) { 13127 case ACTIVE: return "The instance is currently in-force."; 13128 case CANCELLED: return "The instance is withdrawn, rescinded or reversed."; 13129 case DRAFT: return "A new instance the contents of which is not complete."; 13130 case ENTEREDINERROR: return "The instance was entered in error."; 13131 case NULL: return null; 13132 default: return "?"; 13133 } 13134 } 13135 public String getDisplay() { 13136 switch (this) { 13137 case ACTIVE: return "Active"; 13138 case CANCELLED: return "Cancelled"; 13139 case DRAFT: return "Draft"; 13140 case ENTEREDINERROR: return "Entered in Error"; 13141 case NULL: return null; 13142 default: return "?"; 13143 } 13144 } 13145 } 13146 13147 public static class FinancialResourceStatusCodesEnumFactory implements EnumFactory<FinancialResourceStatusCodes> { 13148 public FinancialResourceStatusCodes fromCode(String codeString) throws IllegalArgumentException { 13149 if (codeString == null || "".equals(codeString)) 13150 if (codeString == null || "".equals(codeString)) 13151 return null; 13152 if ("active".equals(codeString)) 13153 return FinancialResourceStatusCodes.ACTIVE; 13154 if ("cancelled".equals(codeString)) 13155 return FinancialResourceStatusCodes.CANCELLED; 13156 if ("draft".equals(codeString)) 13157 return FinancialResourceStatusCodes.DRAFT; 13158 if ("entered-in-error".equals(codeString)) 13159 return FinancialResourceStatusCodes.ENTEREDINERROR; 13160 throw new IllegalArgumentException("Unknown FinancialResourceStatusCodes code '"+codeString+"'"); 13161 } 13162 13163 public Enumeration<FinancialResourceStatusCodes> fromType(PrimitiveType<?> code) throws FHIRException { 13164 if (code == null) 13165 return null; 13166 if (code.isEmpty()) 13167 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.NULL, code); 13168 String codeString = ((PrimitiveType) code).asStringValue(); 13169 if (codeString == null || "".equals(codeString)) 13170 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.NULL, code); 13171 if ("active".equals(codeString)) 13172 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.ACTIVE, code); 13173 if ("cancelled".equals(codeString)) 13174 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.CANCELLED, code); 13175 if ("draft".equals(codeString)) 13176 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.DRAFT, code); 13177 if ("entered-in-error".equals(codeString)) 13178 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.ENTEREDINERROR, code); 13179 throw new FHIRException("Unknown FinancialResourceStatusCodes code '"+codeString+"'"); 13180 } 13181 public String toCode(FinancialResourceStatusCodes code) { 13182 if (code == FinancialResourceStatusCodes.ACTIVE) 13183 return "active"; 13184 if (code == FinancialResourceStatusCodes.CANCELLED) 13185 return "cancelled"; 13186 if (code == FinancialResourceStatusCodes.DRAFT) 13187 return "draft"; 13188 if (code == FinancialResourceStatusCodes.ENTEREDINERROR) 13189 return "entered-in-error"; 13190 return "?"; 13191 } 13192 public String toSystem(FinancialResourceStatusCodes code) { 13193 return code.getSystem(); 13194 } 13195 } 13196 13197 public enum ListMode { 13198 /** 13199 * This list is the master list, maintained in an ongoing fashion with regular updates as the real-world list it is tracking changes. 13200 */ 13201 WORKING, 13202 /** 13203 * This list was prepared as a snapshot. It should not be assumed to be current. 13204 */ 13205 SNAPSHOT, 13206 /** 13207 * 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. 13208 */ 13209 CHANGES, 13210 /** 13211 * added to help the parsers 13212 */ 13213 NULL; 13214 public static ListMode fromCode(String codeString) throws FHIRException { 13215 if (codeString == null || "".equals(codeString)) 13216 return null; 13217 if ("working".equals(codeString)) 13218 return WORKING; 13219 if ("snapshot".equals(codeString)) 13220 return SNAPSHOT; 13221 if ("changes".equals(codeString)) 13222 return CHANGES; 13223 throw new FHIRException("Unknown ListMode code '"+codeString+"'"); 13224 } 13225 public static boolean isValidCode(String codeString) { 13226 if (codeString == null || "".equals(codeString)) 13227 return false; 13228 return Utilities.existsInList(codeString, "working", "snapshot", "changes"); 13229 } 13230 public String toCode() { 13231 switch (this) { 13232 case WORKING: return "working"; 13233 case SNAPSHOT: return "snapshot"; 13234 case CHANGES: return "changes"; 13235 case NULL: return null; 13236 default: return "?"; 13237 } 13238 } 13239 public String getSystem() { 13240 switch (this) { 13241 case WORKING: return "http://hl7.org/fhir/list-mode"; 13242 case SNAPSHOT: return "http://hl7.org/fhir/list-mode"; 13243 case CHANGES: return "http://hl7.org/fhir/list-mode"; 13244 case NULL: return null; 13245 default: return "?"; 13246 } 13247 } 13248 public String getDefinition() { 13249 switch (this) { 13250 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."; 13251 case SNAPSHOT: return "This list was prepared as a snapshot. It should not be assumed to be current."; 13252 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."; 13253 case NULL: return null; 13254 default: return "?"; 13255 } 13256 } 13257 public String getDisplay() { 13258 switch (this) { 13259 case WORKING: return "Working List"; 13260 case SNAPSHOT: return "Snapshot List"; 13261 case CHANGES: return "Change List"; 13262 case NULL: return null; 13263 default: return "?"; 13264 } 13265 } 13266 } 13267 13268 public static class ListModeEnumFactory implements EnumFactory<ListMode> { 13269 public ListMode fromCode(String codeString) throws IllegalArgumentException { 13270 if (codeString == null || "".equals(codeString)) 13271 if (codeString == null || "".equals(codeString)) 13272 return null; 13273 if ("working".equals(codeString)) 13274 return ListMode.WORKING; 13275 if ("snapshot".equals(codeString)) 13276 return ListMode.SNAPSHOT; 13277 if ("changes".equals(codeString)) 13278 return ListMode.CHANGES; 13279 throw new IllegalArgumentException("Unknown ListMode code '"+codeString+"'"); 13280 } 13281 13282 public Enumeration<ListMode> fromType(PrimitiveType<?> code) throws FHIRException { 13283 if (code == null) 13284 return null; 13285 if (code.isEmpty()) 13286 return new Enumeration<ListMode>(this, ListMode.NULL, code); 13287 String codeString = ((PrimitiveType) code).asStringValue(); 13288 if (codeString == null || "".equals(codeString)) 13289 return new Enumeration<ListMode>(this, ListMode.NULL, code); 13290 if ("working".equals(codeString)) 13291 return new Enumeration<ListMode>(this, ListMode.WORKING, code); 13292 if ("snapshot".equals(codeString)) 13293 return new Enumeration<ListMode>(this, ListMode.SNAPSHOT, code); 13294 if ("changes".equals(codeString)) 13295 return new Enumeration<ListMode>(this, ListMode.CHANGES, code); 13296 throw new FHIRException("Unknown ListMode code '"+codeString+"'"); 13297 } 13298 public String toCode(ListMode code) { 13299 if (code == ListMode.WORKING) 13300 return "working"; 13301 if (code == ListMode.SNAPSHOT) 13302 return "snapshot"; 13303 if (code == ListMode.CHANGES) 13304 return "changes"; 13305 return "?"; 13306 } 13307 public String toSystem(ListMode code) { 13308 return code.getSystem(); 13309 } 13310 } 13311 13312 public enum MeasureImprovementNotation { 13313 /** 13314 * null 13315 */ 13316 INCREASE, 13317 /** 13318 * null 13319 */ 13320 DECREASE, 13321 /** 13322 * added to help the parsers 13323 */ 13324 NULL; 13325 public static MeasureImprovementNotation fromCode(String codeString) throws FHIRException { 13326 if (codeString == null || "".equals(codeString)) 13327 return null; 13328 if ("increase".equals(codeString)) 13329 return INCREASE; 13330 if ("decrease".equals(codeString)) 13331 return DECREASE; 13332 throw new FHIRException("Unknown MeasureImprovementNotation code '"+codeString+"'"); 13333 } 13334 public static boolean isValidCode(String codeString) { 13335 if (codeString == null || "".equals(codeString)) 13336 return false; 13337 return Utilities.existsInList(codeString, "increase", "decrease"); 13338 } 13339 public String toCode() { 13340 switch (this) { 13341 case INCREASE: return "increase"; 13342 case DECREASE: return "decrease"; 13343 case NULL: return null; 13344 default: return "?"; 13345 } 13346 } 13347 public String getSystem() { 13348 switch (this) { 13349 case INCREASE: return "http://terminology.hl7.org/CodeSystem/measure-improvement-notation"; 13350 case DECREASE: return "http://terminology.hl7.org/CodeSystem/measure-improvement-notation"; 13351 case NULL: return null; 13352 default: return "?"; 13353 } 13354 } 13355 public String getDefinition() { 13356 switch (this) { 13357 case INCREASE: return ""; 13358 case DECREASE: return ""; 13359 case NULL: return null; 13360 default: return "?"; 13361 } 13362 } 13363 public String getDisplay() { 13364 switch (this) { 13365 case INCREASE: return "Increased score indicates improvement"; 13366 case DECREASE: return "Decreased score indicates improvement"; 13367 case NULL: return null; 13368 default: return "?"; 13369 } 13370 } 13371 } 13372 13373 public static class MeasureImprovementNotationEnumFactory implements EnumFactory<MeasureImprovementNotation> { 13374 public MeasureImprovementNotation fromCode(String codeString) throws IllegalArgumentException { 13375 if (codeString == null || "".equals(codeString)) 13376 if (codeString == null || "".equals(codeString)) 13377 return null; 13378 if ("increase".equals(codeString)) 13379 return MeasureImprovementNotation.INCREASE; 13380 if ("decrease".equals(codeString)) 13381 return MeasureImprovementNotation.DECREASE; 13382 throw new IllegalArgumentException("Unknown MeasureImprovementNotation code '"+codeString+"'"); 13383 } 13384 13385 public Enumeration<MeasureImprovementNotation> fromType(PrimitiveType<?> code) throws FHIRException { 13386 if (code == null) 13387 return null; 13388 if (code.isEmpty()) 13389 return new Enumeration<MeasureImprovementNotation>(this, MeasureImprovementNotation.NULL, code); 13390 String codeString = ((PrimitiveType) code).asStringValue(); 13391 if (codeString == null || "".equals(codeString)) 13392 return new Enumeration<MeasureImprovementNotation>(this, MeasureImprovementNotation.NULL, code); 13393 if ("increase".equals(codeString)) 13394 return new Enumeration<MeasureImprovementNotation>(this, MeasureImprovementNotation.INCREASE, code); 13395 if ("decrease".equals(codeString)) 13396 return new Enumeration<MeasureImprovementNotation>(this, MeasureImprovementNotation.DECREASE, code); 13397 throw new FHIRException("Unknown MeasureImprovementNotation code '"+codeString+"'"); 13398 } 13399 public String toCode(MeasureImprovementNotation code) { 13400 if (code == MeasureImprovementNotation.INCREASE) 13401 return "increase"; 13402 if (code == MeasureImprovementNotation.DECREASE) 13403 return "decrease"; 13404 return "?"; 13405 } 13406 public String toSystem(MeasureImprovementNotation code) { 13407 return code.getSystem(); 13408 } 13409 } 13410 13411 public enum MimeTypes { 13412 /** 13413 * added to help the parsers 13414 */ 13415 NULL; 13416 public static MimeTypes fromCode(String codeString) throws FHIRException { 13417 if (codeString == null || "".equals(codeString)) 13418 return null; 13419 throw new FHIRException("Unknown MimeTypes code '"+codeString+"'"); 13420 } 13421 public static boolean isValidCode(String codeString) { 13422 if (codeString == null || "".equals(codeString)) 13423 return false; 13424 return Utilities.existsInList(codeString); 13425 } 13426 public String toCode() { 13427 switch (this) { 13428 case NULL: return null; 13429 default: return "?"; 13430 } 13431 } 13432 public String getSystem() { 13433 switch (this) { 13434 case NULL: return null; 13435 default: return "?"; 13436 } 13437 } 13438 public String getDefinition() { 13439 switch (this) { 13440 case NULL: return null; 13441 default: return "?"; 13442 } 13443 } 13444 public String getDisplay() { 13445 switch (this) { 13446 case NULL: return null; 13447 default: return "?"; 13448 } 13449 } 13450 } 13451 13452 public static class MimeTypesEnumFactory implements EnumFactory<MimeTypes> { 13453 public MimeTypes fromCode(String codeString) throws IllegalArgumentException { 13454 if (codeString == null || "".equals(codeString)) 13455 if (codeString == null || "".equals(codeString)) 13456 return null; 13457 throw new IllegalArgumentException("Unknown MimeTypes code '"+codeString+"'"); 13458 } 13459 13460 public Enumeration<MimeTypes> fromType(PrimitiveType<?> code) throws FHIRException { 13461 if (code == null) 13462 return null; 13463 if (code.isEmpty()) 13464 return new Enumeration<MimeTypes>(this, MimeTypes.NULL, code); 13465 String codeString = ((PrimitiveType) code).asStringValue(); 13466 if (codeString == null || "".equals(codeString)) 13467 return new Enumeration<MimeTypes>(this, MimeTypes.NULL, code); 13468 throw new FHIRException("Unknown MimeTypes code '"+codeString+"'"); 13469 } 13470 public String toCode(MimeTypes code) { 13471 return "?"; 13472 } 13473 public String toSystem(MimeTypes code) { 13474 return code.getSystem(); 13475 } 13476 } 13477 13478 public enum ObservationStatus { 13479 /** 13480 * The existence of the observation is registered, but there is no result yet available. 13481 */ 13482 REGISTERED, 13483 /** 13484 * This is an initial or interim observation: data may be incomplete or unverified. 13485 */ 13486 PRELIMINARY, 13487 /** 13488 * 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. 13489 */ 13490 FINAL, 13491 /** 13492 * Subsequent to being Final, the observation has been modified subsequent. This includes updates/new information and corrections. 13493 */ 13494 AMENDED, 13495 /** 13496 * Subsequent to being Final, the observation has been modified to correct an error in the test result. 13497 */ 13498 CORRECTED, 13499 /** 13500 * The observation is unavailable because the measurement was not started or not completed (also sometimes called "aborted"). 13501 */ 13502 CANCELLED, 13503 /** 13504 * 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".). 13505 */ 13506 ENTEREDINERROR, 13507 /** 13508 * 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. 13509 */ 13510 UNKNOWN, 13511 /** 13512 * added to help the parsers 13513 */ 13514 NULL; 13515 public static ObservationStatus fromCode(String codeString) throws FHIRException { 13516 if (codeString == null || "".equals(codeString)) 13517 return null; 13518 if ("registered".equals(codeString)) 13519 return REGISTERED; 13520 if ("preliminary".equals(codeString)) 13521 return PRELIMINARY; 13522 if ("final".equals(codeString)) 13523 return FINAL; 13524 if ("amended".equals(codeString)) 13525 return AMENDED; 13526 if ("corrected".equals(codeString)) 13527 return CORRECTED; 13528 if ("cancelled".equals(codeString)) 13529 return CANCELLED; 13530 if ("entered-in-error".equals(codeString)) 13531 return ENTEREDINERROR; 13532 if ("unknown".equals(codeString)) 13533 return UNKNOWN; 13534 throw new FHIRException("Unknown ObservationStatus code '"+codeString+"'"); 13535 } 13536 public static boolean isValidCode(String codeString) { 13537 if (codeString == null || "".equals(codeString)) 13538 return false; 13539 return Utilities.existsInList(codeString, "registered", "preliminary", "final", "amended", "corrected", "cancelled", "entered-in-error", "unknown"); 13540 } 13541 public String toCode() { 13542 switch (this) { 13543 case REGISTERED: return "registered"; 13544 case PRELIMINARY: return "preliminary"; 13545 case FINAL: return "final"; 13546 case AMENDED: return "amended"; 13547 case CORRECTED: return "corrected"; 13548 case CANCELLED: return "cancelled"; 13549 case ENTEREDINERROR: return "entered-in-error"; 13550 case UNKNOWN: return "unknown"; 13551 case NULL: return null; 13552 default: return "?"; 13553 } 13554 } 13555 public String getSystem() { 13556 switch (this) { 13557 case REGISTERED: return "http://hl7.org/fhir/observation-status"; 13558 case PRELIMINARY: return "http://hl7.org/fhir/observation-status"; 13559 case FINAL: return "http://hl7.org/fhir/observation-status"; 13560 case AMENDED: return "http://hl7.org/fhir/observation-status"; 13561 case CORRECTED: return "http://hl7.org/fhir/observation-status"; 13562 case CANCELLED: return "http://hl7.org/fhir/observation-status"; 13563 case ENTEREDINERROR: return "http://hl7.org/fhir/observation-status"; 13564 case UNKNOWN: return "http://hl7.org/fhir/observation-status"; 13565 case NULL: return null; 13566 default: return "?"; 13567 } 13568 } 13569 public String getDefinition() { 13570 switch (this) { 13571 case REGISTERED: return "The existence of the observation is registered, but there is no result yet available."; 13572 case PRELIMINARY: return "This is an initial or interim observation: data may be incomplete or unverified."; 13573 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."; 13574 case AMENDED: return "Subsequent to being Final, the observation has been modified subsequent. This includes updates/new information and corrections."; 13575 case CORRECTED: return "Subsequent to being Final, the observation has been modified to correct an error in the test result."; 13576 case CANCELLED: return "The observation is unavailable because the measurement was not started or not completed (also sometimes called \"aborted\")."; 13577 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\".)."; 13578 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."; 13579 case NULL: return null; 13580 default: return "?"; 13581 } 13582 } 13583 public String getDisplay() { 13584 switch (this) { 13585 case REGISTERED: return "Registered"; 13586 case PRELIMINARY: return "Preliminary"; 13587 case FINAL: return "Final"; 13588 case AMENDED: return "Amended"; 13589 case CORRECTED: return "Corrected"; 13590 case CANCELLED: return "Cancelled"; 13591 case ENTEREDINERROR: return "Entered in Error"; 13592 case UNKNOWN: return "Unknown"; 13593 case NULL: return null; 13594 default: return "?"; 13595 } 13596 } 13597 } 13598 13599 public static class ObservationStatusEnumFactory implements EnumFactory<ObservationStatus> { 13600 public ObservationStatus fromCode(String codeString) throws IllegalArgumentException { 13601 if (codeString == null || "".equals(codeString)) 13602 if (codeString == null || "".equals(codeString)) 13603 return null; 13604 if ("registered".equals(codeString)) 13605 return ObservationStatus.REGISTERED; 13606 if ("preliminary".equals(codeString)) 13607 return ObservationStatus.PRELIMINARY; 13608 if ("final".equals(codeString)) 13609 return ObservationStatus.FINAL; 13610 if ("amended".equals(codeString)) 13611 return ObservationStatus.AMENDED; 13612 if ("corrected".equals(codeString)) 13613 return ObservationStatus.CORRECTED; 13614 if ("cancelled".equals(codeString)) 13615 return ObservationStatus.CANCELLED; 13616 if ("entered-in-error".equals(codeString)) 13617 return ObservationStatus.ENTEREDINERROR; 13618 if ("unknown".equals(codeString)) 13619 return ObservationStatus.UNKNOWN; 13620 throw new IllegalArgumentException("Unknown ObservationStatus code '"+codeString+"'"); 13621 } 13622 13623 public Enumeration<ObservationStatus> fromType(PrimitiveType<?> code) throws FHIRException { 13624 if (code == null) 13625 return null; 13626 if (code.isEmpty()) 13627 return new Enumeration<ObservationStatus>(this, ObservationStatus.NULL, code); 13628 String codeString = ((PrimitiveType) code).asStringValue(); 13629 if (codeString == null || "".equals(codeString)) 13630 return new Enumeration<ObservationStatus>(this, ObservationStatus.NULL, code); 13631 if ("registered".equals(codeString)) 13632 return new Enumeration<ObservationStatus>(this, ObservationStatus.REGISTERED, code); 13633 if ("preliminary".equals(codeString)) 13634 return new Enumeration<ObservationStatus>(this, ObservationStatus.PRELIMINARY, code); 13635 if ("final".equals(codeString)) 13636 return new Enumeration<ObservationStatus>(this, ObservationStatus.FINAL, code); 13637 if ("amended".equals(codeString)) 13638 return new Enumeration<ObservationStatus>(this, ObservationStatus.AMENDED, code); 13639 if ("corrected".equals(codeString)) 13640 return new Enumeration<ObservationStatus>(this, ObservationStatus.CORRECTED, code); 13641 if ("cancelled".equals(codeString)) 13642 return new Enumeration<ObservationStatus>(this, ObservationStatus.CANCELLED, code); 13643 if ("entered-in-error".equals(codeString)) 13644 return new Enumeration<ObservationStatus>(this, ObservationStatus.ENTEREDINERROR, code); 13645 if ("unknown".equals(codeString)) 13646 return new Enumeration<ObservationStatus>(this, ObservationStatus.UNKNOWN, code); 13647 throw new FHIRException("Unknown ObservationStatus code '"+codeString+"'"); 13648 } 13649 public String toCode(ObservationStatus code) { 13650 if (code == ObservationStatus.REGISTERED) 13651 return "registered"; 13652 if (code == ObservationStatus.PRELIMINARY) 13653 return "preliminary"; 13654 if (code == ObservationStatus.FINAL) 13655 return "final"; 13656 if (code == ObservationStatus.AMENDED) 13657 return "amended"; 13658 if (code == ObservationStatus.CORRECTED) 13659 return "corrected"; 13660 if (code == ObservationStatus.CANCELLED) 13661 return "cancelled"; 13662 if (code == ObservationStatus.ENTEREDINERROR) 13663 return "entered-in-error"; 13664 if (code == ObservationStatus.UNKNOWN) 13665 return "unknown"; 13666 return "?"; 13667 } 13668 public String toSystem(ObservationStatus code) { 13669 return code.getSystem(); 13670 } 13671 } 13672 13673 public enum OperationParameterUse { 13674 /** 13675 * This is an input parameter. 13676 */ 13677 IN, 13678 /** 13679 * This is an output parameter. 13680 */ 13681 OUT, 13682 /** 13683 * added to help the parsers 13684 */ 13685 NULL; 13686 public static OperationParameterUse fromCode(String codeString) throws FHIRException { 13687 if (codeString == null || "".equals(codeString)) 13688 return null; 13689 if ("in".equals(codeString)) 13690 return IN; 13691 if ("out".equals(codeString)) 13692 return OUT; 13693 throw new FHIRException("Unknown OperationParameterUse code '"+codeString+"'"); 13694 } 13695 public static boolean isValidCode(String codeString) { 13696 if (codeString == null || "".equals(codeString)) 13697 return false; 13698 return Utilities.existsInList(codeString, "in", "out"); 13699 } 13700 public String toCode() { 13701 switch (this) { 13702 case IN: return "in"; 13703 case OUT: return "out"; 13704 case NULL: return null; 13705 default: return "?"; 13706 } 13707 } 13708 public String getSystem() { 13709 switch (this) { 13710 case IN: return "http://hl7.org/fhir/operation-parameter-use"; 13711 case OUT: return "http://hl7.org/fhir/operation-parameter-use"; 13712 case NULL: return null; 13713 default: return "?"; 13714 } 13715 } 13716 public String getDefinition() { 13717 switch (this) { 13718 case IN: return "This is an input parameter."; 13719 case OUT: return "This is an output parameter."; 13720 case NULL: return null; 13721 default: return "?"; 13722 } 13723 } 13724 public String getDisplay() { 13725 switch (this) { 13726 case IN: return "In"; 13727 case OUT: return "Out"; 13728 case NULL: return null; 13729 default: return "?"; 13730 } 13731 } 13732 } 13733 13734 public static class OperationParameterUseEnumFactory implements EnumFactory<OperationParameterUse> { 13735 public OperationParameterUse fromCode(String codeString) throws IllegalArgumentException { 13736 if (codeString == null || "".equals(codeString)) 13737 if (codeString == null || "".equals(codeString)) 13738 return null; 13739 if ("in".equals(codeString)) 13740 return OperationParameterUse.IN; 13741 if ("out".equals(codeString)) 13742 return OperationParameterUse.OUT; 13743 throw new IllegalArgumentException("Unknown OperationParameterUse code '"+codeString+"'"); 13744 } 13745 13746 public Enumeration<OperationParameterUse> fromType(PrimitiveType<?> code) throws FHIRException { 13747 if (code == null) 13748 return null; 13749 if (code.isEmpty()) 13750 return new Enumeration<OperationParameterUse>(this, OperationParameterUse.NULL, code); 13751 String codeString = ((PrimitiveType) code).asStringValue(); 13752 if (codeString == null || "".equals(codeString)) 13753 return new Enumeration<OperationParameterUse>(this, OperationParameterUse.NULL, code); 13754 if ("in".equals(codeString)) 13755 return new Enumeration<OperationParameterUse>(this, OperationParameterUse.IN, code); 13756 if ("out".equals(codeString)) 13757 return new Enumeration<OperationParameterUse>(this, OperationParameterUse.OUT, code); 13758 throw new FHIRException("Unknown OperationParameterUse code '"+codeString+"'"); 13759 } 13760 public String toCode(OperationParameterUse code) { 13761 if (code == OperationParameterUse.IN) 13762 return "in"; 13763 if (code == OperationParameterUse.OUT) 13764 return "out"; 13765 return "?"; 13766 } 13767 public String toSystem(OperationParameterUse code) { 13768 return code.getSystem(); 13769 } 13770 } 13771 13772 public enum PublicationStatus { 13773 /** 13774 * This resource is still under development and is not yet considered to be ready for normal use. 13775 */ 13776 DRAFT, 13777 /** 13778 * This resource is ready for normal use. 13779 */ 13780 ACTIVE, 13781 /** 13782 * This resource has been withdrawn or superseded and should no longer be used. 13783 */ 13784 RETIRED, 13785 /** 13786 * 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. 13787 */ 13788 UNKNOWN, 13789 /** 13790 * added to help the parsers 13791 */ 13792 NULL; 13793 public static PublicationStatus fromCode(String codeString) throws FHIRException { 13794 if (codeString == null || "".equals(codeString)) 13795 return null; 13796 if ("draft".equals(codeString)) 13797 return DRAFT; 13798 if ("active".equals(codeString)) 13799 return ACTIVE; 13800 if ("retired".equals(codeString)) 13801 return RETIRED; 13802 if ("unknown".equals(codeString)) 13803 return UNKNOWN; 13804 throw new FHIRException("Unknown PublicationStatus code '"+codeString+"'"); 13805 } 13806 public static boolean isValidCode(String codeString) { 13807 if (codeString == null || "".equals(codeString)) 13808 return false; 13809 return Utilities.existsInList(codeString, "draft", "active", "retired", "unknown"); 13810 } 13811 public String toCode() { 13812 switch (this) { 13813 case DRAFT: return "draft"; 13814 case ACTIVE: return "active"; 13815 case RETIRED: return "retired"; 13816 case UNKNOWN: return "unknown"; 13817 case NULL: return null; 13818 default: return "?"; 13819 } 13820 } 13821 public String getSystem() { 13822 switch (this) { 13823 case DRAFT: return "http://hl7.org/fhir/publication-status"; 13824 case ACTIVE: return "http://hl7.org/fhir/publication-status"; 13825 case RETIRED: return "http://hl7.org/fhir/publication-status"; 13826 case UNKNOWN: return "http://hl7.org/fhir/publication-status"; 13827 case NULL: return null; 13828 default: return "?"; 13829 } 13830 } 13831 public String getDefinition() { 13832 switch (this) { 13833 case DRAFT: return "This resource is still under development and is not yet considered to be ready for normal use."; 13834 case ACTIVE: return "This resource is ready for normal use."; 13835 case RETIRED: return "This resource has been withdrawn or superseded and should no longer be used."; 13836 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."; 13837 case NULL: return null; 13838 default: return "?"; 13839 } 13840 } 13841 public String getDisplay() { 13842 switch (this) { 13843 case DRAFT: return "Draft"; 13844 case ACTIVE: return "Active"; 13845 case RETIRED: return "Retired"; 13846 case UNKNOWN: return "Unknown"; 13847 case NULL: return null; 13848 default: return "?"; 13849 } 13850 } 13851 } 13852 13853 public static class PublicationStatusEnumFactory implements EnumFactory<PublicationStatus> { 13854 public PublicationStatus fromCode(String codeString) throws IllegalArgumentException { 13855 if (codeString == null || "".equals(codeString)) 13856 if (codeString == null || "".equals(codeString)) 13857 return null; 13858 if ("draft".equals(codeString)) 13859 return PublicationStatus.DRAFT; 13860 if ("active".equals(codeString)) 13861 return PublicationStatus.ACTIVE; 13862 if ("retired".equals(codeString)) 13863 return PublicationStatus.RETIRED; 13864 if ("unknown".equals(codeString)) 13865 return PublicationStatus.UNKNOWN; 13866 throw new IllegalArgumentException("Unknown PublicationStatus code '"+codeString+"'"); 13867 } 13868 13869 public Enumeration<PublicationStatus> fromType(PrimitiveType<?> code) throws FHIRException { 13870 if (code == null) 13871 return null; 13872 if (code.isEmpty()) 13873 return new Enumeration<PublicationStatus>(this, PublicationStatus.NULL, code); 13874 String codeString = ((PrimitiveType) code).asStringValue(); 13875 if (codeString == null || "".equals(codeString)) 13876 return new Enumeration<PublicationStatus>(this, PublicationStatus.NULL, code); 13877 if ("draft".equals(codeString)) 13878 return new Enumeration<PublicationStatus>(this, PublicationStatus.DRAFT, code); 13879 if ("active".equals(codeString)) 13880 return new Enumeration<PublicationStatus>(this, PublicationStatus.ACTIVE, code); 13881 if ("retired".equals(codeString)) 13882 return new Enumeration<PublicationStatus>(this, PublicationStatus.RETIRED, code); 13883 if ("unknown".equals(codeString)) 13884 return new Enumeration<PublicationStatus>(this, PublicationStatus.UNKNOWN, code); 13885 throw new FHIRException("Unknown PublicationStatus code '"+codeString+"'"); 13886 } 13887 public String toCode(PublicationStatus code) { 13888 if (code == PublicationStatus.DRAFT) 13889 return "draft"; 13890 if (code == PublicationStatus.ACTIVE) 13891 return "active"; 13892 if (code == PublicationStatus.RETIRED) 13893 return "retired"; 13894 if (code == PublicationStatus.UNKNOWN) 13895 return "unknown"; 13896 return "?"; 13897 } 13898 public String toSystem(PublicationStatus code) { 13899 return code.getSystem(); 13900 } 13901 } 13902 13903 public enum QuantityComparator { 13904 /** 13905 * The actual value is less than the given value. 13906 */ 13907 LESS_THAN, 13908 /** 13909 * The actual value is less than or equal to the given value. 13910 */ 13911 LESS_OR_EQUAL, 13912 /** 13913 * The actual value is greater than or equal to the given value. 13914 */ 13915 GREATER_OR_EQUAL, 13916 /** 13917 * The actual value is greater than the given value. 13918 */ 13919 GREATER_THAN, 13920 /** 13921 * The actual value is sufficient for the total quantity to equal the given value. 13922 */ 13923 AD, 13924 /** 13925 * added to help the parsers 13926 */ 13927 NULL; 13928 public static QuantityComparator fromCode(String codeString) throws FHIRException { 13929 if (codeString == null || "".equals(codeString)) 13930 return null; 13931 if ("<".equals(codeString)) 13932 return LESS_THAN; 13933 if ("<=".equals(codeString)) 13934 return LESS_OR_EQUAL; 13935 if (">=".equals(codeString)) 13936 return GREATER_OR_EQUAL; 13937 if (">".equals(codeString)) 13938 return GREATER_THAN; 13939 if ("ad".equals(codeString)) 13940 return AD; 13941 throw new FHIRException("Unknown QuantityComparator code '"+codeString+"'"); 13942 } 13943 public static boolean isValidCode(String codeString) { 13944 if (codeString == null || "".equals(codeString)) 13945 return false; 13946 return Utilities.existsInList(codeString, "<", "<=", ">=", ">", "ad"); 13947 } 13948 public String toCode() { 13949 switch (this) { 13950 case LESS_THAN: return "<"; 13951 case LESS_OR_EQUAL: return "<="; 13952 case GREATER_OR_EQUAL: return ">="; 13953 case GREATER_THAN: return ">"; 13954 case AD: return "ad"; 13955 case NULL: return null; 13956 default: return "?"; 13957 } 13958 } 13959 public String getSystem() { 13960 switch (this) { 13961 case LESS_THAN: return "http://hl7.org/fhir/quantity-comparator"; 13962 case LESS_OR_EQUAL: return "http://hl7.org/fhir/quantity-comparator"; 13963 case GREATER_OR_EQUAL: return "http://hl7.org/fhir/quantity-comparator"; 13964 case GREATER_THAN: return "http://hl7.org/fhir/quantity-comparator"; 13965 case AD: return "http://hl7.org/fhir/quantity-comparator"; 13966 case NULL: return null; 13967 default: return "?"; 13968 } 13969 } 13970 public String getDefinition() { 13971 switch (this) { 13972 case LESS_THAN: return "The actual value is less than the given value."; 13973 case LESS_OR_EQUAL: return "The actual value is less than or equal to the given value."; 13974 case GREATER_OR_EQUAL: return "The actual value is greater than or equal to the given value."; 13975 case GREATER_THAN: return "The actual value is greater than the given value."; 13976 case AD: return "The actual value is sufficient for the total quantity to equal the given value."; 13977 case NULL: return null; 13978 default: return "?"; 13979 } 13980 } 13981 public String getDisplay() { 13982 switch (this) { 13983 case LESS_THAN: return "Less than"; 13984 case LESS_OR_EQUAL: return "Less or Equal to"; 13985 case GREATER_OR_EQUAL: return "Greater or Equal to"; 13986 case GREATER_THAN: return "Greater than"; 13987 case AD: return "Sufficient to achieve this total quantity"; 13988 case NULL: return null; 13989 default: return "?"; 13990 } 13991 } 13992 } 13993 13994 public static class QuantityComparatorEnumFactory implements EnumFactory<QuantityComparator> { 13995 public QuantityComparator fromCode(String codeString) throws IllegalArgumentException { 13996 if (codeString == null || "".equals(codeString)) 13997 if (codeString == null || "".equals(codeString)) 13998 return null; 13999 if ("<".equals(codeString)) 14000 return QuantityComparator.LESS_THAN; 14001 if ("<=".equals(codeString)) 14002 return QuantityComparator.LESS_OR_EQUAL; 14003 if (">=".equals(codeString)) 14004 return QuantityComparator.GREATER_OR_EQUAL; 14005 if (">".equals(codeString)) 14006 return QuantityComparator.GREATER_THAN; 14007 if ("ad".equals(codeString)) 14008 return QuantityComparator.AD; 14009 throw new IllegalArgumentException("Unknown QuantityComparator code '"+codeString+"'"); 14010 } 14011 14012 public Enumeration<QuantityComparator> fromType(PrimitiveType<?> code) throws FHIRException { 14013 if (code == null) 14014 return null; 14015 if (code.isEmpty()) 14016 return new Enumeration<QuantityComparator>(this, QuantityComparator.NULL, code); 14017 String codeString = ((PrimitiveType) code).asStringValue(); 14018 if (codeString == null || "".equals(codeString)) 14019 return new Enumeration<QuantityComparator>(this, QuantityComparator.NULL, code); 14020 if ("<".equals(codeString)) 14021 return new Enumeration<QuantityComparator>(this, QuantityComparator.LESS_THAN, code); 14022 if ("<=".equals(codeString)) 14023 return new Enumeration<QuantityComparator>(this, QuantityComparator.LESS_OR_EQUAL, code); 14024 if (">=".equals(codeString)) 14025 return new Enumeration<QuantityComparator>(this, QuantityComparator.GREATER_OR_EQUAL, code); 14026 if (">".equals(codeString)) 14027 return new Enumeration<QuantityComparator>(this, QuantityComparator.GREATER_THAN, code); 14028 if ("ad".equals(codeString)) 14029 return new Enumeration<QuantityComparator>(this, QuantityComparator.AD, code); 14030 throw new FHIRException("Unknown QuantityComparator code '"+codeString+"'"); 14031 } 14032 public String toCode(QuantityComparator code) { 14033 if (code == QuantityComparator.LESS_THAN) 14034 return "<"; 14035 if (code == QuantityComparator.LESS_OR_EQUAL) 14036 return "<="; 14037 if (code == QuantityComparator.GREATER_OR_EQUAL) 14038 return ">="; 14039 if (code == QuantityComparator.GREATER_THAN) 14040 return ">"; 14041 if (code == QuantityComparator.AD) 14042 return "ad"; 14043 return "?"; 14044 } 14045 public String toSystem(QuantityComparator code) { 14046 return code.getSystem(); 14047 } 14048 } 14049 14050 public enum RequestIntent { 14051 /** 14052 * 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. 14053 */ 14054 PROPOSAL, 14055 /** 14056 * The request represents an intention to ensure something occurs without providing an authorization for others to act. 14057 */ 14058 PLAN, 14059 /** 14060 * The request represents a legally binding instruction authored by a Patient or RelatedPerson. 14061 */ 14062 DIRECTIVE, 14063 /** 14064 * The request represents a request/demand and authorization for action by the requestor. 14065 */ 14066 ORDER, 14067 /** 14068 * The request represents an original authorization for action. 14069 */ 14070 ORIGINALORDER, 14071 /** 14072 * 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. 14073 */ 14074 REFLEXORDER, 14075 /** 14076 * 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. 14077 */ 14078 FILLERORDER, 14079 /** 14080 * 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. 14081 */ 14082 INSTANCEORDER, 14083 /** 14084 * 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. 14085 */ 14086 OPTION, 14087 /** 14088 * added to help the parsers 14089 */ 14090 NULL; 14091 public static RequestIntent fromCode(String codeString) throws FHIRException { 14092 if (codeString == null || "".equals(codeString)) 14093 return null; 14094 if ("proposal".equals(codeString)) 14095 return PROPOSAL; 14096 if ("plan".equals(codeString)) 14097 return PLAN; 14098 if ("directive".equals(codeString)) 14099 return DIRECTIVE; 14100 if ("order".equals(codeString)) 14101 return ORDER; 14102 if ("original-order".equals(codeString)) 14103 return ORIGINALORDER; 14104 if ("reflex-order".equals(codeString)) 14105 return REFLEXORDER; 14106 if ("filler-order".equals(codeString)) 14107 return FILLERORDER; 14108 if ("instance-order".equals(codeString)) 14109 return INSTANCEORDER; 14110 if ("option".equals(codeString)) 14111 return OPTION; 14112 throw new FHIRException("Unknown RequestIntent code '"+codeString+"'"); 14113 } 14114 public static boolean isValidCode(String codeString) { 14115 if (codeString == null || "".equals(codeString)) 14116 return false; 14117 return Utilities.existsInList(codeString, "proposal", "plan", "directive", "order", "original-order", "reflex-order", "filler-order", "instance-order", "option"); 14118 } 14119 public String toCode() { 14120 switch (this) { 14121 case PROPOSAL: return "proposal"; 14122 case PLAN: return "plan"; 14123 case DIRECTIVE: return "directive"; 14124 case ORDER: return "order"; 14125 case ORIGINALORDER: return "original-order"; 14126 case REFLEXORDER: return "reflex-order"; 14127 case FILLERORDER: return "filler-order"; 14128 case INSTANCEORDER: return "instance-order"; 14129 case OPTION: return "option"; 14130 case NULL: return null; 14131 default: return "?"; 14132 } 14133 } 14134 public String getSystem() { 14135 switch (this) { 14136 case PROPOSAL: return "http://hl7.org/fhir/request-intent"; 14137 case PLAN: return "http://hl7.org/fhir/request-intent"; 14138 case DIRECTIVE: return "http://hl7.org/fhir/request-intent"; 14139 case ORDER: return "http://hl7.org/fhir/request-intent"; 14140 case ORIGINALORDER: return "http://hl7.org/fhir/request-intent"; 14141 case REFLEXORDER: return "http://hl7.org/fhir/request-intent"; 14142 case FILLERORDER: return "http://hl7.org/fhir/request-intent"; 14143 case INSTANCEORDER: return "http://hl7.org/fhir/request-intent"; 14144 case OPTION: return "http://hl7.org/fhir/request-intent"; 14145 case NULL: return null; 14146 default: return "?"; 14147 } 14148 } 14149 public String getDefinition() { 14150 switch (this) { 14151 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."; 14152 case PLAN: return "The request represents an intention to ensure something occurs without providing an authorization for others to act."; 14153 case DIRECTIVE: return "The request represents a legally binding instruction authored by a Patient or RelatedPerson."; 14154 case ORDER: return "The request represents a request/demand and authorization for action by the requestor."; 14155 case ORIGINALORDER: return "The request represents an original authorization for action."; 14156 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."; 14157 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."; 14158 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."; 14159 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."; 14160 case NULL: return null; 14161 default: return "?"; 14162 } 14163 } 14164 public String getDisplay() { 14165 switch (this) { 14166 case PROPOSAL: return "Proposal"; 14167 case PLAN: return "Plan"; 14168 case DIRECTIVE: return "Directive"; 14169 case ORDER: return "Order"; 14170 case ORIGINALORDER: return "Original Order"; 14171 case REFLEXORDER: return "Reflex Order"; 14172 case FILLERORDER: return "Filler Order"; 14173 case INSTANCEORDER: return "Instance Order"; 14174 case OPTION: return "Option"; 14175 case NULL: return null; 14176 default: return "?"; 14177 } 14178 } 14179 } 14180 14181 public static class RequestIntentEnumFactory implements EnumFactory<RequestIntent> { 14182 public RequestIntent fromCode(String codeString) throws IllegalArgumentException { 14183 if (codeString == null || "".equals(codeString)) 14184 if (codeString == null || "".equals(codeString)) 14185 return null; 14186 if ("proposal".equals(codeString)) 14187 return RequestIntent.PROPOSAL; 14188 if ("plan".equals(codeString)) 14189 return RequestIntent.PLAN; 14190 if ("directive".equals(codeString)) 14191 return RequestIntent.DIRECTIVE; 14192 if ("order".equals(codeString)) 14193 return RequestIntent.ORDER; 14194 if ("original-order".equals(codeString)) 14195 return RequestIntent.ORIGINALORDER; 14196 if ("reflex-order".equals(codeString)) 14197 return RequestIntent.REFLEXORDER; 14198 if ("filler-order".equals(codeString)) 14199 return RequestIntent.FILLERORDER; 14200 if ("instance-order".equals(codeString)) 14201 return RequestIntent.INSTANCEORDER; 14202 if ("option".equals(codeString)) 14203 return RequestIntent.OPTION; 14204 throw new IllegalArgumentException("Unknown RequestIntent code '"+codeString+"'"); 14205 } 14206 14207 public Enumeration<RequestIntent> fromType(PrimitiveType<?> code) throws FHIRException { 14208 if (code == null) 14209 return null; 14210 if (code.isEmpty()) 14211 return new Enumeration<RequestIntent>(this, RequestIntent.NULL, code); 14212 String codeString = ((PrimitiveType) code).asStringValue(); 14213 if (codeString == null || "".equals(codeString)) 14214 return new Enumeration<RequestIntent>(this, RequestIntent.NULL, code); 14215 if ("proposal".equals(codeString)) 14216 return new Enumeration<RequestIntent>(this, RequestIntent.PROPOSAL, code); 14217 if ("plan".equals(codeString)) 14218 return new Enumeration<RequestIntent>(this, RequestIntent.PLAN, code); 14219 if ("directive".equals(codeString)) 14220 return new Enumeration<RequestIntent>(this, RequestIntent.DIRECTIVE, code); 14221 if ("order".equals(codeString)) 14222 return new Enumeration<RequestIntent>(this, RequestIntent.ORDER, code); 14223 if ("original-order".equals(codeString)) 14224 return new Enumeration<RequestIntent>(this, RequestIntent.ORIGINALORDER, code); 14225 if ("reflex-order".equals(codeString)) 14226 return new Enumeration<RequestIntent>(this, RequestIntent.REFLEXORDER, code); 14227 if ("filler-order".equals(codeString)) 14228 return new Enumeration<RequestIntent>(this, RequestIntent.FILLERORDER, code); 14229 if ("instance-order".equals(codeString)) 14230 return new Enumeration<RequestIntent>(this, RequestIntent.INSTANCEORDER, code); 14231 if ("option".equals(codeString)) 14232 return new Enumeration<RequestIntent>(this, RequestIntent.OPTION, code); 14233 throw new FHIRException("Unknown RequestIntent code '"+codeString+"'"); 14234 } 14235 public String toCode(RequestIntent code) { 14236 if (code == RequestIntent.PROPOSAL) 14237 return "proposal"; 14238 if (code == RequestIntent.PLAN) 14239 return "plan"; 14240 if (code == RequestIntent.DIRECTIVE) 14241 return "directive"; 14242 if (code == RequestIntent.ORDER) 14243 return "order"; 14244 if (code == RequestIntent.ORIGINALORDER) 14245 return "original-order"; 14246 if (code == RequestIntent.REFLEXORDER) 14247 return "reflex-order"; 14248 if (code == RequestIntent.FILLERORDER) 14249 return "filler-order"; 14250 if (code == RequestIntent.INSTANCEORDER) 14251 return "instance-order"; 14252 if (code == RequestIntent.OPTION) 14253 return "option"; 14254 return "?"; 14255 } 14256 public String toSystem(RequestIntent code) { 14257 return code.getSystem(); 14258 } 14259 } 14260 14261 public enum RequestPriority { 14262 /** 14263 * The request has normal priority. 14264 */ 14265 ROUTINE, 14266 /** 14267 * The request should be actioned promptly - higher priority than routine. 14268 */ 14269 URGENT, 14270 /** 14271 * The request should be actioned as soon as possible - higher priority than urgent. 14272 */ 14273 ASAP, 14274 /** 14275 * The request should be actioned immediately - highest possible priority. E.g. an emergency. 14276 */ 14277 STAT, 14278 /** 14279 * added to help the parsers 14280 */ 14281 NULL; 14282 public static RequestPriority fromCode(String codeString) throws FHIRException { 14283 if (codeString == null || "".equals(codeString)) 14284 return null; 14285 if ("routine".equals(codeString)) 14286 return ROUTINE; 14287 if ("urgent".equals(codeString)) 14288 return URGENT; 14289 if ("asap".equals(codeString)) 14290 return ASAP; 14291 if ("stat".equals(codeString)) 14292 return STAT; 14293 throw new FHIRException("Unknown RequestPriority code '"+codeString+"'"); 14294 } 14295 public static boolean isValidCode(String codeString) { 14296 if (codeString == null || "".equals(codeString)) 14297 return false; 14298 return Utilities.existsInList(codeString, "routine", "urgent", "asap", "stat"); 14299 } 14300 public String toCode() { 14301 switch (this) { 14302 case ROUTINE: return "routine"; 14303 case URGENT: return "urgent"; 14304 case ASAP: return "asap"; 14305 case STAT: return "stat"; 14306 case NULL: return null; 14307 default: return "?"; 14308 } 14309 } 14310 public String getSystem() { 14311 switch (this) { 14312 case ROUTINE: return "http://hl7.org/fhir/request-priority"; 14313 case URGENT: return "http://hl7.org/fhir/request-priority"; 14314 case ASAP: return "http://hl7.org/fhir/request-priority"; 14315 case STAT: return "http://hl7.org/fhir/request-priority"; 14316 case NULL: return null; 14317 default: return "?"; 14318 } 14319 } 14320 public String getDefinition() { 14321 switch (this) { 14322 case ROUTINE: return "The request has normal priority."; 14323 case URGENT: return "The request should be actioned promptly - higher priority than routine."; 14324 case ASAP: return "The request should be actioned as soon as possible - higher priority than urgent."; 14325 case STAT: return "The request should be actioned immediately - highest possible priority. E.g. an emergency."; 14326 case NULL: return null; 14327 default: return "?"; 14328 } 14329 } 14330 public String getDisplay() { 14331 switch (this) { 14332 case ROUTINE: return "Routine"; 14333 case URGENT: return "Urgent"; 14334 case ASAP: return "ASAP"; 14335 case STAT: return "STAT"; 14336 case NULL: return null; 14337 default: return "?"; 14338 } 14339 } 14340 } 14341 14342 public static class RequestPriorityEnumFactory implements EnumFactory<RequestPriority> { 14343 public RequestPriority fromCode(String codeString) throws IllegalArgumentException { 14344 if (codeString == null || "".equals(codeString)) 14345 if (codeString == null || "".equals(codeString)) 14346 return null; 14347 if ("routine".equals(codeString)) 14348 return RequestPriority.ROUTINE; 14349 if ("urgent".equals(codeString)) 14350 return RequestPriority.URGENT; 14351 if ("asap".equals(codeString)) 14352 return RequestPriority.ASAP; 14353 if ("stat".equals(codeString)) 14354 return RequestPriority.STAT; 14355 throw new IllegalArgumentException("Unknown RequestPriority code '"+codeString+"'"); 14356 } 14357 14358 public Enumeration<RequestPriority> fromType(PrimitiveType<?> code) throws FHIRException { 14359 if (code == null) 14360 return null; 14361 if (code.isEmpty()) 14362 return new Enumeration<RequestPriority>(this, RequestPriority.NULL, code); 14363 String codeString = ((PrimitiveType) code).asStringValue(); 14364 if (codeString == null || "".equals(codeString)) 14365 return new Enumeration<RequestPriority>(this, RequestPriority.NULL, code); 14366 if ("routine".equals(codeString)) 14367 return new Enumeration<RequestPriority>(this, RequestPriority.ROUTINE, code); 14368 if ("urgent".equals(codeString)) 14369 return new Enumeration<RequestPriority>(this, RequestPriority.URGENT, code); 14370 if ("asap".equals(codeString)) 14371 return new Enumeration<RequestPriority>(this, RequestPriority.ASAP, code); 14372 if ("stat".equals(codeString)) 14373 return new Enumeration<RequestPriority>(this, RequestPriority.STAT, code); 14374 throw new FHIRException("Unknown RequestPriority code '"+codeString+"'"); 14375 } 14376 public String toCode(RequestPriority code) { 14377 if (code == RequestPriority.ROUTINE) 14378 return "routine"; 14379 if (code == RequestPriority.URGENT) 14380 return "urgent"; 14381 if (code == RequestPriority.ASAP) 14382 return "asap"; 14383 if (code == RequestPriority.STAT) 14384 return "stat"; 14385 return "?"; 14386 } 14387 public String toSystem(RequestPriority code) { 14388 return code.getSystem(); 14389 } 14390 } 14391 14392 public enum RequestStatus { 14393 /** 14394 * The request has been created but is not yet complete or ready for action. 14395 */ 14396 DRAFT, 14397 /** 14398 * The request is in force and ready to be acted upon. 14399 */ 14400 ACTIVE, 14401 /** 14402 * The request (and any implicit authorization to act) has been temporarily withdrawn but is expected to resume in the future. 14403 */ 14404 ONHOLD, 14405 /** 14406 * 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. 14407 */ 14408 REVOKED, 14409 /** 14410 * The activity described by the request has been fully performed. No further activity will occur. 14411 */ 14412 COMPLETED, 14413 /** 14414 * 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".). 14415 */ 14416 ENTEREDINERROR, 14417 /** 14418 * 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. 14419 */ 14420 UNKNOWN, 14421 /** 14422 * added to help the parsers 14423 */ 14424 NULL; 14425 public static RequestStatus fromCode(String codeString) throws FHIRException { 14426 if (codeString == null || "".equals(codeString)) 14427 return null; 14428 if ("draft".equals(codeString)) 14429 return DRAFT; 14430 if ("active".equals(codeString)) 14431 return ACTIVE; 14432 if ("on-hold".equals(codeString)) 14433 return ONHOLD; 14434 if ("revoked".equals(codeString)) 14435 return REVOKED; 14436 if ("completed".equals(codeString)) 14437 return COMPLETED; 14438 if ("entered-in-error".equals(codeString)) 14439 return ENTEREDINERROR; 14440 if ("unknown".equals(codeString)) 14441 return UNKNOWN; 14442 throw new FHIRException("Unknown RequestStatus code '"+codeString+"'"); 14443 } 14444 public static boolean isValidCode(String codeString) { 14445 if (codeString == null || "".equals(codeString)) 14446 return false; 14447 return Utilities.existsInList(codeString, "draft", "active", "on-hold", "revoked", "completed", "entered-in-error", "unknown"); 14448 } 14449 public String toCode() { 14450 switch (this) { 14451 case DRAFT: return "draft"; 14452 case ACTIVE: return "active"; 14453 case ONHOLD: return "on-hold"; 14454 case REVOKED: return "revoked"; 14455 case COMPLETED: return "completed"; 14456 case ENTEREDINERROR: return "entered-in-error"; 14457 case UNKNOWN: return "unknown"; 14458 case NULL: return null; 14459 default: return "?"; 14460 } 14461 } 14462 public String getSystem() { 14463 switch (this) { 14464 case DRAFT: return "http://hl7.org/fhir/request-status"; 14465 case ACTIVE: return "http://hl7.org/fhir/request-status"; 14466 case ONHOLD: return "http://hl7.org/fhir/request-status"; 14467 case REVOKED: return "http://hl7.org/fhir/request-status"; 14468 case COMPLETED: return "http://hl7.org/fhir/request-status"; 14469 case ENTEREDINERROR: return "http://hl7.org/fhir/request-status"; 14470 case UNKNOWN: return "http://hl7.org/fhir/request-status"; 14471 case NULL: return null; 14472 default: return "?"; 14473 } 14474 } 14475 public String getDefinition() { 14476 switch (this) { 14477 case DRAFT: return "The request has been created but is not yet complete or ready for action."; 14478 case ACTIVE: return "The request is in force and ready to be acted upon."; 14479 case ONHOLD: return "The request (and any implicit authorization to act) has been temporarily withdrawn but is expected to resume in the future."; 14480 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."; 14481 case COMPLETED: return "The activity described by the request has been fully performed. No further activity will occur."; 14482 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\".)."; 14483 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."; 14484 case NULL: return null; 14485 default: return "?"; 14486 } 14487 } 14488 public String getDisplay() { 14489 switch (this) { 14490 case DRAFT: return "Draft"; 14491 case ACTIVE: return "Active"; 14492 case ONHOLD: return "On Hold"; 14493 case REVOKED: return "Revoked"; 14494 case COMPLETED: return "Completed"; 14495 case ENTEREDINERROR: return "Entered in Error"; 14496 case UNKNOWN: return "Unknown"; 14497 case NULL: return null; 14498 default: return "?"; 14499 } 14500 } 14501 } 14502 14503 public static class RequestStatusEnumFactory implements EnumFactory<RequestStatus> { 14504 public RequestStatus fromCode(String codeString) throws IllegalArgumentException { 14505 if (codeString == null || "".equals(codeString)) 14506 if (codeString == null || "".equals(codeString)) 14507 return null; 14508 if ("draft".equals(codeString)) 14509 return RequestStatus.DRAFT; 14510 if ("active".equals(codeString)) 14511 return RequestStatus.ACTIVE; 14512 if ("on-hold".equals(codeString)) 14513 return RequestStatus.ONHOLD; 14514 if ("revoked".equals(codeString)) 14515 return RequestStatus.REVOKED; 14516 if ("completed".equals(codeString)) 14517 return RequestStatus.COMPLETED; 14518 if ("entered-in-error".equals(codeString)) 14519 return RequestStatus.ENTEREDINERROR; 14520 if ("unknown".equals(codeString)) 14521 return RequestStatus.UNKNOWN; 14522 throw new IllegalArgumentException("Unknown RequestStatus code '"+codeString+"'"); 14523 } 14524 14525 public Enumeration<RequestStatus> fromType(PrimitiveType<?> code) throws FHIRException { 14526 if (code == null) 14527 return null; 14528 if (code.isEmpty()) 14529 return new Enumeration<RequestStatus>(this, RequestStatus.NULL, code); 14530 String codeString = ((PrimitiveType) code).asStringValue(); 14531 if (codeString == null || "".equals(codeString)) 14532 return new Enumeration<RequestStatus>(this, RequestStatus.NULL, code); 14533 if ("draft".equals(codeString)) 14534 return new Enumeration<RequestStatus>(this, RequestStatus.DRAFT, code); 14535 if ("active".equals(codeString)) 14536 return new Enumeration<RequestStatus>(this, RequestStatus.ACTIVE, code); 14537 if ("on-hold".equals(codeString)) 14538 return new Enumeration<RequestStatus>(this, RequestStatus.ONHOLD, code); 14539 if ("revoked".equals(codeString)) 14540 return new Enumeration<RequestStatus>(this, RequestStatus.REVOKED, code); 14541 if ("completed".equals(codeString)) 14542 return new Enumeration<RequestStatus>(this, RequestStatus.COMPLETED, code); 14543 if ("entered-in-error".equals(codeString)) 14544 return new Enumeration<RequestStatus>(this, RequestStatus.ENTEREDINERROR, code); 14545 if ("unknown".equals(codeString)) 14546 return new Enumeration<RequestStatus>(this, RequestStatus.UNKNOWN, code); 14547 throw new FHIRException("Unknown RequestStatus code '"+codeString+"'"); 14548 } 14549 public String toCode(RequestStatus code) { 14550 if (code == RequestStatus.DRAFT) 14551 return "draft"; 14552 if (code == RequestStatus.ACTIVE) 14553 return "active"; 14554 if (code == RequestStatus.ONHOLD) 14555 return "on-hold"; 14556 if (code == RequestStatus.REVOKED) 14557 return "revoked"; 14558 if (code == RequestStatus.COMPLETED) 14559 return "completed"; 14560 if (code == RequestStatus.ENTEREDINERROR) 14561 return "entered-in-error"; 14562 if (code == RequestStatus.UNKNOWN) 14563 return "unknown"; 14564 return "?"; 14565 } 14566 public String toSystem(RequestStatus code) { 14567 return code.getSystem(); 14568 } 14569 } 14570 14571 public enum ResourceTypeEnum { 14572 /** 14573 * 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. 14574 */ 14575 ACCOUNT, 14576 /** 14577 * This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context. 14578 */ 14579 ACTIVITYDEFINITION, 14580 /** 14581 * 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. 14582 */ 14583 ACTORDEFINITION, 14584 /** 14585 * 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). 14586 */ 14587 ADMINISTRABLEPRODUCTDEFINITION, 14588 /** 14589 * 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. 14590 */ 14591 ADVERSEEVENT, 14592 /** 14593 * Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance. 14594 */ 14595 ALLERGYINTOLERANCE, 14596 /** 14597 * 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). 14598 */ 14599 APPOINTMENT, 14600 /** 14601 * A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection. 14602 */ 14603 APPOINTMENTRESPONSE, 14604 /** 14605 * This Resource provides one or more comments, classifiers or ratings about a Resource and supports attribution and rights management metadata for the added content. 14606 */ 14607 ARTIFACTASSESSMENT, 14608 /** 14609 * A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis. 14610 */ 14611 AUDITEVENT, 14612 /** 14613 * 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. 14614 */ 14615 BASIC, 14616 /** 14617 * 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. 14618 */ 14619 BINARY, 14620 /** 14621 * A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity. 14622 */ 14623 BIOLOGICALLYDERIVEDPRODUCT, 14624 /** 14625 * A record of dispensation of a biologically derived product. 14626 */ 14627 BIOLOGICALLYDERIVEDPRODUCTDISPENSE, 14628 /** 14629 * 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. 14630 */ 14631 BODYSTRUCTURE, 14632 /** 14633 * A container for a collection of resources. 14634 */ 14635 BUNDLE, 14636 /** 14637 * 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. 14638 */ 14639 CAPABILITYSTATEMENT, 14640 /** 14641 * 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. 14642 */ 14643 CAREPLAN, 14644 /** 14645 * The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care. 14646 */ 14647 CARETEAM, 14648 /** 14649 * 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. 14650 */ 14651 CHARGEITEM, 14652 /** 14653 * 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. 14654 */ 14655 CHARGEITEMDEFINITION, 14656 /** 14657 * 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. 14658 */ 14659 CITATION, 14660 /** 14661 * 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. 14662 */ 14663 CLAIM, 14664 /** 14665 * This resource provides the adjudication details from the processing of a Claim resource. 14666 */ 14667 CLAIMRESPONSE, 14668 /** 14669 * 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. 14670 */ 14671 CLINICALIMPRESSION, 14672 /** 14673 * A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure. 14674 */ 14675 CLINICALUSEDEFINITION, 14676 /** 14677 * 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. 14678 */ 14679 CODESYSTEM, 14680 /** 14681 * 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. 14682 */ 14683 COMMUNICATION, 14684 /** 14685 * 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. 14686 */ 14687 COMMUNICATIONREQUEST, 14688 /** 14689 * A compartment definition that defines how resources are accessed on a server. 14690 */ 14691 COMPARTMENTDEFINITION, 14692 /** 14693 * 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.). 14694 */ 14695 COMPOSITION, 14696 /** 14697 * 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. 14698 */ 14699 CONCEPTMAP, 14700 /** 14701 * A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern. 14702 */ 14703 CONDITION, 14704 /** 14705 * A definition of a condition and information relevant to managing it. 14706 */ 14707 CONDITIONDEFINITION, 14708 /** 14709 * 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. 14710 */ 14711 CONSENT, 14712 /** 14713 * Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement. 14714 */ 14715 CONTRACT, 14716 /** 14717 * Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment. 14718 */ 14719 COVERAGE, 14720 /** 14721 * 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. 14722 */ 14723 COVERAGEELIGIBILITYREQUEST, 14724 /** 14725 * This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource. 14726 */ 14727 COVERAGEELIGIBILITYRESPONSE, 14728 /** 14729 * 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. 14730 */ 14731 DETECTEDISSUE, 14732 /** 14733 * 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. 14734 */ 14735 DEVICE, 14736 /** 14737 * A record of association of a device. 14738 */ 14739 DEVICEASSOCIATION, 14740 /** 14741 * This is a specialized resource that defines the characteristics and capabilities of a device. 14742 */ 14743 DEVICEDEFINITION, 14744 /** 14745 * 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. 14746 */ 14747 DEVICEDISPENSE, 14748 /** 14749 * 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. 14750 */ 14751 DEVICEMETRIC, 14752 /** 14753 * 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. 14754 */ 14755 DEVICEREQUEST, 14756 /** 14757 * 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. 14758 */ 14759 DEVICEUSAGE, 14760 /** 14761 * 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. 14762 */ 14763 DIAGNOSTICREPORT, 14764 /** 14765 * 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. 14766 */ 14767 DOCUMENTREFERENCE, 14768 /** 14769 * 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). 14770 */ 14771 ENCOUNTER, 14772 /** 14773 * A record of significant events/milestones key data throughout the history of an Encounter 14774 */ 14775 ENCOUNTERHISTORY, 14776 /** 14777 * 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. 14778 */ 14779 ENDPOINT, 14780 /** 14781 * This resource provides the insurance enrollment details to the insurer regarding a specified coverage. 14782 */ 14783 ENROLLMENTREQUEST, 14784 /** 14785 * This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource. 14786 */ 14787 ENROLLMENTRESPONSE, 14788 /** 14789 * 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. 14790 */ 14791 EPISODEOFCARE, 14792 /** 14793 * The EventDefinition resource provides a reusable description of when a particular event can occur. 14794 */ 14795 EVENTDEFINITION, 14796 /** 14797 * 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. 14798 */ 14799 EVIDENCE, 14800 /** 14801 * 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. 14802 */ 14803 EVIDENCEREPORT, 14804 /** 14805 * The EvidenceVariable resource describes an element that knowledge (Evidence) is about. 14806 */ 14807 EVIDENCEVARIABLE, 14808 /** 14809 * A walkthrough of a workflow showing the interaction between systems and the instances shared, possibly including the evolution of instances over time. 14810 */ 14811 EXAMPLESCENARIO, 14812 /** 14813 * 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. 14814 */ 14815 EXPLANATIONOFBENEFIT, 14816 /** 14817 * Significant health conditions for a person related to the patient relevant in the context of care for the patient. 14818 */ 14819 FAMILYMEMBERHISTORY, 14820 /** 14821 * Prospective warnings of potential issues when providing care to the patient. 14822 */ 14823 FLAG, 14824 /** 14825 * 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. 14826 */ 14827 FORMULARYITEM, 14828 /** 14829 * A set of analyses performed to analyze and generate genomic data. 14830 */ 14831 GENOMICSTUDY, 14832 /** 14833 * 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. 14834 */ 14835 GOAL, 14836 /** 14837 * 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. 14838 */ 14839 GRAPHDEFINITION, 14840 /** 14841 * 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. 14842 */ 14843 GROUP, 14844 /** 14845 * 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. 14846 */ 14847 GUIDANCERESPONSE, 14848 /** 14849 * 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. 14850 */ 14851 HEALTHCARESERVICE, 14852 /** 14853 * 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. 14854 */ 14855 IMAGINGSELECTION, 14856 /** 14857 * 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. 14858 */ 14859 IMAGINGSTUDY, 14860 /** 14861 * 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. 14862 */ 14863 IMMUNIZATION, 14864 /** 14865 * Describes a comparison of an immunization event against published recommendations to determine if the administration is "valid" in relation to those recommendations. 14866 */ 14867 IMMUNIZATIONEVALUATION, 14868 /** 14869 * A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification. 14870 */ 14871 IMMUNIZATIONRECOMMENDATION, 14872 /** 14873 * 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. 14874 */ 14875 IMPLEMENTATIONGUIDE, 14876 /** 14877 * An ingredient of a manufactured item or pharmaceutical product. 14878 */ 14879 INGREDIENT, 14880 /** 14881 * Details of a Health Insurance product/plan provided by an organization. 14882 */ 14883 INSURANCEPLAN, 14884 /** 14885 * functional description of an inventory item used in inventory and supply-related workflows. 14886 */ 14887 INVENTORYITEM, 14888 /** 14889 * A report of inventory or stock items. 14890 */ 14891 INVENTORYREPORT, 14892 /** 14893 * Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose. 14894 */ 14895 INVOICE, 14896 /** 14897 * 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. 14898 */ 14899 LIBRARY, 14900 /** 14901 * Identifies two or more records (resource instances) that refer to the same real-world "occurrence". 14902 */ 14903 LINKAGE, 14904 /** 14905 * A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc. 14906 */ 14907 LIST, 14908 /** 14909 * Details and position information for a place where services are provided and resources and participants may be stored, found, contained, or accommodated. 14910 */ 14911 LOCATION, 14912 /** 14913 * The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product. 14914 */ 14915 MANUFACTUREDITEMDEFINITION, 14916 /** 14917 * The Measure resource provides the definition of a quality measure. 14918 */ 14919 MEASURE, 14920 /** 14921 * The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation. 14922 */ 14923 MEASUREREPORT, 14924 /** 14925 * 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. 14926 */ 14927 MEDICATION, 14928 /** 14929 * 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. 14930 */ 14931 MEDICATIONADMINISTRATION, 14932 /** 14933 * 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. 14934 */ 14935 MEDICATIONDISPENSE, 14936 /** 14937 * Information about a medication that is used to support knowledge. 14938 */ 14939 MEDICATIONKNOWLEDGE, 14940 /** 14941 * 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. 14942 */ 14943 MEDICATIONREQUEST, 14944 /** 14945 * 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. 14946 14947The 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. 14948 */ 14949 MEDICATIONSTATEMENT, 14950 /** 14951 * 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.). 14952 */ 14953 MEDICINALPRODUCTDEFINITION, 14954 /** 14955 * 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. 14956 */ 14957 MESSAGEDEFINITION, 14958 /** 14959 * 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. 14960 */ 14961 MESSAGEHEADER, 14962 /** 14963 * Representation of a molecular sequence. 14964 */ 14965 MOLECULARSEQUENCE, 14966 /** 14967 * 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. 14968 */ 14969 NAMINGSYSTEM, 14970 /** 14971 * 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. 14972 */ 14973 NUTRITIONINTAKE, 14974 /** 14975 * A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident. 14976 */ 14977 NUTRITIONORDER, 14978 /** 14979 * A food or supplement that is consumed by patients. 14980 */ 14981 NUTRITIONPRODUCT, 14982 /** 14983 * Measurements and simple assertions made about a patient, device or other subject. 14984 */ 14985 OBSERVATION, 14986 /** 14987 * Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service. 14988 */ 14989 OBSERVATIONDEFINITION, 14990 /** 14991 * A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction). 14992 */ 14993 OPERATIONDEFINITION, 14994 /** 14995 * A collection of error, warning, or information messages that result from a system action. 14996 */ 14997 OPERATIONOUTCOME, 14998 /** 14999 * 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. 15000 */ 15001 ORGANIZATION, 15002 /** 15003 * Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship. 15004 */ 15005 ORGANIZATIONAFFILIATION, 15006 /** 15007 * A medically related item or items, in a container or package. 15008 */ 15009 PACKAGEDPRODUCTDEFINITION, 15010 /** 15011 * 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. 15012 */ 15013 PARAMETERS, 15014 /** 15015 * Demographics and other administrative information about an individual or animal receiving care or other health-related services. 15016 */ 15017 PATIENT, 15018 /** 15019 * This resource provides the status of the payment for goods and services rendered, and the request and response resource references. 15020 */ 15021 PAYMENTNOTICE, 15022 /** 15023 * This resource provides the details including amount of a payment and allocates the payment items being paid. 15024 */ 15025 PAYMENTRECONCILIATION, 15026 /** 15027 * Permission resource holds access rules for a given data and context. 15028 */ 15029 PERMISSION, 15030 /** 15031 * Demographics and administrative information about a person independent of a specific health-related context. 15032 */ 15033 PERSON, 15034 /** 15035 * 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. 15036 */ 15037 PLANDEFINITION, 15038 /** 15039 * A person who is directly or indirectly involved in the provisioning of healthcare or related services. 15040 */ 15041 PRACTITIONER, 15042 /** 15043 * A specific set of Roles/Locations/specialties/services that a practitioner may perform, or has performed at an organization during a period of time. 15044 */ 15045 PRACTITIONERROLE, 15046 /** 15047 * 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. 15048 */ 15049 PROCEDURE, 15050 /** 15051 * 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. 15052 */ 15053 PROVENANCE, 15054 /** 15055 * 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. 15056 */ 15057 QUESTIONNAIRE, 15058 /** 15059 * 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. 15060 */ 15061 QUESTIONNAIRERESPONSE, 15062 /** 15063 * 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. 15064 */ 15065 REGULATEDAUTHORIZATION, 15066 /** 15067 * 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. 15068 */ 15069 RELATEDPERSON, 15070 /** 15071 * 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". 15072 */ 15073 REQUESTORCHESTRATION, 15074 /** 15075 * 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. 15076 */ 15077 REQUIREMENTS, 15078 /** 15079 * 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. 15080 */ 15081 RESEARCHSTUDY, 15082 /** 15083 * A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study. 15084 */ 15085 RESEARCHSUBJECT, 15086 /** 15087 * An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome. 15088 */ 15089 RISKASSESSMENT, 15090 /** 15091 * A container for slots of time that may be available for booking appointments. 15092 */ 15093 SCHEDULE, 15094 /** 15095 * A search parameter that defines a named search item that can be used to search/filter on a resource. 15096 */ 15097 SEARCHPARAMETER, 15098 /** 15099 * A record of a request for service such as diagnostic investigations, treatments, or operations to be performed. 15100 */ 15101 SERVICEREQUEST, 15102 /** 15103 * A slot of time on a schedule that may be available for booking appointments. 15104 */ 15105 SLOT, 15106 /** 15107 * A sample to be used for analysis. 15108 */ 15109 SPECIMEN, 15110 /** 15111 * A kind of specimen with associated set of requirements. 15112 */ 15113 SPECIMENDEFINITION, 15114 /** 15115 * 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. 15116 */ 15117 STRUCTUREDEFINITION, 15118 /** 15119 * A Map of relationships between 2 structures that can be used to transform data. 15120 */ 15121 STRUCTUREMAP, 15122 /** 15123 * The subscription resource describes a particular client's request to be notified about a SubscriptionTopic. 15124 */ 15125 SUBSCRIPTION, 15126 /** 15127 * The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted. 15128 */ 15129 SUBSCRIPTIONSTATUS, 15130 /** 15131 * Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic. 15132 */ 15133 SUBSCRIPTIONTOPIC, 15134 /** 15135 * A homogeneous material with a definite composition. 15136 */ 15137 SUBSTANCE, 15138 /** 15139 * The detailed description of a substance, typically at a level beyond what is used for prescribing. 15140 */ 15141 SUBSTANCEDEFINITION, 15142 /** 15143 * 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. 15144 */ 15145 SUBSTANCENUCLEICACID, 15146 /** 15147 * Properties of a substance specific to it being a polymer. 15148 */ 15149 SUBSTANCEPOLYMER, 15150 /** 15151 * 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. 15152 */ 15153 SUBSTANCEPROTEIN, 15154 /** 15155 * Todo. 15156 */ 15157 SUBSTANCEREFERENCEINFORMATION, 15158 /** 15159 * 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. 15160 */ 15161 SUBSTANCESOURCEMATERIAL, 15162 /** 15163 * Record of delivery of what is supplied. 15164 */ 15165 SUPPLYDELIVERY, 15166 /** 15167 * 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. 15168 */ 15169 SUPPLYREQUEST, 15170 /** 15171 * A task to be performed. 15172 */ 15173 TASK, 15174 /** 15175 * 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. 15176 */ 15177 TERMINOLOGYCAPABILITIES, 15178 /** 15179 * A plan for executing testing on an artifact or specifications 15180 */ 15181 TESTPLAN, 15182 /** 15183 * A summary of information based on the results of executing a TestScript. 15184 */ 15185 TESTREPORT, 15186 /** 15187 * A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification. 15188 */ 15189 TESTSCRIPT, 15190 /** 15191 * Record of transport. 15192 */ 15193 TRANSPORT, 15194 /** 15195 * 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). 15196 */ 15197 VALUESET, 15198 /** 15199 * Describes validation requirements, source(s), status and dates for one or more elements. 15200 */ 15201 VERIFICATIONRESULT, 15202 /** 15203 * An authorization for the provision of glasses and/or contact lenses to a patient. 15204 */ 15205 VISIONPRESCRIPTION, 15206 /** 15207 * added to help the parsers 15208 */ 15209 NULL; 15210 public static ResourceTypeEnum fromCode(String codeString) throws FHIRException { 15211 if (codeString == null || "".equals(codeString)) 15212 return null; 15213 if ("Account".equals(codeString)) 15214 return ACCOUNT; 15215 if ("ActivityDefinition".equals(codeString)) 15216 return ACTIVITYDEFINITION; 15217 if ("ActorDefinition".equals(codeString)) 15218 return ACTORDEFINITION; 15219 if ("AdministrableProductDefinition".equals(codeString)) 15220 return ADMINISTRABLEPRODUCTDEFINITION; 15221 if ("AdverseEvent".equals(codeString)) 15222 return ADVERSEEVENT; 15223 if ("AllergyIntolerance".equals(codeString)) 15224 return ALLERGYINTOLERANCE; 15225 if ("Appointment".equals(codeString)) 15226 return APPOINTMENT; 15227 if ("AppointmentResponse".equals(codeString)) 15228 return APPOINTMENTRESPONSE; 15229 if ("ArtifactAssessment".equals(codeString)) 15230 return ARTIFACTASSESSMENT; 15231 if ("AuditEvent".equals(codeString)) 15232 return AUDITEVENT; 15233 if ("Basic".equals(codeString)) 15234 return BASIC; 15235 if ("Binary".equals(codeString)) 15236 return BINARY; 15237 if ("BiologicallyDerivedProduct".equals(codeString)) 15238 return BIOLOGICALLYDERIVEDPRODUCT; 15239 if ("BiologicallyDerivedProductDispense".equals(codeString)) 15240 return BIOLOGICALLYDERIVEDPRODUCTDISPENSE; 15241 if ("BodyStructure".equals(codeString)) 15242 return BODYSTRUCTURE; 15243 if ("Bundle".equals(codeString)) 15244 return BUNDLE; 15245 if ("CapabilityStatement".equals(codeString)) 15246 return CAPABILITYSTATEMENT; 15247 if ("CarePlan".equals(codeString)) 15248 return CAREPLAN; 15249 if ("CareTeam".equals(codeString)) 15250 return CARETEAM; 15251 if ("ChargeItem".equals(codeString)) 15252 return CHARGEITEM; 15253 if ("ChargeItemDefinition".equals(codeString)) 15254 return CHARGEITEMDEFINITION; 15255 if ("Citation".equals(codeString)) 15256 return CITATION; 15257 if ("Claim".equals(codeString)) 15258 return CLAIM; 15259 if ("ClaimResponse".equals(codeString)) 15260 return CLAIMRESPONSE; 15261 if ("ClinicalImpression".equals(codeString)) 15262 return CLINICALIMPRESSION; 15263 if ("ClinicalUseDefinition".equals(codeString)) 15264 return CLINICALUSEDEFINITION; 15265 if ("CodeSystem".equals(codeString)) 15266 return CODESYSTEM; 15267 if ("Communication".equals(codeString)) 15268 return COMMUNICATION; 15269 if ("CommunicationRequest".equals(codeString)) 15270 return COMMUNICATIONREQUEST; 15271 if ("CompartmentDefinition".equals(codeString)) 15272 return COMPARTMENTDEFINITION; 15273 if ("Composition".equals(codeString)) 15274 return COMPOSITION; 15275 if ("ConceptMap".equals(codeString)) 15276 return CONCEPTMAP; 15277 if ("Condition".equals(codeString)) 15278 return CONDITION; 15279 if ("ConditionDefinition".equals(codeString)) 15280 return CONDITIONDEFINITION; 15281 if ("Consent".equals(codeString)) 15282 return CONSENT; 15283 if ("Contract".equals(codeString)) 15284 return CONTRACT; 15285 if ("Coverage".equals(codeString)) 15286 return COVERAGE; 15287 if ("CoverageEligibilityRequest".equals(codeString)) 15288 return COVERAGEELIGIBILITYREQUEST; 15289 if ("CoverageEligibilityResponse".equals(codeString)) 15290 return COVERAGEELIGIBILITYRESPONSE; 15291 if ("DetectedIssue".equals(codeString)) 15292 return DETECTEDISSUE; 15293 if ("Device".equals(codeString)) 15294 return DEVICE; 15295 if ("DeviceAssociation".equals(codeString)) 15296 return DEVICEASSOCIATION; 15297 if ("DeviceDefinition".equals(codeString)) 15298 return DEVICEDEFINITION; 15299 if ("DeviceDispense".equals(codeString)) 15300 return DEVICEDISPENSE; 15301 if ("DeviceMetric".equals(codeString)) 15302 return DEVICEMETRIC; 15303 if ("DeviceRequest".equals(codeString)) 15304 return DEVICEREQUEST; 15305 if ("DeviceUsage".equals(codeString)) 15306 return DEVICEUSAGE; 15307 if ("DiagnosticReport".equals(codeString)) 15308 return DIAGNOSTICREPORT; 15309 if ("DocumentReference".equals(codeString)) 15310 return DOCUMENTREFERENCE; 15311 if ("Encounter".equals(codeString)) 15312 return ENCOUNTER; 15313 if ("EncounterHistory".equals(codeString)) 15314 return ENCOUNTERHISTORY; 15315 if ("Endpoint".equals(codeString)) 15316 return ENDPOINT; 15317 if ("EnrollmentRequest".equals(codeString)) 15318 return ENROLLMENTREQUEST; 15319 if ("EnrollmentResponse".equals(codeString)) 15320 return ENROLLMENTRESPONSE; 15321 if ("EpisodeOfCare".equals(codeString)) 15322 return EPISODEOFCARE; 15323 if ("EventDefinition".equals(codeString)) 15324 return EVENTDEFINITION; 15325 if ("Evidence".equals(codeString)) 15326 return EVIDENCE; 15327 if ("EvidenceReport".equals(codeString)) 15328 return EVIDENCEREPORT; 15329 if ("EvidenceVariable".equals(codeString)) 15330 return EVIDENCEVARIABLE; 15331 if ("ExampleScenario".equals(codeString)) 15332 return EXAMPLESCENARIO; 15333 if ("ExplanationOfBenefit".equals(codeString)) 15334 return EXPLANATIONOFBENEFIT; 15335 if ("FamilyMemberHistory".equals(codeString)) 15336 return FAMILYMEMBERHISTORY; 15337 if ("Flag".equals(codeString)) 15338 return FLAG; 15339 if ("FormularyItem".equals(codeString)) 15340 return FORMULARYITEM; 15341 if ("GenomicStudy".equals(codeString)) 15342 return GENOMICSTUDY; 15343 if ("Goal".equals(codeString)) 15344 return GOAL; 15345 if ("GraphDefinition".equals(codeString)) 15346 return GRAPHDEFINITION; 15347 if ("Group".equals(codeString)) 15348 return GROUP; 15349 if ("GuidanceResponse".equals(codeString)) 15350 return GUIDANCERESPONSE; 15351 if ("HealthcareService".equals(codeString)) 15352 return HEALTHCARESERVICE; 15353 if ("ImagingSelection".equals(codeString)) 15354 return IMAGINGSELECTION; 15355 if ("ImagingStudy".equals(codeString)) 15356 return IMAGINGSTUDY; 15357 if ("Immunization".equals(codeString)) 15358 return IMMUNIZATION; 15359 if ("ImmunizationEvaluation".equals(codeString)) 15360 return IMMUNIZATIONEVALUATION; 15361 if ("ImmunizationRecommendation".equals(codeString)) 15362 return IMMUNIZATIONRECOMMENDATION; 15363 if ("ImplementationGuide".equals(codeString)) 15364 return IMPLEMENTATIONGUIDE; 15365 if ("Ingredient".equals(codeString)) 15366 return INGREDIENT; 15367 if ("InsurancePlan".equals(codeString)) 15368 return INSURANCEPLAN; 15369 if ("InventoryItem".equals(codeString)) 15370 return INVENTORYITEM; 15371 if ("InventoryReport".equals(codeString)) 15372 return INVENTORYREPORT; 15373 if ("Invoice".equals(codeString)) 15374 return INVOICE; 15375 if ("Library".equals(codeString)) 15376 return LIBRARY; 15377 if ("Linkage".equals(codeString)) 15378 return LINKAGE; 15379 if ("List".equals(codeString)) 15380 return LIST; 15381 if ("Location".equals(codeString)) 15382 return LOCATION; 15383 if ("ManufacturedItemDefinition".equals(codeString)) 15384 return MANUFACTUREDITEMDEFINITION; 15385 if ("Measure".equals(codeString)) 15386 return MEASURE; 15387 if ("MeasureReport".equals(codeString)) 15388 return MEASUREREPORT; 15389 if ("Medication".equals(codeString)) 15390 return MEDICATION; 15391 if ("MedicationAdministration".equals(codeString)) 15392 return MEDICATIONADMINISTRATION; 15393 if ("MedicationDispense".equals(codeString)) 15394 return MEDICATIONDISPENSE; 15395 if ("MedicationKnowledge".equals(codeString)) 15396 return MEDICATIONKNOWLEDGE; 15397 if ("MedicationRequest".equals(codeString)) 15398 return MEDICATIONREQUEST; 15399 if ("MedicationStatement".equals(codeString)) 15400 return MEDICATIONSTATEMENT; 15401 if ("MedicinalProductDefinition".equals(codeString)) 15402 return MEDICINALPRODUCTDEFINITION; 15403 if ("MessageDefinition".equals(codeString)) 15404 return MESSAGEDEFINITION; 15405 if ("MessageHeader".equals(codeString)) 15406 return MESSAGEHEADER; 15407 if ("MolecularSequence".equals(codeString)) 15408 return MOLECULARSEQUENCE; 15409 if ("NamingSystem".equals(codeString)) 15410 return NAMINGSYSTEM; 15411 if ("NutritionIntake".equals(codeString)) 15412 return NUTRITIONINTAKE; 15413 if ("NutritionOrder".equals(codeString)) 15414 return NUTRITIONORDER; 15415 if ("NutritionProduct".equals(codeString)) 15416 return NUTRITIONPRODUCT; 15417 if ("Observation".equals(codeString)) 15418 return OBSERVATION; 15419 if ("ObservationDefinition".equals(codeString)) 15420 return OBSERVATIONDEFINITION; 15421 if ("OperationDefinition".equals(codeString)) 15422 return OPERATIONDEFINITION; 15423 if ("OperationOutcome".equals(codeString)) 15424 return OPERATIONOUTCOME; 15425 if ("Organization".equals(codeString)) 15426 return ORGANIZATION; 15427 if ("OrganizationAffiliation".equals(codeString)) 15428 return ORGANIZATIONAFFILIATION; 15429 if ("PackagedProductDefinition".equals(codeString)) 15430 return PACKAGEDPRODUCTDEFINITION; 15431 if ("Parameters".equals(codeString)) 15432 return PARAMETERS; 15433 if ("Patient".equals(codeString)) 15434 return PATIENT; 15435 if ("PaymentNotice".equals(codeString)) 15436 return PAYMENTNOTICE; 15437 if ("PaymentReconciliation".equals(codeString)) 15438 return PAYMENTRECONCILIATION; 15439 if ("Permission".equals(codeString)) 15440 return PERMISSION; 15441 if ("Person".equals(codeString)) 15442 return PERSON; 15443 if ("PlanDefinition".equals(codeString)) 15444 return PLANDEFINITION; 15445 if ("Practitioner".equals(codeString)) 15446 return PRACTITIONER; 15447 if ("PractitionerRole".equals(codeString)) 15448 return PRACTITIONERROLE; 15449 if ("Procedure".equals(codeString)) 15450 return PROCEDURE; 15451 if ("Provenance".equals(codeString)) 15452 return PROVENANCE; 15453 if ("Questionnaire".equals(codeString)) 15454 return QUESTIONNAIRE; 15455 if ("QuestionnaireResponse".equals(codeString)) 15456 return QUESTIONNAIRERESPONSE; 15457 if ("RegulatedAuthorization".equals(codeString)) 15458 return REGULATEDAUTHORIZATION; 15459 if ("RelatedPerson".equals(codeString)) 15460 return RELATEDPERSON; 15461 if ("RequestOrchestration".equals(codeString)) 15462 return REQUESTORCHESTRATION; 15463 if ("Requirements".equals(codeString)) 15464 return REQUIREMENTS; 15465 if ("ResearchStudy".equals(codeString)) 15466 return RESEARCHSTUDY; 15467 if ("ResearchSubject".equals(codeString)) 15468 return RESEARCHSUBJECT; 15469 if ("RiskAssessment".equals(codeString)) 15470 return RISKASSESSMENT; 15471 if ("Schedule".equals(codeString)) 15472 return SCHEDULE; 15473 if ("SearchParameter".equals(codeString)) 15474 return SEARCHPARAMETER; 15475 if ("ServiceRequest".equals(codeString)) 15476 return SERVICEREQUEST; 15477 if ("Slot".equals(codeString)) 15478 return SLOT; 15479 if ("Specimen".equals(codeString)) 15480 return SPECIMEN; 15481 if ("SpecimenDefinition".equals(codeString)) 15482 return SPECIMENDEFINITION; 15483 if ("StructureDefinition".equals(codeString)) 15484 return STRUCTUREDEFINITION; 15485 if ("StructureMap".equals(codeString)) 15486 return STRUCTUREMAP; 15487 if ("Subscription".equals(codeString)) 15488 return SUBSCRIPTION; 15489 if ("SubscriptionStatus".equals(codeString)) 15490 return SUBSCRIPTIONSTATUS; 15491 if ("SubscriptionTopic".equals(codeString)) 15492 return SUBSCRIPTIONTOPIC; 15493 if ("Substance".equals(codeString)) 15494 return SUBSTANCE; 15495 if ("SubstanceDefinition".equals(codeString)) 15496 return SUBSTANCEDEFINITION; 15497 if ("SubstanceNucleicAcid".equals(codeString)) 15498 return SUBSTANCENUCLEICACID; 15499 if ("SubstancePolymer".equals(codeString)) 15500 return SUBSTANCEPOLYMER; 15501 if ("SubstanceProtein".equals(codeString)) 15502 return SUBSTANCEPROTEIN; 15503 if ("SubstanceReferenceInformation".equals(codeString)) 15504 return SUBSTANCEREFERENCEINFORMATION; 15505 if ("SubstanceSourceMaterial".equals(codeString)) 15506 return SUBSTANCESOURCEMATERIAL; 15507 if ("SupplyDelivery".equals(codeString)) 15508 return SUPPLYDELIVERY; 15509 if ("SupplyRequest".equals(codeString)) 15510 return SUPPLYREQUEST; 15511 if ("Task".equals(codeString)) 15512 return TASK; 15513 if ("TerminologyCapabilities".equals(codeString)) 15514 return TERMINOLOGYCAPABILITIES; 15515 if ("TestPlan".equals(codeString)) 15516 return TESTPLAN; 15517 if ("TestReport".equals(codeString)) 15518 return TESTREPORT; 15519 if ("TestScript".equals(codeString)) 15520 return TESTSCRIPT; 15521 if ("Transport".equals(codeString)) 15522 return TRANSPORT; 15523 if ("ValueSet".equals(codeString)) 15524 return VALUESET; 15525 if ("VerificationResult".equals(codeString)) 15526 return VERIFICATIONRESULT; 15527 if ("VisionPrescription".equals(codeString)) 15528 return VISIONPRESCRIPTION; 15529 throw new FHIRException("Unknown ResourceTypeEnum code '"+codeString+"'"); 15530 } 15531 public static boolean isValidCode(String codeString) { 15532 if (codeString == null || "".equals(codeString)) 15533 return false; 15534 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"); 15535 } 15536 public String toCode() { 15537 switch (this) { 15538 case ACCOUNT: return "Account"; 15539 case ACTIVITYDEFINITION: return "ActivityDefinition"; 15540 case ACTORDEFINITION: return "ActorDefinition"; 15541 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 15542 case ADVERSEEVENT: return "AdverseEvent"; 15543 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 15544 case APPOINTMENT: return "Appointment"; 15545 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 15546 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 15547 case AUDITEVENT: return "AuditEvent"; 15548 case BASIC: return "Basic"; 15549 case BINARY: return "Binary"; 15550 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 15551 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "BiologicallyDerivedProductDispense"; 15552 case BODYSTRUCTURE: return "BodyStructure"; 15553 case BUNDLE: return "Bundle"; 15554 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 15555 case CAREPLAN: return "CarePlan"; 15556 case CARETEAM: return "CareTeam"; 15557 case CHARGEITEM: return "ChargeItem"; 15558 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 15559 case CITATION: return "Citation"; 15560 case CLAIM: return "Claim"; 15561 case CLAIMRESPONSE: return "ClaimResponse"; 15562 case CLINICALIMPRESSION: return "ClinicalImpression"; 15563 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 15564 case CODESYSTEM: return "CodeSystem"; 15565 case COMMUNICATION: return "Communication"; 15566 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 15567 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 15568 case COMPOSITION: return "Composition"; 15569 case CONCEPTMAP: return "ConceptMap"; 15570 case CONDITION: return "Condition"; 15571 case CONDITIONDEFINITION: return "ConditionDefinition"; 15572 case CONSENT: return "Consent"; 15573 case CONTRACT: return "Contract"; 15574 case COVERAGE: return "Coverage"; 15575 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 15576 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 15577 case DETECTEDISSUE: return "DetectedIssue"; 15578 case DEVICE: return "Device"; 15579 case DEVICEASSOCIATION: return "DeviceAssociation"; 15580 case DEVICEDEFINITION: return "DeviceDefinition"; 15581 case DEVICEDISPENSE: return "DeviceDispense"; 15582 case DEVICEMETRIC: return "DeviceMetric"; 15583 case DEVICEREQUEST: return "DeviceRequest"; 15584 case DEVICEUSAGE: return "DeviceUsage"; 15585 case DIAGNOSTICREPORT: return "DiagnosticReport"; 15586 case DOCUMENTREFERENCE: return "DocumentReference"; 15587 case ENCOUNTER: return "Encounter"; 15588 case ENCOUNTERHISTORY: return "EncounterHistory"; 15589 case ENDPOINT: return "Endpoint"; 15590 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 15591 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 15592 case EPISODEOFCARE: return "EpisodeOfCare"; 15593 case EVENTDEFINITION: return "EventDefinition"; 15594 case EVIDENCE: return "Evidence"; 15595 case EVIDENCEREPORT: return "EvidenceReport"; 15596 case EVIDENCEVARIABLE: return "EvidenceVariable"; 15597 case EXAMPLESCENARIO: return "ExampleScenario"; 15598 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 15599 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 15600 case FLAG: return "Flag"; 15601 case FORMULARYITEM: return "FormularyItem"; 15602 case GENOMICSTUDY: return "GenomicStudy"; 15603 case GOAL: return "Goal"; 15604 case GRAPHDEFINITION: return "GraphDefinition"; 15605 case GROUP: return "Group"; 15606 case GUIDANCERESPONSE: return "GuidanceResponse"; 15607 case HEALTHCARESERVICE: return "HealthcareService"; 15608 case IMAGINGSELECTION: return "ImagingSelection"; 15609 case IMAGINGSTUDY: return "ImagingStudy"; 15610 case IMMUNIZATION: return "Immunization"; 15611 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 15612 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 15613 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 15614 case INGREDIENT: return "Ingredient"; 15615 case INSURANCEPLAN: return "InsurancePlan"; 15616 case INVENTORYITEM: return "InventoryItem"; 15617 case INVENTORYREPORT: return "InventoryReport"; 15618 case INVOICE: return "Invoice"; 15619 case LIBRARY: return "Library"; 15620 case LINKAGE: return "Linkage"; 15621 case LIST: return "List"; 15622 case LOCATION: return "Location"; 15623 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 15624 case MEASURE: return "Measure"; 15625 case MEASUREREPORT: return "MeasureReport"; 15626 case MEDICATION: return "Medication"; 15627 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 15628 case MEDICATIONDISPENSE: return "MedicationDispense"; 15629 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 15630 case MEDICATIONREQUEST: return "MedicationRequest"; 15631 case MEDICATIONSTATEMENT: return "MedicationStatement"; 15632 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 15633 case MESSAGEDEFINITION: return "MessageDefinition"; 15634 case MESSAGEHEADER: return "MessageHeader"; 15635 case MOLECULARSEQUENCE: return "MolecularSequence"; 15636 case NAMINGSYSTEM: return "NamingSystem"; 15637 case NUTRITIONINTAKE: return "NutritionIntake"; 15638 case NUTRITIONORDER: return "NutritionOrder"; 15639 case NUTRITIONPRODUCT: return "NutritionProduct"; 15640 case OBSERVATION: return "Observation"; 15641 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 15642 case OPERATIONDEFINITION: return "OperationDefinition"; 15643 case OPERATIONOUTCOME: return "OperationOutcome"; 15644 case ORGANIZATION: return "Organization"; 15645 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 15646 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 15647 case PARAMETERS: return "Parameters"; 15648 case PATIENT: return "Patient"; 15649 case PAYMENTNOTICE: return "PaymentNotice"; 15650 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 15651 case PERMISSION: return "Permission"; 15652 case PERSON: return "Person"; 15653 case PLANDEFINITION: return "PlanDefinition"; 15654 case PRACTITIONER: return "Practitioner"; 15655 case PRACTITIONERROLE: return "PractitionerRole"; 15656 case PROCEDURE: return "Procedure"; 15657 case PROVENANCE: return "Provenance"; 15658 case QUESTIONNAIRE: return "Questionnaire"; 15659 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 15660 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 15661 case RELATEDPERSON: return "RelatedPerson"; 15662 case REQUESTORCHESTRATION: return "RequestOrchestration"; 15663 case REQUIREMENTS: return "Requirements"; 15664 case RESEARCHSTUDY: return "ResearchStudy"; 15665 case RESEARCHSUBJECT: return "ResearchSubject"; 15666 case RISKASSESSMENT: return "RiskAssessment"; 15667 case SCHEDULE: return "Schedule"; 15668 case SEARCHPARAMETER: return "SearchParameter"; 15669 case SERVICEREQUEST: return "ServiceRequest"; 15670 case SLOT: return "Slot"; 15671 case SPECIMEN: return "Specimen"; 15672 case SPECIMENDEFINITION: return "SpecimenDefinition"; 15673 case STRUCTUREDEFINITION: return "StructureDefinition"; 15674 case STRUCTUREMAP: return "StructureMap"; 15675 case SUBSCRIPTION: return "Subscription"; 15676 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 15677 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 15678 case SUBSTANCE: return "Substance"; 15679 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 15680 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 15681 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 15682 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 15683 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 15684 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 15685 case SUPPLYDELIVERY: return "SupplyDelivery"; 15686 case SUPPLYREQUEST: return "SupplyRequest"; 15687 case TASK: return "Task"; 15688 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 15689 case TESTPLAN: return "TestPlan"; 15690 case TESTREPORT: return "TestReport"; 15691 case TESTSCRIPT: return "TestScript"; 15692 case TRANSPORT: return "Transport"; 15693 case VALUESET: return "ValueSet"; 15694 case VERIFICATIONRESULT: return "VerificationResult"; 15695 case VISIONPRESCRIPTION: return "VisionPrescription"; 15696 case NULL: return null; 15697 default: return "?"; 15698 } 15699 } 15700 public String getSystem() { 15701 switch (this) { 15702 case ACCOUNT: return "http://hl7.org/fhir/fhir-types"; 15703 case ACTIVITYDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15704 case ACTORDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15705 case ADMINISTRABLEPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15706 case ADVERSEEVENT: return "http://hl7.org/fhir/fhir-types"; 15707 case ALLERGYINTOLERANCE: return "http://hl7.org/fhir/fhir-types"; 15708 case APPOINTMENT: return "http://hl7.org/fhir/fhir-types"; 15709 case APPOINTMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 15710 case ARTIFACTASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 15711 case AUDITEVENT: return "http://hl7.org/fhir/fhir-types"; 15712 case BASIC: return "http://hl7.org/fhir/fhir-types"; 15713 case BINARY: return "http://hl7.org/fhir/fhir-types"; 15714 case BIOLOGICALLYDERIVEDPRODUCT: return "http://hl7.org/fhir/fhir-types"; 15715 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "http://hl7.org/fhir/fhir-types"; 15716 case BODYSTRUCTURE: return "http://hl7.org/fhir/fhir-types"; 15717 case BUNDLE: return "http://hl7.org/fhir/fhir-types"; 15718 case CAPABILITYSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 15719 case CAREPLAN: return "http://hl7.org/fhir/fhir-types"; 15720 case CARETEAM: return "http://hl7.org/fhir/fhir-types"; 15721 case CHARGEITEM: return "http://hl7.org/fhir/fhir-types"; 15722 case CHARGEITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15723 case CITATION: return "http://hl7.org/fhir/fhir-types"; 15724 case CLAIM: return "http://hl7.org/fhir/fhir-types"; 15725 case CLAIMRESPONSE: return "http://hl7.org/fhir/fhir-types"; 15726 case CLINICALIMPRESSION: return "http://hl7.org/fhir/fhir-types"; 15727 case CLINICALUSEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15728 case CODESYSTEM: return "http://hl7.org/fhir/fhir-types"; 15729 case COMMUNICATION: return "http://hl7.org/fhir/fhir-types"; 15730 case COMMUNICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 15731 case COMPARTMENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15732 case COMPOSITION: return "http://hl7.org/fhir/fhir-types"; 15733 case CONCEPTMAP: return "http://hl7.org/fhir/fhir-types"; 15734 case CONDITION: return "http://hl7.org/fhir/fhir-types"; 15735 case CONDITIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15736 case CONSENT: return "http://hl7.org/fhir/fhir-types"; 15737 case CONTRACT: return "http://hl7.org/fhir/fhir-types"; 15738 case COVERAGE: return "http://hl7.org/fhir/fhir-types"; 15739 case COVERAGEELIGIBILITYREQUEST: return "http://hl7.org/fhir/fhir-types"; 15740 case COVERAGEELIGIBILITYRESPONSE: return "http://hl7.org/fhir/fhir-types"; 15741 case DETECTEDISSUE: return "http://hl7.org/fhir/fhir-types"; 15742 case DEVICE: return "http://hl7.org/fhir/fhir-types"; 15743 case DEVICEASSOCIATION: return "http://hl7.org/fhir/fhir-types"; 15744 case DEVICEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15745 case DEVICEDISPENSE: return "http://hl7.org/fhir/fhir-types"; 15746 case DEVICEMETRIC: return "http://hl7.org/fhir/fhir-types"; 15747 case DEVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 15748 case DEVICEUSAGE: return "http://hl7.org/fhir/fhir-types"; 15749 case DIAGNOSTICREPORT: return "http://hl7.org/fhir/fhir-types"; 15750 case DOCUMENTREFERENCE: return "http://hl7.org/fhir/fhir-types"; 15751 case ENCOUNTER: return "http://hl7.org/fhir/fhir-types"; 15752 case ENCOUNTERHISTORY: return "http://hl7.org/fhir/fhir-types"; 15753 case ENDPOINT: return "http://hl7.org/fhir/fhir-types"; 15754 case ENROLLMENTREQUEST: return "http://hl7.org/fhir/fhir-types"; 15755 case ENROLLMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 15756 case EPISODEOFCARE: return "http://hl7.org/fhir/fhir-types"; 15757 case EVENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15758 case EVIDENCE: return "http://hl7.org/fhir/fhir-types"; 15759 case EVIDENCEREPORT: return "http://hl7.org/fhir/fhir-types"; 15760 case EVIDENCEVARIABLE: return "http://hl7.org/fhir/fhir-types"; 15761 case EXAMPLESCENARIO: return "http://hl7.org/fhir/fhir-types"; 15762 case EXPLANATIONOFBENEFIT: return "http://hl7.org/fhir/fhir-types"; 15763 case FAMILYMEMBERHISTORY: return "http://hl7.org/fhir/fhir-types"; 15764 case FLAG: return "http://hl7.org/fhir/fhir-types"; 15765 case FORMULARYITEM: return "http://hl7.org/fhir/fhir-types"; 15766 case GENOMICSTUDY: return "http://hl7.org/fhir/fhir-types"; 15767 case GOAL: return "http://hl7.org/fhir/fhir-types"; 15768 case GRAPHDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15769 case GROUP: return "http://hl7.org/fhir/fhir-types"; 15770 case GUIDANCERESPONSE: return "http://hl7.org/fhir/fhir-types"; 15771 case HEALTHCARESERVICE: return "http://hl7.org/fhir/fhir-types"; 15772 case IMAGINGSELECTION: return "http://hl7.org/fhir/fhir-types"; 15773 case IMAGINGSTUDY: return "http://hl7.org/fhir/fhir-types"; 15774 case IMMUNIZATION: return "http://hl7.org/fhir/fhir-types"; 15775 case IMMUNIZATIONEVALUATION: return "http://hl7.org/fhir/fhir-types"; 15776 case IMMUNIZATIONRECOMMENDATION: return "http://hl7.org/fhir/fhir-types"; 15777 case IMPLEMENTATIONGUIDE: return "http://hl7.org/fhir/fhir-types"; 15778 case INGREDIENT: return "http://hl7.org/fhir/fhir-types"; 15779 case INSURANCEPLAN: return "http://hl7.org/fhir/fhir-types"; 15780 case INVENTORYITEM: return "http://hl7.org/fhir/fhir-types"; 15781 case INVENTORYREPORT: return "http://hl7.org/fhir/fhir-types"; 15782 case INVOICE: return "http://hl7.org/fhir/fhir-types"; 15783 case LIBRARY: return "http://hl7.org/fhir/fhir-types"; 15784 case LINKAGE: return "http://hl7.org/fhir/fhir-types"; 15785 case LIST: return "http://hl7.org/fhir/fhir-types"; 15786 case LOCATION: return "http://hl7.org/fhir/fhir-types"; 15787 case MANUFACTUREDITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15788 case MEASURE: return "http://hl7.org/fhir/fhir-types"; 15789 case MEASUREREPORT: return "http://hl7.org/fhir/fhir-types"; 15790 case MEDICATION: return "http://hl7.org/fhir/fhir-types"; 15791 case MEDICATIONADMINISTRATION: return "http://hl7.org/fhir/fhir-types"; 15792 case MEDICATIONDISPENSE: return "http://hl7.org/fhir/fhir-types"; 15793 case MEDICATIONKNOWLEDGE: return "http://hl7.org/fhir/fhir-types"; 15794 case MEDICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 15795 case MEDICATIONSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 15796 case MEDICINALPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15797 case MESSAGEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15798 case MESSAGEHEADER: return "http://hl7.org/fhir/fhir-types"; 15799 case MOLECULARSEQUENCE: return "http://hl7.org/fhir/fhir-types"; 15800 case NAMINGSYSTEM: return "http://hl7.org/fhir/fhir-types"; 15801 case NUTRITIONINTAKE: return "http://hl7.org/fhir/fhir-types"; 15802 case NUTRITIONORDER: return "http://hl7.org/fhir/fhir-types"; 15803 case NUTRITIONPRODUCT: return "http://hl7.org/fhir/fhir-types"; 15804 case OBSERVATION: return "http://hl7.org/fhir/fhir-types"; 15805 case OBSERVATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15806 case OPERATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15807 case OPERATIONOUTCOME: return "http://hl7.org/fhir/fhir-types"; 15808 case ORGANIZATION: return "http://hl7.org/fhir/fhir-types"; 15809 case ORGANIZATIONAFFILIATION: return "http://hl7.org/fhir/fhir-types"; 15810 case PACKAGEDPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15811 case PARAMETERS: return "http://hl7.org/fhir/fhir-types"; 15812 case PATIENT: return "http://hl7.org/fhir/fhir-types"; 15813 case PAYMENTNOTICE: return "http://hl7.org/fhir/fhir-types"; 15814 case PAYMENTRECONCILIATION: return "http://hl7.org/fhir/fhir-types"; 15815 case PERMISSION: return "http://hl7.org/fhir/fhir-types"; 15816 case PERSON: return "http://hl7.org/fhir/fhir-types"; 15817 case PLANDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15818 case PRACTITIONER: return "http://hl7.org/fhir/fhir-types"; 15819 case PRACTITIONERROLE: return "http://hl7.org/fhir/fhir-types"; 15820 case PROCEDURE: return "http://hl7.org/fhir/fhir-types"; 15821 case PROVENANCE: return "http://hl7.org/fhir/fhir-types"; 15822 case QUESTIONNAIRE: return "http://hl7.org/fhir/fhir-types"; 15823 case QUESTIONNAIRERESPONSE: return "http://hl7.org/fhir/fhir-types"; 15824 case REGULATEDAUTHORIZATION: return "http://hl7.org/fhir/fhir-types"; 15825 case RELATEDPERSON: return "http://hl7.org/fhir/fhir-types"; 15826 case REQUESTORCHESTRATION: return "http://hl7.org/fhir/fhir-types"; 15827 case REQUIREMENTS: return "http://hl7.org/fhir/fhir-types"; 15828 case RESEARCHSTUDY: return "http://hl7.org/fhir/fhir-types"; 15829 case RESEARCHSUBJECT: return "http://hl7.org/fhir/fhir-types"; 15830 case RISKASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 15831 case SCHEDULE: return "http://hl7.org/fhir/fhir-types"; 15832 case SEARCHPARAMETER: return "http://hl7.org/fhir/fhir-types"; 15833 case SERVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 15834 case SLOT: return "http://hl7.org/fhir/fhir-types"; 15835 case SPECIMEN: return "http://hl7.org/fhir/fhir-types"; 15836 case SPECIMENDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15837 case STRUCTUREDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15838 case STRUCTUREMAP: return "http://hl7.org/fhir/fhir-types"; 15839 case SUBSCRIPTION: return "http://hl7.org/fhir/fhir-types"; 15840 case SUBSCRIPTIONSTATUS: return "http://hl7.org/fhir/fhir-types"; 15841 case SUBSCRIPTIONTOPIC: return "http://hl7.org/fhir/fhir-types"; 15842 case SUBSTANCE: return "http://hl7.org/fhir/fhir-types"; 15843 case SUBSTANCEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 15844 case SUBSTANCENUCLEICACID: return "http://hl7.org/fhir/fhir-types"; 15845 case SUBSTANCEPOLYMER: return "http://hl7.org/fhir/fhir-types"; 15846 case SUBSTANCEPROTEIN: return "http://hl7.org/fhir/fhir-types"; 15847 case SUBSTANCEREFERENCEINFORMATION: return "http://hl7.org/fhir/fhir-types"; 15848 case SUBSTANCESOURCEMATERIAL: return "http://hl7.org/fhir/fhir-types"; 15849 case SUPPLYDELIVERY: return "http://hl7.org/fhir/fhir-types"; 15850 case SUPPLYREQUEST: return "http://hl7.org/fhir/fhir-types"; 15851 case TASK: return "http://hl7.org/fhir/fhir-types"; 15852 case TERMINOLOGYCAPABILITIES: return "http://hl7.org/fhir/fhir-types"; 15853 case TESTPLAN: return "http://hl7.org/fhir/fhir-types"; 15854 case TESTREPORT: return "http://hl7.org/fhir/fhir-types"; 15855 case TESTSCRIPT: return "http://hl7.org/fhir/fhir-types"; 15856 case TRANSPORT: return "http://hl7.org/fhir/fhir-types"; 15857 case VALUESET: return "http://hl7.org/fhir/fhir-types"; 15858 case VERIFICATIONRESULT: return "http://hl7.org/fhir/fhir-types"; 15859 case VISIONPRESCRIPTION: return "http://hl7.org/fhir/fhir-types"; 15860 case NULL: return null; 15861 default: return "?"; 15862 } 15863 } 15864 public String getDefinition() { 15865 switch (this) { 15866 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."; 15867 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."; 15868 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."; 15869 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)."; 15870 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."; 15871 case ALLERGYINTOLERANCE: return "Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance."; 15872 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)."; 15873 case APPOINTMENTRESPONSE: return "A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection."; 15874 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."; 15875 case AUDITEVENT: return "A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis."; 15876 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."; 15877 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."; 15878 case BIOLOGICALLYDERIVEDPRODUCT: return "A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity."; 15879 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "A record of dispensation of a biologically derived product."; 15880 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."; 15881 case BUNDLE: return "A container for a collection of resources."; 15882 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."; 15883 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."; 15884 case CARETEAM: return "The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care."; 15885 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."; 15886 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."; 15887 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."; 15888 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."; 15889 case CLAIMRESPONSE: return "This resource provides the adjudication details from the processing of a Claim resource."; 15890 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."; 15891 case CLINICALUSEDEFINITION: return "A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure."; 15892 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."; 15893 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."; 15894 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."; 15895 case COMPARTMENTDEFINITION: return "A compartment definition that defines how resources are accessed on a server."; 15896 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.)."; 15897 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."; 15898 case CONDITION: return "A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern."; 15899 case CONDITIONDEFINITION: return "A definition of a condition and information relevant to managing it."; 15900 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."; 15901 case CONTRACT: return "Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement."; 15902 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."; 15903 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."; 15904 case COVERAGEELIGIBILITYRESPONSE: return "This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource."; 15905 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."; 15906 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."; 15907 case DEVICEASSOCIATION: return "A record of association of a device."; 15908 case DEVICEDEFINITION: return "This is a specialized resource that defines the characteristics and capabilities of a device."; 15909 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."; 15910 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. "; 15911 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."; 15912 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."; 15913 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."; 15914 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."; 15915 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)."; 15916 case ENCOUNTERHISTORY: return "A record of significant events/milestones key data throughout the history of an Encounter"; 15917 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."; 15918 case ENROLLMENTREQUEST: return "This resource provides the insurance enrollment details to the insurer regarding a specified coverage."; 15919 case ENROLLMENTRESPONSE: return "This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource."; 15920 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."; 15921 case EVENTDEFINITION: return "The EventDefinition resource provides a reusable description of when a particular event can occur."; 15922 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."; 15923 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."; 15924 case EVIDENCEVARIABLE: return "The EvidenceVariable resource describes an element that knowledge (Evidence) is about."; 15925 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."; 15926 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."; 15927 case FAMILYMEMBERHISTORY: return "Significant health conditions for a person related to the patient relevant in the context of care for the patient."; 15928 case FLAG: return "Prospective warnings of potential issues when providing care to the patient."; 15929 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."; 15930 case GENOMICSTUDY: return "A set of analyses performed to analyze and generate genomic data."; 15931 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."; 15932 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."; 15933 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."; 15934 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."; 15935 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."; 15936 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."; 15937 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."; 15938 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."; 15939 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."; 15940 case IMMUNIZATIONRECOMMENDATION: return "A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification."; 15941 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."; 15942 case INGREDIENT: return "An ingredient of a manufactured item or pharmaceutical product."; 15943 case INSURANCEPLAN: return "Details of a Health Insurance product/plan provided by an organization."; 15944 case INVENTORYITEM: return "functional description of an inventory item used in inventory and supply-related workflows."; 15945 case INVENTORYREPORT: return "A report of inventory or stock items."; 15946 case INVOICE: return "Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose."; 15947 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."; 15948 case LINKAGE: return "Identifies two or more records (resource instances) that refer to the same real-world \"occurrence\"."; 15949 case LIST: return "A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc."; 15950 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."; 15951 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."; 15952 case MEASURE: return "The Measure resource provides the definition of a quality measure."; 15953 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."; 15954 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."; 15955 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."; 15956 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."; 15957 case MEDICATIONKNOWLEDGE: return "Information about a medication that is used to support knowledge."; 15958 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."; 15959 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."; 15960 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.)."; 15961 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."; 15962 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."; 15963 case MOLECULARSEQUENCE: return "Representation of a molecular sequence."; 15964 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."; 15965 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."; 15966 case NUTRITIONORDER: return "A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident."; 15967 case NUTRITIONPRODUCT: return "A food or supplement that is consumed by patients."; 15968 case OBSERVATION: return "Measurements and simple assertions made about a patient, device or other subject."; 15969 case OBSERVATIONDEFINITION: return "Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service."; 15970 case OPERATIONDEFINITION: return "A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction)."; 15971 case OPERATIONOUTCOME: return "A collection of error, warning, or information messages that result from a system action."; 15972 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."; 15973 case ORGANIZATIONAFFILIATION: return "Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship."; 15974 case PACKAGEDPRODUCTDEFINITION: return "A medically related item or items, in a container or package."; 15975 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."; 15976 case PATIENT: return "Demographics and other administrative information about an individual or animal receiving care or other health-related services."; 15977 case PAYMENTNOTICE: return "This resource provides the status of the payment for goods and services rendered, and the request and response resource references."; 15978 case PAYMENTRECONCILIATION: return "This resource provides the details including amount of a payment and allocates the payment items being paid."; 15979 case PERMISSION: return "Permission resource holds access rules for a given data and context."; 15980 case PERSON: return "Demographics and administrative information about a person independent of a specific health-related context."; 15981 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."; 15982 case PRACTITIONER: return "A person who is directly or indirectly involved in the provisioning of healthcare or related services."; 15983 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."; 15984 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."; 15985 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."; 15986 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."; 15987 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."; 15988 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."; 15989 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."; 15990 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\"."; 15991 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."; 15992 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."; 15993 case RESEARCHSUBJECT: return "A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study."; 15994 case RISKASSESSMENT: return "An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome."; 15995 case SCHEDULE: return "A container for slots of time that may be available for booking appointments."; 15996 case SEARCHPARAMETER: return "A search parameter that defines a named search item that can be used to search/filter on a resource."; 15997 case SERVICEREQUEST: return "A record of a request for service such as diagnostic investigations, treatments, or operations to be performed."; 15998 case SLOT: return "A slot of time on a schedule that may be available for booking appointments."; 15999 case SPECIMEN: return "A sample to be used for analysis."; 16000 case SPECIMENDEFINITION: return "A kind of specimen with associated set of requirements."; 16001 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."; 16002 case STRUCTUREMAP: return "A Map of relationships between 2 structures that can be used to transform data."; 16003 case SUBSCRIPTION: return "The subscription resource describes a particular client's request to be notified about a SubscriptionTopic."; 16004 case SUBSCRIPTIONSTATUS: return "The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted."; 16005 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."; 16006 case SUBSTANCE: return "A homogeneous material with a definite composition."; 16007 case SUBSTANCEDEFINITION: return "The detailed description of a substance, typically at a level beyond what is used for prescribing."; 16008 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."; 16009 case SUBSTANCEPOLYMER: return "Properties of a substance specific to it being a polymer."; 16010 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."; 16011 case SUBSTANCEREFERENCEINFORMATION: return "Todo."; 16012 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."; 16013 case SUPPLYDELIVERY: return "Record of delivery of what is supplied."; 16014 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."; 16015 case TASK: return "A task to be performed."; 16016 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."; 16017 case TESTPLAN: return "A plan for executing testing on an artifact or specifications"; 16018 case TESTREPORT: return "A summary of information based on the results of executing a TestScript."; 16019 case TESTSCRIPT: return "A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification."; 16020 case TRANSPORT: return "Record of transport."; 16021 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)."; 16022 case VERIFICATIONRESULT: return "Describes validation requirements, source(s), status and dates for one or more elements."; 16023 case VISIONPRESCRIPTION: return "An authorization for the provision of glasses and/or contact lenses to a patient."; 16024 case NULL: return null; 16025 default: return "?"; 16026 } 16027 } 16028 public String getDisplay() { 16029 switch (this) { 16030 case ACCOUNT: return "Account"; 16031 case ACTIVITYDEFINITION: return "ActivityDefinition"; 16032 case ACTORDEFINITION: return "ActorDefinition"; 16033 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 16034 case ADVERSEEVENT: return "AdverseEvent"; 16035 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 16036 case APPOINTMENT: return "Appointment"; 16037 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 16038 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 16039 case AUDITEVENT: return "AuditEvent"; 16040 case BASIC: return "Basic"; 16041 case BINARY: return "Binary"; 16042 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 16043 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "BiologicallyDerivedProductDispense"; 16044 case BODYSTRUCTURE: return "BodyStructure"; 16045 case BUNDLE: return "Bundle"; 16046 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 16047 case CAREPLAN: return "CarePlan"; 16048 case CARETEAM: return "CareTeam"; 16049 case CHARGEITEM: return "ChargeItem"; 16050 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 16051 case CITATION: return "Citation"; 16052 case CLAIM: return "Claim"; 16053 case CLAIMRESPONSE: return "ClaimResponse"; 16054 case CLINICALIMPRESSION: return "ClinicalImpression"; 16055 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 16056 case CODESYSTEM: return "CodeSystem"; 16057 case COMMUNICATION: return "Communication"; 16058 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 16059 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 16060 case COMPOSITION: return "Composition"; 16061 case CONCEPTMAP: return "ConceptMap"; 16062 case CONDITION: return "Condition"; 16063 case CONDITIONDEFINITION: return "ConditionDefinition"; 16064 case CONSENT: return "Consent"; 16065 case CONTRACT: return "Contract"; 16066 case COVERAGE: return "Coverage"; 16067 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 16068 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 16069 case DETECTEDISSUE: return "DetectedIssue"; 16070 case DEVICE: return "Device"; 16071 case DEVICEASSOCIATION: return "DeviceAssociation"; 16072 case DEVICEDEFINITION: return "DeviceDefinition"; 16073 case DEVICEDISPENSE: return "DeviceDispense"; 16074 case DEVICEMETRIC: return "DeviceMetric"; 16075 case DEVICEREQUEST: return "DeviceRequest"; 16076 case DEVICEUSAGE: return "DeviceUsage"; 16077 case DIAGNOSTICREPORT: return "DiagnosticReport"; 16078 case DOCUMENTREFERENCE: return "DocumentReference"; 16079 case ENCOUNTER: return "Encounter"; 16080 case ENCOUNTERHISTORY: return "EncounterHistory"; 16081 case ENDPOINT: return "Endpoint"; 16082 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 16083 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 16084 case EPISODEOFCARE: return "EpisodeOfCare"; 16085 case EVENTDEFINITION: return "EventDefinition"; 16086 case EVIDENCE: return "Evidence"; 16087 case EVIDENCEREPORT: return "EvidenceReport"; 16088 case EVIDENCEVARIABLE: return "EvidenceVariable"; 16089 case EXAMPLESCENARIO: return "ExampleScenario"; 16090 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 16091 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 16092 case FLAG: return "Flag"; 16093 case FORMULARYITEM: return "FormularyItem"; 16094 case GENOMICSTUDY: return "GenomicStudy"; 16095 case GOAL: return "Goal"; 16096 case GRAPHDEFINITION: return "GraphDefinition"; 16097 case GROUP: return "Group"; 16098 case GUIDANCERESPONSE: return "GuidanceResponse"; 16099 case HEALTHCARESERVICE: return "HealthcareService"; 16100 case IMAGINGSELECTION: return "ImagingSelection"; 16101 case IMAGINGSTUDY: return "ImagingStudy"; 16102 case IMMUNIZATION: return "Immunization"; 16103 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 16104 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 16105 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 16106 case INGREDIENT: return "Ingredient"; 16107 case INSURANCEPLAN: return "InsurancePlan"; 16108 case INVENTORYITEM: return "InventoryItem"; 16109 case INVENTORYREPORT: return "InventoryReport"; 16110 case INVOICE: return "Invoice"; 16111 case LIBRARY: return "Library"; 16112 case LINKAGE: return "Linkage"; 16113 case LIST: return "List"; 16114 case LOCATION: return "Location"; 16115 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 16116 case MEASURE: return "Measure"; 16117 case MEASUREREPORT: return "MeasureReport"; 16118 case MEDICATION: return "Medication"; 16119 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 16120 case MEDICATIONDISPENSE: return "MedicationDispense"; 16121 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 16122 case MEDICATIONREQUEST: return "MedicationRequest"; 16123 case MEDICATIONSTATEMENT: return "MedicationStatement"; 16124 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 16125 case MESSAGEDEFINITION: return "MessageDefinition"; 16126 case MESSAGEHEADER: return "MessageHeader"; 16127 case MOLECULARSEQUENCE: return "MolecularSequence"; 16128 case NAMINGSYSTEM: return "NamingSystem"; 16129 case NUTRITIONINTAKE: return "NutritionIntake"; 16130 case NUTRITIONORDER: return "NutritionOrder"; 16131 case NUTRITIONPRODUCT: return "NutritionProduct"; 16132 case OBSERVATION: return "Observation"; 16133 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 16134 case OPERATIONDEFINITION: return "OperationDefinition"; 16135 case OPERATIONOUTCOME: return "OperationOutcome"; 16136 case ORGANIZATION: return "Organization"; 16137 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 16138 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 16139 case PARAMETERS: return "Parameters"; 16140 case PATIENT: return "Patient"; 16141 case PAYMENTNOTICE: return "PaymentNotice"; 16142 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 16143 case PERMISSION: return "Permission"; 16144 case PERSON: return "Person"; 16145 case PLANDEFINITION: return "PlanDefinition"; 16146 case PRACTITIONER: return "Practitioner"; 16147 case PRACTITIONERROLE: return "PractitionerRole"; 16148 case PROCEDURE: return "Procedure"; 16149 case PROVENANCE: return "Provenance"; 16150 case QUESTIONNAIRE: return "Questionnaire"; 16151 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 16152 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 16153 case RELATEDPERSON: return "RelatedPerson"; 16154 case REQUESTORCHESTRATION: return "RequestOrchestration"; 16155 case REQUIREMENTS: return "Requirements"; 16156 case RESEARCHSTUDY: return "ResearchStudy"; 16157 case RESEARCHSUBJECT: return "ResearchSubject"; 16158 case RISKASSESSMENT: return "RiskAssessment"; 16159 case SCHEDULE: return "Schedule"; 16160 case SEARCHPARAMETER: return "SearchParameter"; 16161 case SERVICEREQUEST: return "ServiceRequest"; 16162 case SLOT: return "Slot"; 16163 case SPECIMEN: return "Specimen"; 16164 case SPECIMENDEFINITION: return "SpecimenDefinition"; 16165 case STRUCTUREDEFINITION: return "StructureDefinition"; 16166 case STRUCTUREMAP: return "StructureMap"; 16167 case SUBSCRIPTION: return "Subscription"; 16168 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 16169 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 16170 case SUBSTANCE: return "Substance"; 16171 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 16172 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 16173 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 16174 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 16175 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 16176 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 16177 case SUPPLYDELIVERY: return "SupplyDelivery"; 16178 case SUPPLYREQUEST: return "SupplyRequest"; 16179 case TASK: return "Task"; 16180 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 16181 case TESTPLAN: return "TestPlan"; 16182 case TESTREPORT: return "TestReport"; 16183 case TESTSCRIPT: return "TestScript"; 16184 case TRANSPORT: return "Transport"; 16185 case VALUESET: return "ValueSet"; 16186 case VERIFICATIONRESULT: return "VerificationResult"; 16187 case VISIONPRESCRIPTION: return "VisionPrescription"; 16188 case NULL: return null; 16189 default: return "?"; 16190 } 16191 } 16192 } 16193 16194 public static class ResourceTypeEnumEnumFactory implements EnumFactory<ResourceTypeEnum> { 16195 public ResourceTypeEnum fromCode(String codeString) throws IllegalArgumentException { 16196 if (codeString == null || "".equals(codeString)) 16197 if (codeString == null || "".equals(codeString)) 16198 return null; 16199 if ("Account".equals(codeString)) 16200 return ResourceTypeEnum.ACCOUNT; 16201 if ("ActivityDefinition".equals(codeString)) 16202 return ResourceTypeEnum.ACTIVITYDEFINITION; 16203 if ("ActorDefinition".equals(codeString)) 16204 return ResourceTypeEnum.ACTORDEFINITION; 16205 if ("AdministrableProductDefinition".equals(codeString)) 16206 return ResourceTypeEnum.ADMINISTRABLEPRODUCTDEFINITION; 16207 if ("AdverseEvent".equals(codeString)) 16208 return ResourceTypeEnum.ADVERSEEVENT; 16209 if ("AllergyIntolerance".equals(codeString)) 16210 return ResourceTypeEnum.ALLERGYINTOLERANCE; 16211 if ("Appointment".equals(codeString)) 16212 return ResourceTypeEnum.APPOINTMENT; 16213 if ("AppointmentResponse".equals(codeString)) 16214 return ResourceTypeEnum.APPOINTMENTRESPONSE; 16215 if ("ArtifactAssessment".equals(codeString)) 16216 return ResourceTypeEnum.ARTIFACTASSESSMENT; 16217 if ("AuditEvent".equals(codeString)) 16218 return ResourceTypeEnum.AUDITEVENT; 16219 if ("Basic".equals(codeString)) 16220 return ResourceTypeEnum.BASIC; 16221 if ("Binary".equals(codeString)) 16222 return ResourceTypeEnum.BINARY; 16223 if ("BiologicallyDerivedProduct".equals(codeString)) 16224 return ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCT; 16225 if ("BiologicallyDerivedProductDispense".equals(codeString)) 16226 return ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCTDISPENSE; 16227 if ("BodyStructure".equals(codeString)) 16228 return ResourceTypeEnum.BODYSTRUCTURE; 16229 if ("Bundle".equals(codeString)) 16230 return ResourceTypeEnum.BUNDLE; 16231 if ("CapabilityStatement".equals(codeString)) 16232 return ResourceTypeEnum.CAPABILITYSTATEMENT; 16233 if ("CarePlan".equals(codeString)) 16234 return ResourceTypeEnum.CAREPLAN; 16235 if ("CareTeam".equals(codeString)) 16236 return ResourceTypeEnum.CARETEAM; 16237 if ("ChargeItem".equals(codeString)) 16238 return ResourceTypeEnum.CHARGEITEM; 16239 if ("ChargeItemDefinition".equals(codeString)) 16240 return ResourceTypeEnum.CHARGEITEMDEFINITION; 16241 if ("Citation".equals(codeString)) 16242 return ResourceTypeEnum.CITATION; 16243 if ("Claim".equals(codeString)) 16244 return ResourceTypeEnum.CLAIM; 16245 if ("ClaimResponse".equals(codeString)) 16246 return ResourceTypeEnum.CLAIMRESPONSE; 16247 if ("ClinicalImpression".equals(codeString)) 16248 return ResourceTypeEnum.CLINICALIMPRESSION; 16249 if ("ClinicalUseDefinition".equals(codeString)) 16250 return ResourceTypeEnum.CLINICALUSEDEFINITION; 16251 if ("CodeSystem".equals(codeString)) 16252 return ResourceTypeEnum.CODESYSTEM; 16253 if ("Communication".equals(codeString)) 16254 return ResourceTypeEnum.COMMUNICATION; 16255 if ("CommunicationRequest".equals(codeString)) 16256 return ResourceTypeEnum.COMMUNICATIONREQUEST; 16257 if ("CompartmentDefinition".equals(codeString)) 16258 return ResourceTypeEnum.COMPARTMENTDEFINITION; 16259 if ("Composition".equals(codeString)) 16260 return ResourceTypeEnum.COMPOSITION; 16261 if ("ConceptMap".equals(codeString)) 16262 return ResourceTypeEnum.CONCEPTMAP; 16263 if ("Condition".equals(codeString)) 16264 return ResourceTypeEnum.CONDITION; 16265 if ("ConditionDefinition".equals(codeString)) 16266 return ResourceTypeEnum.CONDITIONDEFINITION; 16267 if ("Consent".equals(codeString)) 16268 return ResourceTypeEnum.CONSENT; 16269 if ("Contract".equals(codeString)) 16270 return ResourceTypeEnum.CONTRACT; 16271 if ("Coverage".equals(codeString)) 16272 return ResourceTypeEnum.COVERAGE; 16273 if ("CoverageEligibilityRequest".equals(codeString)) 16274 return ResourceTypeEnum.COVERAGEELIGIBILITYREQUEST; 16275 if ("CoverageEligibilityResponse".equals(codeString)) 16276 return ResourceTypeEnum.COVERAGEELIGIBILITYRESPONSE; 16277 if ("DetectedIssue".equals(codeString)) 16278 return ResourceTypeEnum.DETECTEDISSUE; 16279 if ("Device".equals(codeString)) 16280 return ResourceTypeEnum.DEVICE; 16281 if ("DeviceAssociation".equals(codeString)) 16282 return ResourceTypeEnum.DEVICEASSOCIATION; 16283 if ("DeviceDefinition".equals(codeString)) 16284 return ResourceTypeEnum.DEVICEDEFINITION; 16285 if ("DeviceDispense".equals(codeString)) 16286 return ResourceTypeEnum.DEVICEDISPENSE; 16287 if ("DeviceMetric".equals(codeString)) 16288 return ResourceTypeEnum.DEVICEMETRIC; 16289 if ("DeviceRequest".equals(codeString)) 16290 return ResourceTypeEnum.DEVICEREQUEST; 16291 if ("DeviceUsage".equals(codeString)) 16292 return ResourceTypeEnum.DEVICEUSAGE; 16293 if ("DiagnosticReport".equals(codeString)) 16294 return ResourceTypeEnum.DIAGNOSTICREPORT; 16295 if ("DocumentReference".equals(codeString)) 16296 return ResourceTypeEnum.DOCUMENTREFERENCE; 16297 if ("Encounter".equals(codeString)) 16298 return ResourceTypeEnum.ENCOUNTER; 16299 if ("EncounterHistory".equals(codeString)) 16300 return ResourceTypeEnum.ENCOUNTERHISTORY; 16301 if ("Endpoint".equals(codeString)) 16302 return ResourceTypeEnum.ENDPOINT; 16303 if ("EnrollmentRequest".equals(codeString)) 16304 return ResourceTypeEnum.ENROLLMENTREQUEST; 16305 if ("EnrollmentResponse".equals(codeString)) 16306 return ResourceTypeEnum.ENROLLMENTRESPONSE; 16307 if ("EpisodeOfCare".equals(codeString)) 16308 return ResourceTypeEnum.EPISODEOFCARE; 16309 if ("EventDefinition".equals(codeString)) 16310 return ResourceTypeEnum.EVENTDEFINITION; 16311 if ("Evidence".equals(codeString)) 16312 return ResourceTypeEnum.EVIDENCE; 16313 if ("EvidenceReport".equals(codeString)) 16314 return ResourceTypeEnum.EVIDENCEREPORT; 16315 if ("EvidenceVariable".equals(codeString)) 16316 return ResourceTypeEnum.EVIDENCEVARIABLE; 16317 if ("ExampleScenario".equals(codeString)) 16318 return ResourceTypeEnum.EXAMPLESCENARIO; 16319 if ("ExplanationOfBenefit".equals(codeString)) 16320 return ResourceTypeEnum.EXPLANATIONOFBENEFIT; 16321 if ("FamilyMemberHistory".equals(codeString)) 16322 return ResourceTypeEnum.FAMILYMEMBERHISTORY; 16323 if ("Flag".equals(codeString)) 16324 return ResourceTypeEnum.FLAG; 16325 if ("FormularyItem".equals(codeString)) 16326 return ResourceTypeEnum.FORMULARYITEM; 16327 if ("GenomicStudy".equals(codeString)) 16328 return ResourceTypeEnum.GENOMICSTUDY; 16329 if ("Goal".equals(codeString)) 16330 return ResourceTypeEnum.GOAL; 16331 if ("GraphDefinition".equals(codeString)) 16332 return ResourceTypeEnum.GRAPHDEFINITION; 16333 if ("Group".equals(codeString)) 16334 return ResourceTypeEnum.GROUP; 16335 if ("GuidanceResponse".equals(codeString)) 16336 return ResourceTypeEnum.GUIDANCERESPONSE; 16337 if ("HealthcareService".equals(codeString)) 16338 return ResourceTypeEnum.HEALTHCARESERVICE; 16339 if ("ImagingSelection".equals(codeString)) 16340 return ResourceTypeEnum.IMAGINGSELECTION; 16341 if ("ImagingStudy".equals(codeString)) 16342 return ResourceTypeEnum.IMAGINGSTUDY; 16343 if ("Immunization".equals(codeString)) 16344 return ResourceTypeEnum.IMMUNIZATION; 16345 if ("ImmunizationEvaluation".equals(codeString)) 16346 return ResourceTypeEnum.IMMUNIZATIONEVALUATION; 16347 if ("ImmunizationRecommendation".equals(codeString)) 16348 return ResourceTypeEnum.IMMUNIZATIONRECOMMENDATION; 16349 if ("ImplementationGuide".equals(codeString)) 16350 return ResourceTypeEnum.IMPLEMENTATIONGUIDE; 16351 if ("Ingredient".equals(codeString)) 16352 return ResourceTypeEnum.INGREDIENT; 16353 if ("InsurancePlan".equals(codeString)) 16354 return ResourceTypeEnum.INSURANCEPLAN; 16355 if ("InventoryItem".equals(codeString)) 16356 return ResourceTypeEnum.INVENTORYITEM; 16357 if ("InventoryReport".equals(codeString)) 16358 return ResourceTypeEnum.INVENTORYREPORT; 16359 if ("Invoice".equals(codeString)) 16360 return ResourceTypeEnum.INVOICE; 16361 if ("Library".equals(codeString)) 16362 return ResourceTypeEnum.LIBRARY; 16363 if ("Linkage".equals(codeString)) 16364 return ResourceTypeEnum.LINKAGE; 16365 if ("List".equals(codeString)) 16366 return ResourceTypeEnum.LIST; 16367 if ("Location".equals(codeString)) 16368 return ResourceTypeEnum.LOCATION; 16369 if ("ManufacturedItemDefinition".equals(codeString)) 16370 return ResourceTypeEnum.MANUFACTUREDITEMDEFINITION; 16371 if ("Measure".equals(codeString)) 16372 return ResourceTypeEnum.MEASURE; 16373 if ("MeasureReport".equals(codeString)) 16374 return ResourceTypeEnum.MEASUREREPORT; 16375 if ("Medication".equals(codeString)) 16376 return ResourceTypeEnum.MEDICATION; 16377 if ("MedicationAdministration".equals(codeString)) 16378 return ResourceTypeEnum.MEDICATIONADMINISTRATION; 16379 if ("MedicationDispense".equals(codeString)) 16380 return ResourceTypeEnum.MEDICATIONDISPENSE; 16381 if ("MedicationKnowledge".equals(codeString)) 16382 return ResourceTypeEnum.MEDICATIONKNOWLEDGE; 16383 if ("MedicationRequest".equals(codeString)) 16384 return ResourceTypeEnum.MEDICATIONREQUEST; 16385 if ("MedicationStatement".equals(codeString)) 16386 return ResourceTypeEnum.MEDICATIONSTATEMENT; 16387 if ("MedicinalProductDefinition".equals(codeString)) 16388 return ResourceTypeEnum.MEDICINALPRODUCTDEFINITION; 16389 if ("MessageDefinition".equals(codeString)) 16390 return ResourceTypeEnum.MESSAGEDEFINITION; 16391 if ("MessageHeader".equals(codeString)) 16392 return ResourceTypeEnum.MESSAGEHEADER; 16393 if ("MolecularSequence".equals(codeString)) 16394 return ResourceTypeEnum.MOLECULARSEQUENCE; 16395 if ("NamingSystem".equals(codeString)) 16396 return ResourceTypeEnum.NAMINGSYSTEM; 16397 if ("NutritionIntake".equals(codeString)) 16398 return ResourceTypeEnum.NUTRITIONINTAKE; 16399 if ("NutritionOrder".equals(codeString)) 16400 return ResourceTypeEnum.NUTRITIONORDER; 16401 if ("NutritionProduct".equals(codeString)) 16402 return ResourceTypeEnum.NUTRITIONPRODUCT; 16403 if ("Observation".equals(codeString)) 16404 return ResourceTypeEnum.OBSERVATION; 16405 if ("ObservationDefinition".equals(codeString)) 16406 return ResourceTypeEnum.OBSERVATIONDEFINITION; 16407 if ("OperationDefinition".equals(codeString)) 16408 return ResourceTypeEnum.OPERATIONDEFINITION; 16409 if ("OperationOutcome".equals(codeString)) 16410 return ResourceTypeEnum.OPERATIONOUTCOME; 16411 if ("Organization".equals(codeString)) 16412 return ResourceTypeEnum.ORGANIZATION; 16413 if ("OrganizationAffiliation".equals(codeString)) 16414 return ResourceTypeEnum.ORGANIZATIONAFFILIATION; 16415 if ("PackagedProductDefinition".equals(codeString)) 16416 return ResourceTypeEnum.PACKAGEDPRODUCTDEFINITION; 16417 if ("Parameters".equals(codeString)) 16418 return ResourceTypeEnum.PARAMETERS; 16419 if ("Patient".equals(codeString)) 16420 return ResourceTypeEnum.PATIENT; 16421 if ("PaymentNotice".equals(codeString)) 16422 return ResourceTypeEnum.PAYMENTNOTICE; 16423 if ("PaymentReconciliation".equals(codeString)) 16424 return ResourceTypeEnum.PAYMENTRECONCILIATION; 16425 if ("Permission".equals(codeString)) 16426 return ResourceTypeEnum.PERMISSION; 16427 if ("Person".equals(codeString)) 16428 return ResourceTypeEnum.PERSON; 16429 if ("PlanDefinition".equals(codeString)) 16430 return ResourceTypeEnum.PLANDEFINITION; 16431 if ("Practitioner".equals(codeString)) 16432 return ResourceTypeEnum.PRACTITIONER; 16433 if ("PractitionerRole".equals(codeString)) 16434 return ResourceTypeEnum.PRACTITIONERROLE; 16435 if ("Procedure".equals(codeString)) 16436 return ResourceTypeEnum.PROCEDURE; 16437 if ("Provenance".equals(codeString)) 16438 return ResourceTypeEnum.PROVENANCE; 16439 if ("Questionnaire".equals(codeString)) 16440 return ResourceTypeEnum.QUESTIONNAIRE; 16441 if ("QuestionnaireResponse".equals(codeString)) 16442 return ResourceTypeEnum.QUESTIONNAIRERESPONSE; 16443 if ("RegulatedAuthorization".equals(codeString)) 16444 return ResourceTypeEnum.REGULATEDAUTHORIZATION; 16445 if ("RelatedPerson".equals(codeString)) 16446 return ResourceTypeEnum.RELATEDPERSON; 16447 if ("RequestOrchestration".equals(codeString)) 16448 return ResourceTypeEnum.REQUESTORCHESTRATION; 16449 if ("Requirements".equals(codeString)) 16450 return ResourceTypeEnum.REQUIREMENTS; 16451 if ("ResearchStudy".equals(codeString)) 16452 return ResourceTypeEnum.RESEARCHSTUDY; 16453 if ("ResearchSubject".equals(codeString)) 16454 return ResourceTypeEnum.RESEARCHSUBJECT; 16455 if ("RiskAssessment".equals(codeString)) 16456 return ResourceTypeEnum.RISKASSESSMENT; 16457 if ("Schedule".equals(codeString)) 16458 return ResourceTypeEnum.SCHEDULE; 16459 if ("SearchParameter".equals(codeString)) 16460 return ResourceTypeEnum.SEARCHPARAMETER; 16461 if ("ServiceRequest".equals(codeString)) 16462 return ResourceTypeEnum.SERVICEREQUEST; 16463 if ("Slot".equals(codeString)) 16464 return ResourceTypeEnum.SLOT; 16465 if ("Specimen".equals(codeString)) 16466 return ResourceTypeEnum.SPECIMEN; 16467 if ("SpecimenDefinition".equals(codeString)) 16468 return ResourceTypeEnum.SPECIMENDEFINITION; 16469 if ("StructureDefinition".equals(codeString)) 16470 return ResourceTypeEnum.STRUCTUREDEFINITION; 16471 if ("StructureMap".equals(codeString)) 16472 return ResourceTypeEnum.STRUCTUREMAP; 16473 if ("Subscription".equals(codeString)) 16474 return ResourceTypeEnum.SUBSCRIPTION; 16475 if ("SubscriptionStatus".equals(codeString)) 16476 return ResourceTypeEnum.SUBSCRIPTIONSTATUS; 16477 if ("SubscriptionTopic".equals(codeString)) 16478 return ResourceTypeEnum.SUBSCRIPTIONTOPIC; 16479 if ("Substance".equals(codeString)) 16480 return ResourceTypeEnum.SUBSTANCE; 16481 if ("SubstanceDefinition".equals(codeString)) 16482 return ResourceTypeEnum.SUBSTANCEDEFINITION; 16483 if ("SubstanceNucleicAcid".equals(codeString)) 16484 return ResourceTypeEnum.SUBSTANCENUCLEICACID; 16485 if ("SubstancePolymer".equals(codeString)) 16486 return ResourceTypeEnum.SUBSTANCEPOLYMER; 16487 if ("SubstanceProtein".equals(codeString)) 16488 return ResourceTypeEnum.SUBSTANCEPROTEIN; 16489 if ("SubstanceReferenceInformation".equals(codeString)) 16490 return ResourceTypeEnum.SUBSTANCEREFERENCEINFORMATION; 16491 if ("SubstanceSourceMaterial".equals(codeString)) 16492 return ResourceTypeEnum.SUBSTANCESOURCEMATERIAL; 16493 if ("SupplyDelivery".equals(codeString)) 16494 return ResourceTypeEnum.SUPPLYDELIVERY; 16495 if ("SupplyRequest".equals(codeString)) 16496 return ResourceTypeEnum.SUPPLYREQUEST; 16497 if ("Task".equals(codeString)) 16498 return ResourceTypeEnum.TASK; 16499 if ("TerminologyCapabilities".equals(codeString)) 16500 return ResourceTypeEnum.TERMINOLOGYCAPABILITIES; 16501 if ("TestPlan".equals(codeString)) 16502 return ResourceTypeEnum.TESTPLAN; 16503 if ("TestReport".equals(codeString)) 16504 return ResourceTypeEnum.TESTREPORT; 16505 if ("TestScript".equals(codeString)) 16506 return ResourceTypeEnum.TESTSCRIPT; 16507 if ("Transport".equals(codeString)) 16508 return ResourceTypeEnum.TRANSPORT; 16509 if ("ValueSet".equals(codeString)) 16510 return ResourceTypeEnum.VALUESET; 16511 if ("VerificationResult".equals(codeString)) 16512 return ResourceTypeEnum.VERIFICATIONRESULT; 16513 if ("VisionPrescription".equals(codeString)) 16514 return ResourceTypeEnum.VISIONPRESCRIPTION; 16515 throw new IllegalArgumentException("Unknown ResourceTypeEnum code '"+codeString+"'"); 16516 } 16517 16518 public Enumeration<ResourceTypeEnum> fromType(PrimitiveType<?> code) throws FHIRException { 16519 if (code == null) 16520 return null; 16521 if (code.isEmpty()) 16522 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NULL, code); 16523 String codeString = ((PrimitiveType) code).asStringValue(); 16524 if (codeString == null || "".equals(codeString)) 16525 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NULL, code); 16526 if ("Account".equals(codeString)) 16527 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ACCOUNT, code); 16528 if ("ActivityDefinition".equals(codeString)) 16529 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ACTIVITYDEFINITION, code); 16530 if ("ActorDefinition".equals(codeString)) 16531 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ACTORDEFINITION, code); 16532 if ("AdministrableProductDefinition".equals(codeString)) 16533 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ADMINISTRABLEPRODUCTDEFINITION, code); 16534 if ("AdverseEvent".equals(codeString)) 16535 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ADVERSEEVENT, code); 16536 if ("AllergyIntolerance".equals(codeString)) 16537 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ALLERGYINTOLERANCE, code); 16538 if ("Appointment".equals(codeString)) 16539 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.APPOINTMENT, code); 16540 if ("AppointmentResponse".equals(codeString)) 16541 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.APPOINTMENTRESPONSE, code); 16542 if ("ArtifactAssessment".equals(codeString)) 16543 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ARTIFACTASSESSMENT, code); 16544 if ("AuditEvent".equals(codeString)) 16545 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.AUDITEVENT, code); 16546 if ("Basic".equals(codeString)) 16547 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BASIC, code); 16548 if ("Binary".equals(codeString)) 16549 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BINARY, code); 16550 if ("BiologicallyDerivedProduct".equals(codeString)) 16551 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCT, code); 16552 if ("BiologicallyDerivedProductDispense".equals(codeString)) 16553 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCTDISPENSE, code); 16554 if ("BodyStructure".equals(codeString)) 16555 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BODYSTRUCTURE, code); 16556 if ("Bundle".equals(codeString)) 16557 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BUNDLE, code); 16558 if ("CapabilityStatement".equals(codeString)) 16559 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CAPABILITYSTATEMENT, code); 16560 if ("CarePlan".equals(codeString)) 16561 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CAREPLAN, code); 16562 if ("CareTeam".equals(codeString)) 16563 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CARETEAM, code); 16564 if ("ChargeItem".equals(codeString)) 16565 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CHARGEITEM, code); 16566 if ("ChargeItemDefinition".equals(codeString)) 16567 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CHARGEITEMDEFINITION, code); 16568 if ("Citation".equals(codeString)) 16569 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CITATION, code); 16570 if ("Claim".equals(codeString)) 16571 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLAIM, code); 16572 if ("ClaimResponse".equals(codeString)) 16573 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLAIMRESPONSE, code); 16574 if ("ClinicalImpression".equals(codeString)) 16575 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLINICALIMPRESSION, code); 16576 if ("ClinicalUseDefinition".equals(codeString)) 16577 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLINICALUSEDEFINITION, code); 16578 if ("CodeSystem".equals(codeString)) 16579 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CODESYSTEM, code); 16580 if ("Communication".equals(codeString)) 16581 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMMUNICATION, code); 16582 if ("CommunicationRequest".equals(codeString)) 16583 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMMUNICATIONREQUEST, code); 16584 if ("CompartmentDefinition".equals(codeString)) 16585 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMPARTMENTDEFINITION, code); 16586 if ("Composition".equals(codeString)) 16587 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMPOSITION, code); 16588 if ("ConceptMap".equals(codeString)) 16589 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONCEPTMAP, code); 16590 if ("Condition".equals(codeString)) 16591 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONDITION, code); 16592 if ("ConditionDefinition".equals(codeString)) 16593 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONDITIONDEFINITION, code); 16594 if ("Consent".equals(codeString)) 16595 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONSENT, code); 16596 if ("Contract".equals(codeString)) 16597 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONTRACT, code); 16598 if ("Coverage".equals(codeString)) 16599 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COVERAGE, code); 16600 if ("CoverageEligibilityRequest".equals(codeString)) 16601 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COVERAGEELIGIBILITYREQUEST, code); 16602 if ("CoverageEligibilityResponse".equals(codeString)) 16603 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COVERAGEELIGIBILITYRESPONSE, code); 16604 if ("DetectedIssue".equals(codeString)) 16605 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DETECTEDISSUE, code); 16606 if ("Device".equals(codeString)) 16607 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICE, code); 16608 if ("DeviceAssociation".equals(codeString)) 16609 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEASSOCIATION, code); 16610 if ("DeviceDefinition".equals(codeString)) 16611 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEDEFINITION, code); 16612 if ("DeviceDispense".equals(codeString)) 16613 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEDISPENSE, code); 16614 if ("DeviceMetric".equals(codeString)) 16615 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEMETRIC, code); 16616 if ("DeviceRequest".equals(codeString)) 16617 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEREQUEST, code); 16618 if ("DeviceUsage".equals(codeString)) 16619 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEUSAGE, code); 16620 if ("DiagnosticReport".equals(codeString)) 16621 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DIAGNOSTICREPORT, code); 16622 if ("DocumentReference".equals(codeString)) 16623 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DOCUMENTREFERENCE, code); 16624 if ("Encounter".equals(codeString)) 16625 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENCOUNTER, code); 16626 if ("EncounterHistory".equals(codeString)) 16627 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENCOUNTERHISTORY, code); 16628 if ("Endpoint".equals(codeString)) 16629 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENDPOINT, code); 16630 if ("EnrollmentRequest".equals(codeString)) 16631 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENROLLMENTREQUEST, code); 16632 if ("EnrollmentResponse".equals(codeString)) 16633 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENROLLMENTRESPONSE, code); 16634 if ("EpisodeOfCare".equals(codeString)) 16635 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EPISODEOFCARE, code); 16636 if ("EventDefinition".equals(codeString)) 16637 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EVENTDEFINITION, code); 16638 if ("Evidence".equals(codeString)) 16639 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EVIDENCE, code); 16640 if ("EvidenceReport".equals(codeString)) 16641 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EVIDENCEREPORT, code); 16642 if ("EvidenceVariable".equals(codeString)) 16643 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EVIDENCEVARIABLE, code); 16644 if ("ExampleScenario".equals(codeString)) 16645 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EXAMPLESCENARIO, code); 16646 if ("ExplanationOfBenefit".equals(codeString)) 16647 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EXPLANATIONOFBENEFIT, code); 16648 if ("FamilyMemberHistory".equals(codeString)) 16649 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.FAMILYMEMBERHISTORY, code); 16650 if ("Flag".equals(codeString)) 16651 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.FLAG, code); 16652 if ("FormularyItem".equals(codeString)) 16653 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.FORMULARYITEM, code); 16654 if ("GenomicStudy".equals(codeString)) 16655 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GENOMICSTUDY, code); 16656 if ("Goal".equals(codeString)) 16657 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GOAL, code); 16658 if ("GraphDefinition".equals(codeString)) 16659 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GRAPHDEFINITION, code); 16660 if ("Group".equals(codeString)) 16661 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GROUP, code); 16662 if ("GuidanceResponse".equals(codeString)) 16663 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GUIDANCERESPONSE, code); 16664 if ("HealthcareService".equals(codeString)) 16665 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.HEALTHCARESERVICE, code); 16666 if ("ImagingSelection".equals(codeString)) 16667 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMAGINGSELECTION, code); 16668 if ("ImagingStudy".equals(codeString)) 16669 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMAGINGSTUDY, code); 16670 if ("Immunization".equals(codeString)) 16671 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMMUNIZATION, code); 16672 if ("ImmunizationEvaluation".equals(codeString)) 16673 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMMUNIZATIONEVALUATION, code); 16674 if ("ImmunizationRecommendation".equals(codeString)) 16675 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMMUNIZATIONRECOMMENDATION, code); 16676 if ("ImplementationGuide".equals(codeString)) 16677 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMPLEMENTATIONGUIDE, code); 16678 if ("Ingredient".equals(codeString)) 16679 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INGREDIENT, code); 16680 if ("InsurancePlan".equals(codeString)) 16681 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INSURANCEPLAN, code); 16682 if ("InventoryItem".equals(codeString)) 16683 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INVENTORYITEM, code); 16684 if ("InventoryReport".equals(codeString)) 16685 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INVENTORYREPORT, code); 16686 if ("Invoice".equals(codeString)) 16687 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INVOICE, code); 16688 if ("Library".equals(codeString)) 16689 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LIBRARY, code); 16690 if ("Linkage".equals(codeString)) 16691 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LINKAGE, code); 16692 if ("List".equals(codeString)) 16693 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LIST, code); 16694 if ("Location".equals(codeString)) 16695 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LOCATION, code); 16696 if ("ManufacturedItemDefinition".equals(codeString)) 16697 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MANUFACTUREDITEMDEFINITION, code); 16698 if ("Measure".equals(codeString)) 16699 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEASURE, code); 16700 if ("MeasureReport".equals(codeString)) 16701 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEASUREREPORT, code); 16702 if ("Medication".equals(codeString)) 16703 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATION, code); 16704 if ("MedicationAdministration".equals(codeString)) 16705 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONADMINISTRATION, code); 16706 if ("MedicationDispense".equals(codeString)) 16707 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONDISPENSE, code); 16708 if ("MedicationKnowledge".equals(codeString)) 16709 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONKNOWLEDGE, code); 16710 if ("MedicationRequest".equals(codeString)) 16711 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONREQUEST, code); 16712 if ("MedicationStatement".equals(codeString)) 16713 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONSTATEMENT, code); 16714 if ("MedicinalProductDefinition".equals(codeString)) 16715 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICINALPRODUCTDEFINITION, code); 16716 if ("MessageDefinition".equals(codeString)) 16717 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MESSAGEDEFINITION, code); 16718 if ("MessageHeader".equals(codeString)) 16719 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MESSAGEHEADER, code); 16720 if ("MolecularSequence".equals(codeString)) 16721 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MOLECULARSEQUENCE, code); 16722 if ("NamingSystem".equals(codeString)) 16723 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NAMINGSYSTEM, code); 16724 if ("NutritionIntake".equals(codeString)) 16725 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NUTRITIONINTAKE, code); 16726 if ("NutritionOrder".equals(codeString)) 16727 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NUTRITIONORDER, code); 16728 if ("NutritionProduct".equals(codeString)) 16729 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NUTRITIONPRODUCT, code); 16730 if ("Observation".equals(codeString)) 16731 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OBSERVATION, code); 16732 if ("ObservationDefinition".equals(codeString)) 16733 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OBSERVATIONDEFINITION, code); 16734 if ("OperationDefinition".equals(codeString)) 16735 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OPERATIONDEFINITION, code); 16736 if ("OperationOutcome".equals(codeString)) 16737 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OPERATIONOUTCOME, code); 16738 if ("Organization".equals(codeString)) 16739 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ORGANIZATION, code); 16740 if ("OrganizationAffiliation".equals(codeString)) 16741 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ORGANIZATIONAFFILIATION, code); 16742 if ("PackagedProductDefinition".equals(codeString)) 16743 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PACKAGEDPRODUCTDEFINITION, code); 16744 if ("Parameters".equals(codeString)) 16745 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PARAMETERS, code); 16746 if ("Patient".equals(codeString)) 16747 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PATIENT, code); 16748 if ("PaymentNotice".equals(codeString)) 16749 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PAYMENTNOTICE, code); 16750 if ("PaymentReconciliation".equals(codeString)) 16751 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PAYMENTRECONCILIATION, code); 16752 if ("Permission".equals(codeString)) 16753 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PERMISSION, code); 16754 if ("Person".equals(codeString)) 16755 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PERSON, code); 16756 if ("PlanDefinition".equals(codeString)) 16757 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PLANDEFINITION, code); 16758 if ("Practitioner".equals(codeString)) 16759 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PRACTITIONER, code); 16760 if ("PractitionerRole".equals(codeString)) 16761 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PRACTITIONERROLE, code); 16762 if ("Procedure".equals(codeString)) 16763 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PROCEDURE, code); 16764 if ("Provenance".equals(codeString)) 16765 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PROVENANCE, code); 16766 if ("Questionnaire".equals(codeString)) 16767 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.QUESTIONNAIRE, code); 16768 if ("QuestionnaireResponse".equals(codeString)) 16769 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.QUESTIONNAIRERESPONSE, code); 16770 if ("RegulatedAuthorization".equals(codeString)) 16771 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.REGULATEDAUTHORIZATION, code); 16772 if ("RelatedPerson".equals(codeString)) 16773 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RELATEDPERSON, code); 16774 if ("RequestOrchestration".equals(codeString)) 16775 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.REQUESTORCHESTRATION, code); 16776 if ("Requirements".equals(codeString)) 16777 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.REQUIREMENTS, code); 16778 if ("ResearchStudy".equals(codeString)) 16779 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RESEARCHSTUDY, code); 16780 if ("ResearchSubject".equals(codeString)) 16781 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RESEARCHSUBJECT, code); 16782 if ("RiskAssessment".equals(codeString)) 16783 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RISKASSESSMENT, code); 16784 if ("Schedule".equals(codeString)) 16785 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SCHEDULE, code); 16786 if ("SearchParameter".equals(codeString)) 16787 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SEARCHPARAMETER, code); 16788 if ("ServiceRequest".equals(codeString)) 16789 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SERVICEREQUEST, code); 16790 if ("Slot".equals(codeString)) 16791 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SLOT, code); 16792 if ("Specimen".equals(codeString)) 16793 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SPECIMEN, code); 16794 if ("SpecimenDefinition".equals(codeString)) 16795 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SPECIMENDEFINITION, code); 16796 if ("StructureDefinition".equals(codeString)) 16797 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.STRUCTUREDEFINITION, code); 16798 if ("StructureMap".equals(codeString)) 16799 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.STRUCTUREMAP, code); 16800 if ("Subscription".equals(codeString)) 16801 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSCRIPTION, code); 16802 if ("SubscriptionStatus".equals(codeString)) 16803 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSCRIPTIONSTATUS, code); 16804 if ("SubscriptionTopic".equals(codeString)) 16805 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSCRIPTIONTOPIC, code); 16806 if ("Substance".equals(codeString)) 16807 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCE, code); 16808 if ("SubstanceDefinition".equals(codeString)) 16809 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEDEFINITION, code); 16810 if ("SubstanceNucleicAcid".equals(codeString)) 16811 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCENUCLEICACID, code); 16812 if ("SubstancePolymer".equals(codeString)) 16813 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEPOLYMER, code); 16814 if ("SubstanceProtein".equals(codeString)) 16815 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEPROTEIN, code); 16816 if ("SubstanceReferenceInformation".equals(codeString)) 16817 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEREFERENCEINFORMATION, code); 16818 if ("SubstanceSourceMaterial".equals(codeString)) 16819 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCESOURCEMATERIAL, code); 16820 if ("SupplyDelivery".equals(codeString)) 16821 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUPPLYDELIVERY, code); 16822 if ("SupplyRequest".equals(codeString)) 16823 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUPPLYREQUEST, code); 16824 if ("Task".equals(codeString)) 16825 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TASK, code); 16826 if ("TerminologyCapabilities".equals(codeString)) 16827 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TERMINOLOGYCAPABILITIES, code); 16828 if ("TestPlan".equals(codeString)) 16829 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TESTPLAN, code); 16830 if ("TestReport".equals(codeString)) 16831 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TESTREPORT, code); 16832 if ("TestScript".equals(codeString)) 16833 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TESTSCRIPT, code); 16834 if ("Transport".equals(codeString)) 16835 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TRANSPORT, code); 16836 if ("ValueSet".equals(codeString)) 16837 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.VALUESET, code); 16838 if ("VerificationResult".equals(codeString)) 16839 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.VERIFICATIONRESULT, code); 16840 if ("VisionPrescription".equals(codeString)) 16841 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.VISIONPRESCRIPTION, code); 16842 throw new FHIRException("Unknown ResourceTypeEnum code '"+codeString+"'"); 16843 } 16844 public String toCode(ResourceTypeEnum code) { 16845 if (code == ResourceTypeEnum.ACCOUNT) 16846 return "Account"; 16847 if (code == ResourceTypeEnum.ACTIVITYDEFINITION) 16848 return "ActivityDefinition"; 16849 if (code == ResourceTypeEnum.ACTORDEFINITION) 16850 return "ActorDefinition"; 16851 if (code == ResourceTypeEnum.ADMINISTRABLEPRODUCTDEFINITION) 16852 return "AdministrableProductDefinition"; 16853 if (code == ResourceTypeEnum.ADVERSEEVENT) 16854 return "AdverseEvent"; 16855 if (code == ResourceTypeEnum.ALLERGYINTOLERANCE) 16856 return "AllergyIntolerance"; 16857 if (code == ResourceTypeEnum.APPOINTMENT) 16858 return "Appointment"; 16859 if (code == ResourceTypeEnum.APPOINTMENTRESPONSE) 16860 return "AppointmentResponse"; 16861 if (code == ResourceTypeEnum.ARTIFACTASSESSMENT) 16862 return "ArtifactAssessment"; 16863 if (code == ResourceTypeEnum.AUDITEVENT) 16864 return "AuditEvent"; 16865 if (code == ResourceTypeEnum.BASIC) 16866 return "Basic"; 16867 if (code == ResourceTypeEnum.BINARY) 16868 return "Binary"; 16869 if (code == ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCT) 16870 return "BiologicallyDerivedProduct"; 16871 if (code == ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCTDISPENSE) 16872 return "BiologicallyDerivedProductDispense"; 16873 if (code == ResourceTypeEnum.BODYSTRUCTURE) 16874 return "BodyStructure"; 16875 if (code == ResourceTypeEnum.BUNDLE) 16876 return "Bundle"; 16877 if (code == ResourceTypeEnum.CAPABILITYSTATEMENT) 16878 return "CapabilityStatement"; 16879 if (code == ResourceTypeEnum.CAREPLAN) 16880 return "CarePlan"; 16881 if (code == ResourceTypeEnum.CARETEAM) 16882 return "CareTeam"; 16883 if (code == ResourceTypeEnum.CHARGEITEM) 16884 return "ChargeItem"; 16885 if (code == ResourceTypeEnum.CHARGEITEMDEFINITION) 16886 return "ChargeItemDefinition"; 16887 if (code == ResourceTypeEnum.CITATION) 16888 return "Citation"; 16889 if (code == ResourceTypeEnum.CLAIM) 16890 return "Claim"; 16891 if (code == ResourceTypeEnum.CLAIMRESPONSE) 16892 return "ClaimResponse"; 16893 if (code == ResourceTypeEnum.CLINICALIMPRESSION) 16894 return "ClinicalImpression"; 16895 if (code == ResourceTypeEnum.CLINICALUSEDEFINITION) 16896 return "ClinicalUseDefinition"; 16897 if (code == ResourceTypeEnum.CODESYSTEM) 16898 return "CodeSystem"; 16899 if (code == ResourceTypeEnum.COMMUNICATION) 16900 return "Communication"; 16901 if (code == ResourceTypeEnum.COMMUNICATIONREQUEST) 16902 return "CommunicationRequest"; 16903 if (code == ResourceTypeEnum.COMPARTMENTDEFINITION) 16904 return "CompartmentDefinition"; 16905 if (code == ResourceTypeEnum.COMPOSITION) 16906 return "Composition"; 16907 if (code == ResourceTypeEnum.CONCEPTMAP) 16908 return "ConceptMap"; 16909 if (code == ResourceTypeEnum.CONDITION) 16910 return "Condition"; 16911 if (code == ResourceTypeEnum.CONDITIONDEFINITION) 16912 return "ConditionDefinition"; 16913 if (code == ResourceTypeEnum.CONSENT) 16914 return "Consent"; 16915 if (code == ResourceTypeEnum.CONTRACT) 16916 return "Contract"; 16917 if (code == ResourceTypeEnum.COVERAGE) 16918 return "Coverage"; 16919 if (code == ResourceTypeEnum.COVERAGEELIGIBILITYREQUEST) 16920 return "CoverageEligibilityRequest"; 16921 if (code == ResourceTypeEnum.COVERAGEELIGIBILITYRESPONSE) 16922 return "CoverageEligibilityResponse"; 16923 if (code == ResourceTypeEnum.DETECTEDISSUE) 16924 return "DetectedIssue"; 16925 if (code == ResourceTypeEnum.DEVICE) 16926 return "Device"; 16927 if (code == ResourceTypeEnum.DEVICEASSOCIATION) 16928 return "DeviceAssociation"; 16929 if (code == ResourceTypeEnum.DEVICEDEFINITION) 16930 return "DeviceDefinition"; 16931 if (code == ResourceTypeEnum.DEVICEDISPENSE) 16932 return "DeviceDispense"; 16933 if (code == ResourceTypeEnum.DEVICEMETRIC) 16934 return "DeviceMetric"; 16935 if (code == ResourceTypeEnum.DEVICEREQUEST) 16936 return "DeviceRequest"; 16937 if (code == ResourceTypeEnum.DEVICEUSAGE) 16938 return "DeviceUsage"; 16939 if (code == ResourceTypeEnum.DIAGNOSTICREPORT) 16940 return "DiagnosticReport"; 16941 if (code == ResourceTypeEnum.DOCUMENTREFERENCE) 16942 return "DocumentReference"; 16943 if (code == ResourceTypeEnum.ENCOUNTER) 16944 return "Encounter"; 16945 if (code == ResourceTypeEnum.ENCOUNTERHISTORY) 16946 return "EncounterHistory"; 16947 if (code == ResourceTypeEnum.ENDPOINT) 16948 return "Endpoint"; 16949 if (code == ResourceTypeEnum.ENROLLMENTREQUEST) 16950 return "EnrollmentRequest"; 16951 if (code == ResourceTypeEnum.ENROLLMENTRESPONSE) 16952 return "EnrollmentResponse"; 16953 if (code == ResourceTypeEnum.EPISODEOFCARE) 16954 return "EpisodeOfCare"; 16955 if (code == ResourceTypeEnum.EVENTDEFINITION) 16956 return "EventDefinition"; 16957 if (code == ResourceTypeEnum.EVIDENCE) 16958 return "Evidence"; 16959 if (code == ResourceTypeEnum.EVIDENCEREPORT) 16960 return "EvidenceReport"; 16961 if (code == ResourceTypeEnum.EVIDENCEVARIABLE) 16962 return "EvidenceVariable"; 16963 if (code == ResourceTypeEnum.EXAMPLESCENARIO) 16964 return "ExampleScenario"; 16965 if (code == ResourceTypeEnum.EXPLANATIONOFBENEFIT) 16966 return "ExplanationOfBenefit"; 16967 if (code == ResourceTypeEnum.FAMILYMEMBERHISTORY) 16968 return "FamilyMemberHistory"; 16969 if (code == ResourceTypeEnum.FLAG) 16970 return "Flag"; 16971 if (code == ResourceTypeEnum.FORMULARYITEM) 16972 return "FormularyItem"; 16973 if (code == ResourceTypeEnum.GENOMICSTUDY) 16974 return "GenomicStudy"; 16975 if (code == ResourceTypeEnum.GOAL) 16976 return "Goal"; 16977 if (code == ResourceTypeEnum.GRAPHDEFINITION) 16978 return "GraphDefinition"; 16979 if (code == ResourceTypeEnum.GROUP) 16980 return "Group"; 16981 if (code == ResourceTypeEnum.GUIDANCERESPONSE) 16982 return "GuidanceResponse"; 16983 if (code == ResourceTypeEnum.HEALTHCARESERVICE) 16984 return "HealthcareService"; 16985 if (code == ResourceTypeEnum.IMAGINGSELECTION) 16986 return "ImagingSelection"; 16987 if (code == ResourceTypeEnum.IMAGINGSTUDY) 16988 return "ImagingStudy"; 16989 if (code == ResourceTypeEnum.IMMUNIZATION) 16990 return "Immunization"; 16991 if (code == ResourceTypeEnum.IMMUNIZATIONEVALUATION) 16992 return "ImmunizationEvaluation"; 16993 if (code == ResourceTypeEnum.IMMUNIZATIONRECOMMENDATION) 16994 return "ImmunizationRecommendation"; 16995 if (code == ResourceTypeEnum.IMPLEMENTATIONGUIDE) 16996 return "ImplementationGuide"; 16997 if (code == ResourceTypeEnum.INGREDIENT) 16998 return "Ingredient"; 16999 if (code == ResourceTypeEnum.INSURANCEPLAN) 17000 return "InsurancePlan"; 17001 if (code == ResourceTypeEnum.INVENTORYITEM) 17002 return "InventoryItem"; 17003 if (code == ResourceTypeEnum.INVENTORYREPORT) 17004 return "InventoryReport"; 17005 if (code == ResourceTypeEnum.INVOICE) 17006 return "Invoice"; 17007 if (code == ResourceTypeEnum.LIBRARY) 17008 return "Library"; 17009 if (code == ResourceTypeEnum.LINKAGE) 17010 return "Linkage"; 17011 if (code == ResourceTypeEnum.LIST) 17012 return "List"; 17013 if (code == ResourceTypeEnum.LOCATION) 17014 return "Location"; 17015 if (code == ResourceTypeEnum.MANUFACTUREDITEMDEFINITION) 17016 return "ManufacturedItemDefinition"; 17017 if (code == ResourceTypeEnum.MEASURE) 17018 return "Measure"; 17019 if (code == ResourceTypeEnum.MEASUREREPORT) 17020 return "MeasureReport"; 17021 if (code == ResourceTypeEnum.MEDICATION) 17022 return "Medication"; 17023 if (code == ResourceTypeEnum.MEDICATIONADMINISTRATION) 17024 return "MedicationAdministration"; 17025 if (code == ResourceTypeEnum.MEDICATIONDISPENSE) 17026 return "MedicationDispense"; 17027 if (code == ResourceTypeEnum.MEDICATIONKNOWLEDGE) 17028 return "MedicationKnowledge"; 17029 if (code == ResourceTypeEnum.MEDICATIONREQUEST) 17030 return "MedicationRequest"; 17031 if (code == ResourceTypeEnum.MEDICATIONSTATEMENT) 17032 return "MedicationStatement"; 17033 if (code == ResourceTypeEnum.MEDICINALPRODUCTDEFINITION) 17034 return "MedicinalProductDefinition"; 17035 if (code == ResourceTypeEnum.MESSAGEDEFINITION) 17036 return "MessageDefinition"; 17037 if (code == ResourceTypeEnum.MESSAGEHEADER) 17038 return "MessageHeader"; 17039 if (code == ResourceTypeEnum.MOLECULARSEQUENCE) 17040 return "MolecularSequence"; 17041 if (code == ResourceTypeEnum.NAMINGSYSTEM) 17042 return "NamingSystem"; 17043 if (code == ResourceTypeEnum.NUTRITIONINTAKE) 17044 return "NutritionIntake"; 17045 if (code == ResourceTypeEnum.NUTRITIONORDER) 17046 return "NutritionOrder"; 17047 if (code == ResourceTypeEnum.NUTRITIONPRODUCT) 17048 return "NutritionProduct"; 17049 if (code == ResourceTypeEnum.OBSERVATION) 17050 return "Observation"; 17051 if (code == ResourceTypeEnum.OBSERVATIONDEFINITION) 17052 return "ObservationDefinition"; 17053 if (code == ResourceTypeEnum.OPERATIONDEFINITION) 17054 return "OperationDefinition"; 17055 if (code == ResourceTypeEnum.OPERATIONOUTCOME) 17056 return "OperationOutcome"; 17057 if (code == ResourceTypeEnum.ORGANIZATION) 17058 return "Organization"; 17059 if (code == ResourceTypeEnum.ORGANIZATIONAFFILIATION) 17060 return "OrganizationAffiliation"; 17061 if (code == ResourceTypeEnum.PACKAGEDPRODUCTDEFINITION) 17062 return "PackagedProductDefinition"; 17063 if (code == ResourceTypeEnum.PARAMETERS) 17064 return "Parameters"; 17065 if (code == ResourceTypeEnum.PATIENT) 17066 return "Patient"; 17067 if (code == ResourceTypeEnum.PAYMENTNOTICE) 17068 return "PaymentNotice"; 17069 if (code == ResourceTypeEnum.PAYMENTRECONCILIATION) 17070 return "PaymentReconciliation"; 17071 if (code == ResourceTypeEnum.PERMISSION) 17072 return "Permission"; 17073 if (code == ResourceTypeEnum.PERSON) 17074 return "Person"; 17075 if (code == ResourceTypeEnum.PLANDEFINITION) 17076 return "PlanDefinition"; 17077 if (code == ResourceTypeEnum.PRACTITIONER) 17078 return "Practitioner"; 17079 if (code == ResourceTypeEnum.PRACTITIONERROLE) 17080 return "PractitionerRole"; 17081 if (code == ResourceTypeEnum.PROCEDURE) 17082 return "Procedure"; 17083 if (code == ResourceTypeEnum.PROVENANCE) 17084 return "Provenance"; 17085 if (code == ResourceTypeEnum.QUESTIONNAIRE) 17086 return "Questionnaire"; 17087 if (code == ResourceTypeEnum.QUESTIONNAIRERESPONSE) 17088 return "QuestionnaireResponse"; 17089 if (code == ResourceTypeEnum.REGULATEDAUTHORIZATION) 17090 return "RegulatedAuthorization"; 17091 if (code == ResourceTypeEnum.RELATEDPERSON) 17092 return "RelatedPerson"; 17093 if (code == ResourceTypeEnum.REQUESTORCHESTRATION) 17094 return "RequestOrchestration"; 17095 if (code == ResourceTypeEnum.REQUIREMENTS) 17096 return "Requirements"; 17097 if (code == ResourceTypeEnum.RESEARCHSTUDY) 17098 return "ResearchStudy"; 17099 if (code == ResourceTypeEnum.RESEARCHSUBJECT) 17100 return "ResearchSubject"; 17101 if (code == ResourceTypeEnum.RISKASSESSMENT) 17102 return "RiskAssessment"; 17103 if (code == ResourceTypeEnum.SCHEDULE) 17104 return "Schedule"; 17105 if (code == ResourceTypeEnum.SEARCHPARAMETER) 17106 return "SearchParameter"; 17107 if (code == ResourceTypeEnum.SERVICEREQUEST) 17108 return "ServiceRequest"; 17109 if (code == ResourceTypeEnum.SLOT) 17110 return "Slot"; 17111 if (code == ResourceTypeEnum.SPECIMEN) 17112 return "Specimen"; 17113 if (code == ResourceTypeEnum.SPECIMENDEFINITION) 17114 return "SpecimenDefinition"; 17115 if (code == ResourceTypeEnum.STRUCTUREDEFINITION) 17116 return "StructureDefinition"; 17117 if (code == ResourceTypeEnum.STRUCTUREMAP) 17118 return "StructureMap"; 17119 if (code == ResourceTypeEnum.SUBSCRIPTION) 17120 return "Subscription"; 17121 if (code == ResourceTypeEnum.SUBSCRIPTIONSTATUS) 17122 return "SubscriptionStatus"; 17123 if (code == ResourceTypeEnum.SUBSCRIPTIONTOPIC) 17124 return "SubscriptionTopic"; 17125 if (code == ResourceTypeEnum.SUBSTANCE) 17126 return "Substance"; 17127 if (code == ResourceTypeEnum.SUBSTANCEDEFINITION) 17128 return "SubstanceDefinition"; 17129 if (code == ResourceTypeEnum.SUBSTANCENUCLEICACID) 17130 return "SubstanceNucleicAcid"; 17131 if (code == ResourceTypeEnum.SUBSTANCEPOLYMER) 17132 return "SubstancePolymer"; 17133 if (code == ResourceTypeEnum.SUBSTANCEPROTEIN) 17134 return "SubstanceProtein"; 17135 if (code == ResourceTypeEnum.SUBSTANCEREFERENCEINFORMATION) 17136 return "SubstanceReferenceInformation"; 17137 if (code == ResourceTypeEnum.SUBSTANCESOURCEMATERIAL) 17138 return "SubstanceSourceMaterial"; 17139 if (code == ResourceTypeEnum.SUPPLYDELIVERY) 17140 return "SupplyDelivery"; 17141 if (code == ResourceTypeEnum.SUPPLYREQUEST) 17142 return "SupplyRequest"; 17143 if (code == ResourceTypeEnum.TASK) 17144 return "Task"; 17145 if (code == ResourceTypeEnum.TERMINOLOGYCAPABILITIES) 17146 return "TerminologyCapabilities"; 17147 if (code == ResourceTypeEnum.TESTPLAN) 17148 return "TestPlan"; 17149 if (code == ResourceTypeEnum.TESTREPORT) 17150 return "TestReport"; 17151 if (code == ResourceTypeEnum.TESTSCRIPT) 17152 return "TestScript"; 17153 if (code == ResourceTypeEnum.TRANSPORT) 17154 return "Transport"; 17155 if (code == ResourceTypeEnum.VALUESET) 17156 return "ValueSet"; 17157 if (code == ResourceTypeEnum.VERIFICATIONRESULT) 17158 return "VerificationResult"; 17159 if (code == ResourceTypeEnum.VISIONPRESCRIPTION) 17160 return "VisionPrescription"; 17161 return "?"; 17162 } 17163 public String toSystem(ResourceTypeEnum code) { 17164 return code.getSystem(); 17165 } 17166 } 17167 17168 public enum SearchComparator { 17169 /** 17170 * the value for the parameter in the resource is equal to the provided value. 17171 */ 17172 EQ, 17173 /** 17174 * the value for the parameter in the resource is not equal to the provided value. 17175 */ 17176 NE, 17177 /** 17178 * the value for the parameter in the resource is greater than the provided value. 17179 */ 17180 GT, 17181 /** 17182 * the value for the parameter in the resource is less than the provided value. 17183 */ 17184 LT, 17185 /** 17186 * the value for the parameter in the resource is greater or equal to the provided value. 17187 */ 17188 GE, 17189 /** 17190 * the value for the parameter in the resource is less or equal to the provided value. 17191 */ 17192 LE, 17193 /** 17194 * the value for the parameter in the resource starts after the provided value. 17195 */ 17196 SA, 17197 /** 17198 * the value for the parameter in the resource ends before the provided value. 17199 */ 17200 EB, 17201 /** 17202 * the value for the parameter in the resource is approximately the same to the provided value. 17203 */ 17204 AP, 17205 /** 17206 * added to help the parsers 17207 */ 17208 NULL; 17209 public static SearchComparator fromCode(String codeString) throws FHIRException { 17210 if (codeString == null || "".equals(codeString)) 17211 return null; 17212 if ("eq".equals(codeString)) 17213 return EQ; 17214 if ("ne".equals(codeString)) 17215 return NE; 17216 if ("gt".equals(codeString)) 17217 return GT; 17218 if ("lt".equals(codeString)) 17219 return LT; 17220 if ("ge".equals(codeString)) 17221 return GE; 17222 if ("le".equals(codeString)) 17223 return LE; 17224 if ("sa".equals(codeString)) 17225 return SA; 17226 if ("eb".equals(codeString)) 17227 return EB; 17228 if ("ap".equals(codeString)) 17229 return AP; 17230 throw new FHIRException("Unknown SearchComparator code '"+codeString+"'"); 17231 } 17232 public static boolean isValidCode(String codeString) { 17233 if (codeString == null || "".equals(codeString)) 17234 return false; 17235 return Utilities.existsInList(codeString, "eq", "ne", "gt", "lt", "ge", "le", "sa", "eb", "ap"); 17236 } 17237 public String toCode() { 17238 switch (this) { 17239 case EQ: return "eq"; 17240 case NE: return "ne"; 17241 case GT: return "gt"; 17242 case LT: return "lt"; 17243 case GE: return "ge"; 17244 case LE: return "le"; 17245 case SA: return "sa"; 17246 case EB: return "eb"; 17247 case AP: return "ap"; 17248 case NULL: return null; 17249 default: return "?"; 17250 } 17251 } 17252 public String getSystem() { 17253 switch (this) { 17254 case EQ: return "http://hl7.org/fhir/search-comparator"; 17255 case NE: return "http://hl7.org/fhir/search-comparator"; 17256 case GT: return "http://hl7.org/fhir/search-comparator"; 17257 case LT: return "http://hl7.org/fhir/search-comparator"; 17258 case GE: return "http://hl7.org/fhir/search-comparator"; 17259 case LE: return "http://hl7.org/fhir/search-comparator"; 17260 case SA: return "http://hl7.org/fhir/search-comparator"; 17261 case EB: return "http://hl7.org/fhir/search-comparator"; 17262 case AP: return "http://hl7.org/fhir/search-comparator"; 17263 case NULL: return null; 17264 default: return "?"; 17265 } 17266 } 17267 public String getDefinition() { 17268 switch (this) { 17269 case EQ: return "the value for the parameter in the resource is equal to the provided value."; 17270 case NE: return "the value for the parameter in the resource is not equal to the provided value."; 17271 case GT: return "the value for the parameter in the resource is greater than the provided value."; 17272 case LT: return "the value for the parameter in the resource is less than the provided value."; 17273 case GE: return "the value for the parameter in the resource is greater or equal to the provided value."; 17274 case LE: return "the value for the parameter in the resource is less or equal to the provided value."; 17275 case SA: return "the value for the parameter in the resource starts after the provided value."; 17276 case EB: return "the value for the parameter in the resource ends before the provided value."; 17277 case AP: return "the value for the parameter in the resource is approximately the same to the provided value."; 17278 case NULL: return null; 17279 default: return "?"; 17280 } 17281 } 17282 public String getDisplay() { 17283 switch (this) { 17284 case EQ: return "Equals"; 17285 case NE: return "Not Equals"; 17286 case GT: return "Greater Than"; 17287 case LT: return "Less Than"; 17288 case GE: return "Greater or Equals"; 17289 case LE: return "Less of Equal"; 17290 case SA: return "Starts After"; 17291 case EB: return "Ends Before"; 17292 case AP: return "Approximately"; 17293 case NULL: return null; 17294 default: return "?"; 17295 } 17296 } 17297 } 17298 17299 public static class SearchComparatorEnumFactory implements EnumFactory<SearchComparator> { 17300 public SearchComparator fromCode(String codeString) throws IllegalArgumentException { 17301 if (codeString == null || "".equals(codeString)) 17302 if (codeString == null || "".equals(codeString)) 17303 return null; 17304 if ("eq".equals(codeString)) 17305 return SearchComparator.EQ; 17306 if ("ne".equals(codeString)) 17307 return SearchComparator.NE; 17308 if ("gt".equals(codeString)) 17309 return SearchComparator.GT; 17310 if ("lt".equals(codeString)) 17311 return SearchComparator.LT; 17312 if ("ge".equals(codeString)) 17313 return SearchComparator.GE; 17314 if ("le".equals(codeString)) 17315 return SearchComparator.LE; 17316 if ("sa".equals(codeString)) 17317 return SearchComparator.SA; 17318 if ("eb".equals(codeString)) 17319 return SearchComparator.EB; 17320 if ("ap".equals(codeString)) 17321 return SearchComparator.AP; 17322 throw new IllegalArgumentException("Unknown SearchComparator code '"+codeString+"'"); 17323 } 17324 17325 public Enumeration<SearchComparator> fromType(PrimitiveType<?> code) throws FHIRException { 17326 if (code == null) 17327 return null; 17328 if (code.isEmpty()) 17329 return new Enumeration<SearchComparator>(this, SearchComparator.NULL, code); 17330 String codeString = ((PrimitiveType) code).asStringValue(); 17331 if (codeString == null || "".equals(codeString)) 17332 return new Enumeration<SearchComparator>(this, SearchComparator.NULL, code); 17333 if ("eq".equals(codeString)) 17334 return new Enumeration<SearchComparator>(this, SearchComparator.EQ, code); 17335 if ("ne".equals(codeString)) 17336 return new Enumeration<SearchComparator>(this, SearchComparator.NE, code); 17337 if ("gt".equals(codeString)) 17338 return new Enumeration<SearchComparator>(this, SearchComparator.GT, code); 17339 if ("lt".equals(codeString)) 17340 return new Enumeration<SearchComparator>(this, SearchComparator.LT, code); 17341 if ("ge".equals(codeString)) 17342 return new Enumeration<SearchComparator>(this, SearchComparator.GE, code); 17343 if ("le".equals(codeString)) 17344 return new Enumeration<SearchComparator>(this, SearchComparator.LE, code); 17345 if ("sa".equals(codeString)) 17346 return new Enumeration<SearchComparator>(this, SearchComparator.SA, code); 17347 if ("eb".equals(codeString)) 17348 return new Enumeration<SearchComparator>(this, SearchComparator.EB, code); 17349 if ("ap".equals(codeString)) 17350 return new Enumeration<SearchComparator>(this, SearchComparator.AP, code); 17351 throw new FHIRException("Unknown SearchComparator code '"+codeString+"'"); 17352 } 17353 public String toCode(SearchComparator code) { 17354 if (code == SearchComparator.EQ) 17355 return "eq"; 17356 if (code == SearchComparator.NE) 17357 return "ne"; 17358 if (code == SearchComparator.GT) 17359 return "gt"; 17360 if (code == SearchComparator.LT) 17361 return "lt"; 17362 if (code == SearchComparator.GE) 17363 return "ge"; 17364 if (code == SearchComparator.LE) 17365 return "le"; 17366 if (code == SearchComparator.SA) 17367 return "sa"; 17368 if (code == SearchComparator.EB) 17369 return "eb"; 17370 if (code == SearchComparator.AP) 17371 return "ap"; 17372 return "?"; 17373 } 17374 public String toSystem(SearchComparator code) { 17375 return code.getSystem(); 17376 } 17377 } 17378 17379 public enum SearchModifierCode { 17380 /** 17381 * The search parameter returns resources that have a value or not. 17382 */ 17383 MISSING, 17384 /** 17385 * The search parameter returns resources that have a value that exactly matches the supplied parameter (the whole string, including casing and accents). 17386 */ 17387 EXACT, 17388 /** 17389 * The search parameter returns resources that include the supplied parameter value anywhere within the field being searched. 17390 */ 17391 CONTAINS, 17392 /** 17393 * The search parameter returns resources that do not contain a match. 17394 */ 17395 NOT, 17396 /** 17397 * 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. 17398 */ 17399 TEXT, 17400 /** 17401 * 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. 17402 */ 17403 IN, 17404 /** 17405 * 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. 17406 */ 17407 NOTIN, 17408 /** 17409 * The search parameter tests whether the value in a resource is subsumed by the specified value (is-a, or hierarchical relationships). 17410 */ 17411 BELOW, 17412 /** 17413 * The search parameter tests whether the value in a resource subsumes the specified value (is-a, or hierarchical relationships). 17414 */ 17415 ABOVE, 17416 /** 17417 * The search parameter only applies to the Resource Type specified as a modifier (e.g. the modifier is not actually :type, but :Patient etc.). 17418 */ 17419 TYPE, 17420 /** 17421 * The search parameter applies to the identifier on the resource, not the reference. 17422 */ 17423 IDENTIFIER, 17424 /** 17425 * 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. 17426 */ 17427 OFTYPE, 17428 /** 17429 * Tests whether the textual display value in a resource (e.g., CodeableConcept.text, Coding.display, or Reference.display) matches the supplied parameter value. 17430 */ 17431 CODETEXT, 17432 /** 17433 * 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. 17434 */ 17435 TEXTADVANCED, 17436 /** 17437 * The search parameter indicates an inclusion directive (_include, _revinclude) that is applied to an included resource instead of the matching resource. 17438 */ 17439 ITERATE, 17440 /** 17441 * added to help the parsers 17442 */ 17443 NULL; 17444 public static SearchModifierCode fromCode(String codeString) throws FHIRException { 17445 if (codeString == null || "".equals(codeString)) 17446 return null; 17447 if ("missing".equals(codeString)) 17448 return MISSING; 17449 if ("exact".equals(codeString)) 17450 return EXACT; 17451 if ("contains".equals(codeString)) 17452 return CONTAINS; 17453 if ("not".equals(codeString)) 17454 return NOT; 17455 if ("text".equals(codeString)) 17456 return TEXT; 17457 if ("in".equals(codeString)) 17458 return IN; 17459 if ("not-in".equals(codeString)) 17460 return NOTIN; 17461 if ("below".equals(codeString)) 17462 return BELOW; 17463 if ("above".equals(codeString)) 17464 return ABOVE; 17465 if ("type".equals(codeString)) 17466 return TYPE; 17467 if ("identifier".equals(codeString)) 17468 return IDENTIFIER; 17469 if ("of-type".equals(codeString)) 17470 return OFTYPE; 17471 if ("code-text".equals(codeString)) 17472 return CODETEXT; 17473 if ("text-advanced".equals(codeString)) 17474 return TEXTADVANCED; 17475 if ("iterate".equals(codeString)) 17476 return ITERATE; 17477 throw new FHIRException("Unknown SearchModifierCode code '"+codeString+"'"); 17478 } 17479 public static boolean isValidCode(String codeString) { 17480 if (codeString == null || "".equals(codeString)) 17481 return false; 17482 return Utilities.existsInList(codeString, "missing", "exact", "contains", "not", "text", "in", "not-in", "below", "above", "type", "identifier", "of-type", "code-text", "text-advanced", "iterate"); 17483 } 17484 public String toCode() { 17485 switch (this) { 17486 case MISSING: return "missing"; 17487 case EXACT: return "exact"; 17488 case CONTAINS: return "contains"; 17489 case NOT: return "not"; 17490 case TEXT: return "text"; 17491 case IN: return "in"; 17492 case NOTIN: return "not-in"; 17493 case BELOW: return "below"; 17494 case ABOVE: return "above"; 17495 case TYPE: return "type"; 17496 case IDENTIFIER: return "identifier"; 17497 case OFTYPE: return "of-type"; 17498 case CODETEXT: return "code-text"; 17499 case TEXTADVANCED: return "text-advanced"; 17500 case ITERATE: return "iterate"; 17501 case NULL: return null; 17502 default: return "?"; 17503 } 17504 } 17505 public String getSystem() { 17506 switch (this) { 17507 case MISSING: return "http://hl7.org/fhir/search-modifier-code"; 17508 case EXACT: return "http://hl7.org/fhir/search-modifier-code"; 17509 case CONTAINS: return "http://hl7.org/fhir/search-modifier-code"; 17510 case NOT: return "http://hl7.org/fhir/search-modifier-code"; 17511 case TEXT: return "http://hl7.org/fhir/search-modifier-code"; 17512 case IN: return "http://hl7.org/fhir/search-modifier-code"; 17513 case NOTIN: return "http://hl7.org/fhir/search-modifier-code"; 17514 case BELOW: return "http://hl7.org/fhir/search-modifier-code"; 17515 case ABOVE: return "http://hl7.org/fhir/search-modifier-code"; 17516 case TYPE: return "http://hl7.org/fhir/search-modifier-code"; 17517 case IDENTIFIER: return "http://hl7.org/fhir/search-modifier-code"; 17518 case OFTYPE: return "http://hl7.org/fhir/search-modifier-code"; 17519 case CODETEXT: return "http://hl7.org/fhir/search-modifier-code"; 17520 case TEXTADVANCED: return "http://hl7.org/fhir/search-modifier-code"; 17521 case ITERATE: return "http://hl7.org/fhir/search-modifier-code"; 17522 case NULL: return null; 17523 default: return "?"; 17524 } 17525 } 17526 public String getDefinition() { 17527 switch (this) { 17528 case MISSING: return "The search parameter returns resources that have a value or not."; 17529 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)."; 17530 case CONTAINS: return "The search parameter returns resources that include the supplied parameter value anywhere within the field being searched."; 17531 case NOT: return "The search parameter returns resources that do not contain a match."; 17532 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."; 17533 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."; 17534 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."; 17535 case BELOW: return "The search parameter tests whether the value in a resource is subsumed by the specified value (is-a, or hierarchical relationships)."; 17536 case ABOVE: return "The search parameter tests whether the value in a resource subsumes the specified value (is-a, or hierarchical relationships)."; 17537 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.)."; 17538 case IDENTIFIER: return "The search parameter applies to the identifier on the resource, not the reference."; 17539 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."; 17540 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."; 17541 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."; 17542 case ITERATE: return "The search parameter indicates an inclusion directive (_include, _revinclude) that is applied to an included resource instead of the matching resource."; 17543 case NULL: return null; 17544 default: return "?"; 17545 } 17546 } 17547 public String getDisplay() { 17548 switch (this) { 17549 case MISSING: return "Missing"; 17550 case EXACT: return "Exact"; 17551 case CONTAINS: return "Contains"; 17552 case NOT: return "Not"; 17553 case TEXT: return "Text"; 17554 case IN: return "In"; 17555 case NOTIN: return "Not In"; 17556 case BELOW: return "Below"; 17557 case ABOVE: return "Above"; 17558 case TYPE: return "Type"; 17559 case IDENTIFIER: return "Identifier"; 17560 case OFTYPE: return "Of Type"; 17561 case CODETEXT: return "Code Text"; 17562 case TEXTADVANCED: return "Text Advanced"; 17563 case ITERATE: return "Iterate"; 17564 case NULL: return null; 17565 default: return "?"; 17566 } 17567 } 17568 } 17569 17570 public static class SearchModifierCodeEnumFactory implements EnumFactory<SearchModifierCode> { 17571 public SearchModifierCode fromCode(String codeString) throws IllegalArgumentException { 17572 if (codeString == null || "".equals(codeString)) 17573 if (codeString == null || "".equals(codeString)) 17574 return null; 17575 if ("missing".equals(codeString)) 17576 return SearchModifierCode.MISSING; 17577 if ("exact".equals(codeString)) 17578 return SearchModifierCode.EXACT; 17579 if ("contains".equals(codeString)) 17580 return SearchModifierCode.CONTAINS; 17581 if ("not".equals(codeString)) 17582 return SearchModifierCode.NOT; 17583 if ("text".equals(codeString)) 17584 return SearchModifierCode.TEXT; 17585 if ("in".equals(codeString)) 17586 return SearchModifierCode.IN; 17587 if ("not-in".equals(codeString)) 17588 return SearchModifierCode.NOTIN; 17589 if ("below".equals(codeString)) 17590 return SearchModifierCode.BELOW; 17591 if ("above".equals(codeString)) 17592 return SearchModifierCode.ABOVE; 17593 if ("type".equals(codeString)) 17594 return SearchModifierCode.TYPE; 17595 if ("identifier".equals(codeString)) 17596 return SearchModifierCode.IDENTIFIER; 17597 if ("of-type".equals(codeString)) 17598 return SearchModifierCode.OFTYPE; 17599 if ("code-text".equals(codeString)) 17600 return SearchModifierCode.CODETEXT; 17601 if ("text-advanced".equals(codeString)) 17602 return SearchModifierCode.TEXTADVANCED; 17603 if ("iterate".equals(codeString)) 17604 return SearchModifierCode.ITERATE; 17605 throw new IllegalArgumentException("Unknown SearchModifierCode code '"+codeString+"'"); 17606 } 17607 17608 public Enumeration<SearchModifierCode> fromType(PrimitiveType<?> code) throws FHIRException { 17609 if (code == null) 17610 return null; 17611 if (code.isEmpty()) 17612 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.NULL, code); 17613 String codeString = ((PrimitiveType) code).asStringValue(); 17614 if (codeString == null || "".equals(codeString)) 17615 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.NULL, code); 17616 if ("missing".equals(codeString)) 17617 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.MISSING, code); 17618 if ("exact".equals(codeString)) 17619 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.EXACT, code); 17620 if ("contains".equals(codeString)) 17621 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.CONTAINS, code); 17622 if ("not".equals(codeString)) 17623 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.NOT, code); 17624 if ("text".equals(codeString)) 17625 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.TEXT, code); 17626 if ("in".equals(codeString)) 17627 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.IN, code); 17628 if ("not-in".equals(codeString)) 17629 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.NOTIN, code); 17630 if ("below".equals(codeString)) 17631 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.BELOW, code); 17632 if ("above".equals(codeString)) 17633 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.ABOVE, code); 17634 if ("type".equals(codeString)) 17635 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.TYPE, code); 17636 if ("identifier".equals(codeString)) 17637 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.IDENTIFIER, code); 17638 if ("of-type".equals(codeString)) 17639 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.OFTYPE, code); 17640 if ("code-text".equals(codeString)) 17641 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.CODETEXT, code); 17642 if ("text-advanced".equals(codeString)) 17643 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.TEXTADVANCED, code); 17644 if ("iterate".equals(codeString)) 17645 return new Enumeration<SearchModifierCode>(this, SearchModifierCode.ITERATE, code); 17646 throw new FHIRException("Unknown SearchModifierCode code '"+codeString+"'"); 17647 } 17648 public String toCode(SearchModifierCode code) { 17649 if (code == SearchModifierCode.MISSING) 17650 return "missing"; 17651 if (code == SearchModifierCode.EXACT) 17652 return "exact"; 17653 if (code == SearchModifierCode.CONTAINS) 17654 return "contains"; 17655 if (code == SearchModifierCode.NOT) 17656 return "not"; 17657 if (code == SearchModifierCode.TEXT) 17658 return "text"; 17659 if (code == SearchModifierCode.IN) 17660 return "in"; 17661 if (code == SearchModifierCode.NOTIN) 17662 return "not-in"; 17663 if (code == SearchModifierCode.BELOW) 17664 return "below"; 17665 if (code == SearchModifierCode.ABOVE) 17666 return "above"; 17667 if (code == SearchModifierCode.TYPE) 17668 return "type"; 17669 if (code == SearchModifierCode.IDENTIFIER) 17670 return "identifier"; 17671 if (code == SearchModifierCode.OFTYPE) 17672 return "of-type"; 17673 if (code == SearchModifierCode.CODETEXT) 17674 return "code-text"; 17675 if (code == SearchModifierCode.TEXTADVANCED) 17676 return "text-advanced"; 17677 if (code == SearchModifierCode.ITERATE) 17678 return "iterate"; 17679 return "?"; 17680 } 17681 public String toSystem(SearchModifierCode code) { 17682 return code.getSystem(); 17683 } 17684 } 17685 17686 public enum SearchParamType { 17687 /** 17688 * Search parameter SHALL be a number (a whole number, or a decimal). 17689 */ 17690 NUMBER, 17691 /** 17692 * Search parameter is on a date/time. The date format is the standard XML format, though other formats may be supported. 17693 */ 17694 DATE, 17695 /** 17696 * 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. 17697 */ 17698 STRING, 17699 /** 17700 * 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. 17701 */ 17702 TOKEN, 17703 /** 17704 * A reference to another resource (Reference or canonical). 17705 */ 17706 REFERENCE, 17707 /** 17708 * A composite search parameter that combines a search on two values together. 17709 */ 17710 COMPOSITE, 17711 /** 17712 * A search parameter that searches on a quantity. 17713 */ 17714 QUANTITY, 17715 /** 17716 * A search parameter that searches on a URI (RFC 3986). 17717 */ 17718 URI, 17719 /** 17720 * Special logic applies to this parameter per the description of the search parameter. 17721 */ 17722 SPECIAL, 17723 /** 17724 * added to help the parsers 17725 */ 17726 NULL; 17727 public static SearchParamType fromCode(String codeString) throws FHIRException { 17728 if (codeString == null || "".equals(codeString)) 17729 return null; 17730 if ("number".equals(codeString)) 17731 return NUMBER; 17732 if ("date".equals(codeString)) 17733 return DATE; 17734 if ("string".equals(codeString)) 17735 return STRING; 17736 if ("token".equals(codeString)) 17737 return TOKEN; 17738 if ("reference".equals(codeString)) 17739 return REFERENCE; 17740 if ("composite".equals(codeString)) 17741 return COMPOSITE; 17742 if ("quantity".equals(codeString)) 17743 return QUANTITY; 17744 if ("uri".equals(codeString)) 17745 return URI; 17746 if ("special".equals(codeString)) 17747 return SPECIAL; 17748 throw new FHIRException("Unknown SearchParamType code '"+codeString+"'"); 17749 } 17750 public static boolean isValidCode(String codeString) { 17751 if (codeString == null || "".equals(codeString)) 17752 return false; 17753 return Utilities.existsInList(codeString, "number", "date", "string", "token", "reference", "composite", "quantity", "uri", "special"); 17754 } 17755 public String toCode() { 17756 switch (this) { 17757 case NUMBER: return "number"; 17758 case DATE: return "date"; 17759 case STRING: return "string"; 17760 case TOKEN: return "token"; 17761 case REFERENCE: return "reference"; 17762 case COMPOSITE: return "composite"; 17763 case QUANTITY: return "quantity"; 17764 case URI: return "uri"; 17765 case SPECIAL: return "special"; 17766 case NULL: return null; 17767 default: return "?"; 17768 } 17769 } 17770 public String getSystem() { 17771 switch (this) { 17772 case NUMBER: return "http://hl7.org/fhir/search-param-type"; 17773 case DATE: return "http://hl7.org/fhir/search-param-type"; 17774 case STRING: return "http://hl7.org/fhir/search-param-type"; 17775 case TOKEN: return "http://hl7.org/fhir/search-param-type"; 17776 case REFERENCE: return "http://hl7.org/fhir/search-param-type"; 17777 case COMPOSITE: return "http://hl7.org/fhir/search-param-type"; 17778 case QUANTITY: return "http://hl7.org/fhir/search-param-type"; 17779 case URI: return "http://hl7.org/fhir/search-param-type"; 17780 case SPECIAL: return "http://hl7.org/fhir/search-param-type"; 17781 case NULL: return null; 17782 default: return "?"; 17783 } 17784 } 17785 public String getDefinition() { 17786 switch (this) { 17787 case NUMBER: return "Search parameter SHALL be a number (a whole number, or a decimal)."; 17788 case DATE: return "Search parameter is on a date/time. The date format is the standard XML format, though other formats may be supported."; 17789 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."; 17790 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."; 17791 case REFERENCE: return "A reference to another resource (Reference or canonical)."; 17792 case COMPOSITE: return "A composite search parameter that combines a search on two values together."; 17793 case QUANTITY: return "A search parameter that searches on a quantity."; 17794 case URI: return "A search parameter that searches on a URI (RFC 3986)."; 17795 case SPECIAL: return "Special logic applies to this parameter per the description of the search parameter."; 17796 case NULL: return null; 17797 default: return "?"; 17798 } 17799 } 17800 public String getDisplay() { 17801 switch (this) { 17802 case NUMBER: return "Number"; 17803 case DATE: return "Date/DateTime"; 17804 case STRING: return "String"; 17805 case TOKEN: return "Token"; 17806 case REFERENCE: return "Reference"; 17807 case COMPOSITE: return "Composite"; 17808 case QUANTITY: return "Quantity"; 17809 case URI: return "URI"; 17810 case SPECIAL: return "Special"; 17811 case NULL: return null; 17812 default: return "?"; 17813 } 17814 } 17815 } 17816 17817 public static class SearchParamTypeEnumFactory implements EnumFactory<SearchParamType> { 17818 public SearchParamType fromCode(String codeString) throws IllegalArgumentException { 17819 if (codeString == null || "".equals(codeString)) 17820 if (codeString == null || "".equals(codeString)) 17821 return null; 17822 if ("number".equals(codeString)) 17823 return SearchParamType.NUMBER; 17824 if ("date".equals(codeString)) 17825 return SearchParamType.DATE; 17826 if ("string".equals(codeString)) 17827 return SearchParamType.STRING; 17828 if ("token".equals(codeString)) 17829 return SearchParamType.TOKEN; 17830 if ("reference".equals(codeString)) 17831 return SearchParamType.REFERENCE; 17832 if ("composite".equals(codeString)) 17833 return SearchParamType.COMPOSITE; 17834 if ("quantity".equals(codeString)) 17835 return SearchParamType.QUANTITY; 17836 if ("uri".equals(codeString)) 17837 return SearchParamType.URI; 17838 if ("special".equals(codeString)) 17839 return SearchParamType.SPECIAL; 17840 throw new IllegalArgumentException("Unknown SearchParamType code '"+codeString+"'"); 17841 } 17842 17843 public Enumeration<SearchParamType> fromType(PrimitiveType<?> code) throws FHIRException { 17844 if (code == null) 17845 return null; 17846 if (code.isEmpty()) 17847 return new Enumeration<SearchParamType>(this, SearchParamType.NULL, code); 17848 String codeString = ((PrimitiveType) code).asStringValue(); 17849 if (codeString == null || "".equals(codeString)) 17850 return new Enumeration<SearchParamType>(this, SearchParamType.NULL, code); 17851 if ("number".equals(codeString)) 17852 return new Enumeration<SearchParamType>(this, SearchParamType.NUMBER, code); 17853 if ("date".equals(codeString)) 17854 return new Enumeration<SearchParamType>(this, SearchParamType.DATE, code); 17855 if ("string".equals(codeString)) 17856 return new Enumeration<SearchParamType>(this, SearchParamType.STRING, code); 17857 if ("token".equals(codeString)) 17858 return new Enumeration<SearchParamType>(this, SearchParamType.TOKEN, code); 17859 if ("reference".equals(codeString)) 17860 return new Enumeration<SearchParamType>(this, SearchParamType.REFERENCE, code); 17861 if ("composite".equals(codeString)) 17862 return new Enumeration<SearchParamType>(this, SearchParamType.COMPOSITE, code); 17863 if ("quantity".equals(codeString)) 17864 return new Enumeration<SearchParamType>(this, SearchParamType.QUANTITY, code); 17865 if ("uri".equals(codeString)) 17866 return new Enumeration<SearchParamType>(this, SearchParamType.URI, code); 17867 if ("special".equals(codeString)) 17868 return new Enumeration<SearchParamType>(this, SearchParamType.SPECIAL, code); 17869 throw new FHIRException("Unknown SearchParamType code '"+codeString+"'"); 17870 } 17871 public String toCode(SearchParamType code) { 17872 if (code == SearchParamType.NUMBER) 17873 return "number"; 17874 if (code == SearchParamType.DATE) 17875 return "date"; 17876 if (code == SearchParamType.STRING) 17877 return "string"; 17878 if (code == SearchParamType.TOKEN) 17879 return "token"; 17880 if (code == SearchParamType.REFERENCE) 17881 return "reference"; 17882 if (code == SearchParamType.COMPOSITE) 17883 return "composite"; 17884 if (code == SearchParamType.QUANTITY) 17885 return "quantity"; 17886 if (code == SearchParamType.URI) 17887 return "uri"; 17888 if (code == SearchParamType.SPECIAL) 17889 return "special"; 17890 return "?"; 17891 } 17892 public String toSystem(SearchParamType code) { 17893 return code.getSystem(); 17894 } 17895 } 17896 17897 public enum SubscriptionStatusCodes { 17898 /** 17899 * The client has requested the subscription, and the server has not yet set it up. 17900 */ 17901 REQUESTED, 17902 /** 17903 * The subscription is active. 17904 */ 17905 ACTIVE, 17906 /** 17907 * The server has an error executing the notification. 17908 */ 17909 ERROR, 17910 /** 17911 * Too many errors have occurred or the subscription has expired. 17912 */ 17913 OFF, 17914 /** 17915 * This subscription has been flagged as incorrect. 17916 */ 17917 ENTEREDINERROR, 17918 /** 17919 * added to help the parsers 17920 */ 17921 NULL; 17922 public static SubscriptionStatusCodes fromCode(String codeString) throws FHIRException { 17923 if (codeString == null || "".equals(codeString)) 17924 return null; 17925 if ("requested".equals(codeString)) 17926 return REQUESTED; 17927 if ("active".equals(codeString)) 17928 return ACTIVE; 17929 if ("error".equals(codeString)) 17930 return ERROR; 17931 if ("off".equals(codeString)) 17932 return OFF; 17933 if ("entered-in-error".equals(codeString)) 17934 return ENTEREDINERROR; 17935 throw new FHIRException("Unknown SubscriptionStatusCodes code '"+codeString+"'"); 17936 } 17937 public static boolean isValidCode(String codeString) { 17938 if (codeString == null || "".equals(codeString)) 17939 return false; 17940 return Utilities.existsInList(codeString, "requested", "active", "error", "off", "entered-in-error"); 17941 } 17942 public String toCode() { 17943 switch (this) { 17944 case REQUESTED: return "requested"; 17945 case ACTIVE: return "active"; 17946 case ERROR: return "error"; 17947 case OFF: return "off"; 17948 case ENTEREDINERROR: return "entered-in-error"; 17949 case NULL: return null; 17950 default: return "?"; 17951 } 17952 } 17953 public String getSystem() { 17954 switch (this) { 17955 case REQUESTED: return "http://hl7.org/fhir/subscription-status"; 17956 case ACTIVE: return "http://hl7.org/fhir/subscription-status"; 17957 case ERROR: return "http://hl7.org/fhir/subscription-status"; 17958 case OFF: return "http://hl7.org/fhir/subscription-status"; 17959 case ENTEREDINERROR: return "http://hl7.org/fhir/subscription-status"; 17960 case NULL: return null; 17961 default: return "?"; 17962 } 17963 } 17964 public String getDefinition() { 17965 switch (this) { 17966 case REQUESTED: return "The client has requested the subscription, and the server has not yet set it up."; 17967 case ACTIVE: return "The subscription is active."; 17968 case ERROR: return "The server has an error executing the notification."; 17969 case OFF: return "Too many errors have occurred or the subscription has expired."; 17970 case ENTEREDINERROR: return "This subscription has been flagged as incorrect."; 17971 case NULL: return null; 17972 default: return "?"; 17973 } 17974 } 17975 public String getDisplay() { 17976 switch (this) { 17977 case REQUESTED: return "Requested"; 17978 case ACTIVE: return "Active"; 17979 case ERROR: return "Error"; 17980 case OFF: return "Off"; 17981 case ENTEREDINERROR: return "Entered in Error"; 17982 case NULL: return null; 17983 default: return "?"; 17984 } 17985 } 17986 } 17987 17988 public static class SubscriptionStatusCodesEnumFactory implements EnumFactory<SubscriptionStatusCodes> { 17989 public SubscriptionStatusCodes fromCode(String codeString) throws IllegalArgumentException { 17990 if (codeString == null || "".equals(codeString)) 17991 if (codeString == null || "".equals(codeString)) 17992 return null; 17993 if ("requested".equals(codeString)) 17994 return SubscriptionStatusCodes.REQUESTED; 17995 if ("active".equals(codeString)) 17996 return SubscriptionStatusCodes.ACTIVE; 17997 if ("error".equals(codeString)) 17998 return SubscriptionStatusCodes.ERROR; 17999 if ("off".equals(codeString)) 18000 return SubscriptionStatusCodes.OFF; 18001 if ("entered-in-error".equals(codeString)) 18002 return SubscriptionStatusCodes.ENTEREDINERROR; 18003 throw new IllegalArgumentException("Unknown SubscriptionStatusCodes code '"+codeString+"'"); 18004 } 18005 18006 public Enumeration<SubscriptionStatusCodes> fromType(PrimitiveType<?> code) throws FHIRException { 18007 if (code == null) 18008 return null; 18009 if (code.isEmpty()) 18010 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.NULL, code); 18011 String codeString = ((PrimitiveType) code).asStringValue(); 18012 if (codeString == null || "".equals(codeString)) 18013 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.NULL, code); 18014 if ("requested".equals(codeString)) 18015 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.REQUESTED, code); 18016 if ("active".equals(codeString)) 18017 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.ACTIVE, code); 18018 if ("error".equals(codeString)) 18019 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.ERROR, code); 18020 if ("off".equals(codeString)) 18021 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.OFF, code); 18022 if ("entered-in-error".equals(codeString)) 18023 return new Enumeration<SubscriptionStatusCodes>(this, SubscriptionStatusCodes.ENTEREDINERROR, code); 18024 throw new FHIRException("Unknown SubscriptionStatusCodes code '"+codeString+"'"); 18025 } 18026 public String toCode(SubscriptionStatusCodes code) { 18027 if (code == SubscriptionStatusCodes.REQUESTED) 18028 return "requested"; 18029 if (code == SubscriptionStatusCodes.ACTIVE) 18030 return "active"; 18031 if (code == SubscriptionStatusCodes.ERROR) 18032 return "error"; 18033 if (code == SubscriptionStatusCodes.OFF) 18034 return "off"; 18035 if (code == SubscriptionStatusCodes.ENTEREDINERROR) 18036 return "entered-in-error"; 18037 return "?"; 18038 } 18039 public String toSystem(SubscriptionStatusCodes code) { 18040 return code.getSystem(); 18041 } 18042 } 18043 18044 public enum Use { 18045 /** 18046 * The treatment is complete and this represents a Claim for the services. 18047 */ 18048 CLAIM, 18049 /** 18050 * The treatment is proposed and this represents a Pre-authorization for the services. 18051 */ 18052 PREAUTHORIZATION, 18053 /** 18054 * The treatment is proposed and this represents a Pre-determination for the services. 18055 */ 18056 PREDETERMINATION, 18057 /** 18058 * added to help the parsers 18059 */ 18060 NULL; 18061 public static Use fromCode(String codeString) throws FHIRException { 18062 if (codeString == null || "".equals(codeString)) 18063 return null; 18064 if ("claim".equals(codeString)) 18065 return CLAIM; 18066 if ("preauthorization".equals(codeString)) 18067 return PREAUTHORIZATION; 18068 if ("predetermination".equals(codeString)) 18069 return PREDETERMINATION; 18070 throw new FHIRException("Unknown Use code '"+codeString+"'"); 18071 } 18072 public static boolean isValidCode(String codeString) { 18073 if (codeString == null || "".equals(codeString)) 18074 return false; 18075 return Utilities.existsInList(codeString, "claim", "preauthorization", "predetermination"); 18076 } 18077 public String toCode() { 18078 switch (this) { 18079 case CLAIM: return "claim"; 18080 case PREAUTHORIZATION: return "preauthorization"; 18081 case PREDETERMINATION: return "predetermination"; 18082 case NULL: return null; 18083 default: return "?"; 18084 } 18085 } 18086 public String getSystem() { 18087 switch (this) { 18088 case CLAIM: return "http://hl7.org/fhir/claim-use"; 18089 case PREAUTHORIZATION: return "http://hl7.org/fhir/claim-use"; 18090 case PREDETERMINATION: return "http://hl7.org/fhir/claim-use"; 18091 case NULL: return null; 18092 default: return "?"; 18093 } 18094 } 18095 public String getDefinition() { 18096 switch (this) { 18097 case CLAIM: return "The treatment is complete and this represents a Claim for the services."; 18098 case PREAUTHORIZATION: return "The treatment is proposed and this represents a Pre-authorization for the services."; 18099 case PREDETERMINATION: return "The treatment is proposed and this represents a Pre-determination for the services."; 18100 case NULL: return null; 18101 default: return "?"; 18102 } 18103 } 18104 public String getDisplay() { 18105 switch (this) { 18106 case CLAIM: return "Claim"; 18107 case PREAUTHORIZATION: return "Preauthorization"; 18108 case PREDETERMINATION: return "Predetermination"; 18109 case NULL: return null; 18110 default: return "?"; 18111 } 18112 } 18113 } 18114 18115 public static class UseEnumFactory implements EnumFactory<Use> { 18116 public Use fromCode(String codeString) throws IllegalArgumentException { 18117 if (codeString == null || "".equals(codeString)) 18118 if (codeString == null || "".equals(codeString)) 18119 return null; 18120 if ("claim".equals(codeString)) 18121 return Use.CLAIM; 18122 if ("preauthorization".equals(codeString)) 18123 return Use.PREAUTHORIZATION; 18124 if ("predetermination".equals(codeString)) 18125 return Use.PREDETERMINATION; 18126 throw new IllegalArgumentException("Unknown Use code '"+codeString+"'"); 18127 } 18128 18129 public Enumeration<Use> fromType(PrimitiveType<?> code) throws FHIRException { 18130 if (code == null) 18131 return null; 18132 if (code.isEmpty()) 18133 return new Enumeration<Use>(this, Use.NULL, code); 18134 String codeString = ((PrimitiveType) code).asStringValue(); 18135 if (codeString == null || "".equals(codeString)) 18136 return new Enumeration<Use>(this, Use.NULL, code); 18137 if ("claim".equals(codeString)) 18138 return new Enumeration<Use>(this, Use.CLAIM, code); 18139 if ("preauthorization".equals(codeString)) 18140 return new Enumeration<Use>(this, Use.PREAUTHORIZATION, code); 18141 if ("predetermination".equals(codeString)) 18142 return new Enumeration<Use>(this, Use.PREDETERMINATION, code); 18143 throw new FHIRException("Unknown Use code '"+codeString+"'"); 18144 } 18145 public String toCode(Use code) { 18146 if (code == Use.CLAIM) 18147 return "claim"; 18148 if (code == Use.PREAUTHORIZATION) 18149 return "preauthorization"; 18150 if (code == Use.PREDETERMINATION) 18151 return "predetermination"; 18152 return "?"; 18153 } 18154 public String toSystem(Use code) { 18155 return code.getSystem(); 18156 } 18157 } 18158 18159 public enum VersionIndependentResourceTypesAll { 18160 /** 18161 * 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. 18162 */ 18163 ACCOUNT, 18164 /** 18165 * This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context. 18166 */ 18167 ACTIVITYDEFINITION, 18168 /** 18169 * 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. 18170 */ 18171 ACTORDEFINITION, 18172 /** 18173 * 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). 18174 */ 18175 ADMINISTRABLEPRODUCTDEFINITION, 18176 /** 18177 * 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. 18178 */ 18179 ADVERSEEVENT, 18180 /** 18181 * Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance. 18182 */ 18183 ALLERGYINTOLERANCE, 18184 /** 18185 * 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). 18186 */ 18187 APPOINTMENT, 18188 /** 18189 * A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection. 18190 */ 18191 APPOINTMENTRESPONSE, 18192 /** 18193 * This Resource provides one or more comments, classifiers or ratings about a Resource and supports attribution and rights management metadata for the added content. 18194 */ 18195 ARTIFACTASSESSMENT, 18196 /** 18197 * A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis. 18198 */ 18199 AUDITEVENT, 18200 /** 18201 * 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. 18202 */ 18203 BASIC, 18204 /** 18205 * 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. 18206 */ 18207 BINARY, 18208 /** 18209 * A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity. 18210 */ 18211 BIOLOGICALLYDERIVEDPRODUCT, 18212 /** 18213 * A record of dispensation of a biologically derived product. 18214 */ 18215 BIOLOGICALLYDERIVEDPRODUCTDISPENSE, 18216 /** 18217 * 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. 18218 */ 18219 BODYSTRUCTURE, 18220 /** 18221 * A container for a collection of resources. 18222 */ 18223 BUNDLE, 18224 /** 18225 * Common Interface declaration for conformance and knowledge artifact resources. 18226 */ 18227 CANONICALRESOURCE, 18228 /** 18229 * 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. 18230 */ 18231 CAPABILITYSTATEMENT, 18232 /** 18233 * 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. 18234 */ 18235 CAREPLAN, 18236 /** 18237 * The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care. 18238 */ 18239 CARETEAM, 18240 /** 18241 * 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. 18242 */ 18243 CHARGEITEM, 18244 /** 18245 * 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. 18246 */ 18247 CHARGEITEMDEFINITION, 18248 /** 18249 * 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. 18250 */ 18251 CITATION, 18252 /** 18253 * 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. 18254 */ 18255 CLAIM, 18256 /** 18257 * This resource provides the adjudication details from the processing of a Claim resource. 18258 */ 18259 CLAIMRESPONSE, 18260 /** 18261 * 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. 18262 */ 18263 CLINICALIMPRESSION, 18264 /** 18265 * A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure. 18266 */ 18267 CLINICALUSEDEFINITION, 18268 /** 18269 * 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. 18270 */ 18271 CODESYSTEM, 18272 /** 18273 * 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. 18274 */ 18275 COMMUNICATION, 18276 /** 18277 * 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. 18278 */ 18279 COMMUNICATIONREQUEST, 18280 /** 18281 * A compartment definition that defines how resources are accessed on a server. 18282 */ 18283 COMPARTMENTDEFINITION, 18284 /** 18285 * 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.). 18286 */ 18287 COMPOSITION, 18288 /** 18289 * 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. 18290 */ 18291 CONCEPTMAP, 18292 /** 18293 * A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern. 18294 */ 18295 CONDITION, 18296 /** 18297 * A definition of a condition and information relevant to managing it. 18298 */ 18299 CONDITIONDEFINITION, 18300 /** 18301 * 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. 18302 */ 18303 CONSENT, 18304 /** 18305 * Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement. 18306 */ 18307 CONTRACT, 18308 /** 18309 * Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment. 18310 */ 18311 COVERAGE, 18312 /** 18313 * 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. 18314 */ 18315 COVERAGEELIGIBILITYREQUEST, 18316 /** 18317 * This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource. 18318 */ 18319 COVERAGEELIGIBILITYRESPONSE, 18320 /** 18321 * 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. 18322 */ 18323 DETECTEDISSUE, 18324 /** 18325 * 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. 18326 */ 18327 DEVICE, 18328 /** 18329 * A record of association of a device. 18330 */ 18331 DEVICEASSOCIATION, 18332 /** 18333 * This is a specialized resource that defines the characteristics and capabilities of a device. 18334 */ 18335 DEVICEDEFINITION, 18336 /** 18337 * 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. 18338 */ 18339 DEVICEDISPENSE, 18340 /** 18341 * 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. 18342 */ 18343 DEVICEMETRIC, 18344 /** 18345 * 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. 18346 */ 18347 DEVICEREQUEST, 18348 /** 18349 * 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. 18350 */ 18351 DEVICEUSAGE, 18352 /** 18353 * 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. 18354 */ 18355 DIAGNOSTICREPORT, 18356 /** 18357 * 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. 18358 */ 18359 DOCUMENTREFERENCE, 18360 /** 18361 * A resource that includes narrative, extensions, and contained resources. 18362 */ 18363 DOMAINRESOURCE, 18364 /** 18365 * 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). 18366 */ 18367 ENCOUNTER, 18368 /** 18369 * A record of significant events/milestones key data throughout the history of an Encounter 18370 */ 18371 ENCOUNTERHISTORY, 18372 /** 18373 * 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. 18374 */ 18375 ENDPOINT, 18376 /** 18377 * This resource provides the insurance enrollment details to the insurer regarding a specified coverage. 18378 */ 18379 ENROLLMENTREQUEST, 18380 /** 18381 * This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource. 18382 */ 18383 ENROLLMENTRESPONSE, 18384 /** 18385 * 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. 18386 */ 18387 EPISODEOFCARE, 18388 /** 18389 * The EventDefinition resource provides a reusable description of when a particular event can occur. 18390 */ 18391 EVENTDEFINITION, 18392 /** 18393 * 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. 18394 */ 18395 EVIDENCE, 18396 /** 18397 * 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. 18398 */ 18399 EVIDENCEREPORT, 18400 /** 18401 * The EvidenceVariable resource describes an element that knowledge (Evidence) is about. 18402 */ 18403 EVIDENCEVARIABLE, 18404 /** 18405 * A walkthrough of a workflow showing the interaction between systems and the instances shared, possibly including the evolution of instances over time. 18406 */ 18407 EXAMPLESCENARIO, 18408 /** 18409 * 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. 18410 */ 18411 EXPLANATIONOFBENEFIT, 18412 /** 18413 * Significant health conditions for a person related to the patient relevant in the context of care for the patient. 18414 */ 18415 FAMILYMEMBERHISTORY, 18416 /** 18417 * Prospective warnings of potential issues when providing care to the patient. 18418 */ 18419 FLAG, 18420 /** 18421 * 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. 18422 */ 18423 FORMULARYITEM, 18424 /** 18425 * A set of analyses performed to analyze and generate genomic data. 18426 */ 18427 GENOMICSTUDY, 18428 /** 18429 * 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. 18430 */ 18431 GOAL, 18432 /** 18433 * 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. 18434 */ 18435 GRAPHDEFINITION, 18436 /** 18437 * 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. 18438 */ 18439 GROUP, 18440 /** 18441 * 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. 18442 */ 18443 GUIDANCERESPONSE, 18444 /** 18445 * 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. 18446 */ 18447 HEALTHCARESERVICE, 18448 /** 18449 * 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. 18450 */ 18451 IMAGINGSELECTION, 18452 /** 18453 * 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. 18454 */ 18455 IMAGINGSTUDY, 18456 /** 18457 * 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. 18458 */ 18459 IMMUNIZATION, 18460 /** 18461 * Describes a comparison of an immunization event against published recommendations to determine if the administration is "valid" in relation to those recommendations. 18462 */ 18463 IMMUNIZATIONEVALUATION, 18464 /** 18465 * A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification. 18466 */ 18467 IMMUNIZATIONRECOMMENDATION, 18468 /** 18469 * 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. 18470 */ 18471 IMPLEMENTATIONGUIDE, 18472 /** 18473 * An ingredient of a manufactured item or pharmaceutical product. 18474 */ 18475 INGREDIENT, 18476 /** 18477 * Details of a Health Insurance product/plan provided by an organization. 18478 */ 18479 INSURANCEPLAN, 18480 /** 18481 * functional description of an inventory item used in inventory and supply-related workflows. 18482 */ 18483 INVENTORYITEM, 18484 /** 18485 * A report of inventory or stock items. 18486 */ 18487 INVENTORYREPORT, 18488 /** 18489 * Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose. 18490 */ 18491 INVOICE, 18492 /** 18493 * 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. 18494 */ 18495 LIBRARY, 18496 /** 18497 * Identifies two or more records (resource instances) that refer to the same real-world "occurrence". 18498 */ 18499 LINKAGE, 18500 /** 18501 * A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc. 18502 */ 18503 LIST, 18504 /** 18505 * Details and position information for a place where services are provided and resources and participants may be stored, found, contained, or accommodated. 18506 */ 18507 LOCATION, 18508 /** 18509 * The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product. 18510 */ 18511 MANUFACTUREDITEMDEFINITION, 18512 /** 18513 * The Measure resource provides the definition of a quality measure. 18514 */ 18515 MEASURE, 18516 /** 18517 * The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation. 18518 */ 18519 MEASUREREPORT, 18520 /** 18521 * 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. 18522 */ 18523 MEDICATION, 18524 /** 18525 * 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. 18526 */ 18527 MEDICATIONADMINISTRATION, 18528 /** 18529 * 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. 18530 */ 18531 MEDICATIONDISPENSE, 18532 /** 18533 * Information about a medication that is used to support knowledge. 18534 */ 18535 MEDICATIONKNOWLEDGE, 18536 /** 18537 * 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. 18538 */ 18539 MEDICATIONREQUEST, 18540 /** 18541 * 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. 18542 18543The 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. 18544 */ 18545 MEDICATIONSTATEMENT, 18546 /** 18547 * 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.). 18548 */ 18549 MEDICINALPRODUCTDEFINITION, 18550 /** 18551 * 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. 18552 */ 18553 MESSAGEDEFINITION, 18554 /** 18555 * 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. 18556 */ 18557 MESSAGEHEADER, 18558 /** 18559 * Common Interface declaration for conformance and knowledge artifact resources. 18560 */ 18561 METADATARESOURCE, 18562 /** 18563 * Representation of a molecular sequence. 18564 */ 18565 MOLECULARSEQUENCE, 18566 /** 18567 * 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. 18568 */ 18569 NAMINGSYSTEM, 18570 /** 18571 * 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. 18572 */ 18573 NUTRITIONINTAKE, 18574 /** 18575 * A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident. 18576 */ 18577 NUTRITIONORDER, 18578 /** 18579 * A food or supplement that is consumed by patients. 18580 */ 18581 NUTRITIONPRODUCT, 18582 /** 18583 * Measurements and simple assertions made about a patient, device or other subject. 18584 */ 18585 OBSERVATION, 18586 /** 18587 * Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service. 18588 */ 18589 OBSERVATIONDEFINITION, 18590 /** 18591 * A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction). 18592 */ 18593 OPERATIONDEFINITION, 18594 /** 18595 * A collection of error, warning, or information messages that result from a system action. 18596 */ 18597 OPERATIONOUTCOME, 18598 /** 18599 * 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. 18600 */ 18601 ORGANIZATION, 18602 /** 18603 * Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship. 18604 */ 18605 ORGANIZATIONAFFILIATION, 18606 /** 18607 * A medically related item or items, in a container or package. 18608 */ 18609 PACKAGEDPRODUCTDEFINITION, 18610 /** 18611 * 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. 18612 */ 18613 PARAMETERS, 18614 /** 18615 * Demographics and other administrative information about an individual or animal receiving care or other health-related services. 18616 */ 18617 PATIENT, 18618 /** 18619 * This resource provides the status of the payment for goods and services rendered, and the request and response resource references. 18620 */ 18621 PAYMENTNOTICE, 18622 /** 18623 * This resource provides the details including amount of a payment and allocates the payment items being paid. 18624 */ 18625 PAYMENTRECONCILIATION, 18626 /** 18627 * Permission resource holds access rules for a given data and context. 18628 */ 18629 PERMISSION, 18630 /** 18631 * Demographics and administrative information about a person independent of a specific health-related context. 18632 */ 18633 PERSON, 18634 /** 18635 * 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. 18636 */ 18637 PLANDEFINITION, 18638 /** 18639 * A person who is directly or indirectly involved in the provisioning of healthcare or related services. 18640 */ 18641 PRACTITIONER, 18642 /** 18643 * A specific set of Roles/Locations/specialties/services that a practitioner may perform, or has performed at an organization during a period of time. 18644 */ 18645 PRACTITIONERROLE, 18646 /** 18647 * 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. 18648 */ 18649 PROCEDURE, 18650 /** 18651 * 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. 18652 */ 18653 PROVENANCE, 18654 /** 18655 * 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. 18656 */ 18657 QUESTIONNAIRE, 18658 /** 18659 * 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. 18660 */ 18661 QUESTIONNAIRERESPONSE, 18662 /** 18663 * 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. 18664 */ 18665 REGULATEDAUTHORIZATION, 18666 /** 18667 * 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. 18668 */ 18669 RELATEDPERSON, 18670 /** 18671 * 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". 18672 */ 18673 REQUESTORCHESTRATION, 18674 /** 18675 * 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. 18676 */ 18677 REQUIREMENTS, 18678 /** 18679 * 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. 18680 */ 18681 RESEARCHSTUDY, 18682 /** 18683 * A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study. 18684 */ 18685 RESEARCHSUBJECT, 18686 /** 18687 * This is the base resource type for everything. 18688 */ 18689 RESOURCE, 18690 /** 18691 * An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome. 18692 */ 18693 RISKASSESSMENT, 18694 /** 18695 * A container for slots of time that may be available for booking appointments. 18696 */ 18697 SCHEDULE, 18698 /** 18699 * A search parameter that defines a named search item that can be used to search/filter on a resource. 18700 */ 18701 SEARCHPARAMETER, 18702 /** 18703 * A record of a request for service such as diagnostic investigations, treatments, or operations to be performed. 18704 */ 18705 SERVICEREQUEST, 18706 /** 18707 * A slot of time on a schedule that may be available for booking appointments. 18708 */ 18709 SLOT, 18710 /** 18711 * A sample to be used for analysis. 18712 */ 18713 SPECIMEN, 18714 /** 18715 * A kind of specimen with associated set of requirements. 18716 */ 18717 SPECIMENDEFINITION, 18718 /** 18719 * 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. 18720 */ 18721 STRUCTUREDEFINITION, 18722 /** 18723 * A Map of relationships between 2 structures that can be used to transform data. 18724 */ 18725 STRUCTUREMAP, 18726 /** 18727 * The subscription resource describes a particular client's request to be notified about a SubscriptionTopic. 18728 */ 18729 SUBSCRIPTION, 18730 /** 18731 * The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted. 18732 */ 18733 SUBSCRIPTIONSTATUS, 18734 /** 18735 * Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic. 18736 */ 18737 SUBSCRIPTIONTOPIC, 18738 /** 18739 * A homogeneous material with a definite composition. 18740 */ 18741 SUBSTANCE, 18742 /** 18743 * The detailed description of a substance, typically at a level beyond what is used for prescribing. 18744 */ 18745 SUBSTANCEDEFINITION, 18746 /** 18747 * 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. 18748 */ 18749 SUBSTANCENUCLEICACID, 18750 /** 18751 * Properties of a substance specific to it being a polymer. 18752 */ 18753 SUBSTANCEPOLYMER, 18754 /** 18755 * 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. 18756 */ 18757 SUBSTANCEPROTEIN, 18758 /** 18759 * Todo. 18760 */ 18761 SUBSTANCEREFERENCEINFORMATION, 18762 /** 18763 * 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. 18764 */ 18765 SUBSTANCESOURCEMATERIAL, 18766 /** 18767 * Record of delivery of what is supplied. 18768 */ 18769 SUPPLYDELIVERY, 18770 /** 18771 * 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. 18772 */ 18773 SUPPLYREQUEST, 18774 /** 18775 * A task to be performed. 18776 */ 18777 TASK, 18778 /** 18779 * 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. 18780 */ 18781 TERMINOLOGYCAPABILITIES, 18782 /** 18783 * A plan for executing testing on an artifact or specifications 18784 */ 18785 TESTPLAN, 18786 /** 18787 * A summary of information based on the results of executing a TestScript. 18788 */ 18789 TESTREPORT, 18790 /** 18791 * A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification. 18792 */ 18793 TESTSCRIPT, 18794 /** 18795 * Record of transport. 18796 */ 18797 TRANSPORT, 18798 /** 18799 * 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). 18800 */ 18801 VALUESET, 18802 /** 18803 * Describes validation requirements, source(s), status and dates for one or more elements. 18804 */ 18805 VERIFICATIONRESULT, 18806 /** 18807 * An authorization for the provision of glasses and/or contact lenses to a patient. 18808 */ 18809 VISIONPRESCRIPTION, 18810 /** 18811 * null 18812 */ 18813 BODYSITE, 18814 /** 18815 * null 18816 */ 18817 CATALOGENTRY, 18818 /** 18819 * null 18820 */ 18821 CONFORMANCE, 18822 /** 18823 * null 18824 */ 18825 DATAELEMENT, 18826 /** 18827 * null 18828 */ 18829 DEVICECOMPONENT, 18830 /** 18831 * null 18832 */ 18833 DEVICEUSEREQUEST, 18834 /** 18835 * null 18836 */ 18837 DEVICEUSESTATEMENT, 18838 /** 18839 * null 18840 */ 18841 DIAGNOSTICORDER, 18842 /** 18843 * null 18844 */ 18845 DOCUMENTMANIFEST, 18846 /** 18847 * null 18848 */ 18849 EFFECTEVIDENCESYNTHESIS, 18850 /** 18851 * null 18852 */ 18853 ELIGIBILITYREQUEST, 18854 /** 18855 * null 18856 */ 18857 ELIGIBILITYRESPONSE, 18858 /** 18859 * null 18860 */ 18861 EXPANSIONPROFILE, 18862 /** 18863 * null 18864 */ 18865 IMAGINGMANIFEST, 18866 /** 18867 * null 18868 */ 18869 IMAGINGOBJECTSELECTION, 18870 /** 18871 * null 18872 */ 18873 MEDIA, 18874 /** 18875 * null 18876 */ 18877 MEDICATIONORDER, 18878 /** 18879 * null 18880 */ 18881 MEDICATIONUSAGE, 18882 /** 18883 * null 18884 */ 18885 MEDICINALPRODUCT, 18886 /** 18887 * null 18888 */ 18889 MEDICINALPRODUCTAUTHORIZATION, 18890 /** 18891 * null 18892 */ 18893 MEDICINALPRODUCTCONTRAINDICATION, 18894 /** 18895 * null 18896 */ 18897 MEDICINALPRODUCTINDICATION, 18898 /** 18899 * null 18900 */ 18901 MEDICINALPRODUCTINGREDIENT, 18902 /** 18903 * null 18904 */ 18905 MEDICINALPRODUCTINTERACTION, 18906 /** 18907 * null 18908 */ 18909 MEDICINALPRODUCTMANUFACTURED, 18910 /** 18911 * null 18912 */ 18913 MEDICINALPRODUCTPACKAGED, 18914 /** 18915 * null 18916 */ 18917 MEDICINALPRODUCTPHARMACEUTICAL, 18918 /** 18919 * null 18920 */ 18921 MEDICINALPRODUCTUNDESIRABLEEFFECT, 18922 /** 18923 * null 18924 */ 18925 ORDER, 18926 /** 18927 * null 18928 */ 18929 ORDERRESPONSE, 18930 /** 18931 * null 18932 */ 18933 PROCEDUREREQUEST, 18934 /** 18935 * null 18936 */ 18937 PROCESSREQUEST, 18938 /** 18939 * null 18940 */ 18941 PROCESSRESPONSE, 18942 /** 18943 * null 18944 */ 18945 REFERRALREQUEST, 18946 /** 18947 * null 18948 */ 18949 REQUESTGROUP, 18950 /** 18951 * null 18952 */ 18953 RESEARCHDEFINITION, 18954 /** 18955 * null 18956 */ 18957 RESEARCHELEMENTDEFINITION, 18958 /** 18959 * null 18960 */ 18961 RISKEVIDENCESYNTHESIS, 18962 /** 18963 * null 18964 */ 18965 SEQUENCE, 18966 /** 18967 * null 18968 */ 18969 SERVICEDEFINITION, 18970 /** 18971 * null 18972 */ 18973 SUBSTANCESPECIFICATION, 18974 /** 18975 * added to help the parsers 18976 */ 18977 NULL; 18978 public static VersionIndependentResourceTypesAll fromCode(String codeString) throws FHIRException { 18979 if (codeString == null || "".equals(codeString)) 18980 return null; 18981 if ("Account".equals(codeString)) 18982 return ACCOUNT; 18983 if ("ActivityDefinition".equals(codeString)) 18984 return ACTIVITYDEFINITION; 18985 if ("ActorDefinition".equals(codeString)) 18986 return ACTORDEFINITION; 18987 if ("AdministrableProductDefinition".equals(codeString)) 18988 return ADMINISTRABLEPRODUCTDEFINITION; 18989 if ("AdverseEvent".equals(codeString)) 18990 return ADVERSEEVENT; 18991 if ("AllergyIntolerance".equals(codeString)) 18992 return ALLERGYINTOLERANCE; 18993 if ("Appointment".equals(codeString)) 18994 return APPOINTMENT; 18995 if ("AppointmentResponse".equals(codeString)) 18996 return APPOINTMENTRESPONSE; 18997 if ("ArtifactAssessment".equals(codeString)) 18998 return ARTIFACTASSESSMENT; 18999 if ("AuditEvent".equals(codeString)) 19000 return AUDITEVENT; 19001 if ("Basic".equals(codeString)) 19002 return BASIC; 19003 if ("Binary".equals(codeString)) 19004 return BINARY; 19005 if ("BiologicallyDerivedProduct".equals(codeString)) 19006 return BIOLOGICALLYDERIVEDPRODUCT; 19007 if ("BiologicallyDerivedProductDispense".equals(codeString)) 19008 return BIOLOGICALLYDERIVEDPRODUCTDISPENSE; 19009 if ("BodyStructure".equals(codeString)) 19010 return BODYSTRUCTURE; 19011 if ("Bundle".equals(codeString)) 19012 return BUNDLE; 19013 if ("CanonicalResource".equals(codeString)) 19014 return CANONICALRESOURCE; 19015 if ("CapabilityStatement".equals(codeString)) 19016 return CAPABILITYSTATEMENT; 19017 if ("CarePlan".equals(codeString)) 19018 return CAREPLAN; 19019 if ("CareTeam".equals(codeString)) 19020 return CARETEAM; 19021 if ("ChargeItem".equals(codeString)) 19022 return CHARGEITEM; 19023 if ("ChargeItemDefinition".equals(codeString)) 19024 return CHARGEITEMDEFINITION; 19025 if ("Citation".equals(codeString)) 19026 return CITATION; 19027 if ("Claim".equals(codeString)) 19028 return CLAIM; 19029 if ("ClaimResponse".equals(codeString)) 19030 return CLAIMRESPONSE; 19031 if ("ClinicalImpression".equals(codeString)) 19032 return CLINICALIMPRESSION; 19033 if ("ClinicalUseDefinition".equals(codeString)) 19034 return CLINICALUSEDEFINITION; 19035 if ("CodeSystem".equals(codeString)) 19036 return CODESYSTEM; 19037 if ("Communication".equals(codeString)) 19038 return COMMUNICATION; 19039 if ("CommunicationRequest".equals(codeString)) 19040 return COMMUNICATIONREQUEST; 19041 if ("CompartmentDefinition".equals(codeString)) 19042 return COMPARTMENTDEFINITION; 19043 if ("Composition".equals(codeString)) 19044 return COMPOSITION; 19045 if ("ConceptMap".equals(codeString)) 19046 return CONCEPTMAP; 19047 if ("Condition".equals(codeString)) 19048 return CONDITION; 19049 if ("ConditionDefinition".equals(codeString)) 19050 return CONDITIONDEFINITION; 19051 if ("Consent".equals(codeString)) 19052 return CONSENT; 19053 if ("Contract".equals(codeString)) 19054 return CONTRACT; 19055 if ("Coverage".equals(codeString)) 19056 return COVERAGE; 19057 if ("CoverageEligibilityRequest".equals(codeString)) 19058 return COVERAGEELIGIBILITYREQUEST; 19059 if ("CoverageEligibilityResponse".equals(codeString)) 19060 return COVERAGEELIGIBILITYRESPONSE; 19061 if ("DetectedIssue".equals(codeString)) 19062 return DETECTEDISSUE; 19063 if ("Device".equals(codeString)) 19064 return DEVICE; 19065 if ("DeviceAssociation".equals(codeString)) 19066 return DEVICEASSOCIATION; 19067 if ("DeviceDefinition".equals(codeString)) 19068 return DEVICEDEFINITION; 19069 if ("DeviceDispense".equals(codeString)) 19070 return DEVICEDISPENSE; 19071 if ("DeviceMetric".equals(codeString)) 19072 return DEVICEMETRIC; 19073 if ("DeviceRequest".equals(codeString)) 19074 return DEVICEREQUEST; 19075 if ("DeviceUsage".equals(codeString)) 19076 return DEVICEUSAGE; 19077 if ("DiagnosticReport".equals(codeString)) 19078 return DIAGNOSTICREPORT; 19079 if ("DocumentReference".equals(codeString)) 19080 return DOCUMENTREFERENCE; 19081 if ("DomainResource".equals(codeString)) 19082 return DOMAINRESOURCE; 19083 if ("Encounter".equals(codeString)) 19084 return ENCOUNTER; 19085 if ("EncounterHistory".equals(codeString)) 19086 return ENCOUNTERHISTORY; 19087 if ("Endpoint".equals(codeString)) 19088 return ENDPOINT; 19089 if ("EnrollmentRequest".equals(codeString)) 19090 return ENROLLMENTREQUEST; 19091 if ("EnrollmentResponse".equals(codeString)) 19092 return ENROLLMENTRESPONSE; 19093 if ("EpisodeOfCare".equals(codeString)) 19094 return EPISODEOFCARE; 19095 if ("EventDefinition".equals(codeString)) 19096 return EVENTDEFINITION; 19097 if ("Evidence".equals(codeString)) 19098 return EVIDENCE; 19099 if ("EvidenceReport".equals(codeString)) 19100 return EVIDENCEREPORT; 19101 if ("EvidenceVariable".equals(codeString)) 19102 return EVIDENCEVARIABLE; 19103 if ("ExampleScenario".equals(codeString)) 19104 return EXAMPLESCENARIO; 19105 if ("ExplanationOfBenefit".equals(codeString)) 19106 return EXPLANATIONOFBENEFIT; 19107 if ("FamilyMemberHistory".equals(codeString)) 19108 return FAMILYMEMBERHISTORY; 19109 if ("Flag".equals(codeString)) 19110 return FLAG; 19111 if ("FormularyItem".equals(codeString)) 19112 return FORMULARYITEM; 19113 if ("GenomicStudy".equals(codeString)) 19114 return GENOMICSTUDY; 19115 if ("Goal".equals(codeString)) 19116 return GOAL; 19117 if ("GraphDefinition".equals(codeString)) 19118 return GRAPHDEFINITION; 19119 if ("Group".equals(codeString)) 19120 return GROUP; 19121 if ("GuidanceResponse".equals(codeString)) 19122 return GUIDANCERESPONSE; 19123 if ("HealthcareService".equals(codeString)) 19124 return HEALTHCARESERVICE; 19125 if ("ImagingSelection".equals(codeString)) 19126 return IMAGINGSELECTION; 19127 if ("ImagingStudy".equals(codeString)) 19128 return IMAGINGSTUDY; 19129 if ("Immunization".equals(codeString)) 19130 return IMMUNIZATION; 19131 if ("ImmunizationEvaluation".equals(codeString)) 19132 return IMMUNIZATIONEVALUATION; 19133 if ("ImmunizationRecommendation".equals(codeString)) 19134 return IMMUNIZATIONRECOMMENDATION; 19135 if ("ImplementationGuide".equals(codeString)) 19136 return IMPLEMENTATIONGUIDE; 19137 if ("Ingredient".equals(codeString)) 19138 return INGREDIENT; 19139 if ("InsurancePlan".equals(codeString)) 19140 return INSURANCEPLAN; 19141 if ("InventoryItem".equals(codeString)) 19142 return INVENTORYITEM; 19143 if ("InventoryReport".equals(codeString)) 19144 return INVENTORYREPORT; 19145 if ("Invoice".equals(codeString)) 19146 return INVOICE; 19147 if ("Library".equals(codeString)) 19148 return LIBRARY; 19149 if ("Linkage".equals(codeString)) 19150 return LINKAGE; 19151 if ("List".equals(codeString)) 19152 return LIST; 19153 if ("Location".equals(codeString)) 19154 return LOCATION; 19155 if ("ManufacturedItemDefinition".equals(codeString)) 19156 return MANUFACTUREDITEMDEFINITION; 19157 if ("Measure".equals(codeString)) 19158 return MEASURE; 19159 if ("MeasureReport".equals(codeString)) 19160 return MEASUREREPORT; 19161 if ("Medication".equals(codeString)) 19162 return MEDICATION; 19163 if ("MedicationAdministration".equals(codeString)) 19164 return MEDICATIONADMINISTRATION; 19165 if ("MedicationDispense".equals(codeString)) 19166 return MEDICATIONDISPENSE; 19167 if ("MedicationKnowledge".equals(codeString)) 19168 return MEDICATIONKNOWLEDGE; 19169 if ("MedicationRequest".equals(codeString)) 19170 return MEDICATIONREQUEST; 19171 if ("MedicationStatement".equals(codeString)) 19172 return MEDICATIONSTATEMENT; 19173 if ("MedicinalProductDefinition".equals(codeString)) 19174 return MEDICINALPRODUCTDEFINITION; 19175 if ("MessageDefinition".equals(codeString)) 19176 return MESSAGEDEFINITION; 19177 if ("MessageHeader".equals(codeString)) 19178 return MESSAGEHEADER; 19179 if ("MetadataResource".equals(codeString)) 19180 return METADATARESOURCE; 19181 if ("MolecularSequence".equals(codeString)) 19182 return MOLECULARSEQUENCE; 19183 if ("NamingSystem".equals(codeString)) 19184 return NAMINGSYSTEM; 19185 if ("NutritionIntake".equals(codeString)) 19186 return NUTRITIONINTAKE; 19187 if ("NutritionOrder".equals(codeString)) 19188 return NUTRITIONORDER; 19189 if ("NutritionProduct".equals(codeString)) 19190 return NUTRITIONPRODUCT; 19191 if ("Observation".equals(codeString)) 19192 return OBSERVATION; 19193 if ("ObservationDefinition".equals(codeString)) 19194 return OBSERVATIONDEFINITION; 19195 if ("OperationDefinition".equals(codeString)) 19196 return OPERATIONDEFINITION; 19197 if ("OperationOutcome".equals(codeString)) 19198 return OPERATIONOUTCOME; 19199 if ("Organization".equals(codeString)) 19200 return ORGANIZATION; 19201 if ("OrganizationAffiliation".equals(codeString)) 19202 return ORGANIZATIONAFFILIATION; 19203 if ("PackagedProductDefinition".equals(codeString)) 19204 return PACKAGEDPRODUCTDEFINITION; 19205 if ("Parameters".equals(codeString)) 19206 return PARAMETERS; 19207 if ("Patient".equals(codeString)) 19208 return PATIENT; 19209 if ("PaymentNotice".equals(codeString)) 19210 return PAYMENTNOTICE; 19211 if ("PaymentReconciliation".equals(codeString)) 19212 return PAYMENTRECONCILIATION; 19213 if ("Permission".equals(codeString)) 19214 return PERMISSION; 19215 if ("Person".equals(codeString)) 19216 return PERSON; 19217 if ("PlanDefinition".equals(codeString)) 19218 return PLANDEFINITION; 19219 if ("Practitioner".equals(codeString)) 19220 return PRACTITIONER; 19221 if ("PractitionerRole".equals(codeString)) 19222 return PRACTITIONERROLE; 19223 if ("Procedure".equals(codeString)) 19224 return PROCEDURE; 19225 if ("Provenance".equals(codeString)) 19226 return PROVENANCE; 19227 if ("Questionnaire".equals(codeString)) 19228 return QUESTIONNAIRE; 19229 if ("QuestionnaireResponse".equals(codeString)) 19230 return QUESTIONNAIRERESPONSE; 19231 if ("RegulatedAuthorization".equals(codeString)) 19232 return REGULATEDAUTHORIZATION; 19233 if ("RelatedPerson".equals(codeString)) 19234 return RELATEDPERSON; 19235 if ("RequestOrchestration".equals(codeString)) 19236 return REQUESTORCHESTRATION; 19237 if ("Requirements".equals(codeString)) 19238 return REQUIREMENTS; 19239 if ("ResearchStudy".equals(codeString)) 19240 return RESEARCHSTUDY; 19241 if ("ResearchSubject".equals(codeString)) 19242 return RESEARCHSUBJECT; 19243 if ("Resource".equals(codeString)) 19244 return RESOURCE; 19245 if ("RiskAssessment".equals(codeString)) 19246 return RISKASSESSMENT; 19247 if ("Schedule".equals(codeString)) 19248 return SCHEDULE; 19249 if ("SearchParameter".equals(codeString)) 19250 return SEARCHPARAMETER; 19251 if ("ServiceRequest".equals(codeString)) 19252 return SERVICEREQUEST; 19253 if ("Slot".equals(codeString)) 19254 return SLOT; 19255 if ("Specimen".equals(codeString)) 19256 return SPECIMEN; 19257 if ("SpecimenDefinition".equals(codeString)) 19258 return SPECIMENDEFINITION; 19259 if ("StructureDefinition".equals(codeString)) 19260 return STRUCTUREDEFINITION; 19261 if ("StructureMap".equals(codeString)) 19262 return STRUCTUREMAP; 19263 if ("Subscription".equals(codeString)) 19264 return SUBSCRIPTION; 19265 if ("SubscriptionStatus".equals(codeString)) 19266 return SUBSCRIPTIONSTATUS; 19267 if ("SubscriptionTopic".equals(codeString)) 19268 return SUBSCRIPTIONTOPIC; 19269 if ("Substance".equals(codeString)) 19270 return SUBSTANCE; 19271 if ("SubstanceDefinition".equals(codeString)) 19272 return SUBSTANCEDEFINITION; 19273 if ("SubstanceNucleicAcid".equals(codeString)) 19274 return SUBSTANCENUCLEICACID; 19275 if ("SubstancePolymer".equals(codeString)) 19276 return SUBSTANCEPOLYMER; 19277 if ("SubstanceProtein".equals(codeString)) 19278 return SUBSTANCEPROTEIN; 19279 if ("SubstanceReferenceInformation".equals(codeString)) 19280 return SUBSTANCEREFERENCEINFORMATION; 19281 if ("SubstanceSourceMaterial".equals(codeString)) 19282 return SUBSTANCESOURCEMATERIAL; 19283 if ("SupplyDelivery".equals(codeString)) 19284 return SUPPLYDELIVERY; 19285 if ("SupplyRequest".equals(codeString)) 19286 return SUPPLYREQUEST; 19287 if ("Task".equals(codeString)) 19288 return TASK; 19289 if ("TerminologyCapabilities".equals(codeString)) 19290 return TERMINOLOGYCAPABILITIES; 19291 if ("TestPlan".equals(codeString)) 19292 return TESTPLAN; 19293 if ("TestReport".equals(codeString)) 19294 return TESTREPORT; 19295 if ("TestScript".equals(codeString)) 19296 return TESTSCRIPT; 19297 if ("Transport".equals(codeString)) 19298 return TRANSPORT; 19299 if ("ValueSet".equals(codeString)) 19300 return VALUESET; 19301 if ("VerificationResult".equals(codeString)) 19302 return VERIFICATIONRESULT; 19303 if ("VisionPrescription".equals(codeString)) 19304 return VISIONPRESCRIPTION; 19305 if ("BodySite".equals(codeString)) 19306 return BODYSITE; 19307 if ("CatalogEntry".equals(codeString)) 19308 return CATALOGENTRY; 19309 if ("Conformance".equals(codeString)) 19310 return CONFORMANCE; 19311 if ("DataElement".equals(codeString)) 19312 return DATAELEMENT; 19313 if ("DeviceComponent".equals(codeString)) 19314 return DEVICECOMPONENT; 19315 if ("DeviceUseRequest".equals(codeString)) 19316 return DEVICEUSEREQUEST; 19317 if ("DeviceUseStatement".equals(codeString)) 19318 return DEVICEUSESTATEMENT; 19319 if ("DiagnosticOrder".equals(codeString)) 19320 return DIAGNOSTICORDER; 19321 if ("DocumentManifest".equals(codeString)) 19322 return DOCUMENTMANIFEST; 19323 if ("EffectEvidenceSynthesis".equals(codeString)) 19324 return EFFECTEVIDENCESYNTHESIS; 19325 if ("EligibilityRequest".equals(codeString)) 19326 return ELIGIBILITYREQUEST; 19327 if ("EligibilityResponse".equals(codeString)) 19328 return ELIGIBILITYRESPONSE; 19329 if ("ExpansionProfile".equals(codeString)) 19330 return EXPANSIONPROFILE; 19331 if ("ImagingManifest".equals(codeString)) 19332 return IMAGINGMANIFEST; 19333 if ("ImagingObjectSelection".equals(codeString)) 19334 return IMAGINGOBJECTSELECTION; 19335 if ("Media".equals(codeString)) 19336 return MEDIA; 19337 if ("MedicationOrder".equals(codeString)) 19338 return MEDICATIONORDER; 19339 if ("MedicationUsage".equals(codeString)) 19340 return MEDICATIONUSAGE; 19341 if ("MedicinalProduct".equals(codeString)) 19342 return MEDICINALPRODUCT; 19343 if ("MedicinalProductAuthorization".equals(codeString)) 19344 return MEDICINALPRODUCTAUTHORIZATION; 19345 if ("MedicinalProductContraindication".equals(codeString)) 19346 return MEDICINALPRODUCTCONTRAINDICATION; 19347 if ("MedicinalProductIndication".equals(codeString)) 19348 return MEDICINALPRODUCTINDICATION; 19349 if ("MedicinalProductIngredient".equals(codeString)) 19350 return MEDICINALPRODUCTINGREDIENT; 19351 if ("MedicinalProductInteraction".equals(codeString)) 19352 return MEDICINALPRODUCTINTERACTION; 19353 if ("MedicinalProductManufactured".equals(codeString)) 19354 return MEDICINALPRODUCTMANUFACTURED; 19355 if ("MedicinalProductPackaged".equals(codeString)) 19356 return MEDICINALPRODUCTPACKAGED; 19357 if ("MedicinalProductPharmaceutical".equals(codeString)) 19358 return MEDICINALPRODUCTPHARMACEUTICAL; 19359 if ("MedicinalProductUndesirableEffect".equals(codeString)) 19360 return MEDICINALPRODUCTUNDESIRABLEEFFECT; 19361 if ("Order".equals(codeString)) 19362 return ORDER; 19363 if ("OrderResponse".equals(codeString)) 19364 return ORDERRESPONSE; 19365 if ("ProcedureRequest".equals(codeString)) 19366 return PROCEDUREREQUEST; 19367 if ("ProcessRequest".equals(codeString)) 19368 return PROCESSREQUEST; 19369 if ("ProcessResponse".equals(codeString)) 19370 return PROCESSRESPONSE; 19371 if ("ReferralRequest".equals(codeString)) 19372 return REFERRALREQUEST; 19373 if ("RequestGroup".equals(codeString)) 19374 return REQUESTGROUP; 19375 if ("ResearchDefinition".equals(codeString)) 19376 return RESEARCHDEFINITION; 19377 if ("ResearchElementDefinition".equals(codeString)) 19378 return RESEARCHELEMENTDEFINITION; 19379 if ("RiskEvidenceSynthesis".equals(codeString)) 19380 return RISKEVIDENCESYNTHESIS; 19381 if ("Sequence".equals(codeString)) 19382 return SEQUENCE; 19383 if ("ServiceDefinition".equals(codeString)) 19384 return SERVICEDEFINITION; 19385 if ("SubstanceSpecification".equals(codeString)) 19386 return SUBSTANCESPECIFICATION; 19387 throw new FHIRException("Unknown VersionIndependentResourceTypesAll code '"+codeString+"'"); 19388 } 19389 public static boolean isValidCode(String codeString) { 19390 if (codeString == null || "".equals(codeString)) 19391 return false; 19392 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"); 19393 } 19394 public String toCode() { 19395 switch (this) { 19396 case ACCOUNT: return "Account"; 19397 case ACTIVITYDEFINITION: return "ActivityDefinition"; 19398 case ACTORDEFINITION: return "ActorDefinition"; 19399 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 19400 case ADVERSEEVENT: return "AdverseEvent"; 19401 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 19402 case APPOINTMENT: return "Appointment"; 19403 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 19404 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 19405 case AUDITEVENT: return "AuditEvent"; 19406 case BASIC: return "Basic"; 19407 case BINARY: return "Binary"; 19408 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 19409 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "BiologicallyDerivedProductDispense"; 19410 case BODYSTRUCTURE: return "BodyStructure"; 19411 case BUNDLE: return "Bundle"; 19412 case CANONICALRESOURCE: return "CanonicalResource"; 19413 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 19414 case CAREPLAN: return "CarePlan"; 19415 case CARETEAM: return "CareTeam"; 19416 case CHARGEITEM: return "ChargeItem"; 19417 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 19418 case CITATION: return "Citation"; 19419 case CLAIM: return "Claim"; 19420 case CLAIMRESPONSE: return "ClaimResponse"; 19421 case CLINICALIMPRESSION: return "ClinicalImpression"; 19422 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 19423 case CODESYSTEM: return "CodeSystem"; 19424 case COMMUNICATION: return "Communication"; 19425 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 19426 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 19427 case COMPOSITION: return "Composition"; 19428 case CONCEPTMAP: return "ConceptMap"; 19429 case CONDITION: return "Condition"; 19430 case CONDITIONDEFINITION: return "ConditionDefinition"; 19431 case CONSENT: return "Consent"; 19432 case CONTRACT: return "Contract"; 19433 case COVERAGE: return "Coverage"; 19434 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 19435 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 19436 case DETECTEDISSUE: return "DetectedIssue"; 19437 case DEVICE: return "Device"; 19438 case DEVICEASSOCIATION: return "DeviceAssociation"; 19439 case DEVICEDEFINITION: return "DeviceDefinition"; 19440 case DEVICEDISPENSE: return "DeviceDispense"; 19441 case DEVICEMETRIC: return "DeviceMetric"; 19442 case DEVICEREQUEST: return "DeviceRequest"; 19443 case DEVICEUSAGE: return "DeviceUsage"; 19444 case DIAGNOSTICREPORT: return "DiagnosticReport"; 19445 case DOCUMENTREFERENCE: return "DocumentReference"; 19446 case DOMAINRESOURCE: return "DomainResource"; 19447 case ENCOUNTER: return "Encounter"; 19448 case ENCOUNTERHISTORY: return "EncounterHistory"; 19449 case ENDPOINT: return "Endpoint"; 19450 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 19451 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 19452 case EPISODEOFCARE: return "EpisodeOfCare"; 19453 case EVENTDEFINITION: return "EventDefinition"; 19454 case EVIDENCE: return "Evidence"; 19455 case EVIDENCEREPORT: return "EvidenceReport"; 19456 case EVIDENCEVARIABLE: return "EvidenceVariable"; 19457 case EXAMPLESCENARIO: return "ExampleScenario"; 19458 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 19459 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 19460 case FLAG: return "Flag"; 19461 case FORMULARYITEM: return "FormularyItem"; 19462 case GENOMICSTUDY: return "GenomicStudy"; 19463 case GOAL: return "Goal"; 19464 case GRAPHDEFINITION: return "GraphDefinition"; 19465 case GROUP: return "Group"; 19466 case GUIDANCERESPONSE: return "GuidanceResponse"; 19467 case HEALTHCARESERVICE: return "HealthcareService"; 19468 case IMAGINGSELECTION: return "ImagingSelection"; 19469 case IMAGINGSTUDY: return "ImagingStudy"; 19470 case IMMUNIZATION: return "Immunization"; 19471 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 19472 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 19473 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 19474 case INGREDIENT: return "Ingredient"; 19475 case INSURANCEPLAN: return "InsurancePlan"; 19476 case INVENTORYITEM: return "InventoryItem"; 19477 case INVENTORYREPORT: return "InventoryReport"; 19478 case INVOICE: return "Invoice"; 19479 case LIBRARY: return "Library"; 19480 case LINKAGE: return "Linkage"; 19481 case LIST: return "List"; 19482 case LOCATION: return "Location"; 19483 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 19484 case MEASURE: return "Measure"; 19485 case MEASUREREPORT: return "MeasureReport"; 19486 case MEDICATION: return "Medication"; 19487 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 19488 case MEDICATIONDISPENSE: return "MedicationDispense"; 19489 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 19490 case MEDICATIONREQUEST: return "MedicationRequest"; 19491 case MEDICATIONSTATEMENT: return "MedicationStatement"; 19492 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 19493 case MESSAGEDEFINITION: return "MessageDefinition"; 19494 case MESSAGEHEADER: return "MessageHeader"; 19495 case METADATARESOURCE: return "MetadataResource"; 19496 case MOLECULARSEQUENCE: return "MolecularSequence"; 19497 case NAMINGSYSTEM: return "NamingSystem"; 19498 case NUTRITIONINTAKE: return "NutritionIntake"; 19499 case NUTRITIONORDER: return "NutritionOrder"; 19500 case NUTRITIONPRODUCT: return "NutritionProduct"; 19501 case OBSERVATION: return "Observation"; 19502 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 19503 case OPERATIONDEFINITION: return "OperationDefinition"; 19504 case OPERATIONOUTCOME: return "OperationOutcome"; 19505 case ORGANIZATION: return "Organization"; 19506 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 19507 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 19508 case PARAMETERS: return "Parameters"; 19509 case PATIENT: return "Patient"; 19510 case PAYMENTNOTICE: return "PaymentNotice"; 19511 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 19512 case PERMISSION: return "Permission"; 19513 case PERSON: return "Person"; 19514 case PLANDEFINITION: return "PlanDefinition"; 19515 case PRACTITIONER: return "Practitioner"; 19516 case PRACTITIONERROLE: return "PractitionerRole"; 19517 case PROCEDURE: return "Procedure"; 19518 case PROVENANCE: return "Provenance"; 19519 case QUESTIONNAIRE: return "Questionnaire"; 19520 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 19521 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 19522 case RELATEDPERSON: return "RelatedPerson"; 19523 case REQUESTORCHESTRATION: return "RequestOrchestration"; 19524 case REQUIREMENTS: return "Requirements"; 19525 case RESEARCHSTUDY: return "ResearchStudy"; 19526 case RESEARCHSUBJECT: return "ResearchSubject"; 19527 case RESOURCE: return "Resource"; 19528 case RISKASSESSMENT: return "RiskAssessment"; 19529 case SCHEDULE: return "Schedule"; 19530 case SEARCHPARAMETER: return "SearchParameter"; 19531 case SERVICEREQUEST: return "ServiceRequest"; 19532 case SLOT: return "Slot"; 19533 case SPECIMEN: return "Specimen"; 19534 case SPECIMENDEFINITION: return "SpecimenDefinition"; 19535 case STRUCTUREDEFINITION: return "StructureDefinition"; 19536 case STRUCTUREMAP: return "StructureMap"; 19537 case SUBSCRIPTION: return "Subscription"; 19538 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 19539 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 19540 case SUBSTANCE: return "Substance"; 19541 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 19542 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 19543 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 19544 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 19545 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 19546 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 19547 case SUPPLYDELIVERY: return "SupplyDelivery"; 19548 case SUPPLYREQUEST: return "SupplyRequest"; 19549 case TASK: return "Task"; 19550 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 19551 case TESTPLAN: return "TestPlan"; 19552 case TESTREPORT: return "TestReport"; 19553 case TESTSCRIPT: return "TestScript"; 19554 case TRANSPORT: return "Transport"; 19555 case VALUESET: return "ValueSet"; 19556 case VERIFICATIONRESULT: return "VerificationResult"; 19557 case VISIONPRESCRIPTION: return "VisionPrescription"; 19558 case BODYSITE: return "BodySite"; 19559 case CATALOGENTRY: return "CatalogEntry"; 19560 case CONFORMANCE: return "Conformance"; 19561 case DATAELEMENT: return "DataElement"; 19562 case DEVICECOMPONENT: return "DeviceComponent"; 19563 case DEVICEUSEREQUEST: return "DeviceUseRequest"; 19564 case DEVICEUSESTATEMENT: return "DeviceUseStatement"; 19565 case DIAGNOSTICORDER: return "DiagnosticOrder"; 19566 case DOCUMENTMANIFEST: return "DocumentManifest"; 19567 case EFFECTEVIDENCESYNTHESIS: return "EffectEvidenceSynthesis"; 19568 case ELIGIBILITYREQUEST: return "EligibilityRequest"; 19569 case ELIGIBILITYRESPONSE: return "EligibilityResponse"; 19570 case EXPANSIONPROFILE: return "ExpansionProfile"; 19571 case IMAGINGMANIFEST: return "ImagingManifest"; 19572 case IMAGINGOBJECTSELECTION: return "ImagingObjectSelection"; 19573 case MEDIA: return "Media"; 19574 case MEDICATIONORDER: return "MedicationOrder"; 19575 case MEDICATIONUSAGE: return "MedicationUsage"; 19576 case MEDICINALPRODUCT: return "MedicinalProduct"; 19577 case MEDICINALPRODUCTAUTHORIZATION: return "MedicinalProductAuthorization"; 19578 case MEDICINALPRODUCTCONTRAINDICATION: return "MedicinalProductContraindication"; 19579 case MEDICINALPRODUCTINDICATION: return "MedicinalProductIndication"; 19580 case MEDICINALPRODUCTINGREDIENT: return "MedicinalProductIngredient"; 19581 case MEDICINALPRODUCTINTERACTION: return "MedicinalProductInteraction"; 19582 case MEDICINALPRODUCTMANUFACTURED: return "MedicinalProductManufactured"; 19583 case MEDICINALPRODUCTPACKAGED: return "MedicinalProductPackaged"; 19584 case MEDICINALPRODUCTPHARMACEUTICAL: return "MedicinalProductPharmaceutical"; 19585 case MEDICINALPRODUCTUNDESIRABLEEFFECT: return "MedicinalProductUndesirableEffect"; 19586 case ORDER: return "Order"; 19587 case ORDERRESPONSE: return "OrderResponse"; 19588 case PROCEDUREREQUEST: return "ProcedureRequest"; 19589 case PROCESSREQUEST: return "ProcessRequest"; 19590 case PROCESSRESPONSE: return "ProcessResponse"; 19591 case REFERRALREQUEST: return "ReferralRequest"; 19592 case REQUESTGROUP: return "RequestGroup"; 19593 case RESEARCHDEFINITION: return "ResearchDefinition"; 19594 case RESEARCHELEMENTDEFINITION: return "ResearchElementDefinition"; 19595 case RISKEVIDENCESYNTHESIS: return "RiskEvidenceSynthesis"; 19596 case SEQUENCE: return "Sequence"; 19597 case SERVICEDEFINITION: return "ServiceDefinition"; 19598 case SUBSTANCESPECIFICATION: return "SubstanceSpecification"; 19599 case NULL: return null; 19600 default: return "?"; 19601 } 19602 } 19603 public String getSystem() { 19604 switch (this) { 19605 case ACCOUNT: return "http://hl7.org/fhir/fhir-types"; 19606 case ACTIVITYDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19607 case ACTORDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19608 case ADMINISTRABLEPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19609 case ADVERSEEVENT: return "http://hl7.org/fhir/fhir-types"; 19610 case ALLERGYINTOLERANCE: return "http://hl7.org/fhir/fhir-types"; 19611 case APPOINTMENT: return "http://hl7.org/fhir/fhir-types"; 19612 case APPOINTMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 19613 case ARTIFACTASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 19614 case AUDITEVENT: return "http://hl7.org/fhir/fhir-types"; 19615 case BASIC: return "http://hl7.org/fhir/fhir-types"; 19616 case BINARY: return "http://hl7.org/fhir/fhir-types"; 19617 case BIOLOGICALLYDERIVEDPRODUCT: return "http://hl7.org/fhir/fhir-types"; 19618 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "http://hl7.org/fhir/fhir-types"; 19619 case BODYSTRUCTURE: return "http://hl7.org/fhir/fhir-types"; 19620 case BUNDLE: return "http://hl7.org/fhir/fhir-types"; 19621 case CANONICALRESOURCE: return "http://hl7.org/fhir/fhir-types"; 19622 case CAPABILITYSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 19623 case CAREPLAN: return "http://hl7.org/fhir/fhir-types"; 19624 case CARETEAM: return "http://hl7.org/fhir/fhir-types"; 19625 case CHARGEITEM: return "http://hl7.org/fhir/fhir-types"; 19626 case CHARGEITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19627 case CITATION: return "http://hl7.org/fhir/fhir-types"; 19628 case CLAIM: return "http://hl7.org/fhir/fhir-types"; 19629 case CLAIMRESPONSE: return "http://hl7.org/fhir/fhir-types"; 19630 case CLINICALIMPRESSION: return "http://hl7.org/fhir/fhir-types"; 19631 case CLINICALUSEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19632 case CODESYSTEM: return "http://hl7.org/fhir/fhir-types"; 19633 case COMMUNICATION: return "http://hl7.org/fhir/fhir-types"; 19634 case COMMUNICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 19635 case COMPARTMENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19636 case COMPOSITION: return "http://hl7.org/fhir/fhir-types"; 19637 case CONCEPTMAP: return "http://hl7.org/fhir/fhir-types"; 19638 case CONDITION: return "http://hl7.org/fhir/fhir-types"; 19639 case CONDITIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19640 case CONSENT: return "http://hl7.org/fhir/fhir-types"; 19641 case CONTRACT: return "http://hl7.org/fhir/fhir-types"; 19642 case COVERAGE: return "http://hl7.org/fhir/fhir-types"; 19643 case COVERAGEELIGIBILITYREQUEST: return "http://hl7.org/fhir/fhir-types"; 19644 case COVERAGEELIGIBILITYRESPONSE: return "http://hl7.org/fhir/fhir-types"; 19645 case DETECTEDISSUE: return "http://hl7.org/fhir/fhir-types"; 19646 case DEVICE: return "http://hl7.org/fhir/fhir-types"; 19647 case DEVICEASSOCIATION: return "http://hl7.org/fhir/fhir-types"; 19648 case DEVICEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19649 case DEVICEDISPENSE: return "http://hl7.org/fhir/fhir-types"; 19650 case DEVICEMETRIC: return "http://hl7.org/fhir/fhir-types"; 19651 case DEVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 19652 case DEVICEUSAGE: return "http://hl7.org/fhir/fhir-types"; 19653 case DIAGNOSTICREPORT: return "http://hl7.org/fhir/fhir-types"; 19654 case DOCUMENTREFERENCE: return "http://hl7.org/fhir/fhir-types"; 19655 case DOMAINRESOURCE: return "http://hl7.org/fhir/fhir-types"; 19656 case ENCOUNTER: return "http://hl7.org/fhir/fhir-types"; 19657 case ENCOUNTERHISTORY: return "http://hl7.org/fhir/fhir-types"; 19658 case ENDPOINT: return "http://hl7.org/fhir/fhir-types"; 19659 case ENROLLMENTREQUEST: return "http://hl7.org/fhir/fhir-types"; 19660 case ENROLLMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 19661 case EPISODEOFCARE: return "http://hl7.org/fhir/fhir-types"; 19662 case EVENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19663 case EVIDENCE: return "http://hl7.org/fhir/fhir-types"; 19664 case EVIDENCEREPORT: return "http://hl7.org/fhir/fhir-types"; 19665 case EVIDENCEVARIABLE: return "http://hl7.org/fhir/fhir-types"; 19666 case EXAMPLESCENARIO: return "http://hl7.org/fhir/fhir-types"; 19667 case EXPLANATIONOFBENEFIT: return "http://hl7.org/fhir/fhir-types"; 19668 case FAMILYMEMBERHISTORY: return "http://hl7.org/fhir/fhir-types"; 19669 case FLAG: return "http://hl7.org/fhir/fhir-types"; 19670 case FORMULARYITEM: return "http://hl7.org/fhir/fhir-types"; 19671 case GENOMICSTUDY: return "http://hl7.org/fhir/fhir-types"; 19672 case GOAL: return "http://hl7.org/fhir/fhir-types"; 19673 case GRAPHDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19674 case GROUP: return "http://hl7.org/fhir/fhir-types"; 19675 case GUIDANCERESPONSE: return "http://hl7.org/fhir/fhir-types"; 19676 case HEALTHCARESERVICE: return "http://hl7.org/fhir/fhir-types"; 19677 case IMAGINGSELECTION: return "http://hl7.org/fhir/fhir-types"; 19678 case IMAGINGSTUDY: return "http://hl7.org/fhir/fhir-types"; 19679 case IMMUNIZATION: return "http://hl7.org/fhir/fhir-types"; 19680 case IMMUNIZATIONEVALUATION: return "http://hl7.org/fhir/fhir-types"; 19681 case IMMUNIZATIONRECOMMENDATION: return "http://hl7.org/fhir/fhir-types"; 19682 case IMPLEMENTATIONGUIDE: return "http://hl7.org/fhir/fhir-types"; 19683 case INGREDIENT: return "http://hl7.org/fhir/fhir-types"; 19684 case INSURANCEPLAN: return "http://hl7.org/fhir/fhir-types"; 19685 case INVENTORYITEM: return "http://hl7.org/fhir/fhir-types"; 19686 case INVENTORYREPORT: return "http://hl7.org/fhir/fhir-types"; 19687 case INVOICE: return "http://hl7.org/fhir/fhir-types"; 19688 case LIBRARY: return "http://hl7.org/fhir/fhir-types"; 19689 case LINKAGE: return "http://hl7.org/fhir/fhir-types"; 19690 case LIST: return "http://hl7.org/fhir/fhir-types"; 19691 case LOCATION: return "http://hl7.org/fhir/fhir-types"; 19692 case MANUFACTUREDITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19693 case MEASURE: return "http://hl7.org/fhir/fhir-types"; 19694 case MEASUREREPORT: return "http://hl7.org/fhir/fhir-types"; 19695 case MEDICATION: return "http://hl7.org/fhir/fhir-types"; 19696 case MEDICATIONADMINISTRATION: return "http://hl7.org/fhir/fhir-types"; 19697 case MEDICATIONDISPENSE: return "http://hl7.org/fhir/fhir-types"; 19698 case MEDICATIONKNOWLEDGE: return "http://hl7.org/fhir/fhir-types"; 19699 case MEDICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 19700 case MEDICATIONSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 19701 case MEDICINALPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19702 case MESSAGEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19703 case MESSAGEHEADER: return "http://hl7.org/fhir/fhir-types"; 19704 case METADATARESOURCE: return "http://hl7.org/fhir/fhir-types"; 19705 case MOLECULARSEQUENCE: return "http://hl7.org/fhir/fhir-types"; 19706 case NAMINGSYSTEM: return "http://hl7.org/fhir/fhir-types"; 19707 case NUTRITIONINTAKE: return "http://hl7.org/fhir/fhir-types"; 19708 case NUTRITIONORDER: return "http://hl7.org/fhir/fhir-types"; 19709 case NUTRITIONPRODUCT: return "http://hl7.org/fhir/fhir-types"; 19710 case OBSERVATION: return "http://hl7.org/fhir/fhir-types"; 19711 case OBSERVATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19712 case OPERATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19713 case OPERATIONOUTCOME: return "http://hl7.org/fhir/fhir-types"; 19714 case ORGANIZATION: return "http://hl7.org/fhir/fhir-types"; 19715 case ORGANIZATIONAFFILIATION: return "http://hl7.org/fhir/fhir-types"; 19716 case PACKAGEDPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19717 case PARAMETERS: return "http://hl7.org/fhir/fhir-types"; 19718 case PATIENT: return "http://hl7.org/fhir/fhir-types"; 19719 case PAYMENTNOTICE: return "http://hl7.org/fhir/fhir-types"; 19720 case PAYMENTRECONCILIATION: return "http://hl7.org/fhir/fhir-types"; 19721 case PERMISSION: return "http://hl7.org/fhir/fhir-types"; 19722 case PERSON: return "http://hl7.org/fhir/fhir-types"; 19723 case PLANDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19724 case PRACTITIONER: return "http://hl7.org/fhir/fhir-types"; 19725 case PRACTITIONERROLE: return "http://hl7.org/fhir/fhir-types"; 19726 case PROCEDURE: return "http://hl7.org/fhir/fhir-types"; 19727 case PROVENANCE: return "http://hl7.org/fhir/fhir-types"; 19728 case QUESTIONNAIRE: return "http://hl7.org/fhir/fhir-types"; 19729 case QUESTIONNAIRERESPONSE: return "http://hl7.org/fhir/fhir-types"; 19730 case REGULATEDAUTHORIZATION: return "http://hl7.org/fhir/fhir-types"; 19731 case RELATEDPERSON: return "http://hl7.org/fhir/fhir-types"; 19732 case REQUESTORCHESTRATION: return "http://hl7.org/fhir/fhir-types"; 19733 case REQUIREMENTS: return "http://hl7.org/fhir/fhir-types"; 19734 case RESEARCHSTUDY: return "http://hl7.org/fhir/fhir-types"; 19735 case RESEARCHSUBJECT: return "http://hl7.org/fhir/fhir-types"; 19736 case RESOURCE: return "http://hl7.org/fhir/fhir-types"; 19737 case RISKASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 19738 case SCHEDULE: return "http://hl7.org/fhir/fhir-types"; 19739 case SEARCHPARAMETER: return "http://hl7.org/fhir/fhir-types"; 19740 case SERVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 19741 case SLOT: return "http://hl7.org/fhir/fhir-types"; 19742 case SPECIMEN: return "http://hl7.org/fhir/fhir-types"; 19743 case SPECIMENDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19744 case STRUCTUREDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19745 case STRUCTUREMAP: return "http://hl7.org/fhir/fhir-types"; 19746 case SUBSCRIPTION: return "http://hl7.org/fhir/fhir-types"; 19747 case SUBSCRIPTIONSTATUS: return "http://hl7.org/fhir/fhir-types"; 19748 case SUBSCRIPTIONTOPIC: return "http://hl7.org/fhir/fhir-types"; 19749 case SUBSTANCE: return "http://hl7.org/fhir/fhir-types"; 19750 case SUBSTANCEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 19751 case SUBSTANCENUCLEICACID: return "http://hl7.org/fhir/fhir-types"; 19752 case SUBSTANCEPOLYMER: return "http://hl7.org/fhir/fhir-types"; 19753 case SUBSTANCEPROTEIN: return "http://hl7.org/fhir/fhir-types"; 19754 case SUBSTANCEREFERENCEINFORMATION: return "http://hl7.org/fhir/fhir-types"; 19755 case SUBSTANCESOURCEMATERIAL: return "http://hl7.org/fhir/fhir-types"; 19756 case SUPPLYDELIVERY: return "http://hl7.org/fhir/fhir-types"; 19757 case SUPPLYREQUEST: return "http://hl7.org/fhir/fhir-types"; 19758 case TASK: return "http://hl7.org/fhir/fhir-types"; 19759 case TERMINOLOGYCAPABILITIES: return "http://hl7.org/fhir/fhir-types"; 19760 case TESTPLAN: return "http://hl7.org/fhir/fhir-types"; 19761 case TESTREPORT: return "http://hl7.org/fhir/fhir-types"; 19762 case TESTSCRIPT: return "http://hl7.org/fhir/fhir-types"; 19763 case TRANSPORT: return "http://hl7.org/fhir/fhir-types"; 19764 case VALUESET: return "http://hl7.org/fhir/fhir-types"; 19765 case VERIFICATIONRESULT: return "http://hl7.org/fhir/fhir-types"; 19766 case VISIONPRESCRIPTION: return "http://hl7.org/fhir/fhir-types"; 19767 case BODYSITE: return "http://hl7.org/fhir/fhir-old-types"; 19768 case CATALOGENTRY: return "http://hl7.org/fhir/fhir-old-types"; 19769 case CONFORMANCE: return "http://hl7.org/fhir/fhir-old-types"; 19770 case DATAELEMENT: return "http://hl7.org/fhir/fhir-old-types"; 19771 case DEVICECOMPONENT: return "http://hl7.org/fhir/fhir-old-types"; 19772 case DEVICEUSEREQUEST: return "http://hl7.org/fhir/fhir-old-types"; 19773 case DEVICEUSESTATEMENT: return "http://hl7.org/fhir/fhir-old-types"; 19774 case DIAGNOSTICORDER: return "http://hl7.org/fhir/fhir-old-types"; 19775 case DOCUMENTMANIFEST: return "http://hl7.org/fhir/fhir-old-types"; 19776 case EFFECTEVIDENCESYNTHESIS: return "http://hl7.org/fhir/fhir-old-types"; 19777 case ELIGIBILITYREQUEST: return "http://hl7.org/fhir/fhir-old-types"; 19778 case ELIGIBILITYRESPONSE: return "http://hl7.org/fhir/fhir-old-types"; 19779 case EXPANSIONPROFILE: return "http://hl7.org/fhir/fhir-old-types"; 19780 case IMAGINGMANIFEST: return "http://hl7.org/fhir/fhir-old-types"; 19781 case IMAGINGOBJECTSELECTION: return "http://hl7.org/fhir/fhir-old-types"; 19782 case MEDIA: return "http://hl7.org/fhir/fhir-old-types"; 19783 case MEDICATIONORDER: return "http://hl7.org/fhir/fhir-old-types"; 19784 case MEDICATIONUSAGE: return "http://hl7.org/fhir/fhir-old-types"; 19785 case MEDICINALPRODUCT: return "http://hl7.org/fhir/fhir-old-types"; 19786 case MEDICINALPRODUCTAUTHORIZATION: return "http://hl7.org/fhir/fhir-old-types"; 19787 case MEDICINALPRODUCTCONTRAINDICATION: return "http://hl7.org/fhir/fhir-old-types"; 19788 case MEDICINALPRODUCTINDICATION: return "http://hl7.org/fhir/fhir-old-types"; 19789 case MEDICINALPRODUCTINGREDIENT: return "http://hl7.org/fhir/fhir-old-types"; 19790 case MEDICINALPRODUCTINTERACTION: return "http://hl7.org/fhir/fhir-old-types"; 19791 case MEDICINALPRODUCTMANUFACTURED: return "http://hl7.org/fhir/fhir-old-types"; 19792 case MEDICINALPRODUCTPACKAGED: return "http://hl7.org/fhir/fhir-old-types"; 19793 case MEDICINALPRODUCTPHARMACEUTICAL: return "http://hl7.org/fhir/fhir-old-types"; 19794 case MEDICINALPRODUCTUNDESIRABLEEFFECT: return "http://hl7.org/fhir/fhir-old-types"; 19795 case ORDER: return "http://hl7.org/fhir/fhir-old-types"; 19796 case ORDERRESPONSE: return "http://hl7.org/fhir/fhir-old-types"; 19797 case PROCEDUREREQUEST: return "http://hl7.org/fhir/fhir-old-types"; 19798 case PROCESSREQUEST: return "http://hl7.org/fhir/fhir-old-types"; 19799 case PROCESSRESPONSE: return "http://hl7.org/fhir/fhir-old-types"; 19800 case REFERRALREQUEST: return "http://hl7.org/fhir/fhir-old-types"; 19801 case REQUESTGROUP: return "http://hl7.org/fhir/fhir-old-types"; 19802 case RESEARCHDEFINITION: return "http://hl7.org/fhir/fhir-old-types"; 19803 case RESEARCHELEMENTDEFINITION: return "http://hl7.org/fhir/fhir-old-types"; 19804 case RISKEVIDENCESYNTHESIS: return "http://hl7.org/fhir/fhir-old-types"; 19805 case SEQUENCE: return "http://hl7.org/fhir/fhir-old-types"; 19806 case SERVICEDEFINITION: return "http://hl7.org/fhir/fhir-old-types"; 19807 case SUBSTANCESPECIFICATION: return "http://hl7.org/fhir/fhir-old-types"; 19808 case NULL: return null; 19809 default: return "?"; 19810 } 19811 } 19812 public String getDefinition() { 19813 switch (this) { 19814 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."; 19815 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."; 19816 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."; 19817 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)."; 19818 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."; 19819 case ALLERGYINTOLERANCE: return "Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance."; 19820 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)."; 19821 case APPOINTMENTRESPONSE: return "A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection."; 19822 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."; 19823 case AUDITEVENT: return "A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis."; 19824 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."; 19825 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."; 19826 case BIOLOGICALLYDERIVEDPRODUCT: return "A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity."; 19827 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "A record of dispensation of a biologically derived product."; 19828 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."; 19829 case BUNDLE: return "A container for a collection of resources."; 19830 case CANONICALRESOURCE: return "Common Interface declaration for conformance and knowledge artifact resources."; 19831 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."; 19832 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."; 19833 case CARETEAM: return "The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care."; 19834 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."; 19835 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."; 19836 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."; 19837 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."; 19838 case CLAIMRESPONSE: return "This resource provides the adjudication details from the processing of a Claim resource."; 19839 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."; 19840 case CLINICALUSEDEFINITION: return "A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure."; 19841 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."; 19842 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."; 19843 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."; 19844 case COMPARTMENTDEFINITION: return "A compartment definition that defines how resources are accessed on a server."; 19845 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.)."; 19846 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."; 19847 case CONDITION: return "A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern."; 19848 case CONDITIONDEFINITION: return "A definition of a condition and information relevant to managing it."; 19849 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."; 19850 case CONTRACT: return "Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement."; 19851 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."; 19852 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."; 19853 case COVERAGEELIGIBILITYRESPONSE: return "This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource."; 19854 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."; 19855 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."; 19856 case DEVICEASSOCIATION: return "A record of association of a device."; 19857 case DEVICEDEFINITION: return "This is a specialized resource that defines the characteristics and capabilities of a device."; 19858 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."; 19859 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. "; 19860 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."; 19861 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."; 19862 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."; 19863 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."; 19864 case DOMAINRESOURCE: return "A resource that includes narrative, extensions, and contained resources."; 19865 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)."; 19866 case ENCOUNTERHISTORY: return "A record of significant events/milestones key data throughout the history of an Encounter"; 19867 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."; 19868 case ENROLLMENTREQUEST: return "This resource provides the insurance enrollment details to the insurer regarding a specified coverage."; 19869 case ENROLLMENTRESPONSE: return "This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource."; 19870 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."; 19871 case EVENTDEFINITION: return "The EventDefinition resource provides a reusable description of when a particular event can occur."; 19872 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."; 19873 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."; 19874 case EVIDENCEVARIABLE: return "The EvidenceVariable resource describes an element that knowledge (Evidence) is about."; 19875 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."; 19876 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."; 19877 case FAMILYMEMBERHISTORY: return "Significant health conditions for a person related to the patient relevant in the context of care for the patient."; 19878 case FLAG: return "Prospective warnings of potential issues when providing care to the patient."; 19879 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."; 19880 case GENOMICSTUDY: return "A set of analyses performed to analyze and generate genomic data."; 19881 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."; 19882 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."; 19883 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."; 19884 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."; 19885 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."; 19886 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."; 19887 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."; 19888 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."; 19889 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."; 19890 case IMMUNIZATIONRECOMMENDATION: return "A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification."; 19891 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."; 19892 case INGREDIENT: return "An ingredient of a manufactured item or pharmaceutical product."; 19893 case INSURANCEPLAN: return "Details of a Health Insurance product/plan provided by an organization."; 19894 case INVENTORYITEM: return "functional description of an inventory item used in inventory and supply-related workflows."; 19895 case INVENTORYREPORT: return "A report of inventory or stock items."; 19896 case INVOICE: return "Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose."; 19897 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."; 19898 case LINKAGE: return "Identifies two or more records (resource instances) that refer to the same real-world \"occurrence\"."; 19899 case LIST: return "A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc."; 19900 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."; 19901 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."; 19902 case MEASURE: return "The Measure resource provides the definition of a quality measure."; 19903 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."; 19904 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."; 19905 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."; 19906 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."; 19907 case MEDICATIONKNOWLEDGE: return "Information about a medication that is used to support knowledge."; 19908 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."; 19909 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."; 19910 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.)."; 19911 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."; 19912 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."; 19913 case METADATARESOURCE: return "Common Interface declaration for conformance and knowledge artifact resources."; 19914 case MOLECULARSEQUENCE: return "Representation of a molecular sequence."; 19915 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."; 19916 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."; 19917 case NUTRITIONORDER: return "A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident."; 19918 case NUTRITIONPRODUCT: return "A food or supplement that is consumed by patients."; 19919 case OBSERVATION: return "Measurements and simple assertions made about a patient, device or other subject."; 19920 case OBSERVATIONDEFINITION: return "Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service."; 19921 case OPERATIONDEFINITION: return "A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction)."; 19922 case OPERATIONOUTCOME: return "A collection of error, warning, or information messages that result from a system action."; 19923 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."; 19924 case ORGANIZATIONAFFILIATION: return "Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship."; 19925 case PACKAGEDPRODUCTDEFINITION: return "A medically related item or items, in a container or package."; 19926 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."; 19927 case PATIENT: return "Demographics and other administrative information about an individual or animal receiving care or other health-related services."; 19928 case PAYMENTNOTICE: return "This resource provides the status of the payment for goods and services rendered, and the request and response resource references."; 19929 case PAYMENTRECONCILIATION: return "This resource provides the details including amount of a payment and allocates the payment items being paid."; 19930 case PERMISSION: return "Permission resource holds access rules for a given data and context."; 19931 case PERSON: return "Demographics and administrative information about a person independent of a specific health-related context."; 19932 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."; 19933 case PRACTITIONER: return "A person who is directly or indirectly involved in the provisioning of healthcare or related services."; 19934 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."; 19935 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."; 19936 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."; 19937 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."; 19938 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."; 19939 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."; 19940 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."; 19941 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\"."; 19942 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."; 19943 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."; 19944 case RESEARCHSUBJECT: return "A ResearchSubject is a participant or object which is the recipient of investigative activities in a research study."; 19945 case RESOURCE: return "This is the base resource type for everything."; 19946 case RISKASSESSMENT: return "An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome."; 19947 case SCHEDULE: return "A container for slots of time that may be available for booking appointments."; 19948 case SEARCHPARAMETER: return "A search parameter that defines a named search item that can be used to search/filter on a resource."; 19949 case SERVICEREQUEST: return "A record of a request for service such as diagnostic investigations, treatments, or operations to be performed."; 19950 case SLOT: return "A slot of time on a schedule that may be available for booking appointments."; 19951 case SPECIMEN: return "A sample to be used for analysis."; 19952 case SPECIMENDEFINITION: return "A kind of specimen with associated set of requirements."; 19953 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."; 19954 case STRUCTUREMAP: return "A Map of relationships between 2 structures that can be used to transform data."; 19955 case SUBSCRIPTION: return "The subscription resource describes a particular client's request to be notified about a SubscriptionTopic."; 19956 case SUBSCRIPTIONSTATUS: return "The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted."; 19957 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."; 19958 case SUBSTANCE: return "A homogeneous material with a definite composition."; 19959 case SUBSTANCEDEFINITION: return "The detailed description of a substance, typically at a level beyond what is used for prescribing."; 19960 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."; 19961 case SUBSTANCEPOLYMER: return "Properties of a substance specific to it being a polymer."; 19962 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."; 19963 case SUBSTANCEREFERENCEINFORMATION: return "Todo."; 19964 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."; 19965 case SUPPLYDELIVERY: return "Record of delivery of what is supplied."; 19966 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."; 19967 case TASK: return "A task to be performed."; 19968 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."; 19969 case TESTPLAN: return "A plan for executing testing on an artifact or specifications"; 19970 case TESTREPORT: return "A summary of information based on the results of executing a TestScript."; 19971 case TESTSCRIPT: return "A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification."; 19972 case TRANSPORT: return "Record of transport."; 19973 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)."; 19974 case VERIFICATIONRESULT: return "Describes validation requirements, source(s), status and dates for one or more elements."; 19975 case VISIONPRESCRIPTION: return "An authorization for the provision of glasses and/or contact lenses to a patient."; 19976 case BODYSITE: return ""; 19977 case CATALOGENTRY: return ""; 19978 case CONFORMANCE: return ""; 19979 case DATAELEMENT: return ""; 19980 case DEVICECOMPONENT: return ""; 19981 case DEVICEUSEREQUEST: return ""; 19982 case DEVICEUSESTATEMENT: return ""; 19983 case DIAGNOSTICORDER: return ""; 19984 case DOCUMENTMANIFEST: return ""; 19985 case EFFECTEVIDENCESYNTHESIS: return ""; 19986 case ELIGIBILITYREQUEST: return ""; 19987 case ELIGIBILITYRESPONSE: return ""; 19988 case EXPANSIONPROFILE: return ""; 19989 case IMAGINGMANIFEST: return ""; 19990 case IMAGINGOBJECTSELECTION: return ""; 19991 case MEDIA: return ""; 19992 case MEDICATIONORDER: return ""; 19993 case MEDICATIONUSAGE: return ""; 19994 case MEDICINALPRODUCT: return ""; 19995 case MEDICINALPRODUCTAUTHORIZATION: return ""; 19996 case MEDICINALPRODUCTCONTRAINDICATION: return ""; 19997 case MEDICINALPRODUCTINDICATION: return ""; 19998 case MEDICINALPRODUCTINGREDIENT: return ""; 19999 case MEDICINALPRODUCTINTERACTION: return ""; 20000 case MEDICINALPRODUCTMANUFACTURED: return ""; 20001 case MEDICINALPRODUCTPACKAGED: return ""; 20002 case MEDICINALPRODUCTPHARMACEUTICAL: return ""; 20003 case MEDICINALPRODUCTUNDESIRABLEEFFECT: return ""; 20004 case ORDER: return ""; 20005 case ORDERRESPONSE: return ""; 20006 case PROCEDUREREQUEST: return ""; 20007 case PROCESSREQUEST: return ""; 20008 case PROCESSRESPONSE: return ""; 20009 case REFERRALREQUEST: return ""; 20010 case REQUESTGROUP: return ""; 20011 case RESEARCHDEFINITION: return ""; 20012 case RESEARCHELEMENTDEFINITION: return ""; 20013 case RISKEVIDENCESYNTHESIS: return ""; 20014 case SEQUENCE: return ""; 20015 case SERVICEDEFINITION: return ""; 20016 case SUBSTANCESPECIFICATION: return ""; 20017 case NULL: return null; 20018 default: return "?"; 20019 } 20020 } 20021 public String getDisplay() { 20022 switch (this) { 20023 case ACCOUNT: return "Account"; 20024 case ACTIVITYDEFINITION: return "ActivityDefinition"; 20025 case ACTORDEFINITION: return "ActorDefinition"; 20026 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 20027 case ADVERSEEVENT: return "AdverseEvent"; 20028 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 20029 case APPOINTMENT: return "Appointment"; 20030 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 20031 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 20032 case AUDITEVENT: return "AuditEvent"; 20033 case BASIC: return "Basic"; 20034 case BINARY: return "Binary"; 20035 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 20036 case BIOLOGICALLYDERIVEDPRODUCTDISPENSE: return "BiologicallyDerivedProductDispense"; 20037 case BODYSTRUCTURE: return "BodyStructure"; 20038 case BUNDLE: return "Bundle"; 20039 case CANONICALRESOURCE: return "CanonicalResource"; 20040 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 20041 case CAREPLAN: return "CarePlan"; 20042 case CARETEAM: return "CareTeam"; 20043 case CHARGEITEM: return "ChargeItem"; 20044 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 20045 case CITATION: return "Citation"; 20046 case CLAIM: return "Claim"; 20047 case CLAIMRESPONSE: return "ClaimResponse"; 20048 case CLINICALIMPRESSION: return "ClinicalImpression"; 20049 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 20050 case CODESYSTEM: return "CodeSystem"; 20051 case COMMUNICATION: return "Communication"; 20052 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 20053 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 20054 case COMPOSITION: return "Composition"; 20055 case CONCEPTMAP: return "ConceptMap"; 20056 case CONDITION: return "Condition"; 20057 case CONDITIONDEFINITION: return "ConditionDefinition"; 20058 case CONSENT: return "Consent"; 20059 case CONTRACT: return "Contract"; 20060 case COVERAGE: return "Coverage"; 20061 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 20062 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 20063 case DETECTEDISSUE: return "DetectedIssue"; 20064 case DEVICE: return "Device"; 20065 case DEVICEASSOCIATION: return "DeviceAssociation"; 20066 case DEVICEDEFINITION: return "DeviceDefinition"; 20067 case DEVICEDISPENSE: return "DeviceDispense"; 20068 case DEVICEMETRIC: return "DeviceMetric"; 20069 case DEVICEREQUEST: return "DeviceRequest"; 20070 case DEVICEUSAGE: return "DeviceUsage"; 20071 case DIAGNOSTICREPORT: return "DiagnosticReport"; 20072 case DOCUMENTREFERENCE: return "DocumentReference"; 20073 case DOMAINRESOURCE: return "DomainResource"; 20074 case ENCOUNTER: return "Encounter"; 20075 case ENCOUNTERHISTORY: return "EncounterHistory"; 20076 case ENDPOINT: return "Endpoint"; 20077 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 20078 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 20079 case EPISODEOFCARE: return "EpisodeOfCare"; 20080 case EVENTDEFINITION: return "EventDefinition"; 20081 case EVIDENCE: return "Evidence"; 20082 case EVIDENCEREPORT: return "EvidenceReport"; 20083 case EVIDENCEVARIABLE: return "EvidenceVariable"; 20084 case EXAMPLESCENARIO: return "ExampleScenario"; 20085 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 20086 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 20087 case FLAG: return "Flag"; 20088 case FORMULARYITEM: return "FormularyItem"; 20089 case GENOMICSTUDY: return "GenomicStudy"; 20090 case GOAL: return "Goal"; 20091 case GRAPHDEFINITION: return "GraphDefinition"; 20092 case GROUP: return "Group"; 20093 case GUIDANCERESPONSE: return "GuidanceResponse"; 20094 case HEALTHCARESERVICE: return "HealthcareService"; 20095 case IMAGINGSELECTION: return "ImagingSelection"; 20096 case IMAGINGSTUDY: return "ImagingStudy"; 20097 case IMMUNIZATION: return "Immunization"; 20098 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 20099 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 20100 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 20101 case INGREDIENT: return "Ingredient"; 20102 case INSURANCEPLAN: return "InsurancePlan"; 20103 case INVENTORYITEM: return "InventoryItem"; 20104 case INVENTORYREPORT: return "InventoryReport"; 20105 case INVOICE: return "Invoice"; 20106 case LIBRARY: return "Library"; 20107 case LINKAGE: return "Linkage"; 20108 case LIST: return "List"; 20109 case LOCATION: return "Location"; 20110 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 20111 case MEASURE: return "Measure"; 20112 case MEASUREREPORT: return "MeasureReport"; 20113 case MEDICATION: return "Medication"; 20114 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 20115 case MEDICATIONDISPENSE: return "MedicationDispense"; 20116 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 20117 case MEDICATIONREQUEST: return "MedicationRequest"; 20118 case MEDICATIONSTATEMENT: return "MedicationStatement"; 20119 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 20120 case MESSAGEDEFINITION: return "MessageDefinition"; 20121 case MESSAGEHEADER: return "MessageHeader"; 20122 case METADATARESOURCE: return "MetadataResource"; 20123 case MOLECULARSEQUENCE: return "MolecularSequence"; 20124 case NAMINGSYSTEM: return "NamingSystem"; 20125 case NUTRITIONINTAKE: return "NutritionIntake"; 20126 case NUTRITIONORDER: return "NutritionOrder"; 20127 case NUTRITIONPRODUCT: return "NutritionProduct"; 20128 case OBSERVATION: return "Observation"; 20129 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 20130 case OPERATIONDEFINITION: return "OperationDefinition"; 20131 case OPERATIONOUTCOME: return "OperationOutcome"; 20132 case ORGANIZATION: return "Organization"; 20133 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 20134 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 20135 case PARAMETERS: return "Parameters"; 20136 case PATIENT: return "Patient"; 20137 case PAYMENTNOTICE: return "PaymentNotice"; 20138 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 20139 case PERMISSION: return "Permission"; 20140 case PERSON: return "Person"; 20141 case PLANDEFINITION: return "PlanDefinition"; 20142 case PRACTITIONER: return "Practitioner"; 20143 case PRACTITIONERROLE: return "PractitionerRole"; 20144 case PROCEDURE: return "Procedure"; 20145 case PROVENANCE: return "Provenance"; 20146 case QUESTIONNAIRE: return "Questionnaire"; 20147 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 20148 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 20149 case RELATEDPERSON: return "RelatedPerson"; 20150 case REQUESTORCHESTRATION: return "RequestOrchestration"; 20151 case REQUIREMENTS: return "Requirements"; 20152 case RESEARCHSTUDY: return "ResearchStudy"; 20153 case RESEARCHSUBJECT: return "ResearchSubject"; 20154 case RESOURCE: return "Resource"; 20155 case RISKASSESSMENT: return "RiskAssessment"; 20156 case SCHEDULE: return "Schedule"; 20157 case SEARCHPARAMETER: return "SearchParameter"; 20158 case SERVICEREQUEST: return "ServiceRequest"; 20159 case SLOT: return "Slot"; 20160 case SPECIMEN: return "Specimen"; 20161 case SPECIMENDEFINITION: return "SpecimenDefinition"; 20162 case STRUCTUREDEFINITION: return "StructureDefinition"; 20163 case STRUCTUREMAP: return "StructureMap"; 20164 case SUBSCRIPTION: return "Subscription"; 20165 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 20166 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 20167 case SUBSTANCE: return "Substance"; 20168 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 20169 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 20170 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 20171 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 20172 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 20173 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 20174 case SUPPLYDELIVERY: return "SupplyDelivery"; 20175 case SUPPLYREQUEST: return "SupplyRequest"; 20176 case TASK: return "Task"; 20177 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 20178 case TESTPLAN: return "TestPlan"; 20179 case TESTREPORT: return "TestReport"; 20180 case TESTSCRIPT: return "TestScript"; 20181 case TRANSPORT: return "Transport"; 20182 case VALUESET: return "ValueSet"; 20183 case VERIFICATIONRESULT: return "VerificationResult"; 20184 case VISIONPRESCRIPTION: return "VisionPrescription"; 20185 case BODYSITE: return "BodySite"; 20186 case CATALOGENTRY: return "CatalogEntry"; 20187 case CONFORMANCE: return "Conformance"; 20188 case DATAELEMENT: return "DataElement"; 20189 case DEVICECOMPONENT: return "DeviceComponent"; 20190 case DEVICEUSEREQUEST: return "DeviceUseRequest"; 20191 case DEVICEUSESTATEMENT: return "DeviceUseStatement"; 20192 case DIAGNOSTICORDER: return "DiagnosticOrder"; 20193 case DOCUMENTMANIFEST: return "DocumentManifest"; 20194 case EFFECTEVIDENCESYNTHESIS: return "EffectEvidenceSynthesis"; 20195 case ELIGIBILITYREQUEST: return "EligibilityRequest"; 20196 case ELIGIBILITYRESPONSE: return "EligibilityResponse"; 20197 case EXPANSIONPROFILE: return "ExpansionProfile"; 20198 case IMAGINGMANIFEST: return "ImagingManifest"; 20199 case IMAGINGOBJECTSELECTION: return "ImagingObjectSelection"; 20200 case MEDIA: return "Media"; 20201 case MEDICATIONORDER: return "MedicationOrder"; 20202 case MEDICATIONUSAGE: return "MedicationUsage"; 20203 case MEDICINALPRODUCT: return "MedicinalProduct"; 20204 case MEDICINALPRODUCTAUTHORIZATION: return "MedicinalProductAuthorization"; 20205 case MEDICINALPRODUCTCONTRAINDICATION: return "MedicinalProductContraindication"; 20206 case MEDICINALPRODUCTINDICATION: return "MedicinalProductIndication"; 20207 case MEDICINALPRODUCTINGREDIENT: return "MedicinalProductIngredient"; 20208 case MEDICINALPRODUCTINTERACTION: return "MedicinalProductInteraction"; 20209 case MEDICINALPRODUCTMANUFACTURED: return "MedicinalProductManufactured"; 20210 case MEDICINALPRODUCTPACKAGED: return "MedicinalProductPackaged"; 20211 case MEDICINALPRODUCTPHARMACEUTICAL: return "MedicinalProductPharmaceutical"; 20212 case MEDICINALPRODUCTUNDESIRABLEEFFECT: return "MedicinalProductUndesirableEffect"; 20213 case ORDER: return "Order"; 20214 case ORDERRESPONSE: return "OrderResponse"; 20215 case PROCEDUREREQUEST: return "ProcedureRequest"; 20216 case PROCESSREQUEST: return "ProcessRequest"; 20217 case PROCESSRESPONSE: return "ProcessResponse"; 20218 case REFERRALREQUEST: return "ReferralRequest"; 20219 case REQUESTGROUP: return "RequestGroup"; 20220 case RESEARCHDEFINITION: return "ResearchDefinition"; 20221 case RESEARCHELEMENTDEFINITION: return "ResearchElementDefinition"; 20222 case RISKEVIDENCESYNTHESIS: return "RiskEvidenceSynthesis"; 20223 case SEQUENCE: return "Sequence"; 20224 case SERVICEDEFINITION: return "ServiceDefinition"; 20225 case SUBSTANCESPECIFICATION: return "SubstanceSpecification"; 20226 case NULL: return null; 20227 default: return "?"; 20228 } 20229 } 20230 } 20231 20232 public static class VersionIndependentResourceTypesAllEnumFactory implements EnumFactory<VersionIndependentResourceTypesAll> { 20233 public VersionIndependentResourceTypesAll fromCode(String codeString) throws IllegalArgumentException { 20234 if (codeString == null || "".equals(codeString)) 20235 if (codeString == null || "".equals(codeString)) 20236 return null; 20237 if ("Account".equals(codeString)) 20238 return VersionIndependentResourceTypesAll.ACCOUNT; 20239 if ("ActivityDefinition".equals(codeString)) 20240 return VersionIndependentResourceTypesAll.ACTIVITYDEFINITION; 20241 if ("ActorDefinition".equals(codeString)) 20242 return VersionIndependentResourceTypesAll.ACTORDEFINITION; 20243 if ("AdministrableProductDefinition".equals(codeString)) 20244 return VersionIndependentResourceTypesAll.ADMINISTRABLEPRODUCTDEFINITION; 20245 if ("AdverseEvent".equals(codeString)) 20246 return VersionIndependentResourceTypesAll.ADVERSEEVENT; 20247 if ("AllergyIntolerance".equals(codeString)) 20248 return VersionIndependentResourceTypesAll.ALLERGYINTOLERANCE; 20249 if ("Appointment".equals(codeString)) 20250 return VersionIndependentResourceTypesAll.APPOINTMENT; 20251 if ("AppointmentResponse".equals(codeString)) 20252 return VersionIndependentResourceTypesAll.APPOINTMENTRESPONSE; 20253 if ("ArtifactAssessment".equals(codeString)) 20254 return VersionIndependentResourceTypesAll.ARTIFACTASSESSMENT; 20255 if ("AuditEvent".equals(codeString)) 20256 return VersionIndependentResourceTypesAll.AUDITEVENT; 20257 if ("Basic".equals(codeString)) 20258 return VersionIndependentResourceTypesAll.BASIC; 20259 if ("Binary".equals(codeString)) 20260 return VersionIndependentResourceTypesAll.BINARY; 20261 if ("BiologicallyDerivedProduct".equals(codeString)) 20262 return VersionIndependentResourceTypesAll.BIOLOGICALLYDERIVEDPRODUCT; 20263 if ("BiologicallyDerivedProductDispense".equals(codeString)) 20264 return VersionIndependentResourceTypesAll.BIOLOGICALLYDERIVEDPRODUCTDISPENSE; 20265 if ("BodyStructure".equals(codeString)) 20266 return VersionIndependentResourceTypesAll.BODYSTRUCTURE; 20267 if ("Bundle".equals(codeString)) 20268 return VersionIndependentResourceTypesAll.BUNDLE; 20269 if ("CanonicalResource".equals(codeString)) 20270 return VersionIndependentResourceTypesAll.CANONICALRESOURCE; 20271 if ("CapabilityStatement".equals(codeString)) 20272 return VersionIndependentResourceTypesAll.CAPABILITYSTATEMENT; 20273 if ("CarePlan".equals(codeString)) 20274 return VersionIndependentResourceTypesAll.CAREPLAN; 20275 if ("CareTeam".equals(codeString)) 20276 return VersionIndependentResourceTypesAll.CARETEAM; 20277 if ("ChargeItem".equals(codeString)) 20278 return VersionIndependentResourceTypesAll.CHARGEITEM; 20279 if ("ChargeItemDefinition".equals(codeString)) 20280 return VersionIndependentResourceTypesAll.CHARGEITEMDEFINITION; 20281 if ("Citation".equals(codeString)) 20282 return VersionIndependentResourceTypesAll.CITATION; 20283 if ("Claim".equals(codeString)) 20284 return VersionIndependentResourceTypesAll.CLAIM; 20285 if ("ClaimResponse".equals(codeString)) 20286 return VersionIndependentResourceTypesAll.CLAIMRESPONSE; 20287 if ("ClinicalImpression".equals(codeString)) 20288 return VersionIndependentResourceTypesAll.CLINICALIMPRESSION; 20289 if ("ClinicalUseDefinition".equals(codeString)) 20290 return VersionIndependentResourceTypesAll.CLINICALUSEDEFINITION; 20291 if ("CodeSystem".equals(codeString)) 20292 return VersionIndependentResourceTypesAll.CODESYSTEM; 20293 if ("Communication".equals(codeString)) 20294 return VersionIndependentResourceTypesAll.COMMUNICATION; 20295 if ("CommunicationRequest".equals(codeString)) 20296 return VersionIndependentResourceTypesAll.COMMUNICATIONREQUEST; 20297 if ("CompartmentDefinition".equals(codeString)) 20298 return VersionIndependentResourceTypesAll.COMPARTMENTDEFINITION; 20299 if ("Composition".equals(codeString)) 20300 return VersionIndependentResourceTypesAll.COMPOSITION; 20301 if ("ConceptMap".equals(codeString)) 20302 return VersionIndependentResourceTypesAll.CONCEPTMAP; 20303 if ("Condition".equals(codeString)) 20304 return VersionIndependentResourceTypesAll.CONDITION; 20305 if ("ConditionDefinition".equals(codeString)) 20306 return VersionIndependentResourceTypesAll.CONDITIONDEFINITION; 20307 if ("Consent".equals(codeString)) 20308 return VersionIndependentResourceTypesAll.CONSENT; 20309 if ("Contract".equals(codeString)) 20310 return VersionIndependentResourceTypesAll.CONTRACT; 20311 if ("Coverage".equals(codeString)) 20312 return VersionIndependentResourceTypesAll.COVERAGE; 20313 if ("CoverageEligibilityRequest".equals(codeString)) 20314 return VersionIndependentResourceTypesAll.COVERAGEELIGIBILITYREQUEST; 20315 if ("CoverageEligibilityResponse".equals(codeString)) 20316 return VersionIndependentResourceTypesAll.COVERAGEELIGIBILITYRESPONSE; 20317 if ("DetectedIssue".equals(codeString)) 20318 return VersionIndependentResourceTypesAll.DETECTEDISSUE; 20319 if ("Device".equals(codeString)) 20320 return VersionIndependentResourceTypesAll.DEVICE; 20321 if ("DeviceAssociation".equals(codeString)) 20322 return VersionIndependentResourceTypesAll.DEVICEASSOCIATION; 20323 if ("DeviceDefinition".equals(codeString)) 20324 return VersionIndependentResourceTypesAll.DEVICEDEFINITION; 20325 if ("DeviceDispense".equals(codeString)) 20326 return VersionIndependentResourceTypesAll.DEVICEDISPENSE; 20327 if ("DeviceMetric".equals(codeString)) 20328 return VersionIndependentResourceTypesAll.DEVICEMETRIC; 20329 if ("DeviceRequest".equals(codeString)) 20330 return VersionIndependentResourceTypesAll.DEVICEREQUEST; 20331 if ("DeviceUsage".equals(codeString)) 20332 return VersionIndependentResourceTypesAll.DEVICEUSAGE; 20333 if ("DiagnosticReport".equals(codeString)) 20334 return VersionIndependentResourceTypesAll.DIAGNOSTICREPORT; 20335 if ("DocumentReference".equals(codeString)) 20336 return VersionIndependentResourceTypesAll.DOCUMENTREFERENCE; 20337 if ("DomainResource".equals(codeString)) 20338 return VersionIndependentResourceTypesAll.DOMAINRESOURCE; 20339 if ("Encounter".equals(codeString)) 20340 return VersionIndependentResourceTypesAll.ENCOUNTER; 20341 if ("EncounterHistory".equals(codeString)) 20342 return VersionIndependentResourceTypesAll.ENCOUNTERHISTORY; 20343 if ("Endpoint".equals(codeString)) 20344 return VersionIndependentResourceTypesAll.ENDPOINT; 20345 if ("EnrollmentRequest".equals(codeString)) 20346 return VersionIndependentResourceTypesAll.ENROLLMENTREQUEST; 20347 if ("EnrollmentResponse".equals(codeString)) 20348 return VersionIndependentResourceTypesAll.ENROLLMENTRESPONSE; 20349 if ("EpisodeOfCare".equals(codeString)) 20350 return VersionIndependentResourceTypesAll.EPISODEOFCARE; 20351 if ("EventDefinition".equals(codeString)) 20352 return VersionIndependentResourceTypesAll.EVENTDEFINITION; 20353 if ("Evidence".equals(codeString)) 20354 return VersionIndependentResourceTypesAll.EVIDENCE; 20355 if ("EvidenceReport".equals(codeString)) 20356 return VersionIndependentResourceTypesAll.EVIDENCEREPORT; 20357 if ("EvidenceVariable".equals(codeString)) 20358 return VersionIndependentResourceTypesAll.EVIDENCEVARIABLE; 20359 if ("ExampleScenario".equals(codeString)) 20360 return VersionIndependentResourceTypesAll.EXAMPLESCENARIO; 20361 if ("ExplanationOfBenefit".equals(codeString)) 20362 return VersionIndependentResourceTypesAll.EXPLANATIONOFBENEFIT; 20363 if ("FamilyMemberHistory".equals(codeString)) 20364 return VersionIndependentResourceTypesAll.FAMILYMEMBERHISTORY; 20365 if ("Flag".equals(codeString)) 20366 return VersionIndependentResourceTypesAll.FLAG; 20367 if ("FormularyItem".equals(codeString)) 20368 return VersionIndependentResourceTypesAll.FORMULARYITEM; 20369 if ("GenomicStudy".equals(codeString)) 20370 return VersionIndependentResourceTypesAll.GENOMICSTUDY; 20371 if ("Goal".equals(codeString)) 20372 return VersionIndependentResourceTypesAll.GOAL; 20373 if ("GraphDefinition".equals(codeString)) 20374 return VersionIndependentResourceTypesAll.GRAPHDEFINITION; 20375 if ("Group".equals(codeString)) 20376 return VersionIndependentResourceTypesAll.GROUP; 20377 if ("GuidanceResponse".equals(codeString)) 20378 return VersionIndependentResourceTypesAll.GUIDANCERESPONSE; 20379 if ("HealthcareService".equals(codeString)) 20380 return VersionIndependentResourceTypesAll.HEALTHCARESERVICE; 20381 if ("ImagingSelection".equals(codeString)) 20382 return VersionIndependentResourceTypesAll.IMAGINGSELECTION; 20383 if ("ImagingStudy".equals(codeString)) 20384 return VersionIndependentResourceTypesAll.IMAGINGSTUDY; 20385 if ("Immunization".equals(codeString)) 20386 return VersionIndependentResourceTypesAll.IMMUNIZATION; 20387 if ("ImmunizationEvaluation".equals(codeString)) 20388 return VersionIndependentResourceTypesAll.IMMUNIZATIONEVALUATION; 20389 if ("ImmunizationRecommendation".equals(codeString)) 20390 return VersionIndependentResourceTypesAll.IMMUNIZATIONRECOMMENDATION; 20391 if ("ImplementationGuide".equals(codeString)) 20392 return VersionIndependentResourceTypesAll.IMPLEMENTATIONGUIDE; 20393 if ("Ingredient".equals(codeString)) 20394 return VersionIndependentResourceTypesAll.INGREDIENT; 20395 if ("InsurancePlan".equals(codeString)) 20396 return VersionIndependentResourceTypesAll.INSURANCEPLAN; 20397 if ("InventoryItem".equals(codeString)) 20398 return VersionIndependentResourceTypesAll.INVENTORYITEM; 20399 if ("InventoryReport".equals(codeString)) 20400 return VersionIndependentResourceTypesAll.INVENTORYREPORT; 20401 if ("Invoice".equals(codeString)) 20402 return VersionIndependentResourceTypesAll.INVOICE; 20403 if ("Library".equals(codeString)) 20404 return VersionIndependentResourceTypesAll.LIBRARY; 20405 if ("Linkage".equals(codeString)) 20406 return VersionIndependentResourceTypesAll.LINKAGE; 20407 if ("List".equals(codeString)) 20408 return VersionIndependentResourceTypesAll.LIST; 20409 if ("Location".equals(codeString)) 20410 return VersionIndependentResourceTypesAll.LOCATION; 20411 if ("ManufacturedItemDefinition".equals(codeString)) 20412 return VersionIndependentResourceTypesAll.MANUFACTUREDITEMDEFINITION; 20413 if ("Measure".equals(codeString)) 20414 return VersionIndependentResourceTypesAll.MEASURE; 20415 if ("MeasureReport".equals(codeString)) 20416 return VersionIndependentResourceTypesAll.MEASUREREPORT; 20417 if ("Medication".equals(codeString)) 20418 return VersionIndependentResourceTypesAll.MEDICATION; 20419 if ("MedicationAdministration".equals(codeString)) 20420 return VersionIndependentResourceTypesAll.MEDICATIONADMINISTRATION; 20421 if ("MedicationDispense".equals(codeString)) 20422 return VersionIndependentResourceTypesAll.MEDICATIONDISPENSE; 20423 if ("MedicationKnowledge".equals(codeString)) 20424 return VersionIndependentResourceTypesAll.MEDICATIONKNOWLEDGE; 20425 if ("MedicationRequest".equals(codeString)) 20426 return VersionIndependentResourceTypesAll.MEDICATIONREQUEST; 20427 if ("MedicationStatement".equals(codeString)) 20428 return VersionIndependentResourceTypesAll.MEDICATIONSTATEMENT; 20429 if ("MedicinalProductDefinition".equals(codeString)) 20430 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTDEFINITION; 20431 if ("MessageDefinition".equals(codeString)) 20432 return VersionIndependentResourceTypesAll.MESSAGEDEFINITION; 20433 if ("MessageHeader".equals(codeString)) 20434 return VersionIndependentResourceTypesAll.MESSAGEHEADER; 20435 if ("MetadataResource".equals(codeString)) 20436 return VersionIndependentResourceTypesAll.METADATARESOURCE; 20437 if ("MolecularSequence".equals(codeString)) 20438 return VersionIndependentResourceTypesAll.MOLECULARSEQUENCE; 20439 if ("NamingSystem".equals(codeString)) 20440 return VersionIndependentResourceTypesAll.NAMINGSYSTEM; 20441 if ("NutritionIntake".equals(codeString)) 20442 return VersionIndependentResourceTypesAll.NUTRITIONINTAKE; 20443 if ("NutritionOrder".equals(codeString)) 20444 return VersionIndependentResourceTypesAll.NUTRITIONORDER; 20445 if ("NutritionProduct".equals(codeString)) 20446 return VersionIndependentResourceTypesAll.NUTRITIONPRODUCT; 20447 if ("Observation".equals(codeString)) 20448 return VersionIndependentResourceTypesAll.OBSERVATION; 20449 if ("ObservationDefinition".equals(codeString)) 20450 return VersionIndependentResourceTypesAll.OBSERVATIONDEFINITION; 20451 if ("OperationDefinition".equals(codeString)) 20452 return VersionIndependentResourceTypesAll.OPERATIONDEFINITION; 20453 if ("OperationOutcome".equals(codeString)) 20454 return VersionIndependentResourceTypesAll.OPERATIONOUTCOME; 20455 if ("Organization".equals(codeString)) 20456 return VersionIndependentResourceTypesAll.ORGANIZATION; 20457 if ("OrganizationAffiliation".equals(codeString)) 20458 return VersionIndependentResourceTypesAll.ORGANIZATIONAFFILIATION; 20459 if ("PackagedProductDefinition".equals(codeString)) 20460 return VersionIndependentResourceTypesAll.PACKAGEDPRODUCTDEFINITION; 20461 if ("Parameters".equals(codeString)) 20462 return VersionIndependentResourceTypesAll.PARAMETERS; 20463 if ("Patient".equals(codeString)) 20464 return VersionIndependentResourceTypesAll.PATIENT; 20465 if ("PaymentNotice".equals(codeString)) 20466 return VersionIndependentResourceTypesAll.PAYMENTNOTICE; 20467 if ("PaymentReconciliation".equals(codeString)) 20468 return VersionIndependentResourceTypesAll.PAYMENTRECONCILIATION; 20469 if ("Permission".equals(codeString)) 20470 return VersionIndependentResourceTypesAll.PERMISSION; 20471 if ("Person".equals(codeString)) 20472 return VersionIndependentResourceTypesAll.PERSON; 20473 if ("PlanDefinition".equals(codeString)) 20474 return VersionIndependentResourceTypesAll.PLANDEFINITION; 20475 if ("Practitioner".equals(codeString)) 20476 return VersionIndependentResourceTypesAll.PRACTITIONER; 20477 if ("PractitionerRole".equals(codeString)) 20478 return VersionIndependentResourceTypesAll.PRACTITIONERROLE; 20479 if ("Procedure".equals(codeString)) 20480 return VersionIndependentResourceTypesAll.PROCEDURE; 20481 if ("Provenance".equals(codeString)) 20482 return VersionIndependentResourceTypesAll.PROVENANCE; 20483 if ("Questionnaire".equals(codeString)) 20484 return VersionIndependentResourceTypesAll.QUESTIONNAIRE; 20485 if ("QuestionnaireResponse".equals(codeString)) 20486 return VersionIndependentResourceTypesAll.QUESTIONNAIRERESPONSE; 20487 if ("RegulatedAuthorization".equals(codeString)) 20488 return VersionIndependentResourceTypesAll.REGULATEDAUTHORIZATION; 20489 if ("RelatedPerson".equals(codeString)) 20490 return VersionIndependentResourceTypesAll.RELATEDPERSON; 20491 if ("RequestOrchestration".equals(codeString)) 20492 return VersionIndependentResourceTypesAll.REQUESTORCHESTRATION; 20493 if ("Requirements".equals(codeString)) 20494 return VersionIndependentResourceTypesAll.REQUIREMENTS; 20495 if ("ResearchStudy".equals(codeString)) 20496 return VersionIndependentResourceTypesAll.RESEARCHSTUDY; 20497 if ("ResearchSubject".equals(codeString)) 20498 return VersionIndependentResourceTypesAll.RESEARCHSUBJECT; 20499 if ("Resource".equals(codeString)) 20500 return VersionIndependentResourceTypesAll.RESOURCE; 20501 if ("RiskAssessment".equals(codeString)) 20502 return VersionIndependentResourceTypesAll.RISKASSESSMENT; 20503 if ("Schedule".equals(codeString)) 20504 return VersionIndependentResourceTypesAll.SCHEDULE; 20505 if ("SearchParameter".equals(codeString)) 20506 return VersionIndependentResourceTypesAll.SEARCHPARAMETER; 20507 if ("ServiceRequest".equals(codeString)) 20508 return VersionIndependentResourceTypesAll.SERVICEREQUEST; 20509 if ("Slot".equals(codeString)) 20510 return VersionIndependentResourceTypesAll.SLOT; 20511 if ("Specimen".equals(codeString)) 20512 return VersionIndependentResourceTypesAll.SPECIMEN; 20513 if ("SpecimenDefinition".equals(codeString)) 20514 return VersionIndependentResourceTypesAll.SPECIMENDEFINITION; 20515 if ("StructureDefinition".equals(codeString)) 20516 return VersionIndependentResourceTypesAll.STRUCTUREDEFINITION; 20517 if ("StructureMap".equals(codeString)) 20518 return VersionIndependentResourceTypesAll.STRUCTUREMAP; 20519 if ("Subscription".equals(codeString)) 20520 return VersionIndependentResourceTypesAll.SUBSCRIPTION; 20521 if ("SubscriptionStatus".equals(codeString)) 20522 return VersionIndependentResourceTypesAll.SUBSCRIPTIONSTATUS; 20523 if ("SubscriptionTopic".equals(codeString)) 20524 return VersionIndependentResourceTypesAll.SUBSCRIPTIONTOPIC; 20525 if ("Substance".equals(codeString)) 20526 return VersionIndependentResourceTypesAll.SUBSTANCE; 20527 if ("SubstanceDefinition".equals(codeString)) 20528 return VersionIndependentResourceTypesAll.SUBSTANCEDEFINITION; 20529 if ("SubstanceNucleicAcid".equals(codeString)) 20530 return VersionIndependentResourceTypesAll.SUBSTANCENUCLEICACID; 20531 if ("SubstancePolymer".equals(codeString)) 20532 return VersionIndependentResourceTypesAll.SUBSTANCEPOLYMER; 20533 if ("SubstanceProtein".equals(codeString)) 20534 return VersionIndependentResourceTypesAll.SUBSTANCEPROTEIN; 20535 if ("SubstanceReferenceInformation".equals(codeString)) 20536 return VersionIndependentResourceTypesAll.SUBSTANCEREFERENCEINFORMATION; 20537 if ("SubstanceSourceMaterial".equals(codeString)) 20538 return VersionIndependentResourceTypesAll.SUBSTANCESOURCEMATERIAL; 20539 if ("SupplyDelivery".equals(codeString)) 20540 return VersionIndependentResourceTypesAll.SUPPLYDELIVERY; 20541 if ("SupplyRequest".equals(codeString)) 20542 return VersionIndependentResourceTypesAll.SUPPLYREQUEST; 20543 if ("Task".equals(codeString)) 20544 return VersionIndependentResourceTypesAll.TASK; 20545 if ("TerminologyCapabilities".equals(codeString)) 20546 return VersionIndependentResourceTypesAll.TERMINOLOGYCAPABILITIES; 20547 if ("TestPlan".equals(codeString)) 20548 return VersionIndependentResourceTypesAll.TESTPLAN; 20549 if ("TestReport".equals(codeString)) 20550 return VersionIndependentResourceTypesAll.TESTREPORT; 20551 if ("TestScript".equals(codeString)) 20552 return VersionIndependentResourceTypesAll.TESTSCRIPT; 20553 if ("Transport".equals(codeString)) 20554 return VersionIndependentResourceTypesAll.TRANSPORT; 20555 if ("ValueSet".equals(codeString)) 20556 return VersionIndependentResourceTypesAll.VALUESET; 20557 if ("VerificationResult".equals(codeString)) 20558 return VersionIndependentResourceTypesAll.VERIFICATIONRESULT; 20559 if ("VisionPrescription".equals(codeString)) 20560 return VersionIndependentResourceTypesAll.VISIONPRESCRIPTION; 20561 if ("BodySite".equals(codeString)) 20562 return VersionIndependentResourceTypesAll.BODYSITE; 20563 if ("CatalogEntry".equals(codeString)) 20564 return VersionIndependentResourceTypesAll.CATALOGENTRY; 20565 if ("Conformance".equals(codeString)) 20566 return VersionIndependentResourceTypesAll.CONFORMANCE; 20567 if ("DataElement".equals(codeString)) 20568 return VersionIndependentResourceTypesAll.DATAELEMENT; 20569 if ("DeviceComponent".equals(codeString)) 20570 return VersionIndependentResourceTypesAll.DEVICECOMPONENT; 20571 if ("DeviceUseRequest".equals(codeString)) 20572 return VersionIndependentResourceTypesAll.DEVICEUSEREQUEST; 20573 if ("DeviceUseStatement".equals(codeString)) 20574 return VersionIndependentResourceTypesAll.DEVICEUSESTATEMENT; 20575 if ("DiagnosticOrder".equals(codeString)) 20576 return VersionIndependentResourceTypesAll.DIAGNOSTICORDER; 20577 if ("DocumentManifest".equals(codeString)) 20578 return VersionIndependentResourceTypesAll.DOCUMENTMANIFEST; 20579 if ("EffectEvidenceSynthesis".equals(codeString)) 20580 return VersionIndependentResourceTypesAll.EFFECTEVIDENCESYNTHESIS; 20581 if ("EligibilityRequest".equals(codeString)) 20582 return VersionIndependentResourceTypesAll.ELIGIBILITYREQUEST; 20583 if ("EligibilityResponse".equals(codeString)) 20584 return VersionIndependentResourceTypesAll.ELIGIBILITYRESPONSE; 20585 if ("ExpansionProfile".equals(codeString)) 20586 return VersionIndependentResourceTypesAll.EXPANSIONPROFILE; 20587 if ("ImagingManifest".equals(codeString)) 20588 return VersionIndependentResourceTypesAll.IMAGINGMANIFEST; 20589 if ("ImagingObjectSelection".equals(codeString)) 20590 return VersionIndependentResourceTypesAll.IMAGINGOBJECTSELECTION; 20591 if ("Media".equals(codeString)) 20592 return VersionIndependentResourceTypesAll.MEDIA; 20593 if ("MedicationOrder".equals(codeString)) 20594 return VersionIndependentResourceTypesAll.MEDICATIONORDER; 20595 if ("MedicationUsage".equals(codeString)) 20596 return VersionIndependentResourceTypesAll.MEDICATIONUSAGE; 20597 if ("MedicinalProduct".equals(codeString)) 20598 return VersionIndependentResourceTypesAll.MEDICINALPRODUCT; 20599 if ("MedicinalProductAuthorization".equals(codeString)) 20600 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTAUTHORIZATION; 20601 if ("MedicinalProductContraindication".equals(codeString)) 20602 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTCONTRAINDICATION; 20603 if ("MedicinalProductIndication".equals(codeString)) 20604 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTINDICATION; 20605 if ("MedicinalProductIngredient".equals(codeString)) 20606 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTINGREDIENT; 20607 if ("MedicinalProductInteraction".equals(codeString)) 20608 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTINTERACTION; 20609 if ("MedicinalProductManufactured".equals(codeString)) 20610 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTMANUFACTURED; 20611 if ("MedicinalProductPackaged".equals(codeString)) 20612 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTPACKAGED; 20613 if ("MedicinalProductPharmaceutical".equals(codeString)) 20614 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTPHARMACEUTICAL; 20615 if ("MedicinalProductUndesirableEffect".equals(codeString)) 20616 return VersionIndependentResourceTypesAll.MEDICINALPRODUCTUNDESIRABLEEFFECT; 20617 if ("Order".equals(codeString)) 20618 return VersionIndependentResourceTypesAll.ORDER; 20619 if ("OrderResponse".equals(codeString)) 20620 return VersionIndependentResourceTypesAll.ORDERRESPONSE; 20621 if ("ProcedureRequest".equals(codeString)) 20622 return VersionIndependentResourceTypesAll.PROCEDUREREQUEST; 20623 if ("ProcessRequest".equals(codeString)) 20624 return VersionIndependentResourceTypesAll.PROCESSREQUEST; 20625 if ("ProcessResponse".equals(codeString)) 20626 return VersionIndependentResourceTypesAll.PROCESSRESPONSE; 20627 if ("ReferralRequest".equals(codeString)) 20628 return VersionIndependentResourceTypesAll.REFERRALREQUEST; 20629 if ("RequestGroup".equals(codeString)) 20630 return VersionIndependentResourceTypesAll.REQUESTGROUP; 20631 if ("ResearchDefinition".equals(codeString)) 20632 return VersionIndependentResourceTypesAll.RESEARCHDEFINITION; 20633 if ("ResearchElementDefinition".equals(codeString)) 20634 return VersionIndependentResourceTypesAll.RESEARCHELEMENTDEFINITION; 20635 if ("RiskEvidenceSynthesis".equals(codeString)) 20636 return VersionIndependentResourceTypesAll.RISKEVIDENCESYNTHESIS; 20637 if ("Sequence".equals(codeString)) 20638 return VersionIndependentResourceTypesAll.SEQUENCE; 20639 if ("ServiceDefinition".equals(codeString)) 20640 return VersionIndependentResourceTypesAll.SERVICEDEFINITION; 20641 if ("SubstanceSpecification".equals(codeString)) 20642 return VersionIndependentResourceTypesAll.SUBSTANCESPECIFICATION; 20643 throw new IllegalArgumentException("Unknown VersionIndependentResourceTypesAll code '"+codeString+"'"); 20644 } 20645 20646 public Enumeration<VersionIndependentResourceTypesAll> fromType(PrimitiveType<?> code) throws FHIRException { 20647 if (code == null) 20648 return null; 20649 if (code.isEmpty()) 20650 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.NULL, code); 20651 String codeString = ((PrimitiveType) code).asStringValue(); 20652 if (codeString == null || "".equals(codeString)) 20653 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.NULL, code); 20654 if ("Account".equals(codeString)) 20655 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ACCOUNT, code); 20656 if ("ActivityDefinition".equals(codeString)) 20657 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ACTIVITYDEFINITION, code); 20658 if ("ActorDefinition".equals(codeString)) 20659 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ACTORDEFINITION, code); 20660 if ("AdministrableProductDefinition".equals(codeString)) 20661 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ADMINISTRABLEPRODUCTDEFINITION, code); 20662 if ("AdverseEvent".equals(codeString)) 20663 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ADVERSEEVENT, code); 20664 if ("AllergyIntolerance".equals(codeString)) 20665 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ALLERGYINTOLERANCE, code); 20666 if ("Appointment".equals(codeString)) 20667 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.APPOINTMENT, code); 20668 if ("AppointmentResponse".equals(codeString)) 20669 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.APPOINTMENTRESPONSE, code); 20670 if ("ArtifactAssessment".equals(codeString)) 20671 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ARTIFACTASSESSMENT, code); 20672 if ("AuditEvent".equals(codeString)) 20673 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.AUDITEVENT, code); 20674 if ("Basic".equals(codeString)) 20675 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BASIC, code); 20676 if ("Binary".equals(codeString)) 20677 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BINARY, code); 20678 if ("BiologicallyDerivedProduct".equals(codeString)) 20679 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BIOLOGICALLYDERIVEDPRODUCT, code); 20680 if ("BiologicallyDerivedProductDispense".equals(codeString)) 20681 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BIOLOGICALLYDERIVEDPRODUCTDISPENSE, code); 20682 if ("BodyStructure".equals(codeString)) 20683 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BODYSTRUCTURE, code); 20684 if ("Bundle".equals(codeString)) 20685 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BUNDLE, code); 20686 if ("CanonicalResource".equals(codeString)) 20687 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CANONICALRESOURCE, code); 20688 if ("CapabilityStatement".equals(codeString)) 20689 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CAPABILITYSTATEMENT, code); 20690 if ("CarePlan".equals(codeString)) 20691 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CAREPLAN, code); 20692 if ("CareTeam".equals(codeString)) 20693 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CARETEAM, code); 20694 if ("ChargeItem".equals(codeString)) 20695 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CHARGEITEM, code); 20696 if ("ChargeItemDefinition".equals(codeString)) 20697 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CHARGEITEMDEFINITION, code); 20698 if ("Citation".equals(codeString)) 20699 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CITATION, code); 20700 if ("Claim".equals(codeString)) 20701 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CLAIM, code); 20702 if ("ClaimResponse".equals(codeString)) 20703 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CLAIMRESPONSE, code); 20704 if ("ClinicalImpression".equals(codeString)) 20705 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CLINICALIMPRESSION, code); 20706 if ("ClinicalUseDefinition".equals(codeString)) 20707 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CLINICALUSEDEFINITION, code); 20708 if ("CodeSystem".equals(codeString)) 20709 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CODESYSTEM, code); 20710 if ("Communication".equals(codeString)) 20711 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COMMUNICATION, code); 20712 if ("CommunicationRequest".equals(codeString)) 20713 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COMMUNICATIONREQUEST, code); 20714 if ("CompartmentDefinition".equals(codeString)) 20715 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COMPARTMENTDEFINITION, code); 20716 if ("Composition".equals(codeString)) 20717 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COMPOSITION, code); 20718 if ("ConceptMap".equals(codeString)) 20719 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CONCEPTMAP, code); 20720 if ("Condition".equals(codeString)) 20721 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CONDITION, code); 20722 if ("ConditionDefinition".equals(codeString)) 20723 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CONDITIONDEFINITION, code); 20724 if ("Consent".equals(codeString)) 20725 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CONSENT, code); 20726 if ("Contract".equals(codeString)) 20727 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CONTRACT, code); 20728 if ("Coverage".equals(codeString)) 20729 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COVERAGE, code); 20730 if ("CoverageEligibilityRequest".equals(codeString)) 20731 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COVERAGEELIGIBILITYREQUEST, code); 20732 if ("CoverageEligibilityResponse".equals(codeString)) 20733 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.COVERAGEELIGIBILITYRESPONSE, code); 20734 if ("DetectedIssue".equals(codeString)) 20735 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DETECTEDISSUE, code); 20736 if ("Device".equals(codeString)) 20737 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICE, code); 20738 if ("DeviceAssociation".equals(codeString)) 20739 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEASSOCIATION, code); 20740 if ("DeviceDefinition".equals(codeString)) 20741 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEDEFINITION, code); 20742 if ("DeviceDispense".equals(codeString)) 20743 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEDISPENSE, code); 20744 if ("DeviceMetric".equals(codeString)) 20745 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEMETRIC, code); 20746 if ("DeviceRequest".equals(codeString)) 20747 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEREQUEST, code); 20748 if ("DeviceUsage".equals(codeString)) 20749 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEUSAGE, code); 20750 if ("DiagnosticReport".equals(codeString)) 20751 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DIAGNOSTICREPORT, code); 20752 if ("DocumentReference".equals(codeString)) 20753 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DOCUMENTREFERENCE, code); 20754 if ("DomainResource".equals(codeString)) 20755 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DOMAINRESOURCE, code); 20756 if ("Encounter".equals(codeString)) 20757 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ENCOUNTER, code); 20758 if ("EncounterHistory".equals(codeString)) 20759 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ENCOUNTERHISTORY, code); 20760 if ("Endpoint".equals(codeString)) 20761 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ENDPOINT, code); 20762 if ("EnrollmentRequest".equals(codeString)) 20763 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ENROLLMENTREQUEST, code); 20764 if ("EnrollmentResponse".equals(codeString)) 20765 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ENROLLMENTRESPONSE, code); 20766 if ("EpisodeOfCare".equals(codeString)) 20767 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EPISODEOFCARE, code); 20768 if ("EventDefinition".equals(codeString)) 20769 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EVENTDEFINITION, code); 20770 if ("Evidence".equals(codeString)) 20771 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EVIDENCE, code); 20772 if ("EvidenceReport".equals(codeString)) 20773 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EVIDENCEREPORT, code); 20774 if ("EvidenceVariable".equals(codeString)) 20775 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EVIDENCEVARIABLE, code); 20776 if ("ExampleScenario".equals(codeString)) 20777 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EXAMPLESCENARIO, code); 20778 if ("ExplanationOfBenefit".equals(codeString)) 20779 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EXPLANATIONOFBENEFIT, code); 20780 if ("FamilyMemberHistory".equals(codeString)) 20781 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.FAMILYMEMBERHISTORY, code); 20782 if ("Flag".equals(codeString)) 20783 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.FLAG, code); 20784 if ("FormularyItem".equals(codeString)) 20785 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.FORMULARYITEM, code); 20786 if ("GenomicStudy".equals(codeString)) 20787 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.GENOMICSTUDY, code); 20788 if ("Goal".equals(codeString)) 20789 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.GOAL, code); 20790 if ("GraphDefinition".equals(codeString)) 20791 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.GRAPHDEFINITION, code); 20792 if ("Group".equals(codeString)) 20793 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.GROUP, code); 20794 if ("GuidanceResponse".equals(codeString)) 20795 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.GUIDANCERESPONSE, code); 20796 if ("HealthcareService".equals(codeString)) 20797 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.HEALTHCARESERVICE, code); 20798 if ("ImagingSelection".equals(codeString)) 20799 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMAGINGSELECTION, code); 20800 if ("ImagingStudy".equals(codeString)) 20801 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMAGINGSTUDY, code); 20802 if ("Immunization".equals(codeString)) 20803 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMMUNIZATION, code); 20804 if ("ImmunizationEvaluation".equals(codeString)) 20805 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMMUNIZATIONEVALUATION, code); 20806 if ("ImmunizationRecommendation".equals(codeString)) 20807 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMMUNIZATIONRECOMMENDATION, code); 20808 if ("ImplementationGuide".equals(codeString)) 20809 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMPLEMENTATIONGUIDE, code); 20810 if ("Ingredient".equals(codeString)) 20811 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.INGREDIENT, code); 20812 if ("InsurancePlan".equals(codeString)) 20813 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.INSURANCEPLAN, code); 20814 if ("InventoryItem".equals(codeString)) 20815 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.INVENTORYITEM, code); 20816 if ("InventoryReport".equals(codeString)) 20817 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.INVENTORYREPORT, code); 20818 if ("Invoice".equals(codeString)) 20819 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.INVOICE, code); 20820 if ("Library".equals(codeString)) 20821 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.LIBRARY, code); 20822 if ("Linkage".equals(codeString)) 20823 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.LINKAGE, code); 20824 if ("List".equals(codeString)) 20825 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.LIST, code); 20826 if ("Location".equals(codeString)) 20827 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.LOCATION, code); 20828 if ("ManufacturedItemDefinition".equals(codeString)) 20829 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MANUFACTUREDITEMDEFINITION, code); 20830 if ("Measure".equals(codeString)) 20831 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEASURE, code); 20832 if ("MeasureReport".equals(codeString)) 20833 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEASUREREPORT, code); 20834 if ("Medication".equals(codeString)) 20835 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATION, code); 20836 if ("MedicationAdministration".equals(codeString)) 20837 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONADMINISTRATION, code); 20838 if ("MedicationDispense".equals(codeString)) 20839 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONDISPENSE, code); 20840 if ("MedicationKnowledge".equals(codeString)) 20841 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONKNOWLEDGE, code); 20842 if ("MedicationRequest".equals(codeString)) 20843 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONREQUEST, code); 20844 if ("MedicationStatement".equals(codeString)) 20845 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONSTATEMENT, code); 20846 if ("MedicinalProductDefinition".equals(codeString)) 20847 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTDEFINITION, code); 20848 if ("MessageDefinition".equals(codeString)) 20849 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MESSAGEDEFINITION, code); 20850 if ("MessageHeader".equals(codeString)) 20851 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MESSAGEHEADER, code); 20852 if ("MetadataResource".equals(codeString)) 20853 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.METADATARESOURCE, code); 20854 if ("MolecularSequence".equals(codeString)) 20855 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MOLECULARSEQUENCE, code); 20856 if ("NamingSystem".equals(codeString)) 20857 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.NAMINGSYSTEM, code); 20858 if ("NutritionIntake".equals(codeString)) 20859 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.NUTRITIONINTAKE, code); 20860 if ("NutritionOrder".equals(codeString)) 20861 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.NUTRITIONORDER, code); 20862 if ("NutritionProduct".equals(codeString)) 20863 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.NUTRITIONPRODUCT, code); 20864 if ("Observation".equals(codeString)) 20865 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.OBSERVATION, code); 20866 if ("ObservationDefinition".equals(codeString)) 20867 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.OBSERVATIONDEFINITION, code); 20868 if ("OperationDefinition".equals(codeString)) 20869 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.OPERATIONDEFINITION, code); 20870 if ("OperationOutcome".equals(codeString)) 20871 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.OPERATIONOUTCOME, code); 20872 if ("Organization".equals(codeString)) 20873 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ORGANIZATION, code); 20874 if ("OrganizationAffiliation".equals(codeString)) 20875 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ORGANIZATIONAFFILIATION, code); 20876 if ("PackagedProductDefinition".equals(codeString)) 20877 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PACKAGEDPRODUCTDEFINITION, code); 20878 if ("Parameters".equals(codeString)) 20879 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PARAMETERS, code); 20880 if ("Patient".equals(codeString)) 20881 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PATIENT, code); 20882 if ("PaymentNotice".equals(codeString)) 20883 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PAYMENTNOTICE, code); 20884 if ("PaymentReconciliation".equals(codeString)) 20885 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PAYMENTRECONCILIATION, code); 20886 if ("Permission".equals(codeString)) 20887 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PERMISSION, code); 20888 if ("Person".equals(codeString)) 20889 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PERSON, code); 20890 if ("PlanDefinition".equals(codeString)) 20891 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PLANDEFINITION, code); 20892 if ("Practitioner".equals(codeString)) 20893 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PRACTITIONER, code); 20894 if ("PractitionerRole".equals(codeString)) 20895 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PRACTITIONERROLE, code); 20896 if ("Procedure".equals(codeString)) 20897 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PROCEDURE, code); 20898 if ("Provenance".equals(codeString)) 20899 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PROVENANCE, code); 20900 if ("Questionnaire".equals(codeString)) 20901 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.QUESTIONNAIRE, code); 20902 if ("QuestionnaireResponse".equals(codeString)) 20903 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.QUESTIONNAIRERESPONSE, code); 20904 if ("RegulatedAuthorization".equals(codeString)) 20905 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.REGULATEDAUTHORIZATION, code); 20906 if ("RelatedPerson".equals(codeString)) 20907 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RELATEDPERSON, code); 20908 if ("RequestOrchestration".equals(codeString)) 20909 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.REQUESTORCHESTRATION, code); 20910 if ("Requirements".equals(codeString)) 20911 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.REQUIREMENTS, code); 20912 if ("ResearchStudy".equals(codeString)) 20913 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RESEARCHSTUDY, code); 20914 if ("ResearchSubject".equals(codeString)) 20915 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RESEARCHSUBJECT, code); 20916 if ("Resource".equals(codeString)) 20917 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RESOURCE, code); 20918 if ("RiskAssessment".equals(codeString)) 20919 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RISKASSESSMENT, code); 20920 if ("Schedule".equals(codeString)) 20921 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SCHEDULE, code); 20922 if ("SearchParameter".equals(codeString)) 20923 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SEARCHPARAMETER, code); 20924 if ("ServiceRequest".equals(codeString)) 20925 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SERVICEREQUEST, code); 20926 if ("Slot".equals(codeString)) 20927 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SLOT, code); 20928 if ("Specimen".equals(codeString)) 20929 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SPECIMEN, code); 20930 if ("SpecimenDefinition".equals(codeString)) 20931 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SPECIMENDEFINITION, code); 20932 if ("StructureDefinition".equals(codeString)) 20933 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.STRUCTUREDEFINITION, code); 20934 if ("StructureMap".equals(codeString)) 20935 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.STRUCTUREMAP, code); 20936 if ("Subscription".equals(codeString)) 20937 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSCRIPTION, code); 20938 if ("SubscriptionStatus".equals(codeString)) 20939 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSCRIPTIONSTATUS, code); 20940 if ("SubscriptionTopic".equals(codeString)) 20941 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSCRIPTIONTOPIC, code); 20942 if ("Substance".equals(codeString)) 20943 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCE, code); 20944 if ("SubstanceDefinition".equals(codeString)) 20945 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCEDEFINITION, code); 20946 if ("SubstanceNucleicAcid".equals(codeString)) 20947 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCENUCLEICACID, code); 20948 if ("SubstancePolymer".equals(codeString)) 20949 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCEPOLYMER, code); 20950 if ("SubstanceProtein".equals(codeString)) 20951 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCEPROTEIN, code); 20952 if ("SubstanceReferenceInformation".equals(codeString)) 20953 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCEREFERENCEINFORMATION, code); 20954 if ("SubstanceSourceMaterial".equals(codeString)) 20955 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCESOURCEMATERIAL, code); 20956 if ("SupplyDelivery".equals(codeString)) 20957 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUPPLYDELIVERY, code); 20958 if ("SupplyRequest".equals(codeString)) 20959 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUPPLYREQUEST, code); 20960 if ("Task".equals(codeString)) 20961 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.TASK, code); 20962 if ("TerminologyCapabilities".equals(codeString)) 20963 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.TERMINOLOGYCAPABILITIES, code); 20964 if ("TestPlan".equals(codeString)) 20965 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.TESTPLAN, code); 20966 if ("TestReport".equals(codeString)) 20967 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.TESTREPORT, code); 20968 if ("TestScript".equals(codeString)) 20969 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.TESTSCRIPT, code); 20970 if ("Transport".equals(codeString)) 20971 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.TRANSPORT, code); 20972 if ("ValueSet".equals(codeString)) 20973 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.VALUESET, code); 20974 if ("VerificationResult".equals(codeString)) 20975 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.VERIFICATIONRESULT, code); 20976 if ("VisionPrescription".equals(codeString)) 20977 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.VISIONPRESCRIPTION, code); 20978 if ("BodySite".equals(codeString)) 20979 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.BODYSITE, code); 20980 if ("CatalogEntry".equals(codeString)) 20981 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CATALOGENTRY, code); 20982 if ("Conformance".equals(codeString)) 20983 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.CONFORMANCE, code); 20984 if ("DataElement".equals(codeString)) 20985 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DATAELEMENT, code); 20986 if ("DeviceComponent".equals(codeString)) 20987 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICECOMPONENT, code); 20988 if ("DeviceUseRequest".equals(codeString)) 20989 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEUSEREQUEST, code); 20990 if ("DeviceUseStatement".equals(codeString)) 20991 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DEVICEUSESTATEMENT, code); 20992 if ("DiagnosticOrder".equals(codeString)) 20993 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DIAGNOSTICORDER, code); 20994 if ("DocumentManifest".equals(codeString)) 20995 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.DOCUMENTMANIFEST, code); 20996 if ("EffectEvidenceSynthesis".equals(codeString)) 20997 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EFFECTEVIDENCESYNTHESIS, code); 20998 if ("EligibilityRequest".equals(codeString)) 20999 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ELIGIBILITYREQUEST, code); 21000 if ("EligibilityResponse".equals(codeString)) 21001 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ELIGIBILITYRESPONSE, code); 21002 if ("ExpansionProfile".equals(codeString)) 21003 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.EXPANSIONPROFILE, code); 21004 if ("ImagingManifest".equals(codeString)) 21005 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMAGINGMANIFEST, code); 21006 if ("ImagingObjectSelection".equals(codeString)) 21007 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.IMAGINGOBJECTSELECTION, code); 21008 if ("Media".equals(codeString)) 21009 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDIA, code); 21010 if ("MedicationOrder".equals(codeString)) 21011 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONORDER, code); 21012 if ("MedicationUsage".equals(codeString)) 21013 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICATIONUSAGE, code); 21014 if ("MedicinalProduct".equals(codeString)) 21015 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCT, code); 21016 if ("MedicinalProductAuthorization".equals(codeString)) 21017 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTAUTHORIZATION, code); 21018 if ("MedicinalProductContraindication".equals(codeString)) 21019 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTCONTRAINDICATION, code); 21020 if ("MedicinalProductIndication".equals(codeString)) 21021 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTINDICATION, code); 21022 if ("MedicinalProductIngredient".equals(codeString)) 21023 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTINGREDIENT, code); 21024 if ("MedicinalProductInteraction".equals(codeString)) 21025 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTINTERACTION, code); 21026 if ("MedicinalProductManufactured".equals(codeString)) 21027 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTMANUFACTURED, code); 21028 if ("MedicinalProductPackaged".equals(codeString)) 21029 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTPACKAGED, code); 21030 if ("MedicinalProductPharmaceutical".equals(codeString)) 21031 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTPHARMACEUTICAL, code); 21032 if ("MedicinalProductUndesirableEffect".equals(codeString)) 21033 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.MEDICINALPRODUCTUNDESIRABLEEFFECT, code); 21034 if ("Order".equals(codeString)) 21035 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ORDER, code); 21036 if ("OrderResponse".equals(codeString)) 21037 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.ORDERRESPONSE, code); 21038 if ("ProcedureRequest".equals(codeString)) 21039 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PROCEDUREREQUEST, code); 21040 if ("ProcessRequest".equals(codeString)) 21041 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PROCESSREQUEST, code); 21042 if ("ProcessResponse".equals(codeString)) 21043 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.PROCESSRESPONSE, code); 21044 if ("ReferralRequest".equals(codeString)) 21045 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.REFERRALREQUEST, code); 21046 if ("RequestGroup".equals(codeString)) 21047 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.REQUESTGROUP, code); 21048 if ("ResearchDefinition".equals(codeString)) 21049 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RESEARCHDEFINITION, code); 21050 if ("ResearchElementDefinition".equals(codeString)) 21051 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RESEARCHELEMENTDEFINITION, code); 21052 if ("RiskEvidenceSynthesis".equals(codeString)) 21053 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.RISKEVIDENCESYNTHESIS, code); 21054 if ("Sequence".equals(codeString)) 21055 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SEQUENCE, code); 21056 if ("ServiceDefinition".equals(codeString)) 21057 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SERVICEDEFINITION, code); 21058 if ("SubstanceSpecification".equals(codeString)) 21059 return new Enumeration<VersionIndependentResourceTypesAll>(this, VersionIndependentResourceTypesAll.SUBSTANCESPECIFICATION, code); 21060 throw new FHIRException("Unknown VersionIndependentResourceTypesAll code '"+codeString+"'"); 21061 } 21062 public String toCode(VersionIndependentResourceTypesAll code) { 21063 if (code == VersionIndependentResourceTypesAll.ACCOUNT) 21064 return "Account"; 21065 if (code == VersionIndependentResourceTypesAll.ACTIVITYDEFINITION) 21066 return "ActivityDefinition"; 21067 if (code == VersionIndependentResourceTypesAll.ACTORDEFINITION) 21068 return "ActorDefinition"; 21069 if (code == VersionIndependentResourceTypesAll.ADMINISTRABLEPRODUCTDEFINITION) 21070 return "AdministrableProductDefinition"; 21071 if (code == VersionIndependentResourceTypesAll.ADVERSEEVENT) 21072 return "AdverseEvent"; 21073 if (code == VersionIndependentResourceTypesAll.ALLERGYINTOLERANCE) 21074 return "AllergyIntolerance"; 21075 if (code == VersionIndependentResourceTypesAll.APPOINTMENT) 21076 return "Appointment"; 21077 if (code == VersionIndependentResourceTypesAll.APPOINTMENTRESPONSE) 21078 return "AppointmentResponse"; 21079 if (code == VersionIndependentResourceTypesAll.ARTIFACTASSESSMENT) 21080 return "ArtifactAssessment"; 21081 if (code == VersionIndependentResourceTypesAll.AUDITEVENT) 21082 return "AuditEvent"; 21083 if (code == VersionIndependentResourceTypesAll.BASIC) 21084 return "Basic"; 21085 if (code == VersionIndependentResourceTypesAll.BINARY) 21086 return "Binary"; 21087 if (code == VersionIndependentResourceTypesAll.BIOLOGICALLYDERIVEDPRODUCT) 21088 return "BiologicallyDerivedProduct"; 21089 if (code == VersionIndependentResourceTypesAll.BIOLOGICALLYDERIVEDPRODUCTDISPENSE) 21090 return "BiologicallyDerivedProductDispense"; 21091 if (code == VersionIndependentResourceTypesAll.BODYSTRUCTURE) 21092 return "BodyStructure"; 21093 if (code == VersionIndependentResourceTypesAll.BUNDLE) 21094 return "Bundle"; 21095 if (code == VersionIndependentResourceTypesAll.CANONICALRESOURCE) 21096 return "CanonicalResource"; 21097 if (code == VersionIndependentResourceTypesAll.CAPABILITYSTATEMENT) 21098 return "CapabilityStatement"; 21099 if (code == VersionIndependentResourceTypesAll.CAREPLAN) 21100 return "CarePlan"; 21101 if (code == VersionIndependentResourceTypesAll.CARETEAM) 21102 return "CareTeam"; 21103 if (code == VersionIndependentResourceTypesAll.CHARGEITEM) 21104 return "ChargeItem"; 21105 if (code == VersionIndependentResourceTypesAll.CHARGEITEMDEFINITION) 21106 return "ChargeItemDefinition"; 21107 if (code == VersionIndependentResourceTypesAll.CITATION) 21108 return "Citation"; 21109 if (code == VersionIndependentResourceTypesAll.CLAIM) 21110 return "Claim"; 21111 if (code == VersionIndependentResourceTypesAll.CLAIMRESPONSE) 21112 return "ClaimResponse"; 21113 if (code == VersionIndependentResourceTypesAll.CLINICALIMPRESSION) 21114 return "ClinicalImpression"; 21115 if (code == VersionIndependentResourceTypesAll.CLINICALUSEDEFINITION) 21116 return "ClinicalUseDefinition"; 21117 if (code == VersionIndependentResourceTypesAll.CODESYSTEM) 21118 return "CodeSystem"; 21119 if (code == VersionIndependentResourceTypesAll.COMMUNICATION) 21120 return "Communication"; 21121 if (code == VersionIndependentResourceTypesAll.COMMUNICATIONREQUEST) 21122 return "CommunicationRequest"; 21123 if (code == VersionIndependentResourceTypesAll.COMPARTMENTDEFINITION) 21124 return "CompartmentDefinition"; 21125 if (code == VersionIndependentResourceTypesAll.COMPOSITION) 21126 return "Composition"; 21127 if (code == VersionIndependentResourceTypesAll.CONCEPTMAP) 21128 return "ConceptMap"; 21129 if (code == VersionIndependentResourceTypesAll.CONDITION) 21130 return "Condition"; 21131 if (code == VersionIndependentResourceTypesAll.CONDITIONDEFINITION) 21132 return "ConditionDefinition"; 21133 if (code == VersionIndependentResourceTypesAll.CONSENT) 21134 return "Consent"; 21135 if (code == VersionIndependentResourceTypesAll.CONTRACT) 21136 return "Contract"; 21137 if (code == VersionIndependentResourceTypesAll.COVERAGE) 21138 return "Coverage"; 21139 if (code == VersionIndependentResourceTypesAll.COVERAGEELIGIBILITYREQUEST) 21140 return "CoverageEligibilityRequest"; 21141 if (code == VersionIndependentResourceTypesAll.COVERAGEELIGIBILITYRESPONSE) 21142 return "CoverageEligibilityResponse"; 21143 if (code == VersionIndependentResourceTypesAll.DETECTEDISSUE) 21144 return "DetectedIssue"; 21145 if (code == VersionIndependentResourceTypesAll.DEVICE) 21146 return "Device"; 21147 if (code == VersionIndependentResourceTypesAll.DEVICEASSOCIATION) 21148 return "DeviceAssociation"; 21149 if (code == VersionIndependentResourceTypesAll.DEVICEDEFINITION) 21150 return "DeviceDefinition"; 21151 if (code == VersionIndependentResourceTypesAll.DEVICEDISPENSE) 21152 return "DeviceDispense"; 21153 if (code == VersionIndependentResourceTypesAll.DEVICEMETRIC) 21154 return "DeviceMetric"; 21155 if (code == VersionIndependentResourceTypesAll.DEVICEREQUEST) 21156 return "DeviceRequest"; 21157 if (code == VersionIndependentResourceTypesAll.DEVICEUSAGE) 21158 return "DeviceUsage"; 21159 if (code == VersionIndependentResourceTypesAll.DIAGNOSTICREPORT) 21160 return "DiagnosticReport"; 21161 if (code == VersionIndependentResourceTypesAll.DOCUMENTREFERENCE) 21162 return "DocumentReference"; 21163 if (code == VersionIndependentResourceTypesAll.DOMAINRESOURCE) 21164 return "DomainResource"; 21165 if (code == VersionIndependentResourceTypesAll.ENCOUNTER) 21166 return "Encounter"; 21167 if (code == VersionIndependentResourceTypesAll.ENCOUNTERHISTORY) 21168 return "EncounterHistory"; 21169 if (code == VersionIndependentResourceTypesAll.ENDPOINT) 21170 return "Endpoint"; 21171 if (code == VersionIndependentResourceTypesAll.ENROLLMENTREQUEST) 21172 return "EnrollmentRequest"; 21173 if (code == VersionIndependentResourceTypesAll.ENROLLMENTRESPONSE) 21174 return "EnrollmentResponse"; 21175 if (code == VersionIndependentResourceTypesAll.EPISODEOFCARE) 21176 return "EpisodeOfCare"; 21177 if (code == VersionIndependentResourceTypesAll.EVENTDEFINITION) 21178 return "EventDefinition"; 21179 if (code == VersionIndependentResourceTypesAll.EVIDENCE) 21180 return "Evidence"; 21181 if (code == VersionIndependentResourceTypesAll.EVIDENCEREPORT) 21182 return "EvidenceReport"; 21183 if (code == VersionIndependentResourceTypesAll.EVIDENCEVARIABLE) 21184 return "EvidenceVariable"; 21185 if (code == VersionIndependentResourceTypesAll.EXAMPLESCENARIO) 21186 return "ExampleScenario"; 21187 if (code == VersionIndependentResourceTypesAll.EXPLANATIONOFBENEFIT) 21188 return "ExplanationOfBenefit"; 21189 if (code == VersionIndependentResourceTypesAll.FAMILYMEMBERHISTORY) 21190 return "FamilyMemberHistory"; 21191 if (code == VersionIndependentResourceTypesAll.FLAG) 21192 return "Flag"; 21193 if (code == VersionIndependentResourceTypesAll.FORMULARYITEM) 21194 return "FormularyItem"; 21195 if (code == VersionIndependentResourceTypesAll.GENOMICSTUDY) 21196 return "GenomicStudy"; 21197 if (code == VersionIndependentResourceTypesAll.GOAL) 21198 return "Goal"; 21199 if (code == VersionIndependentResourceTypesAll.GRAPHDEFINITION) 21200 return "GraphDefinition"; 21201 if (code == VersionIndependentResourceTypesAll.GROUP) 21202 return "Group"; 21203 if (code == VersionIndependentResourceTypesAll.GUIDANCERESPONSE) 21204 return "GuidanceResponse"; 21205 if (code == VersionIndependentResourceTypesAll.HEALTHCARESERVICE) 21206 return "HealthcareService"; 21207 if (code == VersionIndependentResourceTypesAll.IMAGINGSELECTION) 21208 return "ImagingSelection"; 21209 if (code == VersionIndependentResourceTypesAll.IMAGINGSTUDY) 21210 return "ImagingStudy"; 21211 if (code == VersionIndependentResourceTypesAll.IMMUNIZATION) 21212 return "Immunization"; 21213 if (code == VersionIndependentResourceTypesAll.IMMUNIZATIONEVALUATION) 21214 return "ImmunizationEvaluation"; 21215 if (code == VersionIndependentResourceTypesAll.IMMUNIZATIONRECOMMENDATION) 21216 return "ImmunizationRecommendation"; 21217 if (code == VersionIndependentResourceTypesAll.IMPLEMENTATIONGUIDE) 21218 return "ImplementationGuide"; 21219 if (code == VersionIndependentResourceTypesAll.INGREDIENT) 21220 return "Ingredient"; 21221 if (code == VersionIndependentResourceTypesAll.INSURANCEPLAN) 21222 return "InsurancePlan"; 21223 if (code == VersionIndependentResourceTypesAll.INVENTORYITEM) 21224 return "InventoryItem"; 21225 if (code == VersionIndependentResourceTypesAll.INVENTORYREPORT) 21226 return "InventoryReport"; 21227 if (code == VersionIndependentResourceTypesAll.INVOICE) 21228 return "Invoice"; 21229 if (code == VersionIndependentResourceTypesAll.LIBRARY) 21230 return "Library"; 21231 if (code == VersionIndependentResourceTypesAll.LINKAGE) 21232 return "Linkage"; 21233 if (code == VersionIndependentResourceTypesAll.LIST) 21234 return "List"; 21235 if (code == VersionIndependentResourceTypesAll.LOCATION) 21236 return "Location"; 21237 if (code == VersionIndependentResourceTypesAll.MANUFACTUREDITEMDEFINITION) 21238 return "ManufacturedItemDefinition"; 21239 if (code == VersionIndependentResourceTypesAll.MEASURE) 21240 return "Measure"; 21241 if (code == VersionIndependentResourceTypesAll.MEASUREREPORT) 21242 return "MeasureReport"; 21243 if (code == VersionIndependentResourceTypesAll.MEDICATION) 21244 return "Medication"; 21245 if (code == VersionIndependentResourceTypesAll.MEDICATIONADMINISTRATION) 21246 return "MedicationAdministration"; 21247 if (code == VersionIndependentResourceTypesAll.MEDICATIONDISPENSE) 21248 return "MedicationDispense"; 21249 if (code == VersionIndependentResourceTypesAll.MEDICATIONKNOWLEDGE) 21250 return "MedicationKnowledge"; 21251 if (code == VersionIndependentResourceTypesAll.MEDICATIONREQUEST) 21252 return "MedicationRequest"; 21253 if (code == VersionIndependentResourceTypesAll.MEDICATIONSTATEMENT) 21254 return "MedicationStatement"; 21255 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTDEFINITION) 21256 return "MedicinalProductDefinition"; 21257 if (code == VersionIndependentResourceTypesAll.MESSAGEDEFINITION) 21258 return "MessageDefinition"; 21259 if (code == VersionIndependentResourceTypesAll.MESSAGEHEADER) 21260 return "MessageHeader"; 21261 if (code == VersionIndependentResourceTypesAll.METADATARESOURCE) 21262 return "MetadataResource"; 21263 if (code == VersionIndependentResourceTypesAll.MOLECULARSEQUENCE) 21264 return "MolecularSequence"; 21265 if (code == VersionIndependentResourceTypesAll.NAMINGSYSTEM) 21266 return "NamingSystem"; 21267 if (code == VersionIndependentResourceTypesAll.NUTRITIONINTAKE) 21268 return "NutritionIntake"; 21269 if (code == VersionIndependentResourceTypesAll.NUTRITIONORDER) 21270 return "NutritionOrder"; 21271 if (code == VersionIndependentResourceTypesAll.NUTRITIONPRODUCT) 21272 return "NutritionProduct"; 21273 if (code == VersionIndependentResourceTypesAll.OBSERVATION) 21274 return "Observation"; 21275 if (code == VersionIndependentResourceTypesAll.OBSERVATIONDEFINITION) 21276 return "ObservationDefinition"; 21277 if (code == VersionIndependentResourceTypesAll.OPERATIONDEFINITION) 21278 return "OperationDefinition"; 21279 if (code == VersionIndependentResourceTypesAll.OPERATIONOUTCOME) 21280 return "OperationOutcome"; 21281 if (code == VersionIndependentResourceTypesAll.ORGANIZATION) 21282 return "Organization"; 21283 if (code == VersionIndependentResourceTypesAll.ORGANIZATIONAFFILIATION) 21284 return "OrganizationAffiliation"; 21285 if (code == VersionIndependentResourceTypesAll.PACKAGEDPRODUCTDEFINITION) 21286 return "PackagedProductDefinition"; 21287 if (code == VersionIndependentResourceTypesAll.PARAMETERS) 21288 return "Parameters"; 21289 if (code == VersionIndependentResourceTypesAll.PATIENT) 21290 return "Patient"; 21291 if (code == VersionIndependentResourceTypesAll.PAYMENTNOTICE) 21292 return "PaymentNotice"; 21293 if (code == VersionIndependentResourceTypesAll.PAYMENTRECONCILIATION) 21294 return "PaymentReconciliation"; 21295 if (code == VersionIndependentResourceTypesAll.PERMISSION) 21296 return "Permission"; 21297 if (code == VersionIndependentResourceTypesAll.PERSON) 21298 return "Person"; 21299 if (code == VersionIndependentResourceTypesAll.PLANDEFINITION) 21300 return "PlanDefinition"; 21301 if (code == VersionIndependentResourceTypesAll.PRACTITIONER) 21302 return "Practitioner"; 21303 if (code == VersionIndependentResourceTypesAll.PRACTITIONERROLE) 21304 return "PractitionerRole"; 21305 if (code == VersionIndependentResourceTypesAll.PROCEDURE) 21306 return "Procedure"; 21307 if (code == VersionIndependentResourceTypesAll.PROVENANCE) 21308 return "Provenance"; 21309 if (code == VersionIndependentResourceTypesAll.QUESTIONNAIRE) 21310 return "Questionnaire"; 21311 if (code == VersionIndependentResourceTypesAll.QUESTIONNAIRERESPONSE) 21312 return "QuestionnaireResponse"; 21313 if (code == VersionIndependentResourceTypesAll.REGULATEDAUTHORIZATION) 21314 return "RegulatedAuthorization"; 21315 if (code == VersionIndependentResourceTypesAll.RELATEDPERSON) 21316 return "RelatedPerson"; 21317 if (code == VersionIndependentResourceTypesAll.REQUESTORCHESTRATION) 21318 return "RequestOrchestration"; 21319 if (code == VersionIndependentResourceTypesAll.REQUIREMENTS) 21320 return "Requirements"; 21321 if (code == VersionIndependentResourceTypesAll.RESEARCHSTUDY) 21322 return "ResearchStudy"; 21323 if (code == VersionIndependentResourceTypesAll.RESEARCHSUBJECT) 21324 return "ResearchSubject"; 21325 if (code == VersionIndependentResourceTypesAll.RESOURCE) 21326 return "Resource"; 21327 if (code == VersionIndependentResourceTypesAll.RISKASSESSMENT) 21328 return "RiskAssessment"; 21329 if (code == VersionIndependentResourceTypesAll.SCHEDULE) 21330 return "Schedule"; 21331 if (code == VersionIndependentResourceTypesAll.SEARCHPARAMETER) 21332 return "SearchParameter"; 21333 if (code == VersionIndependentResourceTypesAll.SERVICEREQUEST) 21334 return "ServiceRequest"; 21335 if (code == VersionIndependentResourceTypesAll.SLOT) 21336 return "Slot"; 21337 if (code == VersionIndependentResourceTypesAll.SPECIMEN) 21338 return "Specimen"; 21339 if (code == VersionIndependentResourceTypesAll.SPECIMENDEFINITION) 21340 return "SpecimenDefinition"; 21341 if (code == VersionIndependentResourceTypesAll.STRUCTUREDEFINITION) 21342 return "StructureDefinition"; 21343 if (code == VersionIndependentResourceTypesAll.STRUCTUREMAP) 21344 return "StructureMap"; 21345 if (code == VersionIndependentResourceTypesAll.SUBSCRIPTION) 21346 return "Subscription"; 21347 if (code == VersionIndependentResourceTypesAll.SUBSCRIPTIONSTATUS) 21348 return "SubscriptionStatus"; 21349 if (code == VersionIndependentResourceTypesAll.SUBSCRIPTIONTOPIC) 21350 return "SubscriptionTopic"; 21351 if (code == VersionIndependentResourceTypesAll.SUBSTANCE) 21352 return "Substance"; 21353 if (code == VersionIndependentResourceTypesAll.SUBSTANCEDEFINITION) 21354 return "SubstanceDefinition"; 21355 if (code == VersionIndependentResourceTypesAll.SUBSTANCENUCLEICACID) 21356 return "SubstanceNucleicAcid"; 21357 if (code == VersionIndependentResourceTypesAll.SUBSTANCEPOLYMER) 21358 return "SubstancePolymer"; 21359 if (code == VersionIndependentResourceTypesAll.SUBSTANCEPROTEIN) 21360 return "SubstanceProtein"; 21361 if (code == VersionIndependentResourceTypesAll.SUBSTANCEREFERENCEINFORMATION) 21362 return "SubstanceReferenceInformation"; 21363 if (code == VersionIndependentResourceTypesAll.SUBSTANCESOURCEMATERIAL) 21364 return "SubstanceSourceMaterial"; 21365 if (code == VersionIndependentResourceTypesAll.SUPPLYDELIVERY) 21366 return "SupplyDelivery"; 21367 if (code == VersionIndependentResourceTypesAll.SUPPLYREQUEST) 21368 return "SupplyRequest"; 21369 if (code == VersionIndependentResourceTypesAll.TASK) 21370 return "Task"; 21371 if (code == VersionIndependentResourceTypesAll.TERMINOLOGYCAPABILITIES) 21372 return "TerminologyCapabilities"; 21373 if (code == VersionIndependentResourceTypesAll.TESTPLAN) 21374 return "TestPlan"; 21375 if (code == VersionIndependentResourceTypesAll.TESTREPORT) 21376 return "TestReport"; 21377 if (code == VersionIndependentResourceTypesAll.TESTSCRIPT) 21378 return "TestScript"; 21379 if (code == VersionIndependentResourceTypesAll.TRANSPORT) 21380 return "Transport"; 21381 if (code == VersionIndependentResourceTypesAll.VALUESET) 21382 return "ValueSet"; 21383 if (code == VersionIndependentResourceTypesAll.VERIFICATIONRESULT) 21384 return "VerificationResult"; 21385 if (code == VersionIndependentResourceTypesAll.VISIONPRESCRIPTION) 21386 return "VisionPrescription"; 21387 if (code == VersionIndependentResourceTypesAll.BODYSITE) 21388 return "BodySite"; 21389 if (code == VersionIndependentResourceTypesAll.CATALOGENTRY) 21390 return "CatalogEntry"; 21391 if (code == VersionIndependentResourceTypesAll.CONFORMANCE) 21392 return "Conformance"; 21393 if (code == VersionIndependentResourceTypesAll.DATAELEMENT) 21394 return "DataElement"; 21395 if (code == VersionIndependentResourceTypesAll.DEVICECOMPONENT) 21396 return "DeviceComponent"; 21397 if (code == VersionIndependentResourceTypesAll.DEVICEUSEREQUEST) 21398 return "DeviceUseRequest"; 21399 if (code == VersionIndependentResourceTypesAll.DEVICEUSESTATEMENT) 21400 return "DeviceUseStatement"; 21401 if (code == VersionIndependentResourceTypesAll.DIAGNOSTICORDER) 21402 return "DiagnosticOrder"; 21403 if (code == VersionIndependentResourceTypesAll.DOCUMENTMANIFEST) 21404 return "DocumentManifest"; 21405 if (code == VersionIndependentResourceTypesAll.EFFECTEVIDENCESYNTHESIS) 21406 return "EffectEvidenceSynthesis"; 21407 if (code == VersionIndependentResourceTypesAll.ELIGIBILITYREQUEST) 21408 return "EligibilityRequest"; 21409 if (code == VersionIndependentResourceTypesAll.ELIGIBILITYRESPONSE) 21410 return "EligibilityResponse"; 21411 if (code == VersionIndependentResourceTypesAll.EXPANSIONPROFILE) 21412 return "ExpansionProfile"; 21413 if (code == VersionIndependentResourceTypesAll.IMAGINGMANIFEST) 21414 return "ImagingManifest"; 21415 if (code == VersionIndependentResourceTypesAll.IMAGINGOBJECTSELECTION) 21416 return "ImagingObjectSelection"; 21417 if (code == VersionIndependentResourceTypesAll.MEDIA) 21418 return "Media"; 21419 if (code == VersionIndependentResourceTypesAll.MEDICATIONORDER) 21420 return "MedicationOrder"; 21421 if (code == VersionIndependentResourceTypesAll.MEDICATIONUSAGE) 21422 return "MedicationUsage"; 21423 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCT) 21424 return "MedicinalProduct"; 21425 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTAUTHORIZATION) 21426 return "MedicinalProductAuthorization"; 21427 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTCONTRAINDICATION) 21428 return "MedicinalProductContraindication"; 21429 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTINDICATION) 21430 return "MedicinalProductIndication"; 21431 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTINGREDIENT) 21432 return "MedicinalProductIngredient"; 21433 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTINTERACTION) 21434 return "MedicinalProductInteraction"; 21435 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTMANUFACTURED) 21436 return "MedicinalProductManufactured"; 21437 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTPACKAGED) 21438 return "MedicinalProductPackaged"; 21439 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTPHARMACEUTICAL) 21440 return "MedicinalProductPharmaceutical"; 21441 if (code == VersionIndependentResourceTypesAll.MEDICINALPRODUCTUNDESIRABLEEFFECT) 21442 return "MedicinalProductUndesirableEffect"; 21443 if (code == VersionIndependentResourceTypesAll.ORDER) 21444 return "Order"; 21445 if (code == VersionIndependentResourceTypesAll.ORDERRESPONSE) 21446 return "OrderResponse"; 21447 if (code == VersionIndependentResourceTypesAll.PROCEDUREREQUEST) 21448 return "ProcedureRequest"; 21449 if (code == VersionIndependentResourceTypesAll.PROCESSREQUEST) 21450 return "ProcessRequest"; 21451 if (code == VersionIndependentResourceTypesAll.PROCESSRESPONSE) 21452 return "ProcessResponse"; 21453 if (code == VersionIndependentResourceTypesAll.REFERRALREQUEST) 21454 return "ReferralRequest"; 21455 if (code == VersionIndependentResourceTypesAll.REQUESTGROUP) 21456 return "RequestGroup"; 21457 if (code == VersionIndependentResourceTypesAll.RESEARCHDEFINITION) 21458 return "ResearchDefinition"; 21459 if (code == VersionIndependentResourceTypesAll.RESEARCHELEMENTDEFINITION) 21460 return "ResearchElementDefinition"; 21461 if (code == VersionIndependentResourceTypesAll.RISKEVIDENCESYNTHESIS) 21462 return "RiskEvidenceSynthesis"; 21463 if (code == VersionIndependentResourceTypesAll.SEQUENCE) 21464 return "Sequence"; 21465 if (code == VersionIndependentResourceTypesAll.SERVICEDEFINITION) 21466 return "ServiceDefinition"; 21467 if (code == VersionIndependentResourceTypesAll.SUBSTANCESPECIFICATION) 21468 return "SubstanceSpecification"; 21469 return "?"; 21470 } 21471 public String toSystem(VersionIndependentResourceTypesAll code) { 21472 return code.getSystem(); 21473 } 21474 } 21475 21476 21477} 21478