001package org.hl7.fhir.r5.model; 002 003 004/* 005 * #%L 006 * org.hl7.fhir.r5 007 * %% 008 * Copyright (C) 2014 - 2019 Health Level 7 009 * %% 010 * Licensed under the Apache License, Version 2.0 (the \"License\"); 011 * you may not use this file except in compliance with the License. 012 * You may obtain a copy of the License at 013 * 014 * http://www.apache.org/licenses/LICENSE-2.0 015 * 016 * Unless required by applicable law or agreed to in writing, software 017 * distributed under the License is distributed on an \"AS IS\" BASIS, 018 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 019 * See the License for the specific language governing permissions and 020 * limitations under the License. 021 * #L% 022 */ 023 024/* 025 Copyright (c) 2011+, HL7, Inc. 026 All rights reserved. 027 028 Redistribution and use in source and binary forms, with or without modification, \ 029 are permitted provided that the following conditions are met: 030 031 * Redistributions of source code must retain the above copyright notice, this \ 032 list of conditions and the following disclaimer. 033 * Redistributions in binary form must reproduce the above copyright notice, \ 034 this list of conditions and the following disclaimer in the documentation \ 035 and/or other materials provided with the distribution. 036 * Neither the name of HL7 nor the names of its contributors may be used to 037 endorse or promote products derived from this software without specific 038 prior written permission. 039 040 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \ 041 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \ 042 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \ 043 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \ 044 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \ 045 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \ 046 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \ 047 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \ 048 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \ 049 POSSIBILITY OF SUCH DAMAGE. 050 */ 051 052// Generated on Tue, Dec 31, 2019 12:12+1100 for FHIR vcurrent 053 054 055import org.hl7.fhir.instance.model.api.*; 056import org.hl7.fhir.exceptions.FHIRException; 057 058public class Enumerations { 059 060// In here: 061// ActionCardinalityBehavior: Defines behavior for an action or a group for how many times that item may be repeated.[PlanDefinition, RequestGroup] 062// ActionConditionKind: Defines the kinds of conditions that can appear on actions.[PlanDefinition, RequestGroup] 063// ActionGroupingBehavior: Defines organization behavior of a group.[PlanDefinition, RequestGroup] 064// ActionParticipantType: The type of participant for the action.[ActivityDefinition, PlanDefinition] 065// ActionPrecheckBehavior: Defines selection frequency behavior for an action or group.[PlanDefinition, RequestGroup] 066// ActionRelationshipType: Defines the types of relationships between actions.[PlanDefinition, RequestGroup] 067// ActionRequiredBehavior: Defines expectations around whether an action or action group is required.[PlanDefinition, RequestGroup] 068// ActionSelectionBehavior: Defines selection behavior of a group.[PlanDefinition, RequestGroup] 069// AdministrativeGender: The gender of a person used for administrative purposes.[ObservationDefinition, Patient, Person, Practitioner, RelatedPerson] 070// BindingStrength: Indication of the degree of conformance expectations associated with a binding.[ElementDefinition, OperationDefinition] 071// CapabilityStatementKind: How a capability statement is intended to be used.[CapabilityStatement, CapabilityStatement2, TerminologyCapabilities] 072// ClaimProcessingCodes: This value set includes Claim Processing Outcome codes.[ClaimResponse, CoverageEligibilityResponse, EnrollmentResponse, ExplanationOfBenefit, PaymentReconciliation] 073// CompartmentType: Which type a compartment definition describes.[CompartmentDefinition, GraphDefinition] 074// CompositionStatus: The workflow/clinical status of the composition.[Composition, DocumentReference] 075// ConceptMapRelationship: The relationship between concepts.[ConceptMap] 076// DaysOfWeek: The days of the week.[HealthcareService, Location, PractitionerRole, Timing] 077// DeviceNameType: The type of name the device is referred by.[Device, DeviceDefinition] 078// DocumentReferenceStatus: The status of the document reference.[DocumentManifest, DocumentReference] 079// DocumentRelationshipType: The type of relationship between documents.[Composition, DocumentReference] 080// EventStatus: Codes identifying the lifecycle stage of an event.[ClinicalImpression, Communication, Procedure] 081// FHIRAllTypes: A list of all the concrete types defined in this version of the FHIR specification - Abstract Types, Data Types and Resource Types.[DataRequirement, OperationDefinition, ParameterDefinition] 082// FHIRVersion: All published FHIR Versions.[CapabilityStatement, CapabilityStatement2, ImplementationGuide, StructureDefinition] 083// FilterOperator: The kind of operation to perform as a part of a property based filter.[CodeSystem, ValueSet] 084// FinancialResourceStatusCodes: This value set includes Status codes.[Claim, ClaimResponse, Coverage, CoverageEligibilityRequest, CoverageEligibilityResponse, EnrollmentRequest, EnrollmentResponse, PaymentNotice, PaymentReconciliation, VisionPrescription] 085// InvoicePriceComponentType: Codes indicating the kind of the price component.[ChargeItemDefinition, Invoice] 086// ListMode: The processing mode that applies to this list.[Composition, List] 087// MeasureImprovementNotation: Observation values that indicate what change in a measurement value or score is indicative of an improvement in the measured item or scored issue.[Measure, MeasureReport] 088// MimeTypes: This value set includes all possible codes from BCP-13 (http://tools.ietf.org/html/bcp13)[Attachment, Binary, CapabilityStatement, CapabilityStatement2, ElementDefinition, Endpoint, Signature, Subscription, TestScript] 089// NoteType: The presentation types of notes.[ClaimResponse, ExplanationOfBenefit, PaymentReconciliation] 090// ObservationStatus: Codes providing the status of an observation.[DetectedIssue, Observation, RiskAssessment] 091// OperationParameterUse: Whether an operation parameter is an input or an output parameter.[OperationDefinition, ParameterDefinition] 092// ParticipationStatus: The Participation status of an appointment.[Appointment, AppointmentResponse] 093// PublicationStatus: The lifecycle status of an artifact.[ActivityDefinition, CanonicalResource, CapabilityStatement, CapabilityStatement2, ChargeItemDefinition, CodeSystem, CompartmentDefinition, ConceptMap, ConditionDefinition, EventDefinition, Evidence, EvidenceVariable, ExampleScenario, GraphDefinition, ImplementationGuide, InsurancePlan, Library, Measure, MessageDefinition, NamingSystem, ObservationDefinition, OperationDefinition, PlanDefinition, Questionnaire, SearchParameter, SpecimenDefinition, StructureDefinition, StructureMap, TerminologyCapabilities, TestScript, Topic, ValueSet] 094// QuantityComparator: How the Quantity should be understood and represented.[Age, Count, Distance, Duration, Quantity] 095// RequestIntent: Codes indicating the degree of authority/intentionality associated with a request.[ActivityDefinition, DeviceRequest, NutritionOrder, RequestGroup, ServiceRequest] 096// RequestPriority: The clinical priority of a diagnostic order.[ActivityDefinition, Communication, CommunicationRequest, DeviceRequest, MedicationRequest, PlanDefinition, RequestGroup, ServiceRequest, SupplyRequest, Task] 097// RequestStatus: Codes identifying the lifecycle stage of a request.[CarePlan, CommunicationRequest, DeviceRequest, NutritionOrder, RequestGroup, ServiceRequest] 098// ResourceTypeEnum: One of the resource types defined as part of this version of FHIR.[CapabilityStatement, CapabilityStatement2, CompartmentDefinition, ExampleScenario, GraphDefinition, ImplementationGuide, MessageDefinition, OperationDefinition, Questionnaire, SearchParameter, Topic] 099// RestfulCapabilityMode: The mode of a RESTful capability statement.[CapabilityStatement, CapabilityStatement2] 100// SearchParamType: Data types allowed to be used for search parameters.[CapabilityStatement, CapabilityStatement2, OperationDefinition, SearchParameter] 101// Use: The purpose of the Claim: predetermination, preauthorization, claim.[Claim, ClaimResponse, ExplanationOfBenefit] 102 103 104 public enum ActionCardinalityBehavior { 105 /** 106 * The action may only be selected one time. 107 */ 108 SINGLE, 109 /** 110 * The action may be selected multiple times. 111 */ 112 MULTIPLE, 113 /** 114 * added to help the parsers 115 */ 116 NULL; 117 public static ActionCardinalityBehavior fromCode(String codeString) throws FHIRException { 118 if (codeString == null || "".equals(codeString)) 119 return null; 120 if ("single".equals(codeString)) 121 return SINGLE; 122 if ("multiple".equals(codeString)) 123 return MULTIPLE; 124 throw new FHIRException("Unknown ActionCardinalityBehavior code '"+codeString+"'"); 125 } 126 public String toCode() { 127 switch (this) { 128 case SINGLE: return "single"; 129 case MULTIPLE: return "multiple"; 130 default: return "?"; 131 } 132 } 133 public String getSystem() { 134 switch (this) { 135 case SINGLE: return "http://hl7.org/fhir/action-cardinality-behavior"; 136 case MULTIPLE: return "http://hl7.org/fhir/action-cardinality-behavior"; 137 default: return "?"; 138 } 139 } 140 public String getDefinition() { 141 switch (this) { 142 case SINGLE: return "The action may only be selected one time."; 143 case MULTIPLE: return "The action may be selected multiple times."; 144 default: return "?"; 145 } 146 } 147 public String getDisplay() { 148 switch (this) { 149 case SINGLE: return "Single"; 150 case MULTIPLE: return "Multiple"; 151 default: return "?"; 152 } 153 } 154 } 155 156 public static class ActionCardinalityBehaviorEnumFactory implements EnumFactory<ActionCardinalityBehavior> { 157 public ActionCardinalityBehavior fromCode(String codeString) throws IllegalArgumentException { 158 if (codeString == null || "".equals(codeString)) 159 if (codeString == null || "".equals(codeString)) 160 return null; 161 if ("single".equals(codeString)) 162 return ActionCardinalityBehavior.SINGLE; 163 if ("multiple".equals(codeString)) 164 return ActionCardinalityBehavior.MULTIPLE; 165 throw new IllegalArgumentException("Unknown ActionCardinalityBehavior code '"+codeString+"'"); 166 } 167 public Enumeration<ActionCardinalityBehavior> fromType(Base code) throws FHIRException { 168 if (code == null) 169 return null; 170 if (code.isEmpty()) 171 return new Enumeration<ActionCardinalityBehavior>(this); 172 String codeString = ((PrimitiveType) code).asStringValue(); 173 if (codeString == null || "".equals(codeString)) 174 return null; 175 if ("single".equals(codeString)) 176 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.SINGLE); 177 if ("multiple".equals(codeString)) 178 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.MULTIPLE); 179 throw new FHIRException("Unknown ActionCardinalityBehavior code '"+codeString+"'"); 180 } 181 public String toCode(ActionCardinalityBehavior code) { 182 if (code == ActionCardinalityBehavior.SINGLE) 183 return "single"; 184 if (code == ActionCardinalityBehavior.MULTIPLE) 185 return "multiple"; 186 return "?"; 187 } 188 public String toSystem(ActionCardinalityBehavior code) { 189 return code.getSystem(); 190 } 191 } 192 193 public enum ActionConditionKind { 194 /** 195 * The condition describes whether or not a given action is applicable. 196 */ 197 APPLICABILITY, 198 /** 199 * The condition is a starting condition for the action. 200 */ 201 START, 202 /** 203 * The condition is a stop, or exit condition for the action. 204 */ 205 STOP, 206 /** 207 * added to help the parsers 208 */ 209 NULL; 210 public static ActionConditionKind fromCode(String codeString) throws FHIRException { 211 if (codeString == null || "".equals(codeString)) 212 return null; 213 if ("applicability".equals(codeString)) 214 return APPLICABILITY; 215 if ("start".equals(codeString)) 216 return START; 217 if ("stop".equals(codeString)) 218 return STOP; 219 throw new FHIRException("Unknown ActionConditionKind code '"+codeString+"'"); 220 } 221 public String toCode() { 222 switch (this) { 223 case APPLICABILITY: return "applicability"; 224 case START: return "start"; 225 case STOP: return "stop"; 226 default: return "?"; 227 } 228 } 229 public String getSystem() { 230 switch (this) { 231 case APPLICABILITY: return "http://hl7.org/fhir/action-condition-kind"; 232 case START: return "http://hl7.org/fhir/action-condition-kind"; 233 case STOP: return "http://hl7.org/fhir/action-condition-kind"; 234 default: return "?"; 235 } 236 } 237 public String getDefinition() { 238 switch (this) { 239 case APPLICABILITY: return "The condition describes whether or not a given action is applicable."; 240 case START: return "The condition is a starting condition for the action."; 241 case STOP: return "The condition is a stop, or exit condition for the action."; 242 default: return "?"; 243 } 244 } 245 public String getDisplay() { 246 switch (this) { 247 case APPLICABILITY: return "Applicability"; 248 case START: return "Start"; 249 case STOP: return "Stop"; 250 default: return "?"; 251 } 252 } 253 } 254 255 public static class ActionConditionKindEnumFactory implements EnumFactory<ActionConditionKind> { 256 public ActionConditionKind fromCode(String codeString) throws IllegalArgumentException { 257 if (codeString == null || "".equals(codeString)) 258 if (codeString == null || "".equals(codeString)) 259 return null; 260 if ("applicability".equals(codeString)) 261 return ActionConditionKind.APPLICABILITY; 262 if ("start".equals(codeString)) 263 return ActionConditionKind.START; 264 if ("stop".equals(codeString)) 265 return ActionConditionKind.STOP; 266 throw new IllegalArgumentException("Unknown ActionConditionKind code '"+codeString+"'"); 267 } 268 public Enumeration<ActionConditionKind> fromType(Base code) throws FHIRException { 269 if (code == null) 270 return null; 271 if (code.isEmpty()) 272 return new Enumeration<ActionConditionKind>(this); 273 String codeString = ((PrimitiveType) code).asStringValue(); 274 if (codeString == null || "".equals(codeString)) 275 return null; 276 if ("applicability".equals(codeString)) 277 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.APPLICABILITY); 278 if ("start".equals(codeString)) 279 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.START); 280 if ("stop".equals(codeString)) 281 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.STOP); 282 throw new FHIRException("Unknown ActionConditionKind code '"+codeString+"'"); 283 } 284 public String toCode(ActionConditionKind code) { 285 if (code == ActionConditionKind.APPLICABILITY) 286 return "applicability"; 287 if (code == ActionConditionKind.START) 288 return "start"; 289 if (code == ActionConditionKind.STOP) 290 return "stop"; 291 return "?"; 292 } 293 public String toSystem(ActionConditionKind code) { 294 return code.getSystem(); 295 } 296 } 297 298 public enum ActionGroupingBehavior { 299 /** 300 * Any group marked with this behavior should be displayed as a visual group to the end user. 301 */ 302 VISUALGROUP, 303 /** 304 * A group with this behavior logically groups its sub-elements, and may be shown as a visual group to the end user, but it is not required to do so. 305 */ 306 LOGICALGROUP, 307 /** 308 * A group of related alternative actions is a sentence group if the target referenced by the action is the same in all the actions and each action simply constitutes a different variation on how to specify the details for the target. For example, two actions that could be in a SentenceGroup are "aspirin, 500 mg, 2 times per day" and "aspirin, 300 mg, 3 times per day". In both cases, aspirin is the target referenced by the action, and the two actions represent different options for how aspirin might be ordered for the patient. Note that a SentenceGroup would almost always have an associated selection behavior of "AtMostOne", unless it's a required action, in which case, it would be "ExactlyOne". 309 */ 310 SENTENCEGROUP, 311 /** 312 * added to help the parsers 313 */ 314 NULL; 315 public static ActionGroupingBehavior fromCode(String codeString) throws FHIRException { 316 if (codeString == null || "".equals(codeString)) 317 return null; 318 if ("visual-group".equals(codeString)) 319 return VISUALGROUP; 320 if ("logical-group".equals(codeString)) 321 return LOGICALGROUP; 322 if ("sentence-group".equals(codeString)) 323 return SENTENCEGROUP; 324 throw new FHIRException("Unknown ActionGroupingBehavior code '"+codeString+"'"); 325 } 326 public String toCode() { 327 switch (this) { 328 case VISUALGROUP: return "visual-group"; 329 case LOGICALGROUP: return "logical-group"; 330 case SENTENCEGROUP: return "sentence-group"; 331 default: return "?"; 332 } 333 } 334 public String getSystem() { 335 switch (this) { 336 case VISUALGROUP: return "http://hl7.org/fhir/action-grouping-behavior"; 337 case LOGICALGROUP: return "http://hl7.org/fhir/action-grouping-behavior"; 338 case SENTENCEGROUP: return "http://hl7.org/fhir/action-grouping-behavior"; 339 default: return "?"; 340 } 341 } 342 public String getDefinition() { 343 switch (this) { 344 case VISUALGROUP: return "Any group marked with this behavior should be displayed as a visual group to the end user."; 345 case LOGICALGROUP: return "A group with this behavior logically groups its sub-elements, and may be shown as a visual group to the end user, but it is not required to do so."; 346 case SENTENCEGROUP: return "A group of related alternative actions is a sentence group if the target referenced by the action is the same in all the actions and each action simply constitutes a different variation on how to specify the details for the target. For example, two actions that could be in a SentenceGroup are \"aspirin, 500 mg, 2 times per day\" and \"aspirin, 300 mg, 3 times per day\". In both cases, aspirin is the target referenced by the action, and the two actions represent different options for how aspirin might be ordered for the patient. Note that a SentenceGroup would almost always have an associated selection behavior of \"AtMostOne\", unless it's a required action, in which case, it would be \"ExactlyOne\"."; 347 default: return "?"; 348 } 349 } 350 public String getDisplay() { 351 switch (this) { 352 case VISUALGROUP: return "Visual Group"; 353 case LOGICALGROUP: return "Logical Group"; 354 case SENTENCEGROUP: return "Sentence Group"; 355 default: return "?"; 356 } 357 } 358 } 359 360 public static class ActionGroupingBehaviorEnumFactory implements EnumFactory<ActionGroupingBehavior> { 361 public ActionGroupingBehavior fromCode(String codeString) throws IllegalArgumentException { 362 if (codeString == null || "".equals(codeString)) 363 if (codeString == null || "".equals(codeString)) 364 return null; 365 if ("visual-group".equals(codeString)) 366 return ActionGroupingBehavior.VISUALGROUP; 367 if ("logical-group".equals(codeString)) 368 return ActionGroupingBehavior.LOGICALGROUP; 369 if ("sentence-group".equals(codeString)) 370 return ActionGroupingBehavior.SENTENCEGROUP; 371 throw new IllegalArgumentException("Unknown ActionGroupingBehavior code '"+codeString+"'"); 372 } 373 public Enumeration<ActionGroupingBehavior> fromType(Base code) throws FHIRException { 374 if (code == null) 375 return null; 376 if (code.isEmpty()) 377 return new Enumeration<ActionGroupingBehavior>(this); 378 String codeString = ((PrimitiveType) code).asStringValue(); 379 if (codeString == null || "".equals(codeString)) 380 return null; 381 if ("visual-group".equals(codeString)) 382 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.VISUALGROUP); 383 if ("logical-group".equals(codeString)) 384 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.LOGICALGROUP); 385 if ("sentence-group".equals(codeString)) 386 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.SENTENCEGROUP); 387 throw new FHIRException("Unknown ActionGroupingBehavior code '"+codeString+"'"); 388 } 389 public String toCode(ActionGroupingBehavior code) { 390 if (code == ActionGroupingBehavior.VISUALGROUP) 391 return "visual-group"; 392 if (code == ActionGroupingBehavior.LOGICALGROUP) 393 return "logical-group"; 394 if (code == ActionGroupingBehavior.SENTENCEGROUP) 395 return "sentence-group"; 396 return "?"; 397 } 398 public String toSystem(ActionGroupingBehavior code) { 399 return code.getSystem(); 400 } 401 } 402 403 public enum ActionParticipantType { 404 /** 405 * The participant is the patient under evaluation. 406 */ 407 PATIENT, 408 /** 409 * The participant is a practitioner involved in the patient's care. 410 */ 411 PRACTITIONER, 412 /** 413 * The participant is a person related to the patient. 414 */ 415 RELATEDPERSON, 416 /** 417 * The participant is a system or device used in the care of the patient. 418 */ 419 DEVICE, 420 /** 421 * added to help the parsers 422 */ 423 NULL; 424 public static ActionParticipantType fromCode(String codeString) throws FHIRException { 425 if (codeString == null || "".equals(codeString)) 426 return null; 427 if ("patient".equals(codeString)) 428 return PATIENT; 429 if ("practitioner".equals(codeString)) 430 return PRACTITIONER; 431 if ("related-person".equals(codeString)) 432 return RELATEDPERSON; 433 if ("device".equals(codeString)) 434 return DEVICE; 435 throw new FHIRException("Unknown ActionParticipantType code '"+codeString+"'"); 436 } 437 public String toCode() { 438 switch (this) { 439 case PATIENT: return "patient"; 440 case PRACTITIONER: return "practitioner"; 441 case RELATEDPERSON: return "related-person"; 442 case DEVICE: return "device"; 443 default: return "?"; 444 } 445 } 446 public String getSystem() { 447 switch (this) { 448 case PATIENT: return "http://hl7.org/fhir/action-participant-type"; 449 case PRACTITIONER: return "http://hl7.org/fhir/action-participant-type"; 450 case RELATEDPERSON: return "http://hl7.org/fhir/action-participant-type"; 451 case DEVICE: return "http://hl7.org/fhir/action-participant-type"; 452 default: return "?"; 453 } 454 } 455 public String getDefinition() { 456 switch (this) { 457 case PATIENT: return "The participant is the patient under evaluation."; 458 case PRACTITIONER: return "The participant is a practitioner involved in the patient's care."; 459 case RELATEDPERSON: return "The participant is a person related to the patient."; 460 case DEVICE: return "The participant is a system or device used in the care of the patient."; 461 default: return "?"; 462 } 463 } 464 public String getDisplay() { 465 switch (this) { 466 case PATIENT: return "Patient"; 467 case PRACTITIONER: return "Practitioner"; 468 case RELATEDPERSON: return "Related Person"; 469 case DEVICE: return "Device"; 470 default: return "?"; 471 } 472 } 473 } 474 475 public static class ActionParticipantTypeEnumFactory implements EnumFactory<ActionParticipantType> { 476 public ActionParticipantType fromCode(String codeString) throws IllegalArgumentException { 477 if (codeString == null || "".equals(codeString)) 478 if (codeString == null || "".equals(codeString)) 479 return null; 480 if ("patient".equals(codeString)) 481 return ActionParticipantType.PATIENT; 482 if ("practitioner".equals(codeString)) 483 return ActionParticipantType.PRACTITIONER; 484 if ("related-person".equals(codeString)) 485 return ActionParticipantType.RELATEDPERSON; 486 if ("device".equals(codeString)) 487 return ActionParticipantType.DEVICE; 488 throw new IllegalArgumentException("Unknown ActionParticipantType code '"+codeString+"'"); 489 } 490 public Enumeration<ActionParticipantType> fromType(Base code) throws FHIRException { 491 if (code == null) 492 return null; 493 if (code.isEmpty()) 494 return new Enumeration<ActionParticipantType>(this); 495 String codeString = ((PrimitiveType) code).asStringValue(); 496 if (codeString == null || "".equals(codeString)) 497 return null; 498 if ("patient".equals(codeString)) 499 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PATIENT); 500 if ("practitioner".equals(codeString)) 501 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PRACTITIONER); 502 if ("related-person".equals(codeString)) 503 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.RELATEDPERSON); 504 if ("device".equals(codeString)) 505 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.DEVICE); 506 throw new FHIRException("Unknown ActionParticipantType code '"+codeString+"'"); 507 } 508 public String toCode(ActionParticipantType code) { 509 if (code == ActionParticipantType.PATIENT) 510 return "patient"; 511 if (code == ActionParticipantType.PRACTITIONER) 512 return "practitioner"; 513 if (code == ActionParticipantType.RELATEDPERSON) 514 return "related-person"; 515 if (code == ActionParticipantType.DEVICE) 516 return "device"; 517 return "?"; 518 } 519 public String toSystem(ActionParticipantType code) { 520 return code.getSystem(); 521 } 522 } 523 524 public enum ActionPrecheckBehavior { 525 /** 526 * An action with this behavior is one of the most frequent action that is, or should be, included by an end user, for the particular context in which the action occurs. The system displaying the action to the end user should consider "pre-checking" such an action as a convenience for the user. 527 */ 528 YES, 529 /** 530 * An action with this behavior is one of the less frequent actions included by the end user, for the particular context in which the action occurs. The system displaying the actions to the end user would typically not "pre-check" such an action. 531 */ 532 NO, 533 /** 534 * added to help the parsers 535 */ 536 NULL; 537 public static ActionPrecheckBehavior fromCode(String codeString) throws FHIRException { 538 if (codeString == null || "".equals(codeString)) 539 return null; 540 if ("yes".equals(codeString)) 541 return YES; 542 if ("no".equals(codeString)) 543 return NO; 544 throw new FHIRException("Unknown ActionPrecheckBehavior code '"+codeString+"'"); 545 } 546 public String toCode() { 547 switch (this) { 548 case YES: return "yes"; 549 case NO: return "no"; 550 default: return "?"; 551 } 552 } 553 public String getSystem() { 554 switch (this) { 555 case YES: return "http://hl7.org/fhir/action-precheck-behavior"; 556 case NO: return "http://hl7.org/fhir/action-precheck-behavior"; 557 default: return "?"; 558 } 559 } 560 public String getDefinition() { 561 switch (this) { 562 case YES: return "An action with this behavior is one of the most frequent action that is, or should be, included by an end user, for the particular context in which the action occurs. The system displaying the action to the end user should consider \"pre-checking\" such an action as a convenience for the user."; 563 case NO: return "An action with this behavior is one of the less frequent actions included by the end user, for the particular context in which the action occurs. The system displaying the actions to the end user would typically not \"pre-check\" such an action."; 564 default: return "?"; 565 } 566 } 567 public String getDisplay() { 568 switch (this) { 569 case YES: return "Yes"; 570 case NO: return "No"; 571 default: return "?"; 572 } 573 } 574 } 575 576 public static class ActionPrecheckBehaviorEnumFactory implements EnumFactory<ActionPrecheckBehavior> { 577 public ActionPrecheckBehavior fromCode(String codeString) throws IllegalArgumentException { 578 if (codeString == null || "".equals(codeString)) 579 if (codeString == null || "".equals(codeString)) 580 return null; 581 if ("yes".equals(codeString)) 582 return ActionPrecheckBehavior.YES; 583 if ("no".equals(codeString)) 584 return ActionPrecheckBehavior.NO; 585 throw new IllegalArgumentException("Unknown ActionPrecheckBehavior code '"+codeString+"'"); 586 } 587 public Enumeration<ActionPrecheckBehavior> fromType(Base code) throws FHIRException { 588 if (code == null) 589 return null; 590 if (code.isEmpty()) 591 return new Enumeration<ActionPrecheckBehavior>(this); 592 String codeString = ((PrimitiveType) code).asStringValue(); 593 if (codeString == null || "".equals(codeString)) 594 return null; 595 if ("yes".equals(codeString)) 596 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.YES); 597 if ("no".equals(codeString)) 598 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NO); 599 throw new FHIRException("Unknown ActionPrecheckBehavior code '"+codeString+"'"); 600 } 601 public String toCode(ActionPrecheckBehavior code) { 602 if (code == ActionPrecheckBehavior.YES) 603 return "yes"; 604 if (code == ActionPrecheckBehavior.NO) 605 return "no"; 606 return "?"; 607 } 608 public String toSystem(ActionPrecheckBehavior code) { 609 return code.getSystem(); 610 } 611 } 612 613 public enum ActionRelationshipType { 614 /** 615 * The action must be performed before the start of the related action. 616 */ 617 BEFORESTART, 618 /** 619 * The action must be performed before the related action. 620 */ 621 BEFORE, 622 /** 623 * The action must be performed before the end of the related action. 624 */ 625 BEFOREEND, 626 /** 627 * The action must be performed concurrent with the start of the related action. 628 */ 629 CONCURRENTWITHSTART, 630 /** 631 * The action must be performed concurrent with the related action. 632 */ 633 CONCURRENT, 634 /** 635 * The action must be performed concurrent with the end of the related action. 636 */ 637 CONCURRENTWITHEND, 638 /** 639 * The action must be performed after the start of the related action. 640 */ 641 AFTERSTART, 642 /** 643 * The action must be performed after the related action. 644 */ 645 AFTER, 646 /** 647 * The action must be performed after the end of the related action. 648 */ 649 AFTEREND, 650 /** 651 * added to help the parsers 652 */ 653 NULL; 654 public static ActionRelationshipType fromCode(String codeString) throws FHIRException { 655 if (codeString == null || "".equals(codeString)) 656 return null; 657 if ("before-start".equals(codeString)) 658 return BEFORESTART; 659 if ("before".equals(codeString)) 660 return BEFORE; 661 if ("before-end".equals(codeString)) 662 return BEFOREEND; 663 if ("concurrent-with-start".equals(codeString)) 664 return CONCURRENTWITHSTART; 665 if ("concurrent".equals(codeString)) 666 return CONCURRENT; 667 if ("concurrent-with-end".equals(codeString)) 668 return CONCURRENTWITHEND; 669 if ("after-start".equals(codeString)) 670 return AFTERSTART; 671 if ("after".equals(codeString)) 672 return AFTER; 673 if ("after-end".equals(codeString)) 674 return AFTEREND; 675 throw new FHIRException("Unknown ActionRelationshipType code '"+codeString+"'"); 676 } 677 public String toCode() { 678 switch (this) { 679 case BEFORESTART: return "before-start"; 680 case BEFORE: return "before"; 681 case BEFOREEND: return "before-end"; 682 case CONCURRENTWITHSTART: return "concurrent-with-start"; 683 case CONCURRENT: return "concurrent"; 684 case CONCURRENTWITHEND: return "concurrent-with-end"; 685 case AFTERSTART: return "after-start"; 686 case AFTER: return "after"; 687 case AFTEREND: return "after-end"; 688 default: return "?"; 689 } 690 } 691 public String getSystem() { 692 switch (this) { 693 case BEFORESTART: return "http://hl7.org/fhir/action-relationship-type"; 694 case BEFORE: return "http://hl7.org/fhir/action-relationship-type"; 695 case BEFOREEND: return "http://hl7.org/fhir/action-relationship-type"; 696 case CONCURRENTWITHSTART: return "http://hl7.org/fhir/action-relationship-type"; 697 case CONCURRENT: return "http://hl7.org/fhir/action-relationship-type"; 698 case CONCURRENTWITHEND: return "http://hl7.org/fhir/action-relationship-type"; 699 case AFTERSTART: return "http://hl7.org/fhir/action-relationship-type"; 700 case AFTER: return "http://hl7.org/fhir/action-relationship-type"; 701 case AFTEREND: return "http://hl7.org/fhir/action-relationship-type"; 702 default: return "?"; 703 } 704 } 705 public String getDefinition() { 706 switch (this) { 707 case BEFORESTART: return "The action must be performed before the start of the related action."; 708 case BEFORE: return "The action must be performed before the related action."; 709 case BEFOREEND: return "The action must be performed before the end of the related action."; 710 case CONCURRENTWITHSTART: return "The action must be performed concurrent with the start of the related action."; 711 case CONCURRENT: return "The action must be performed concurrent with the related action."; 712 case CONCURRENTWITHEND: return "The action must be performed concurrent with the end of the related action."; 713 case AFTERSTART: return "The action must be performed after the start of the related action."; 714 case AFTER: return "The action must be performed after the related action."; 715 case AFTEREND: return "The action must be performed after the end of the related action."; 716 default: return "?"; 717 } 718 } 719 public String getDisplay() { 720 switch (this) { 721 case BEFORESTART: return "Before Start"; 722 case BEFORE: return "Before"; 723 case BEFOREEND: return "Before End"; 724 case CONCURRENTWITHSTART: return "Concurrent With Start"; 725 case CONCURRENT: return "Concurrent"; 726 case CONCURRENTWITHEND: return "Concurrent With End"; 727 case AFTERSTART: return "After Start"; 728 case AFTER: return "After"; 729 case AFTEREND: return "After End"; 730 default: return "?"; 731 } 732 } 733 } 734 735 public static class ActionRelationshipTypeEnumFactory implements EnumFactory<ActionRelationshipType> { 736 public ActionRelationshipType fromCode(String codeString) throws IllegalArgumentException { 737 if (codeString == null || "".equals(codeString)) 738 if (codeString == null || "".equals(codeString)) 739 return null; 740 if ("before-start".equals(codeString)) 741 return ActionRelationshipType.BEFORESTART; 742 if ("before".equals(codeString)) 743 return ActionRelationshipType.BEFORE; 744 if ("before-end".equals(codeString)) 745 return ActionRelationshipType.BEFOREEND; 746 if ("concurrent-with-start".equals(codeString)) 747 return ActionRelationshipType.CONCURRENTWITHSTART; 748 if ("concurrent".equals(codeString)) 749 return ActionRelationshipType.CONCURRENT; 750 if ("concurrent-with-end".equals(codeString)) 751 return ActionRelationshipType.CONCURRENTWITHEND; 752 if ("after-start".equals(codeString)) 753 return ActionRelationshipType.AFTERSTART; 754 if ("after".equals(codeString)) 755 return ActionRelationshipType.AFTER; 756 if ("after-end".equals(codeString)) 757 return ActionRelationshipType.AFTEREND; 758 throw new IllegalArgumentException("Unknown ActionRelationshipType code '"+codeString+"'"); 759 } 760 public Enumeration<ActionRelationshipType> fromType(Base code) throws FHIRException { 761 if (code == null) 762 return null; 763 if (code.isEmpty()) 764 return new Enumeration<ActionRelationshipType>(this); 765 String codeString = ((PrimitiveType) code).asStringValue(); 766 if (codeString == null || "".equals(codeString)) 767 return null; 768 if ("before-start".equals(codeString)) 769 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORESTART); 770 if ("before".equals(codeString)) 771 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORE); 772 if ("before-end".equals(codeString)) 773 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFOREEND); 774 if ("concurrent-with-start".equals(codeString)) 775 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHSTART); 776 if ("concurrent".equals(codeString)) 777 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENT); 778 if ("concurrent-with-end".equals(codeString)) 779 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHEND); 780 if ("after-start".equals(codeString)) 781 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTERSTART); 782 if ("after".equals(codeString)) 783 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTER); 784 if ("after-end".equals(codeString)) 785 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTEREND); 786 throw new FHIRException("Unknown ActionRelationshipType code '"+codeString+"'"); 787 } 788 public String toCode(ActionRelationshipType code) { 789 if (code == ActionRelationshipType.BEFORESTART) 790 return "before-start"; 791 if (code == ActionRelationshipType.BEFORE) 792 return "before"; 793 if (code == ActionRelationshipType.BEFOREEND) 794 return "before-end"; 795 if (code == ActionRelationshipType.CONCURRENTWITHSTART) 796 return "concurrent-with-start"; 797 if (code == ActionRelationshipType.CONCURRENT) 798 return "concurrent"; 799 if (code == ActionRelationshipType.CONCURRENTWITHEND) 800 return "concurrent-with-end"; 801 if (code == ActionRelationshipType.AFTERSTART) 802 return "after-start"; 803 if (code == ActionRelationshipType.AFTER) 804 return "after"; 805 if (code == ActionRelationshipType.AFTEREND) 806 return "after-end"; 807 return "?"; 808 } 809 public String toSystem(ActionRelationshipType code) { 810 return code.getSystem(); 811 } 812 } 813 814 public enum ActionRequiredBehavior { 815 /** 816 * An action with this behavior must be included in the actions processed by the end user; the end user SHALL NOT choose not to include this action. 817 */ 818 MUST, 819 /** 820 * An action with this behavior may be included in the set of actions processed by the end user. 821 */ 822 COULD, 823 /** 824 * An action with this behavior must be included in the set of actions processed by the end user, unless the end user provides documentation as to why the action was not included. 825 */ 826 MUSTUNLESSDOCUMENTED, 827 /** 828 * added to help the parsers 829 */ 830 NULL; 831 public static ActionRequiredBehavior fromCode(String codeString) throws FHIRException { 832 if (codeString == null || "".equals(codeString)) 833 return null; 834 if ("must".equals(codeString)) 835 return MUST; 836 if ("could".equals(codeString)) 837 return COULD; 838 if ("must-unless-documented".equals(codeString)) 839 return MUSTUNLESSDOCUMENTED; 840 throw new FHIRException("Unknown ActionRequiredBehavior code '"+codeString+"'"); 841 } 842 public String toCode() { 843 switch (this) { 844 case MUST: return "must"; 845 case COULD: return "could"; 846 case MUSTUNLESSDOCUMENTED: return "must-unless-documented"; 847 default: return "?"; 848 } 849 } 850 public String getSystem() { 851 switch (this) { 852 case MUST: return "http://hl7.org/fhir/action-required-behavior"; 853 case COULD: return "http://hl7.org/fhir/action-required-behavior"; 854 case MUSTUNLESSDOCUMENTED: return "http://hl7.org/fhir/action-required-behavior"; 855 default: return "?"; 856 } 857 } 858 public String getDefinition() { 859 switch (this) { 860 case MUST: return "An action with this behavior must be included in the actions processed by the end user; the end user SHALL NOT choose not to include this action."; 861 case COULD: return "An action with this behavior may be included in the set of actions processed by the end user."; 862 case MUSTUNLESSDOCUMENTED: return "An action with this behavior must be included in the set of actions processed by the end user, unless the end user provides documentation as to why the action was not included."; 863 default: return "?"; 864 } 865 } 866 public String getDisplay() { 867 switch (this) { 868 case MUST: return "Must"; 869 case COULD: return "Could"; 870 case MUSTUNLESSDOCUMENTED: return "Must Unless Documented"; 871 default: return "?"; 872 } 873 } 874 } 875 876 public static class ActionRequiredBehaviorEnumFactory implements EnumFactory<ActionRequiredBehavior> { 877 public ActionRequiredBehavior fromCode(String codeString) throws IllegalArgumentException { 878 if (codeString == null || "".equals(codeString)) 879 if (codeString == null || "".equals(codeString)) 880 return null; 881 if ("must".equals(codeString)) 882 return ActionRequiredBehavior.MUST; 883 if ("could".equals(codeString)) 884 return ActionRequiredBehavior.COULD; 885 if ("must-unless-documented".equals(codeString)) 886 return ActionRequiredBehavior.MUSTUNLESSDOCUMENTED; 887 throw new IllegalArgumentException("Unknown ActionRequiredBehavior code '"+codeString+"'"); 888 } 889 public Enumeration<ActionRequiredBehavior> fromType(Base code) throws FHIRException { 890 if (code == null) 891 return null; 892 if (code.isEmpty()) 893 return new Enumeration<ActionRequiredBehavior>(this); 894 String codeString = ((PrimitiveType) code).asStringValue(); 895 if (codeString == null || "".equals(codeString)) 896 return null; 897 if ("must".equals(codeString)) 898 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUST); 899 if ("could".equals(codeString)) 900 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.COULD); 901 if ("must-unless-documented".equals(codeString)) 902 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUSTUNLESSDOCUMENTED); 903 throw new FHIRException("Unknown ActionRequiredBehavior code '"+codeString+"'"); 904 } 905 public String toCode(ActionRequiredBehavior code) { 906 if (code == ActionRequiredBehavior.MUST) 907 return "must"; 908 if (code == ActionRequiredBehavior.COULD) 909 return "could"; 910 if (code == ActionRequiredBehavior.MUSTUNLESSDOCUMENTED) 911 return "must-unless-documented"; 912 return "?"; 913 } 914 public String toSystem(ActionRequiredBehavior code) { 915 return code.getSystem(); 916 } 917 } 918 919 public enum ActionSelectionBehavior { 920 /** 921 * Any number of the actions in the group may be chosen, from zero to all. 922 */ 923 ANY, 924 /** 925 * All the actions in the group must be selected as a single unit. 926 */ 927 ALL, 928 /** 929 * All the actions in the group are meant to be chosen as a single unit: either all must be selected by the end user, or none may be selected. 930 */ 931 ALLORNONE, 932 /** 933 * The end user must choose one and only one of the selectable actions in the group. The user SHALL NOT choose none of the actions in the group. 934 */ 935 EXACTLYONE, 936 /** 937 * The end user may choose zero or at most one of the actions in the group. 938 */ 939 ATMOSTONE, 940 /** 941 * The end user must choose a minimum of one, and as many additional as desired. 942 */ 943 ONEORMORE, 944 /** 945 * added to help the parsers 946 */ 947 NULL; 948 public static ActionSelectionBehavior fromCode(String codeString) throws FHIRException { 949 if (codeString == null || "".equals(codeString)) 950 return null; 951 if ("any".equals(codeString)) 952 return ANY; 953 if ("all".equals(codeString)) 954 return ALL; 955 if ("all-or-none".equals(codeString)) 956 return ALLORNONE; 957 if ("exactly-one".equals(codeString)) 958 return EXACTLYONE; 959 if ("at-most-one".equals(codeString)) 960 return ATMOSTONE; 961 if ("one-or-more".equals(codeString)) 962 return ONEORMORE; 963 throw new FHIRException("Unknown ActionSelectionBehavior code '"+codeString+"'"); 964 } 965 public String toCode() { 966 switch (this) { 967 case ANY: return "any"; 968 case ALL: return "all"; 969 case ALLORNONE: return "all-or-none"; 970 case EXACTLYONE: return "exactly-one"; 971 case ATMOSTONE: return "at-most-one"; 972 case ONEORMORE: return "one-or-more"; 973 default: return "?"; 974 } 975 } 976 public String getSystem() { 977 switch (this) { 978 case ANY: return "http://hl7.org/fhir/action-selection-behavior"; 979 case ALL: return "http://hl7.org/fhir/action-selection-behavior"; 980 case ALLORNONE: return "http://hl7.org/fhir/action-selection-behavior"; 981 case EXACTLYONE: return "http://hl7.org/fhir/action-selection-behavior"; 982 case ATMOSTONE: return "http://hl7.org/fhir/action-selection-behavior"; 983 case ONEORMORE: return "http://hl7.org/fhir/action-selection-behavior"; 984 default: return "?"; 985 } 986 } 987 public String getDefinition() { 988 switch (this) { 989 case ANY: return "Any number of the actions in the group may be chosen, from zero to all."; 990 case ALL: return "All the actions in the group must be selected as a single unit."; 991 case ALLORNONE: return "All the actions in the group are meant to be chosen as a single unit: either all must be selected by the end user, or none may be selected."; 992 case EXACTLYONE: return "The end user must choose one and only one of the selectable actions in the group. The user SHALL NOT choose none of the actions in the group."; 993 case ATMOSTONE: return "The end user may choose zero or at most one of the actions in the group."; 994 case ONEORMORE: return "The end user must choose a minimum of one, and as many additional as desired."; 995 default: return "?"; 996 } 997 } 998 public String getDisplay() { 999 switch (this) { 1000 case ANY: return "Any"; 1001 case ALL: return "All"; 1002 case ALLORNONE: return "All Or None"; 1003 case EXACTLYONE: return "Exactly One"; 1004 case ATMOSTONE: return "At Most One"; 1005 case ONEORMORE: return "One Or More"; 1006 default: return "?"; 1007 } 1008 } 1009 } 1010 1011 public static class ActionSelectionBehaviorEnumFactory implements EnumFactory<ActionSelectionBehavior> { 1012 public ActionSelectionBehavior fromCode(String codeString) throws IllegalArgumentException { 1013 if (codeString == null || "".equals(codeString)) 1014 if (codeString == null || "".equals(codeString)) 1015 return null; 1016 if ("any".equals(codeString)) 1017 return ActionSelectionBehavior.ANY; 1018 if ("all".equals(codeString)) 1019 return ActionSelectionBehavior.ALL; 1020 if ("all-or-none".equals(codeString)) 1021 return ActionSelectionBehavior.ALLORNONE; 1022 if ("exactly-one".equals(codeString)) 1023 return ActionSelectionBehavior.EXACTLYONE; 1024 if ("at-most-one".equals(codeString)) 1025 return ActionSelectionBehavior.ATMOSTONE; 1026 if ("one-or-more".equals(codeString)) 1027 return ActionSelectionBehavior.ONEORMORE; 1028 throw new IllegalArgumentException("Unknown ActionSelectionBehavior code '"+codeString+"'"); 1029 } 1030 public Enumeration<ActionSelectionBehavior> fromType(Base code) throws FHIRException { 1031 if (code == null) 1032 return null; 1033 if (code.isEmpty()) 1034 return new Enumeration<ActionSelectionBehavior>(this); 1035 String codeString = ((PrimitiveType) code).asStringValue(); 1036 if (codeString == null || "".equals(codeString)) 1037 return null; 1038 if ("any".equals(codeString)) 1039 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ANY); 1040 if ("all".equals(codeString)) 1041 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALL); 1042 if ("all-or-none".equals(codeString)) 1043 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALLORNONE); 1044 if ("exactly-one".equals(codeString)) 1045 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.EXACTLYONE); 1046 if ("at-most-one".equals(codeString)) 1047 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ATMOSTONE); 1048 if ("one-or-more".equals(codeString)) 1049 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ONEORMORE); 1050 throw new FHIRException("Unknown ActionSelectionBehavior code '"+codeString+"'"); 1051 } 1052 public String toCode(ActionSelectionBehavior code) { 1053 if (code == ActionSelectionBehavior.ANY) 1054 return "any"; 1055 if (code == ActionSelectionBehavior.ALL) 1056 return "all"; 1057 if (code == ActionSelectionBehavior.ALLORNONE) 1058 return "all-or-none"; 1059 if (code == ActionSelectionBehavior.EXACTLYONE) 1060 return "exactly-one"; 1061 if (code == ActionSelectionBehavior.ATMOSTONE) 1062 return "at-most-one"; 1063 if (code == ActionSelectionBehavior.ONEORMORE) 1064 return "one-or-more"; 1065 return "?"; 1066 } 1067 public String toSystem(ActionSelectionBehavior code) { 1068 return code.getSystem(); 1069 } 1070 } 1071 1072 public enum AdministrativeGender { 1073 /** 1074 * Male. 1075 */ 1076 MALE, 1077 /** 1078 * Female. 1079 */ 1080 FEMALE, 1081 /** 1082 * Other. 1083 */ 1084 OTHER, 1085 /** 1086 * Unknown. 1087 */ 1088 UNKNOWN, 1089 /** 1090 * added to help the parsers 1091 */ 1092 NULL; 1093 public static AdministrativeGender fromCode(String codeString) throws FHIRException { 1094 if (codeString == null || "".equals(codeString)) 1095 return null; 1096 if ("male".equals(codeString)) 1097 return MALE; 1098 if ("female".equals(codeString)) 1099 return FEMALE; 1100 if ("other".equals(codeString)) 1101 return OTHER; 1102 if ("unknown".equals(codeString)) 1103 return UNKNOWN; 1104 throw new FHIRException("Unknown AdministrativeGender code '"+codeString+"'"); 1105 } 1106 public String toCode() { 1107 switch (this) { 1108 case MALE: return "male"; 1109 case FEMALE: return "female"; 1110 case OTHER: return "other"; 1111 case UNKNOWN: return "unknown"; 1112 default: return "?"; 1113 } 1114 } 1115 public String getSystem() { 1116 switch (this) { 1117 case MALE: return "http://hl7.org/fhir/administrative-gender"; 1118 case FEMALE: return "http://hl7.org/fhir/administrative-gender"; 1119 case OTHER: return "http://hl7.org/fhir/administrative-gender"; 1120 case UNKNOWN: return "http://hl7.org/fhir/administrative-gender"; 1121 default: return "?"; 1122 } 1123 } 1124 public String getDefinition() { 1125 switch (this) { 1126 case MALE: return "Male."; 1127 case FEMALE: return "Female."; 1128 case OTHER: return "Other."; 1129 case UNKNOWN: return "Unknown."; 1130 default: return "?"; 1131 } 1132 } 1133 public String getDisplay() { 1134 switch (this) { 1135 case MALE: return "Male"; 1136 case FEMALE: return "Female"; 1137 case OTHER: return "Other"; 1138 case UNKNOWN: return "Unknown"; 1139 default: return "?"; 1140 } 1141 } 1142 } 1143 1144 public static class AdministrativeGenderEnumFactory implements EnumFactory<AdministrativeGender> { 1145 public AdministrativeGender fromCode(String codeString) throws IllegalArgumentException { 1146 if (codeString == null || "".equals(codeString)) 1147 if (codeString == null || "".equals(codeString)) 1148 return null; 1149 if ("male".equals(codeString)) 1150 return AdministrativeGender.MALE; 1151 if ("female".equals(codeString)) 1152 return AdministrativeGender.FEMALE; 1153 if ("other".equals(codeString)) 1154 return AdministrativeGender.OTHER; 1155 if ("unknown".equals(codeString)) 1156 return AdministrativeGender.UNKNOWN; 1157 throw new IllegalArgumentException("Unknown AdministrativeGender code '"+codeString+"'"); 1158 } 1159 public Enumeration<AdministrativeGender> fromType(Base code) throws FHIRException { 1160 if (code == null) 1161 return null; 1162 if (code.isEmpty()) 1163 return new Enumeration<AdministrativeGender>(this); 1164 String codeString = ((PrimitiveType) code).asStringValue(); 1165 if (codeString == null || "".equals(codeString)) 1166 return null; 1167 if ("male".equals(codeString)) 1168 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.MALE); 1169 if ("female".equals(codeString)) 1170 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.FEMALE); 1171 if ("other".equals(codeString)) 1172 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.OTHER); 1173 if ("unknown".equals(codeString)) 1174 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.UNKNOWN); 1175 throw new FHIRException("Unknown AdministrativeGender code '"+codeString+"'"); 1176 } 1177 public String toCode(AdministrativeGender code) { 1178 if (code == AdministrativeGender.MALE) 1179 return "male"; 1180 if (code == AdministrativeGender.FEMALE) 1181 return "female"; 1182 if (code == AdministrativeGender.OTHER) 1183 return "other"; 1184 if (code == AdministrativeGender.UNKNOWN) 1185 return "unknown"; 1186 return "?"; 1187 } 1188 public String toSystem(AdministrativeGender code) { 1189 return code.getSystem(); 1190 } 1191 } 1192 1193 public enum BindingStrength { 1194 /** 1195 * To be conformant, the concept in this element SHALL be from the specified value set. 1196 */ 1197 REQUIRED, 1198 /** 1199 * To be conformant, the concept in this element SHALL be from the specified value set if any of the codes within the value set can apply to the concept being communicated. If the value set does not cover the concept (based on human review), alternate codings (or, data type allowing, text) may be included instead. 1200 */ 1201 EXTENSIBLE, 1202 /** 1203 * Instances are encouraged to draw from the specified codes for interoperability purposes but are not required to do so to be considered conformant. 1204 */ 1205 PREFERRED, 1206 /** 1207 * Instances are not expected or even encouraged to draw from the specified value set. The value set merely provides examples of the types of concepts intended to be included. 1208 */ 1209 EXAMPLE, 1210 /** 1211 * added to help the parsers 1212 */ 1213 NULL; 1214 public static BindingStrength fromCode(String codeString) throws FHIRException { 1215 if (codeString == null || "".equals(codeString)) 1216 return null; 1217 if ("required".equals(codeString)) 1218 return REQUIRED; 1219 if ("extensible".equals(codeString)) 1220 return EXTENSIBLE; 1221 if ("preferred".equals(codeString)) 1222 return PREFERRED; 1223 if ("example".equals(codeString)) 1224 return EXAMPLE; 1225 throw new FHIRException("Unknown BindingStrength code '"+codeString+"'"); 1226 } 1227 public String toCode() { 1228 switch (this) { 1229 case REQUIRED: return "required"; 1230 case EXTENSIBLE: return "extensible"; 1231 case PREFERRED: return "preferred"; 1232 case EXAMPLE: return "example"; 1233 default: return "?"; 1234 } 1235 } 1236 public String getSystem() { 1237 switch (this) { 1238 case REQUIRED: return "http://hl7.org/fhir/binding-strength"; 1239 case EXTENSIBLE: return "http://hl7.org/fhir/binding-strength"; 1240 case PREFERRED: return "http://hl7.org/fhir/binding-strength"; 1241 case EXAMPLE: return "http://hl7.org/fhir/binding-strength"; 1242 default: return "?"; 1243 } 1244 } 1245 public String getDefinition() { 1246 switch (this) { 1247 case REQUIRED: return "To be conformant, the concept in this element SHALL be from the specified value set."; 1248 case EXTENSIBLE: return "To be conformant, the concept in this element SHALL be from the specified value set if any of the codes within the value set can apply to the concept being communicated. If the value set does not cover the concept (based on human review), alternate codings (or, data type allowing, text) may be included instead."; 1249 case PREFERRED: return "Instances are encouraged to draw from the specified codes for interoperability purposes but are not required to do so to be considered conformant."; 1250 case EXAMPLE: return "Instances are not expected or even encouraged to draw from the specified value set. The value set merely provides examples of the types of concepts intended to be included."; 1251 default: return "?"; 1252 } 1253 } 1254 public String getDisplay() { 1255 switch (this) { 1256 case REQUIRED: return "Required"; 1257 case EXTENSIBLE: return "Extensible"; 1258 case PREFERRED: return "Preferred"; 1259 case EXAMPLE: return "Example"; 1260 default: return "?"; 1261 } 1262 } 1263 } 1264 1265 public static class BindingStrengthEnumFactory implements EnumFactory<BindingStrength> { 1266 public BindingStrength fromCode(String codeString) throws IllegalArgumentException { 1267 if (codeString == null || "".equals(codeString)) 1268 if (codeString == null || "".equals(codeString)) 1269 return null; 1270 if ("required".equals(codeString)) 1271 return BindingStrength.REQUIRED; 1272 if ("extensible".equals(codeString)) 1273 return BindingStrength.EXTENSIBLE; 1274 if ("preferred".equals(codeString)) 1275 return BindingStrength.PREFERRED; 1276 if ("example".equals(codeString)) 1277 return BindingStrength.EXAMPLE; 1278 throw new IllegalArgumentException("Unknown BindingStrength code '"+codeString+"'"); 1279 } 1280 public Enumeration<BindingStrength> fromType(Base code) throws FHIRException { 1281 if (code == null) 1282 return null; 1283 if (code.isEmpty()) 1284 return new Enumeration<BindingStrength>(this); 1285 String codeString = ((PrimitiveType) code).asStringValue(); 1286 if (codeString == null || "".equals(codeString)) 1287 return null; 1288 if ("required".equals(codeString)) 1289 return new Enumeration<BindingStrength>(this, BindingStrength.REQUIRED); 1290 if ("extensible".equals(codeString)) 1291 return new Enumeration<BindingStrength>(this, BindingStrength.EXTENSIBLE); 1292 if ("preferred".equals(codeString)) 1293 return new Enumeration<BindingStrength>(this, BindingStrength.PREFERRED); 1294 if ("example".equals(codeString)) 1295 return new Enumeration<BindingStrength>(this, BindingStrength.EXAMPLE); 1296 throw new FHIRException("Unknown BindingStrength code '"+codeString+"'"); 1297 } 1298 public String toCode(BindingStrength code) { 1299 if (code == BindingStrength.REQUIRED) 1300 return "required"; 1301 if (code == BindingStrength.EXTENSIBLE) 1302 return "extensible"; 1303 if (code == BindingStrength.PREFERRED) 1304 return "preferred"; 1305 if (code == BindingStrength.EXAMPLE) 1306 return "example"; 1307 return "?"; 1308 } 1309 public String toSystem(BindingStrength code) { 1310 return code.getSystem(); 1311 } 1312 } 1313 1314 public enum CapabilityStatementKind { 1315 /** 1316 * The CapabilityStatement instance represents the present capabilities of a specific system instance. This is the kind returned by /metadata for a FHIR server end-point. 1317 */ 1318 INSTANCE, 1319 /** 1320 * The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation. 1321 */ 1322 CAPABILITY, 1323 /** 1324 * The CapabilityStatement instance represents a set of requirements for other systems to meet; e.g. as part of an implementation guide or 'request for proposal'. 1325 */ 1326 REQUIREMENTS, 1327 /** 1328 * added to help the parsers 1329 */ 1330 NULL; 1331 public static CapabilityStatementKind fromCode(String codeString) throws FHIRException { 1332 if (codeString == null || "".equals(codeString)) 1333 return null; 1334 if ("instance".equals(codeString)) 1335 return INSTANCE; 1336 if ("capability".equals(codeString)) 1337 return CAPABILITY; 1338 if ("requirements".equals(codeString)) 1339 return REQUIREMENTS; 1340 throw new FHIRException("Unknown CapabilityStatementKind code '"+codeString+"'"); 1341 } 1342 public String toCode() { 1343 switch (this) { 1344 case INSTANCE: return "instance"; 1345 case CAPABILITY: return "capability"; 1346 case REQUIREMENTS: return "requirements"; 1347 default: return "?"; 1348 } 1349 } 1350 public String getSystem() { 1351 switch (this) { 1352 case INSTANCE: return "http://hl7.org/fhir/capability-statement-kind"; 1353 case CAPABILITY: return "http://hl7.org/fhir/capability-statement-kind"; 1354 case REQUIREMENTS: return "http://hl7.org/fhir/capability-statement-kind"; 1355 default: return "?"; 1356 } 1357 } 1358 public String getDefinition() { 1359 switch (this) { 1360 case INSTANCE: return "The CapabilityStatement instance represents the present capabilities of a specific system instance. This is the kind returned by /metadata for a FHIR server end-point."; 1361 case CAPABILITY: return "The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation."; 1362 case REQUIREMENTS: return "The CapabilityStatement instance represents a set of requirements for other systems to meet; e.g. as part of an implementation guide or 'request for proposal'."; 1363 default: return "?"; 1364 } 1365 } 1366 public String getDisplay() { 1367 switch (this) { 1368 case INSTANCE: return "Instance"; 1369 case CAPABILITY: return "Capability"; 1370 case REQUIREMENTS: return "Requirements"; 1371 default: return "?"; 1372 } 1373 } 1374 } 1375 1376 public static class CapabilityStatementKindEnumFactory implements EnumFactory<CapabilityStatementKind> { 1377 public CapabilityStatementKind fromCode(String codeString) throws IllegalArgumentException { 1378 if (codeString == null || "".equals(codeString)) 1379 if (codeString == null || "".equals(codeString)) 1380 return null; 1381 if ("instance".equals(codeString)) 1382 return CapabilityStatementKind.INSTANCE; 1383 if ("capability".equals(codeString)) 1384 return CapabilityStatementKind.CAPABILITY; 1385 if ("requirements".equals(codeString)) 1386 return CapabilityStatementKind.REQUIREMENTS; 1387 throw new IllegalArgumentException("Unknown CapabilityStatementKind code '"+codeString+"'"); 1388 } 1389 public Enumeration<CapabilityStatementKind> fromType(Base code) throws FHIRException { 1390 if (code == null) 1391 return null; 1392 if (code.isEmpty()) 1393 return new Enumeration<CapabilityStatementKind>(this); 1394 String codeString = ((PrimitiveType) code).asStringValue(); 1395 if (codeString == null || "".equals(codeString)) 1396 return null; 1397 if ("instance".equals(codeString)) 1398 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.INSTANCE); 1399 if ("capability".equals(codeString)) 1400 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.CAPABILITY); 1401 if ("requirements".equals(codeString)) 1402 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.REQUIREMENTS); 1403 throw new FHIRException("Unknown CapabilityStatementKind code '"+codeString+"'"); 1404 } 1405 public String toCode(CapabilityStatementKind code) { 1406 if (code == CapabilityStatementKind.INSTANCE) 1407 return "instance"; 1408 if (code == CapabilityStatementKind.CAPABILITY) 1409 return "capability"; 1410 if (code == CapabilityStatementKind.REQUIREMENTS) 1411 return "requirements"; 1412 return "?"; 1413 } 1414 public String toSystem(CapabilityStatementKind code) { 1415 return code.getSystem(); 1416 } 1417 } 1418 1419 public enum ClaimProcessingCodes { 1420 /** 1421 * null 1422 */ 1423 QUEUED, 1424 /** 1425 * The processing completed without errors. 1426 */ 1427 COMPLETE, 1428 /** 1429 * The processing identified errors. 1430 */ 1431 ERROR, 1432 /** 1433 * No errors have been detected and some of the adjudication has been performed. 1434 */ 1435 PARTIAL, 1436 /** 1437 * added to help the parsers 1438 */ 1439 NULL; 1440 public static ClaimProcessingCodes fromCode(String codeString) throws FHIRException { 1441 if (codeString == null || "".equals(codeString)) 1442 return null; 1443 if ("queued".equals(codeString)) 1444 return QUEUED; 1445 if ("complete".equals(codeString)) 1446 return COMPLETE; 1447 if ("error".equals(codeString)) 1448 return ERROR; 1449 if ("partial".equals(codeString)) 1450 return PARTIAL; 1451 throw new FHIRException("Unknown ClaimProcessingCodes code '"+codeString+"'"); 1452 } 1453 public String toCode() { 1454 switch (this) { 1455 case QUEUED: return "queued"; 1456 case COMPLETE: return "complete"; 1457 case ERROR: return "error"; 1458 case PARTIAL: return "partial"; 1459 default: return "?"; 1460 } 1461 } 1462 public String getSystem() { 1463 switch (this) { 1464 case QUEUED: return "http://hl7.org/fhir/remittance-outcome"; 1465 case COMPLETE: return "http://hl7.org/fhir/remittance-outcome"; 1466 case ERROR: return "http://hl7.org/fhir/remittance-outcome"; 1467 case PARTIAL: return "http://hl7.org/fhir/remittance-outcome"; 1468 default: return "?"; 1469 } 1470 } 1471 public String getDefinition() { 1472 switch (this) { 1473 case QUEUED: return ""; 1474 case COMPLETE: return "The processing completed without errors."; 1475 case ERROR: return "The processing identified errors."; 1476 case PARTIAL: return "No errors have been detected and some of the adjudication has been performed."; 1477 default: return "?"; 1478 } 1479 } 1480 public String getDisplay() { 1481 switch (this) { 1482 case QUEUED: return "Queued"; 1483 case COMPLETE: return "Processing Complete"; 1484 case ERROR: return "Error"; 1485 case PARTIAL: return "Partial Processing"; 1486 default: return "?"; 1487 } 1488 } 1489 } 1490 1491 public static class ClaimProcessingCodesEnumFactory implements EnumFactory<ClaimProcessingCodes> { 1492 public ClaimProcessingCodes fromCode(String codeString) throws IllegalArgumentException { 1493 if (codeString == null || "".equals(codeString)) 1494 if (codeString == null || "".equals(codeString)) 1495 return null; 1496 if ("queued".equals(codeString)) 1497 return ClaimProcessingCodes.QUEUED; 1498 if ("complete".equals(codeString)) 1499 return ClaimProcessingCodes.COMPLETE; 1500 if ("error".equals(codeString)) 1501 return ClaimProcessingCodes.ERROR; 1502 if ("partial".equals(codeString)) 1503 return ClaimProcessingCodes.PARTIAL; 1504 throw new IllegalArgumentException("Unknown ClaimProcessingCodes code '"+codeString+"'"); 1505 } 1506 public Enumeration<ClaimProcessingCodes> fromType(Base code) throws FHIRException { 1507 if (code == null) 1508 return null; 1509 if (code.isEmpty()) 1510 return new Enumeration<ClaimProcessingCodes>(this); 1511 String codeString = ((PrimitiveType) code).asStringValue(); 1512 if (codeString == null || "".equals(codeString)) 1513 return null; 1514 if ("queued".equals(codeString)) 1515 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.QUEUED); 1516 if ("complete".equals(codeString)) 1517 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.COMPLETE); 1518 if ("error".equals(codeString)) 1519 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.ERROR); 1520 if ("partial".equals(codeString)) 1521 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.PARTIAL); 1522 throw new FHIRException("Unknown ClaimProcessingCodes code '"+codeString+"'"); 1523 } 1524 public String toCode(ClaimProcessingCodes code) { 1525 if (code == ClaimProcessingCodes.QUEUED) 1526 return "queued"; 1527 if (code == ClaimProcessingCodes.COMPLETE) 1528 return "complete"; 1529 if (code == ClaimProcessingCodes.ERROR) 1530 return "error"; 1531 if (code == ClaimProcessingCodes.PARTIAL) 1532 return "partial"; 1533 return "?"; 1534 } 1535 public String toSystem(ClaimProcessingCodes code) { 1536 return code.getSystem(); 1537 } 1538 } 1539 1540 public enum CompartmentType { 1541 /** 1542 * The compartment definition is for the patient compartment. 1543 */ 1544 PATIENT, 1545 /** 1546 * The compartment definition is for the encounter compartment. 1547 */ 1548 ENCOUNTER, 1549 /** 1550 * The compartment definition is for the related-person compartment. 1551 */ 1552 RELATEDPERSON, 1553 /** 1554 * The compartment definition is for the practitioner compartment. 1555 */ 1556 PRACTITIONER, 1557 /** 1558 * The compartment definition is for the device compartment. 1559 */ 1560 DEVICE, 1561 /** 1562 * added to help the parsers 1563 */ 1564 NULL; 1565 public static CompartmentType fromCode(String codeString) throws FHIRException { 1566 if (codeString == null || "".equals(codeString)) 1567 return null; 1568 if ("Patient".equals(codeString)) 1569 return PATIENT; 1570 if ("Encounter".equals(codeString)) 1571 return ENCOUNTER; 1572 if ("RelatedPerson".equals(codeString)) 1573 return RELATEDPERSON; 1574 if ("Practitioner".equals(codeString)) 1575 return PRACTITIONER; 1576 if ("Device".equals(codeString)) 1577 return DEVICE; 1578 throw new FHIRException("Unknown CompartmentType code '"+codeString+"'"); 1579 } 1580 public String toCode() { 1581 switch (this) { 1582 case PATIENT: return "Patient"; 1583 case ENCOUNTER: return "Encounter"; 1584 case RELATEDPERSON: return "RelatedPerson"; 1585 case PRACTITIONER: return "Practitioner"; 1586 case DEVICE: return "Device"; 1587 default: return "?"; 1588 } 1589 } 1590 public String getSystem() { 1591 switch (this) { 1592 case PATIENT: return "http://hl7.org/fhir/compartment-type"; 1593 case ENCOUNTER: return "http://hl7.org/fhir/compartment-type"; 1594 case RELATEDPERSON: return "http://hl7.org/fhir/compartment-type"; 1595 case PRACTITIONER: return "http://hl7.org/fhir/compartment-type"; 1596 case DEVICE: return "http://hl7.org/fhir/compartment-type"; 1597 default: return "?"; 1598 } 1599 } 1600 public String getDefinition() { 1601 switch (this) { 1602 case PATIENT: return "The compartment definition is for the patient compartment."; 1603 case ENCOUNTER: return "The compartment definition is for the encounter compartment."; 1604 case RELATEDPERSON: return "The compartment definition is for the related-person compartment."; 1605 case PRACTITIONER: return "The compartment definition is for the practitioner compartment."; 1606 case DEVICE: return "The compartment definition is for the device compartment."; 1607 default: return "?"; 1608 } 1609 } 1610 public String getDisplay() { 1611 switch (this) { 1612 case PATIENT: return "Patient"; 1613 case ENCOUNTER: return "Encounter"; 1614 case RELATEDPERSON: return "RelatedPerson"; 1615 case PRACTITIONER: return "Practitioner"; 1616 case DEVICE: return "Device"; 1617 default: return "?"; 1618 } 1619 } 1620 } 1621 1622 public static class CompartmentTypeEnumFactory implements EnumFactory<CompartmentType> { 1623 public CompartmentType fromCode(String codeString) throws IllegalArgumentException { 1624 if (codeString == null || "".equals(codeString)) 1625 if (codeString == null || "".equals(codeString)) 1626 return null; 1627 if ("Patient".equals(codeString)) 1628 return CompartmentType.PATIENT; 1629 if ("Encounter".equals(codeString)) 1630 return CompartmentType.ENCOUNTER; 1631 if ("RelatedPerson".equals(codeString)) 1632 return CompartmentType.RELATEDPERSON; 1633 if ("Practitioner".equals(codeString)) 1634 return CompartmentType.PRACTITIONER; 1635 if ("Device".equals(codeString)) 1636 return CompartmentType.DEVICE; 1637 throw new IllegalArgumentException("Unknown CompartmentType code '"+codeString+"'"); 1638 } 1639 public Enumeration<CompartmentType> fromType(Base code) throws FHIRException { 1640 if (code == null) 1641 return null; 1642 if (code.isEmpty()) 1643 return new Enumeration<CompartmentType>(this); 1644 String codeString = ((PrimitiveType) code).asStringValue(); 1645 if (codeString == null || "".equals(codeString)) 1646 return null; 1647 if ("Patient".equals(codeString)) 1648 return new Enumeration<CompartmentType>(this, CompartmentType.PATIENT); 1649 if ("Encounter".equals(codeString)) 1650 return new Enumeration<CompartmentType>(this, CompartmentType.ENCOUNTER); 1651 if ("RelatedPerson".equals(codeString)) 1652 return new Enumeration<CompartmentType>(this, CompartmentType.RELATEDPERSON); 1653 if ("Practitioner".equals(codeString)) 1654 return new Enumeration<CompartmentType>(this, CompartmentType.PRACTITIONER); 1655 if ("Device".equals(codeString)) 1656 return new Enumeration<CompartmentType>(this, CompartmentType.DEVICE); 1657 throw new FHIRException("Unknown CompartmentType code '"+codeString+"'"); 1658 } 1659 public String toCode(CompartmentType code) { 1660 if (code == CompartmentType.PATIENT) 1661 return "Patient"; 1662 if (code == CompartmentType.ENCOUNTER) 1663 return "Encounter"; 1664 if (code == CompartmentType.RELATEDPERSON) 1665 return "RelatedPerson"; 1666 if (code == CompartmentType.PRACTITIONER) 1667 return "Practitioner"; 1668 if (code == CompartmentType.DEVICE) 1669 return "Device"; 1670 return "?"; 1671 } 1672 public String toSystem(CompartmentType code) { 1673 return code.getSystem(); 1674 } 1675 } 1676 1677 public enum CompositionStatus { 1678 /** 1679 * This is a preliminary composition or document (also known as initial or interim). The content may be incomplete or unverified. 1680 */ 1681 PRELIMINARY, 1682 /** 1683 * This version of the composition is complete and verified by an appropriate person and no further work is planned. Any subsequent updates would be on a new version of the composition. 1684 */ 1685 FINAL, 1686 /** 1687 * The composition content or the referenced resources have been modified (edited or added to) subsequent to being released as "final" and the composition is complete and verified by an authorized person. 1688 */ 1689 AMENDED, 1690 /** 1691 * The composition or document was originally created/issued in error, and this is an amendment that marks that the entire series should not be considered as valid. 1692 */ 1693 ENTEREDINERROR, 1694 /** 1695 * added to help the parsers 1696 */ 1697 NULL; 1698 public static CompositionStatus fromCode(String codeString) throws FHIRException { 1699 if (codeString == null || "".equals(codeString)) 1700 return null; 1701 if ("preliminary".equals(codeString)) 1702 return PRELIMINARY; 1703 if ("final".equals(codeString)) 1704 return FINAL; 1705 if ("amended".equals(codeString)) 1706 return AMENDED; 1707 if ("entered-in-error".equals(codeString)) 1708 return ENTEREDINERROR; 1709 throw new FHIRException("Unknown CompositionStatus code '"+codeString+"'"); 1710 } 1711 public String toCode() { 1712 switch (this) { 1713 case PRELIMINARY: return "preliminary"; 1714 case FINAL: return "final"; 1715 case AMENDED: return "amended"; 1716 case ENTEREDINERROR: return "entered-in-error"; 1717 default: return "?"; 1718 } 1719 } 1720 public String getSystem() { 1721 switch (this) { 1722 case PRELIMINARY: return "http://hl7.org/fhir/composition-status"; 1723 case FINAL: return "http://hl7.org/fhir/composition-status"; 1724 case AMENDED: return "http://hl7.org/fhir/composition-status"; 1725 case ENTEREDINERROR: return "http://hl7.org/fhir/composition-status"; 1726 default: return "?"; 1727 } 1728 } 1729 public String getDefinition() { 1730 switch (this) { 1731 case PRELIMINARY: return "This is a preliminary composition or document (also known as initial or interim). The content may be incomplete or unverified."; 1732 case FINAL: return "This version of the composition is complete and verified by an appropriate person and no further work is planned. Any subsequent updates would be on a new version of the composition."; 1733 case AMENDED: return "The composition content or the referenced resources have been modified (edited or added to) subsequent to being released as \"final\" and the composition is complete and verified by an authorized person."; 1734 case ENTEREDINERROR: return "The composition or document was originally created/issued in error, and this is an amendment that marks that the entire series should not be considered as valid."; 1735 default: return "?"; 1736 } 1737 } 1738 public String getDisplay() { 1739 switch (this) { 1740 case PRELIMINARY: return "Preliminary"; 1741 case FINAL: return "Final"; 1742 case AMENDED: return "Amended"; 1743 case ENTEREDINERROR: return "Entered in Error"; 1744 default: return "?"; 1745 } 1746 } 1747 } 1748 1749 public static class CompositionStatusEnumFactory implements EnumFactory<CompositionStatus> { 1750 public CompositionStatus fromCode(String codeString) throws IllegalArgumentException { 1751 if (codeString == null || "".equals(codeString)) 1752 if (codeString == null || "".equals(codeString)) 1753 return null; 1754 if ("preliminary".equals(codeString)) 1755 return CompositionStatus.PRELIMINARY; 1756 if ("final".equals(codeString)) 1757 return CompositionStatus.FINAL; 1758 if ("amended".equals(codeString)) 1759 return CompositionStatus.AMENDED; 1760 if ("entered-in-error".equals(codeString)) 1761 return CompositionStatus.ENTEREDINERROR; 1762 throw new IllegalArgumentException("Unknown CompositionStatus code '"+codeString+"'"); 1763 } 1764 public Enumeration<CompositionStatus> fromType(Base code) throws FHIRException { 1765 if (code == null) 1766 return null; 1767 if (code.isEmpty()) 1768 return new Enumeration<CompositionStatus>(this); 1769 String codeString = ((PrimitiveType) code).asStringValue(); 1770 if (codeString == null || "".equals(codeString)) 1771 return null; 1772 if ("preliminary".equals(codeString)) 1773 return new Enumeration<CompositionStatus>(this, CompositionStatus.PRELIMINARY); 1774 if ("final".equals(codeString)) 1775 return new Enumeration<CompositionStatus>(this, CompositionStatus.FINAL); 1776 if ("amended".equals(codeString)) 1777 return new Enumeration<CompositionStatus>(this, CompositionStatus.AMENDED); 1778 if ("entered-in-error".equals(codeString)) 1779 return new Enumeration<CompositionStatus>(this, CompositionStatus.ENTEREDINERROR); 1780 throw new FHIRException("Unknown CompositionStatus code '"+codeString+"'"); 1781 } 1782 public String toCode(CompositionStatus code) { 1783 if (code == CompositionStatus.PRELIMINARY) 1784 return "preliminary"; 1785 if (code == CompositionStatus.FINAL) 1786 return "final"; 1787 if (code == CompositionStatus.AMENDED) 1788 return "amended"; 1789 if (code == CompositionStatus.ENTEREDINERROR) 1790 return "entered-in-error"; 1791 return "?"; 1792 } 1793 public String toSystem(CompositionStatus code) { 1794 return code.getSystem(); 1795 } 1796 } 1797 1798 public enum ConceptMapRelationship { 1799 /** 1800 * The concepts are related to each other, but the exact relationship is not known. 1801 */ 1802 RELATEDTO, 1803 /** 1804 * The definitions of the concepts mean the same thing. 1805 */ 1806 EQUIVALENT, 1807 /** 1808 * The target concept is broader in meaning than the source concept. 1809 */ 1810 BROADER, 1811 /** 1812 * The target concept is narrower in meaning than the source concept. 1813 */ 1814 NARROWER, 1815 /** 1816 * This is an explicit assertion that the target concept is not related to the source concept. 1817 */ 1818 NOTRELATEDTO, 1819 /** 1820 * added to help the parsers 1821 */ 1822 NULL; 1823 public static ConceptMapRelationship fromCode(String codeString) throws FHIRException { 1824 if (codeString == null || "".equals(codeString)) 1825 return null; 1826 if ("related-to".equals(codeString)) 1827 return RELATEDTO; 1828 if ("equivalent".equals(codeString)) 1829 return EQUIVALENT; 1830 if ("broader".equals(codeString)) 1831 return BROADER; 1832 if ("narrower".equals(codeString)) 1833 return NARROWER; 1834 if ("not-related-to".equals(codeString)) 1835 return NOTRELATEDTO; 1836 throw new FHIRException("Unknown ConceptMapRelationship code '"+codeString+"'"); 1837 } 1838 public String toCode() { 1839 switch (this) { 1840 case RELATEDTO: return "related-to"; 1841 case EQUIVALENT: return "equivalent"; 1842 case BROADER: return "broader"; 1843 case NARROWER: return "narrower"; 1844 case NOTRELATEDTO: return "not-related-to"; 1845 default: return "?"; 1846 } 1847 } 1848 public String getSystem() { 1849 switch (this) { 1850 case RELATEDTO: return "http://hl7.org/fhir/concept-map-relationship"; 1851 case EQUIVALENT: return "http://hl7.org/fhir/concept-map-relationship"; 1852 case BROADER: return "http://hl7.org/fhir/concept-map-relationship"; 1853 case NARROWER: return "http://hl7.org/fhir/concept-map-relationship"; 1854 case NOTRELATEDTO: return "http://hl7.org/fhir/concept-map-relationship"; 1855 default: return "?"; 1856 } 1857 } 1858 public String getDefinition() { 1859 switch (this) { 1860 case RELATEDTO: return "The concepts are related to each other, but the exact relationship is not known."; 1861 case EQUIVALENT: return "The definitions of the concepts mean the same thing."; 1862 case BROADER: return "The target concept is broader in meaning than the source concept."; 1863 case NARROWER: return "The target concept is narrower in meaning than the source concept."; 1864 case NOTRELATEDTO: return "This is an explicit assertion that the target concept is not related to the source concept."; 1865 default: return "?"; 1866 } 1867 } 1868 public String getDisplay() { 1869 switch (this) { 1870 case RELATEDTO: return "Related To"; 1871 case EQUIVALENT: return "Equivalent"; 1872 case BROADER: return "Broader"; 1873 case NARROWER: return "Narrower"; 1874 case NOTRELATEDTO: return "Not Related To"; 1875 default: return "?"; 1876 } 1877 } 1878 } 1879 1880 public static class ConceptMapRelationshipEnumFactory implements EnumFactory<ConceptMapRelationship> { 1881 public ConceptMapRelationship fromCode(String codeString) throws IllegalArgumentException { 1882 if (codeString == null || "".equals(codeString)) 1883 if (codeString == null || "".equals(codeString)) 1884 return null; 1885 if ("related-to".equals(codeString)) 1886 return ConceptMapRelationship.RELATEDTO; 1887 if ("equivalent".equals(codeString)) 1888 return ConceptMapRelationship.EQUIVALENT; 1889 if ("broader".equals(codeString)) 1890 return ConceptMapRelationship.BROADER; 1891 if ("narrower".equals(codeString)) 1892 return ConceptMapRelationship.NARROWER; 1893 if ("not-related-to".equals(codeString)) 1894 return ConceptMapRelationship.NOTRELATEDTO; 1895 throw new IllegalArgumentException("Unknown ConceptMapRelationship code '"+codeString+"'"); 1896 } 1897 public Enumeration<ConceptMapRelationship> fromType(Base code) throws FHIRException { 1898 if (code == null) 1899 return null; 1900 if (code.isEmpty()) 1901 return new Enumeration<ConceptMapRelationship>(this); 1902 String codeString = ((PrimitiveType) code).asStringValue(); 1903 if (codeString == null || "".equals(codeString)) 1904 return null; 1905 if ("related-to".equals(codeString)) 1906 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.RELATEDTO); 1907 if ("equivalent".equals(codeString)) 1908 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.EQUIVALENT); 1909 if ("broader".equals(codeString)) 1910 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.BROADER); 1911 if ("narrower".equals(codeString)) 1912 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NARROWER); 1913 if ("not-related-to".equals(codeString)) 1914 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NOTRELATEDTO); 1915 throw new FHIRException("Unknown ConceptMapRelationship code '"+codeString+"'"); 1916 } 1917 public String toCode(ConceptMapRelationship code) { 1918 if (code == ConceptMapRelationship.RELATEDTO) 1919 return "related-to"; 1920 if (code == ConceptMapRelationship.EQUIVALENT) 1921 return "equivalent"; 1922 if (code == ConceptMapRelationship.BROADER) 1923 return "broader"; 1924 if (code == ConceptMapRelationship.NARROWER) 1925 return "narrower"; 1926 if (code == ConceptMapRelationship.NOTRELATEDTO) 1927 return "not-related-to"; 1928 return "?"; 1929 } 1930 public String toSystem(ConceptMapRelationship code) { 1931 return code.getSystem(); 1932 } 1933 } 1934 1935 public enum DaysOfWeek { 1936 /** 1937 * Monday. 1938 */ 1939 MON, 1940 /** 1941 * Tuesday. 1942 */ 1943 TUE, 1944 /** 1945 * Wednesday. 1946 */ 1947 WED, 1948 /** 1949 * Thursday. 1950 */ 1951 THU, 1952 /** 1953 * Friday. 1954 */ 1955 FRI, 1956 /** 1957 * Saturday. 1958 */ 1959 SAT, 1960 /** 1961 * Sunday. 1962 */ 1963 SUN, 1964 /** 1965 * added to help the parsers 1966 */ 1967 NULL; 1968 public static DaysOfWeek fromCode(String codeString) throws FHIRException { 1969 if (codeString == null || "".equals(codeString)) 1970 return null; 1971 if ("mon".equals(codeString)) 1972 return MON; 1973 if ("tue".equals(codeString)) 1974 return TUE; 1975 if ("wed".equals(codeString)) 1976 return WED; 1977 if ("thu".equals(codeString)) 1978 return THU; 1979 if ("fri".equals(codeString)) 1980 return FRI; 1981 if ("sat".equals(codeString)) 1982 return SAT; 1983 if ("sun".equals(codeString)) 1984 return SUN; 1985 throw new FHIRException("Unknown DaysOfWeek code '"+codeString+"'"); 1986 } 1987 public String toCode() { 1988 switch (this) { 1989 case MON: return "mon"; 1990 case TUE: return "tue"; 1991 case WED: return "wed"; 1992 case THU: return "thu"; 1993 case FRI: return "fri"; 1994 case SAT: return "sat"; 1995 case SUN: return "sun"; 1996 default: return "?"; 1997 } 1998 } 1999 public String getSystem() { 2000 switch (this) { 2001 case MON: return "http://hl7.org/fhir/days-of-week"; 2002 case TUE: return "http://hl7.org/fhir/days-of-week"; 2003 case WED: return "http://hl7.org/fhir/days-of-week"; 2004 case THU: return "http://hl7.org/fhir/days-of-week"; 2005 case FRI: return "http://hl7.org/fhir/days-of-week"; 2006 case SAT: return "http://hl7.org/fhir/days-of-week"; 2007 case SUN: return "http://hl7.org/fhir/days-of-week"; 2008 default: return "?"; 2009 } 2010 } 2011 public String getDefinition() { 2012 switch (this) { 2013 case MON: return "Monday."; 2014 case TUE: return "Tuesday."; 2015 case WED: return "Wednesday."; 2016 case THU: return "Thursday."; 2017 case FRI: return "Friday."; 2018 case SAT: return "Saturday."; 2019 case SUN: return "Sunday."; 2020 default: return "?"; 2021 } 2022 } 2023 public String getDisplay() { 2024 switch (this) { 2025 case MON: return "Monday"; 2026 case TUE: return "Tuesday"; 2027 case WED: return "Wednesday"; 2028 case THU: return "Thursday"; 2029 case FRI: return "Friday"; 2030 case SAT: return "Saturday"; 2031 case SUN: return "Sunday"; 2032 default: return "?"; 2033 } 2034 } 2035 } 2036 2037 public static class DaysOfWeekEnumFactory implements EnumFactory<DaysOfWeek> { 2038 public DaysOfWeek fromCode(String codeString) throws IllegalArgumentException { 2039 if (codeString == null || "".equals(codeString)) 2040 if (codeString == null || "".equals(codeString)) 2041 return null; 2042 if ("mon".equals(codeString)) 2043 return DaysOfWeek.MON; 2044 if ("tue".equals(codeString)) 2045 return DaysOfWeek.TUE; 2046 if ("wed".equals(codeString)) 2047 return DaysOfWeek.WED; 2048 if ("thu".equals(codeString)) 2049 return DaysOfWeek.THU; 2050 if ("fri".equals(codeString)) 2051 return DaysOfWeek.FRI; 2052 if ("sat".equals(codeString)) 2053 return DaysOfWeek.SAT; 2054 if ("sun".equals(codeString)) 2055 return DaysOfWeek.SUN; 2056 throw new IllegalArgumentException("Unknown DaysOfWeek code '"+codeString+"'"); 2057 } 2058 public Enumeration<DaysOfWeek> fromType(Base code) throws FHIRException { 2059 if (code == null) 2060 return null; 2061 if (code.isEmpty()) 2062 return new Enumeration<DaysOfWeek>(this); 2063 String codeString = ((PrimitiveType) code).asStringValue(); 2064 if (codeString == null || "".equals(codeString)) 2065 return null; 2066 if ("mon".equals(codeString)) 2067 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.MON); 2068 if ("tue".equals(codeString)) 2069 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.TUE); 2070 if ("wed".equals(codeString)) 2071 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.WED); 2072 if ("thu".equals(codeString)) 2073 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.THU); 2074 if ("fri".equals(codeString)) 2075 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.FRI); 2076 if ("sat".equals(codeString)) 2077 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.SAT); 2078 if ("sun".equals(codeString)) 2079 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.SUN); 2080 throw new FHIRException("Unknown DaysOfWeek code '"+codeString+"'"); 2081 } 2082 public String toCode(DaysOfWeek code) { 2083 if (code == DaysOfWeek.MON) 2084 return "mon"; 2085 if (code == DaysOfWeek.TUE) 2086 return "tue"; 2087 if (code == DaysOfWeek.WED) 2088 return "wed"; 2089 if (code == DaysOfWeek.THU) 2090 return "thu"; 2091 if (code == DaysOfWeek.FRI) 2092 return "fri"; 2093 if (code == DaysOfWeek.SAT) 2094 return "sat"; 2095 if (code == DaysOfWeek.SUN) 2096 return "sun"; 2097 return "?"; 2098 } 2099 public String toSystem(DaysOfWeek code) { 2100 return code.getSystem(); 2101 } 2102 } 2103 2104 public enum DeviceNameType { 2105 /** 2106 * UDI Label name. 2107 */ 2108 UDILABELNAME, 2109 /** 2110 * User Friendly name. 2111 */ 2112 USERFRIENDLYNAME, 2113 /** 2114 * Patient Reported name. 2115 */ 2116 PATIENTREPORTEDNAME, 2117 /** 2118 * Manufacturer name. 2119 */ 2120 MANUFACTURERNAME, 2121 /** 2122 * Model name. 2123 */ 2124 MODELNAME, 2125 /** 2126 * other. 2127 */ 2128 OTHER, 2129 /** 2130 * added to help the parsers 2131 */ 2132 NULL; 2133 public static DeviceNameType fromCode(String codeString) throws FHIRException { 2134 if (codeString == null || "".equals(codeString)) 2135 return null; 2136 if ("udi-label-name".equals(codeString)) 2137 return UDILABELNAME; 2138 if ("user-friendly-name".equals(codeString)) 2139 return USERFRIENDLYNAME; 2140 if ("patient-reported-name".equals(codeString)) 2141 return PATIENTREPORTEDNAME; 2142 if ("manufacturer-name".equals(codeString)) 2143 return MANUFACTURERNAME; 2144 if ("model-name".equals(codeString)) 2145 return MODELNAME; 2146 if ("other".equals(codeString)) 2147 return OTHER; 2148 throw new FHIRException("Unknown DeviceNameType code '"+codeString+"'"); 2149 } 2150 public String toCode() { 2151 switch (this) { 2152 case UDILABELNAME: return "udi-label-name"; 2153 case USERFRIENDLYNAME: return "user-friendly-name"; 2154 case PATIENTREPORTEDNAME: return "patient-reported-name"; 2155 case MANUFACTURERNAME: return "manufacturer-name"; 2156 case MODELNAME: return "model-name"; 2157 case OTHER: return "other"; 2158 default: return "?"; 2159 } 2160 } 2161 public String getSystem() { 2162 switch (this) { 2163 case UDILABELNAME: return "http://hl7.org/fhir/device-nametype"; 2164 case USERFRIENDLYNAME: return "http://hl7.org/fhir/device-nametype"; 2165 case PATIENTREPORTEDNAME: return "http://hl7.org/fhir/device-nametype"; 2166 case MANUFACTURERNAME: return "http://hl7.org/fhir/device-nametype"; 2167 case MODELNAME: return "http://hl7.org/fhir/device-nametype"; 2168 case OTHER: return "http://hl7.org/fhir/device-nametype"; 2169 default: return "?"; 2170 } 2171 } 2172 public String getDefinition() { 2173 switch (this) { 2174 case UDILABELNAME: return "UDI Label name."; 2175 case USERFRIENDLYNAME: return "User Friendly name."; 2176 case PATIENTREPORTEDNAME: return "Patient Reported name."; 2177 case MANUFACTURERNAME: return "Manufacturer name."; 2178 case MODELNAME: return "Model name."; 2179 case OTHER: return "other."; 2180 default: return "?"; 2181 } 2182 } 2183 public String getDisplay() { 2184 switch (this) { 2185 case UDILABELNAME: return "UDI Label name"; 2186 case USERFRIENDLYNAME: return "User Friendly name"; 2187 case PATIENTREPORTEDNAME: return "Patient Reported name"; 2188 case MANUFACTURERNAME: return "Manufacturer name"; 2189 case MODELNAME: return "Model name"; 2190 case OTHER: return "other"; 2191 default: return "?"; 2192 } 2193 } 2194 } 2195 2196 public static class DeviceNameTypeEnumFactory implements EnumFactory<DeviceNameType> { 2197 public DeviceNameType fromCode(String codeString) throws IllegalArgumentException { 2198 if (codeString == null || "".equals(codeString)) 2199 if (codeString == null || "".equals(codeString)) 2200 return null; 2201 if ("udi-label-name".equals(codeString)) 2202 return DeviceNameType.UDILABELNAME; 2203 if ("user-friendly-name".equals(codeString)) 2204 return DeviceNameType.USERFRIENDLYNAME; 2205 if ("patient-reported-name".equals(codeString)) 2206 return DeviceNameType.PATIENTREPORTEDNAME; 2207 if ("manufacturer-name".equals(codeString)) 2208 return DeviceNameType.MANUFACTURERNAME; 2209 if ("model-name".equals(codeString)) 2210 return DeviceNameType.MODELNAME; 2211 if ("other".equals(codeString)) 2212 return DeviceNameType.OTHER; 2213 throw new IllegalArgumentException("Unknown DeviceNameType code '"+codeString+"'"); 2214 } 2215 public Enumeration<DeviceNameType> fromType(Base code) throws FHIRException { 2216 if (code == null) 2217 return null; 2218 if (code.isEmpty()) 2219 return new Enumeration<DeviceNameType>(this); 2220 String codeString = ((PrimitiveType) code).asStringValue(); 2221 if (codeString == null || "".equals(codeString)) 2222 return null; 2223 if ("udi-label-name".equals(codeString)) 2224 return new Enumeration<DeviceNameType>(this, DeviceNameType.UDILABELNAME); 2225 if ("user-friendly-name".equals(codeString)) 2226 return new Enumeration<DeviceNameType>(this, DeviceNameType.USERFRIENDLYNAME); 2227 if ("patient-reported-name".equals(codeString)) 2228 return new Enumeration<DeviceNameType>(this, DeviceNameType.PATIENTREPORTEDNAME); 2229 if ("manufacturer-name".equals(codeString)) 2230 return new Enumeration<DeviceNameType>(this, DeviceNameType.MANUFACTURERNAME); 2231 if ("model-name".equals(codeString)) 2232 return new Enumeration<DeviceNameType>(this, DeviceNameType.MODELNAME); 2233 if ("other".equals(codeString)) 2234 return new Enumeration<DeviceNameType>(this, DeviceNameType.OTHER); 2235 throw new FHIRException("Unknown DeviceNameType code '"+codeString+"'"); 2236 } 2237 public String toCode(DeviceNameType code) { 2238 if (code == DeviceNameType.UDILABELNAME) 2239 return "udi-label-name"; 2240 if (code == DeviceNameType.USERFRIENDLYNAME) 2241 return "user-friendly-name"; 2242 if (code == DeviceNameType.PATIENTREPORTEDNAME) 2243 return "patient-reported-name"; 2244 if (code == DeviceNameType.MANUFACTURERNAME) 2245 return "manufacturer-name"; 2246 if (code == DeviceNameType.MODELNAME) 2247 return "model-name"; 2248 if (code == DeviceNameType.OTHER) 2249 return "other"; 2250 return "?"; 2251 } 2252 public String toSystem(DeviceNameType code) { 2253 return code.getSystem(); 2254 } 2255 } 2256 2257 public enum DocumentReferenceStatus { 2258 /** 2259 * This is the current reference for this document. 2260 */ 2261 CURRENT, 2262 /** 2263 * This reference has been superseded by another reference. 2264 */ 2265 SUPERSEDED, 2266 /** 2267 * This reference was created in error. 2268 */ 2269 ENTEREDINERROR, 2270 /** 2271 * added to help the parsers 2272 */ 2273 NULL; 2274 public static DocumentReferenceStatus fromCode(String codeString) throws FHIRException { 2275 if (codeString == null || "".equals(codeString)) 2276 return null; 2277 if ("current".equals(codeString)) 2278 return CURRENT; 2279 if ("superseded".equals(codeString)) 2280 return SUPERSEDED; 2281 if ("entered-in-error".equals(codeString)) 2282 return ENTEREDINERROR; 2283 throw new FHIRException("Unknown DocumentReferenceStatus code '"+codeString+"'"); 2284 } 2285 public String toCode() { 2286 switch (this) { 2287 case CURRENT: return "current"; 2288 case SUPERSEDED: return "superseded"; 2289 case ENTEREDINERROR: return "entered-in-error"; 2290 default: return "?"; 2291 } 2292 } 2293 public String getSystem() { 2294 switch (this) { 2295 case CURRENT: return "http://hl7.org/fhir/document-reference-status"; 2296 case SUPERSEDED: return "http://hl7.org/fhir/document-reference-status"; 2297 case ENTEREDINERROR: return "http://hl7.org/fhir/document-reference-status"; 2298 default: return "?"; 2299 } 2300 } 2301 public String getDefinition() { 2302 switch (this) { 2303 case CURRENT: return "This is the current reference for this document."; 2304 case SUPERSEDED: return "This reference has been superseded by another reference."; 2305 case ENTEREDINERROR: return "This reference was created in error."; 2306 default: return "?"; 2307 } 2308 } 2309 public String getDisplay() { 2310 switch (this) { 2311 case CURRENT: return "Current"; 2312 case SUPERSEDED: return "Superseded"; 2313 case ENTEREDINERROR: return "Entered in Error"; 2314 default: return "?"; 2315 } 2316 } 2317 } 2318 2319 public static class DocumentReferenceStatusEnumFactory implements EnumFactory<DocumentReferenceStatus> { 2320 public DocumentReferenceStatus fromCode(String codeString) throws IllegalArgumentException { 2321 if (codeString == null || "".equals(codeString)) 2322 if (codeString == null || "".equals(codeString)) 2323 return null; 2324 if ("current".equals(codeString)) 2325 return DocumentReferenceStatus.CURRENT; 2326 if ("superseded".equals(codeString)) 2327 return DocumentReferenceStatus.SUPERSEDED; 2328 if ("entered-in-error".equals(codeString)) 2329 return DocumentReferenceStatus.ENTEREDINERROR; 2330 throw new IllegalArgumentException("Unknown DocumentReferenceStatus code '"+codeString+"'"); 2331 } 2332 public Enumeration<DocumentReferenceStatus> fromType(Base code) throws FHIRException { 2333 if (code == null) 2334 return null; 2335 if (code.isEmpty()) 2336 return new Enumeration<DocumentReferenceStatus>(this); 2337 String codeString = ((PrimitiveType) code).asStringValue(); 2338 if (codeString == null || "".equals(codeString)) 2339 return null; 2340 if ("current".equals(codeString)) 2341 return new Enumeration<DocumentReferenceStatus>(this, DocumentReferenceStatus.CURRENT); 2342 if ("superseded".equals(codeString)) 2343 return new Enumeration<DocumentReferenceStatus>(this, DocumentReferenceStatus.SUPERSEDED); 2344 if ("entered-in-error".equals(codeString)) 2345 return new Enumeration<DocumentReferenceStatus>(this, DocumentReferenceStatus.ENTEREDINERROR); 2346 throw new FHIRException("Unknown DocumentReferenceStatus code '"+codeString+"'"); 2347 } 2348 public String toCode(DocumentReferenceStatus code) { 2349 if (code == DocumentReferenceStatus.CURRENT) 2350 return "current"; 2351 if (code == DocumentReferenceStatus.SUPERSEDED) 2352 return "superseded"; 2353 if (code == DocumentReferenceStatus.ENTEREDINERROR) 2354 return "entered-in-error"; 2355 return "?"; 2356 } 2357 public String toSystem(DocumentReferenceStatus code) { 2358 return code.getSystem(); 2359 } 2360 } 2361 2362 public enum DocumentRelationshipType { 2363 /** 2364 * This document logically replaces or supersedes the target document. 2365 */ 2366 REPLACES, 2367 /** 2368 * This document was generated by transforming the target document (e.g. format or language conversion). 2369 */ 2370 TRANSFORMS, 2371 /** 2372 * This document is a signature of the target document. 2373 */ 2374 SIGNS, 2375 /** 2376 * This document adds additional information to the target document. 2377 */ 2378 APPENDS, 2379 /** 2380 * added to help the parsers 2381 */ 2382 NULL; 2383 public static DocumentRelationshipType fromCode(String codeString) throws FHIRException { 2384 if (codeString == null || "".equals(codeString)) 2385 return null; 2386 if ("replaces".equals(codeString)) 2387 return REPLACES; 2388 if ("transforms".equals(codeString)) 2389 return TRANSFORMS; 2390 if ("signs".equals(codeString)) 2391 return SIGNS; 2392 if ("appends".equals(codeString)) 2393 return APPENDS; 2394 throw new FHIRException("Unknown DocumentRelationshipType code '"+codeString+"'"); 2395 } 2396 public String toCode() { 2397 switch (this) { 2398 case REPLACES: return "replaces"; 2399 case TRANSFORMS: return "transforms"; 2400 case SIGNS: return "signs"; 2401 case APPENDS: return "appends"; 2402 default: return "?"; 2403 } 2404 } 2405 public String getSystem() { 2406 switch (this) { 2407 case REPLACES: return "http://hl7.org/fhir/document-relationship-type"; 2408 case TRANSFORMS: return "http://hl7.org/fhir/document-relationship-type"; 2409 case SIGNS: return "http://hl7.org/fhir/document-relationship-type"; 2410 case APPENDS: return "http://hl7.org/fhir/document-relationship-type"; 2411 default: return "?"; 2412 } 2413 } 2414 public String getDefinition() { 2415 switch (this) { 2416 case REPLACES: return "This document logically replaces or supersedes the target document."; 2417 case TRANSFORMS: return "This document was generated by transforming the target document (e.g. format or language conversion)."; 2418 case SIGNS: return "This document is a signature of the target document."; 2419 case APPENDS: return "This document adds additional information to the target document."; 2420 default: return "?"; 2421 } 2422 } 2423 public String getDisplay() { 2424 switch (this) { 2425 case REPLACES: return "Replaces"; 2426 case TRANSFORMS: return "Transforms"; 2427 case SIGNS: return "Signs"; 2428 case APPENDS: return "Appends"; 2429 default: return "?"; 2430 } 2431 } 2432 } 2433 2434 public static class DocumentRelationshipTypeEnumFactory implements EnumFactory<DocumentRelationshipType> { 2435 public DocumentRelationshipType fromCode(String codeString) throws IllegalArgumentException { 2436 if (codeString == null || "".equals(codeString)) 2437 if (codeString == null || "".equals(codeString)) 2438 return null; 2439 if ("replaces".equals(codeString)) 2440 return DocumentRelationshipType.REPLACES; 2441 if ("transforms".equals(codeString)) 2442 return DocumentRelationshipType.TRANSFORMS; 2443 if ("signs".equals(codeString)) 2444 return DocumentRelationshipType.SIGNS; 2445 if ("appends".equals(codeString)) 2446 return DocumentRelationshipType.APPENDS; 2447 throw new IllegalArgumentException("Unknown DocumentRelationshipType code '"+codeString+"'"); 2448 } 2449 public Enumeration<DocumentRelationshipType> fromType(Base code) throws FHIRException { 2450 if (code == null) 2451 return null; 2452 if (code.isEmpty()) 2453 return new Enumeration<DocumentRelationshipType>(this); 2454 String codeString = ((PrimitiveType) code).asStringValue(); 2455 if (codeString == null || "".equals(codeString)) 2456 return null; 2457 if ("replaces".equals(codeString)) 2458 return new Enumeration<DocumentRelationshipType>(this, DocumentRelationshipType.REPLACES); 2459 if ("transforms".equals(codeString)) 2460 return new Enumeration<DocumentRelationshipType>(this, DocumentRelationshipType.TRANSFORMS); 2461 if ("signs".equals(codeString)) 2462 return new Enumeration<DocumentRelationshipType>(this, DocumentRelationshipType.SIGNS); 2463 if ("appends".equals(codeString)) 2464 return new Enumeration<DocumentRelationshipType>(this, DocumentRelationshipType.APPENDS); 2465 throw new FHIRException("Unknown DocumentRelationshipType code '"+codeString+"'"); 2466 } 2467 public String toCode(DocumentRelationshipType code) { 2468 if (code == DocumentRelationshipType.REPLACES) 2469 return "replaces"; 2470 if (code == DocumentRelationshipType.TRANSFORMS) 2471 return "transforms"; 2472 if (code == DocumentRelationshipType.SIGNS) 2473 return "signs"; 2474 if (code == DocumentRelationshipType.APPENDS) 2475 return "appends"; 2476 return "?"; 2477 } 2478 public String toSystem(DocumentRelationshipType code) { 2479 return code.getSystem(); 2480 } 2481 } 2482 2483 public enum EventStatus { 2484 /** 2485 * The core event has not started yet, but some staging activities have begun (e.g. surgical suite preparation). Preparation stages may be tracked for billing purposes. 2486 */ 2487 PREPARATION, 2488 /** 2489 * The event is currently occurring. 2490 */ 2491 INPROGRESS, 2492 /** 2493 * The event was terminated prior to any activity beyond preparation. I.e. The 'main' activity has not yet begun. The boundary between preparatory and the 'main' activity is context-specific. 2494 */ 2495 NOTDONE, 2496 /** 2497 * The event has been temporarily stopped but is expected to resume in the future. 2498 */ 2499 ONHOLD, 2500 /** 2501 * The event was terminated prior to the full completion of the intended activity but after at least some of the 'main' activity (beyond preparation) has occurred. 2502 */ 2503 STOPPED, 2504 /** 2505 * The event has now concluded. 2506 */ 2507 COMPLETED, 2508 /** 2509 * This electronic record should never have existed, though it is possible that real-world decisions were based on it. (If real-world activity has occurred, the status should be "stopped" rather than "entered-in-error".). 2510 */ 2511 ENTEREDINERROR, 2512 /** 2513 * The authoring/source system does not know which of the status values currently applies for this event. Note: This concept is not to be used for "other" - one of the listed statuses is presumed to apply, but the authoring/source system does not know which. 2514 */ 2515 UNKNOWN, 2516 /** 2517 * added to help the parsers 2518 */ 2519 NULL; 2520 public static EventStatus fromCode(String codeString) throws FHIRException { 2521 if (codeString == null || "".equals(codeString)) 2522 return null; 2523 if ("preparation".equals(codeString)) 2524 return PREPARATION; 2525 if ("in-progress".equals(codeString)) 2526 return INPROGRESS; 2527 if ("not-done".equals(codeString)) 2528 return NOTDONE; 2529 if ("on-hold".equals(codeString)) 2530 return ONHOLD; 2531 if ("stopped".equals(codeString)) 2532 return STOPPED; 2533 if ("completed".equals(codeString)) 2534 return COMPLETED; 2535 if ("entered-in-error".equals(codeString)) 2536 return ENTEREDINERROR; 2537 if ("unknown".equals(codeString)) 2538 return UNKNOWN; 2539 throw new FHIRException("Unknown EventStatus code '"+codeString+"'"); 2540 } 2541 public String toCode() { 2542 switch (this) { 2543 case PREPARATION: return "preparation"; 2544 case INPROGRESS: return "in-progress"; 2545 case NOTDONE: return "not-done"; 2546 case ONHOLD: return "on-hold"; 2547 case STOPPED: return "stopped"; 2548 case COMPLETED: return "completed"; 2549 case ENTEREDINERROR: return "entered-in-error"; 2550 case UNKNOWN: return "unknown"; 2551 default: return "?"; 2552 } 2553 } 2554 public String getSystem() { 2555 switch (this) { 2556 case PREPARATION: return "http://hl7.org/fhir/event-status"; 2557 case INPROGRESS: return "http://hl7.org/fhir/event-status"; 2558 case NOTDONE: return "http://hl7.org/fhir/event-status"; 2559 case ONHOLD: return "http://hl7.org/fhir/event-status"; 2560 case STOPPED: return "http://hl7.org/fhir/event-status"; 2561 case COMPLETED: return "http://hl7.org/fhir/event-status"; 2562 case ENTEREDINERROR: return "http://hl7.org/fhir/event-status"; 2563 case UNKNOWN: return "http://hl7.org/fhir/event-status"; 2564 default: return "?"; 2565 } 2566 } 2567 public String getDefinition() { 2568 switch (this) { 2569 case PREPARATION: return "The core event has not started yet, but some staging activities have begun (e.g. surgical suite preparation). Preparation stages may be tracked for billing purposes."; 2570 case INPROGRESS: return "The event is currently occurring."; 2571 case NOTDONE: return "The event was terminated prior to any activity beyond preparation. I.e. The 'main' activity has not yet begun. The boundary between preparatory and the 'main' activity is context-specific."; 2572 case ONHOLD: return "The event has been temporarily stopped but is expected to resume in the future."; 2573 case STOPPED: return "The event was terminated prior to the full completion of the intended activity but after at least some of the 'main' activity (beyond preparation) has occurred."; 2574 case COMPLETED: return "The event has now concluded."; 2575 case ENTEREDINERROR: return "This electronic record should never have existed, though it is possible that real-world decisions were based on it. (If real-world activity has occurred, the status should be \"stopped\" rather than \"entered-in-error\".)."; 2576 case UNKNOWN: return "The authoring/source system does not know which of the status values currently applies for this event. Note: This concept is not to be used for \"other\" - one of the listed statuses is presumed to apply, but the authoring/source system does not know which."; 2577 default: return "?"; 2578 } 2579 } 2580 public String getDisplay() { 2581 switch (this) { 2582 case PREPARATION: return "Preparation"; 2583 case INPROGRESS: return "In Progress"; 2584 case NOTDONE: return "Not Done"; 2585 case ONHOLD: return "On Hold"; 2586 case STOPPED: return "Stopped"; 2587 case COMPLETED: return "Completed"; 2588 case ENTEREDINERROR: return "Entered in Error"; 2589 case UNKNOWN: return "Unknown"; 2590 default: return "?"; 2591 } 2592 } 2593 } 2594 2595 public static class EventStatusEnumFactory implements EnumFactory<EventStatus> { 2596 public EventStatus fromCode(String codeString) throws IllegalArgumentException { 2597 if (codeString == null || "".equals(codeString)) 2598 if (codeString == null || "".equals(codeString)) 2599 return null; 2600 if ("preparation".equals(codeString)) 2601 return EventStatus.PREPARATION; 2602 if ("in-progress".equals(codeString)) 2603 return EventStatus.INPROGRESS; 2604 if ("not-done".equals(codeString)) 2605 return EventStatus.NOTDONE; 2606 if ("on-hold".equals(codeString)) 2607 return EventStatus.ONHOLD; 2608 if ("stopped".equals(codeString)) 2609 return EventStatus.STOPPED; 2610 if ("completed".equals(codeString)) 2611 return EventStatus.COMPLETED; 2612 if ("entered-in-error".equals(codeString)) 2613 return EventStatus.ENTEREDINERROR; 2614 if ("unknown".equals(codeString)) 2615 return EventStatus.UNKNOWN; 2616 throw new IllegalArgumentException("Unknown EventStatus code '"+codeString+"'"); 2617 } 2618 public Enumeration<EventStatus> fromType(Base code) throws FHIRException { 2619 if (code == null) 2620 return null; 2621 if (code.isEmpty()) 2622 return new Enumeration<EventStatus>(this); 2623 String codeString = ((PrimitiveType) code).asStringValue(); 2624 if (codeString == null || "".equals(codeString)) 2625 return null; 2626 if ("preparation".equals(codeString)) 2627 return new Enumeration<EventStatus>(this, EventStatus.PREPARATION); 2628 if ("in-progress".equals(codeString)) 2629 return new Enumeration<EventStatus>(this, EventStatus.INPROGRESS); 2630 if ("not-done".equals(codeString)) 2631 return new Enumeration<EventStatus>(this, EventStatus.NOTDONE); 2632 if ("on-hold".equals(codeString)) 2633 return new Enumeration<EventStatus>(this, EventStatus.ONHOLD); 2634 if ("stopped".equals(codeString)) 2635 return new Enumeration<EventStatus>(this, EventStatus.STOPPED); 2636 if ("completed".equals(codeString)) 2637 return new Enumeration<EventStatus>(this, EventStatus.COMPLETED); 2638 if ("entered-in-error".equals(codeString)) 2639 return new Enumeration<EventStatus>(this, EventStatus.ENTEREDINERROR); 2640 if ("unknown".equals(codeString)) 2641 return new Enumeration<EventStatus>(this, EventStatus.UNKNOWN); 2642 throw new FHIRException("Unknown EventStatus code '"+codeString+"'"); 2643 } 2644 public String toCode(EventStatus code) { 2645 if (code == EventStatus.PREPARATION) 2646 return "preparation"; 2647 if (code == EventStatus.INPROGRESS) 2648 return "in-progress"; 2649 if (code == EventStatus.NOTDONE) 2650 return "not-done"; 2651 if (code == EventStatus.ONHOLD) 2652 return "on-hold"; 2653 if (code == EventStatus.STOPPED) 2654 return "stopped"; 2655 if (code == EventStatus.COMPLETED) 2656 return "completed"; 2657 if (code == EventStatus.ENTEREDINERROR) 2658 return "entered-in-error"; 2659 if (code == EventStatus.UNKNOWN) 2660 return "unknown"; 2661 return "?"; 2662 } 2663 public String toSystem(EventStatus code) { 2664 return code.getSystem(); 2665 } 2666 } 2667 2668 public enum FHIRAllTypes { 2669 /** 2670 * An address expressed using postal conventions (as opposed to GPS or other location definition formats). This data type may be used to convey addresses for use in delivering mail as well as for visiting locations which might not be valid for mail delivery. There are a variety of postal address formats defined around the world. 2671 */ 2672 ADDRESS, 2673 /** 2674 * A duration of time during which an organism (or a process) has existed. 2675 */ 2676 AGE, 2677 /** 2678 * A text note which also contains information about who made the statement and when. 2679 */ 2680 ANNOTATION, 2681 /** 2682 * For referring to data content defined in other formats. 2683 */ 2684 ATTACHMENT, 2685 /** 2686 * Base definition for all elements that are defined inside a resource - but not those in a data type. 2687 */ 2688 BACKBONEELEMENT, 2689 /** 2690 * Base definition for the few data types that are allowed to carry modifier extensions. 2691 */ 2692 BACKBONETYPE, 2693 /** 2694 * Base definition for all types defined in FHIR type system. 2695 */ 2696 BASE, 2697 /** 2698 * A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text. 2699 */ 2700 CODEABLECONCEPT, 2701 /** 2702 * A reference to a resource (by instance), or instead, a reference to a cencept defined in a terminology or ontology (by class). 2703 */ 2704 CODEABLEREFERENCE, 2705 /** 2706 * A reference to a code defined by a terminology system. 2707 */ 2708 CODING, 2709 /** 2710 * Specifies contact information for a person or organization. 2711 */ 2712 CONTACTDETAIL, 2713 /** 2714 * Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc. 2715 */ 2716 CONTACTPOINT, 2717 /** 2718 * A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers. 2719 */ 2720 CONTRIBUTOR, 2721 /** 2722 * A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies. 2723 */ 2724 COUNT, 2725 /** 2726 * Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data. 2727 */ 2728 DATAREQUIREMENT, 2729 /** 2730 * The base class for all re-useable types defined as part of the FHIR Specification. 2731 */ 2732 DATATYPE, 2733 /** 2734 * A length - a value with a unit that is a physical distance. 2735 */ 2736 DISTANCE, 2737 /** 2738 * Indicates how the medication is/was taken or should be taken by the patient. 2739 */ 2740 DOSAGE, 2741 /** 2742 * A length of time. 2743 */ 2744 DURATION, 2745 /** 2746 * Base definition for all elements in a resource. 2747 */ 2748 ELEMENT, 2749 /** 2750 * Captures constraints on each element within the resource, profile, or extension. 2751 */ 2752 ELEMENTDEFINITION, 2753 /** 2754 * A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used. 2755 */ 2756 EXPRESSION, 2757 /** 2758 * Optional Extension Element - found in all resources. 2759 */ 2760 EXTENSION, 2761 /** 2762 * A human's name with the ability to identify parts and usage. 2763 */ 2764 HUMANNAME, 2765 /** 2766 * An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers. 2767 */ 2768 IDENTIFIER, 2769 /** 2770 * The marketing status describes the date when a medicinal product is actually put on the market or the date as of which it is no longer available. 2771 */ 2772 MARKETINGSTATUS, 2773 /** 2774 * The metadata about a resource. This is content in the resource that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource. 2775 */ 2776 META, 2777 /** 2778 * An amount of economic utility in some recognized currency. 2779 */ 2780 MONEY, 2781 /** 2782 * null 2783 */ 2784 MONEYQUANTITY, 2785 /** 2786 * A human-readable summary of the resource conveying the essential clinical and business information for the resource. 2787 */ 2788 NARRATIVE, 2789 /** 2790 * An ordered list (distribution) of statistics. 2791 */ 2792 ORDEREDDISTRIBUTION, 2793 /** 2794 * The parameters to the module. This collection specifies both the input and output parameters. Input parameters are provided by the caller as part of the $evaluate operation. Output parameters are included in the GuidanceResponse. 2795 */ 2796 PARAMETERDEFINITION, 2797 /** 2798 * A time period defined by a start and end date and optionally time. 2799 */ 2800 PERIOD, 2801 /** 2802 * A populatioof people with some set of grouping criteria. 2803 */ 2804 POPULATION, 2805 /** 2806 * The base type for all re-useable types defined that have a simple property. 2807 */ 2808 PRIMITIVETYPE, 2809 /** 2810 * The marketing status describes the date when a medicinal product is actually put on the market or the date as of which it is no longer available. 2811 */ 2812 PRODCHARACTERISTIC, 2813 /** 2814 * The shelf-life and storage information for a medicinal product item or container can be described using this class. 2815 */ 2816 PRODUCTSHELFLIFE, 2817 /** 2818 * A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies. 2819 */ 2820 QUANTITY, 2821 /** 2822 * A set of ordered Quantities defined by a low and high limit. 2823 */ 2824 RANGE, 2825 /** 2826 * A relationship of two Quantity values - expressed as a numerator and a denominator. 2827 */ 2828 RATIO, 2829 /** 2830 * A reference from one resource to another. 2831 */ 2832 REFERENCE, 2833 /** 2834 * Related artifacts such as additional documentation, justification, or bibliographic references. 2835 */ 2836 RELATEDARTIFACT, 2837 /** 2838 * A series of measurements taken by a device, with upper and lower limits. There may be more than one dimension in the data. 2839 */ 2840 SAMPLEDDATA, 2841 /** 2842 * A signature along with supporting context. The signature may be a digital signature that is cryptographic in nature, or some other signature acceptable to the domain. This other signature may be as simple as a graphical image representing a hand-written signature, or a signature ceremony Different signature approaches have different utilities. 2843 */ 2844 SIGNATURE, 2845 /** 2846 * null 2847 */ 2848 SIMPLEQUANTITY, 2849 /** 2850 * A fact or piece of data from a study of a large quantity of numerical data. A mathematical or quantified characteristic of a group of observations. 2851 */ 2852 STATISTIC, 2853 /** 2854 * Chemical substances are a single substance type whose primary defining element is the molecular structure. Chemical substances shall be defined on the basis of their complete covalent molecular structure; the presence of a salt (counter-ion) and/or solvates (water, alcohols) is also captured. Purity, grade, physical form or particle size are not taken into account in the definition of a chemical substance or in the assignment of a Substance ID. 2855 */ 2856 SUBSTANCEAMOUNT, 2857 /** 2858 * Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out. 2859 */ 2860 TIMING, 2861 /** 2862 * A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element. 2863 */ 2864 TRIGGERDEFINITION, 2865 /** 2866 * Specifies clinical/business/etc. metadata that can be used to retrieve, index and/or categorize an artifact. This metadata can either be specific to the applicable population (e.g., age category, DRG) or the specific context of care (e.g., venue, care setting, provider of care). 2867 */ 2868 USAGECONTEXT, 2869 /** 2870 * A stream of bytes 2871 */ 2872 BASE64BINARY, 2873 /** 2874 * Value of "true" or "false" 2875 */ 2876 BOOLEAN, 2877 /** 2878 * A URI that is a reference to a canonical URL on a FHIR resource 2879 */ 2880 CANONICAL, 2881 /** 2882 * A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents 2883 */ 2884 CODE, 2885 /** 2886 * A date or partial date (e.g. just year or year + month). There is no time zone. The format is a union of the schema types gYear, gYearMonth and date. Dates SHALL be valid dates. 2887 */ 2888 DATE, 2889 /** 2890 * A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates. 2891 */ 2892 DATETIME, 2893 /** 2894 * A rational number with implicit precision 2895 */ 2896 DECIMAL, 2897 /** 2898 * Any combination of letters, numerals, "-" and ".", with a length limit of 64 characters. (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.) Ids are case-insensitive. 2899 */ 2900 ID, 2901 /** 2902 * An instant in time - known at least to the second 2903 */ 2904 INSTANT, 2905 /** 2906 * A whole number 2907 */ 2908 INTEGER, 2909 /** 2910 * A very large whole number 2911 */ 2912 INTEGER64, 2913 /** 2914 * A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine 2915 */ 2916 MARKDOWN, 2917 /** 2918 * An OID represented as a URI 2919 */ 2920 OID, 2921 /** 2922 * An integer with a value that is positive (e.g. >0) 2923 */ 2924 POSITIVEINT, 2925 /** 2926 * A sequence of Unicode characters 2927 */ 2928 STRING, 2929 /** 2930 * A time during the day, with no date specified 2931 */ 2932 TIME, 2933 /** 2934 * An integer with a value that is not negative (e.g. >= 0) 2935 */ 2936 UNSIGNEDINT, 2937 /** 2938 * String of characters used to identify a name or a resource 2939 */ 2940 URI, 2941 /** 2942 * A URI that is a literal reference 2943 */ 2944 URL, 2945 /** 2946 * A UUID, represented as a URI 2947 */ 2948 UUID, 2949 /** 2950 * XHTML format, as defined by W3C, but restricted usage (mainly, no active content) 2951 */ 2952 XHTML, 2953 /** 2954 * A financial tool for tracking value accrued for a particular purpose. In the healthcare field, used to track charges for a patient, cost centers, etc. 2955 */ 2956 ACCOUNT, 2957 /** 2958 * This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context. 2959 */ 2960 ACTIVITYDEFINITION, 2961 /** 2962 * A pharmaceutical product described in terms of its composition and dose form. 2963 */ 2964 ADMINISTRABLEPRODUCTDEFINITION, 2965 /** 2966 * An event (i.e. any change to current patient status) that may be related to unintended effects on a patient or research subject. The unintended effects may require additional monitoring, treatment or hospitalization or may result in death. The AdverseEvent resource also extends to potential or avoided events that could have had such effects. 2967 */ 2968 ADVERSEEVENT, 2969 /** 2970 * Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance. 2971 */ 2972 ALLERGYINTOLERANCE, 2973 /** 2974 * A booking of a healthcare event among patient(s), practitioner(s), related person(s) and/or device(s) for a specific date/time. This may result in one or more Encounter(s). 2975 */ 2976 APPOINTMENT, 2977 /** 2978 * A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection. 2979 */ 2980 APPOINTMENTRESPONSE, 2981 /** 2982 * A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis. 2983 */ 2984 AUDITEVENT, 2985 /** 2986 * Basic is used for handling concepts not yet defined in FHIR, narrative-only resources that don't map to an existing resource, and custom resources not appropriate for inclusion in the FHIR specification. 2987 */ 2988 BASIC, 2989 /** 2990 * A resource that represents the data of a single raw artifact as digital content accessible in its native format. A Binary resource can contain any content, whether text, image, pdf, zip archive, etc. 2991 */ 2992 BINARY, 2993 /** 2994 * A material substance originating from a biological entity intended to be transplanted or infused 2995into another (possibly the same) biological entity. 2996 */ 2997 BIOLOGICALLYDERIVEDPRODUCT, 2998 /** 2999 * Record details about an anatomical structure. This resource may be used when a coded concept does not provide the necessary detail needed for the use case. 3000 */ 3001 BODYSTRUCTURE, 3002 /** 3003 * A container for a collection of resources. 3004 */ 3005 BUNDLE, 3006 /** 3007 * A Capability Statement documents a set of capabilities (behaviors) of a FHIR Server for a particular version of FHIR that may be used as a statement of actual server functionality or a statement of required or desired server implementation. 3008 */ 3009 CAPABILITYSTATEMENT, 3010 /** 3011 * A Capability Statement documents a set of capabilities (behaviors) of a FHIR Server for a particular version of FHIR that may be used as a statement of actual server functionality or a statement of required or desired server implementation. 3012 */ 3013 CAPABILITYSTATEMENT2, 3014 /** 3015 * Describes the intention of how one or more practitioners intend to deliver care for a particular patient, group or community for a period of time, possibly limited to care for a specific condition or set of conditions. 3016 */ 3017 CAREPLAN, 3018 /** 3019 * The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care. 3020 */ 3021 CARETEAM, 3022 /** 3023 * Catalog entries are wrappers that contextualize items included in a catalog. 3024 */ 3025 CATALOGENTRY, 3026 /** 3027 * The resource ChargeItem describes the provision of healthcare provider products for a certain patient, therefore referring not only to the product, but containing in addition details of the provision, like date, time, amounts and participating organizations and persons. Main Usage of the ChargeItem is to enable the billing process and internal cost allocation. 3028 */ 3029 CHARGEITEM, 3030 /** 3031 * The ChargeItemDefinition resource provides the properties that apply to the (billing) codes necessary to calculate costs and prices. The properties may differ largely depending on type and realm, therefore this resource gives only a rough structure and requires profiling for each type of billing code system. 3032 */ 3033 CHARGEITEMDEFINITION, 3034 /** 3035 * A provider issued list of professional services and products which have been provided, or are to be provided, to a patient which is sent to an insurer for reimbursement. 3036 */ 3037 CLAIM, 3038 /** 3039 * This resource provides the adjudication details from the processing of a Claim resource. 3040 */ 3041 CLAIMRESPONSE, 3042 /** 3043 * A record of a clinical assessment performed to determine what problem(s) may affect the patient and before planning the treatments or management strategies that are best to manage a patient's condition. Assessments are often 1:1 with a clinical consultation / encounter, but this varies greatly depending on the clinical workflow. This resource is called "ClinicalImpression" rather than "ClinicalAssessment" to avoid confusion with the recording of assessment tools such as Apgar score. 3044 */ 3045 CLINICALIMPRESSION, 3046 /** 3047 * A single usage issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure. 3048 */ 3049 CLINICALUSEISSUE, 3050 /** 3051 * The CodeSystem resource is used to declare the existence of and describe a code system or code system supplement and its key properties, and optionally define a part or all of its content. 3052 */ 3053 CODESYSTEM, 3054 /** 3055 * An occurrence of information being transmitted; e.g. an alert that was sent to a responsible provider, a public health agency communication to a provider/reporter in response to a case report for a reportable condition. 3056 */ 3057 COMMUNICATION, 3058 /** 3059 * A request to convey information; e.g. the CDS system proposes that an alert be sent to a responsible provider, the CDS system proposes that the public health agency be notified about a reportable condition. 3060 */ 3061 COMMUNICATIONREQUEST, 3062 /** 3063 * A compartment definition that defines how resources are accessed on a server. 3064 */ 3065 COMPARTMENTDEFINITION, 3066 /** 3067 * A set of healthcare-related information that is assembled together into a single logical package that provides a single coherent statement of meaning, establishes its own context and that has clinical attestation with regard to who is making the statement. A Composition defines the structure and narrative content necessary for a document. However, a Composition alone does not constitute a document. Rather, the Composition must be the first entry in a Bundle where Bundle.type=document, and any other resources referenced from Composition must be included as subsequent entries in the Bundle (for example Patient, Practitioner, Encounter, etc.). 3068 */ 3069 COMPOSITION, 3070 /** 3071 * A statement of relationships from one set of concepts to one or more other concepts - either concepts in code systems, or data element/data element concepts, or classes in class models. 3072 */ 3073 CONCEPTMAP, 3074 /** 3075 * A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern. 3076 */ 3077 CONDITION, 3078 /** 3079 * A definition of a condition and information relevant to managing it. 3080 */ 3081 CONDITIONDEFINITION, 3082 /** 3083 * A record of a healthcare consumer’s choices or choices made on their behalf by a third party, which permits or denies identified recipient(s) or recipient role(s) to perform one or more actions within a given policy context, for specific purposes and periods of time. 3084 */ 3085 CONSENT, 3086 /** 3087 * Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement. 3088 */ 3089 CONTRACT, 3090 /** 3091 * Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment. 3092 */ 3093 COVERAGE, 3094 /** 3095 * The CoverageEligibilityRequest provides patient and insurance coverage information to an insurer for them to respond, in the form of an CoverageEligibilityResponse, with information regarding whether the stated coverage is valid and in-force and optionally to provide the insurance details of the policy. 3096 */ 3097 COVERAGEELIGIBILITYREQUEST, 3098 /** 3099 * This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource. 3100 */ 3101 COVERAGEELIGIBILITYRESPONSE, 3102 /** 3103 * Indicates an actual or potential clinical issue with or between one or more active or proposed clinical actions for a patient; e.g. Drug-drug interaction, Ineffective treatment frequency, Procedure-condition conflict, etc. 3104 */ 3105 DETECTEDISSUE, 3106 /** 3107 * A type of a manufactured item that is used in the provision of healthcare without being substantially changed through that activity. The device may be a medical or non-medical device. 3108 */ 3109 DEVICE, 3110 /** 3111 * The characteristics, operational status and capabilities of a medical-related component of a medical device. 3112 */ 3113 DEVICEDEFINITION, 3114 /** 3115 * Describes a measurement, calculation or setting capability of a medical device. 3116 */ 3117 DEVICEMETRIC, 3118 /** 3119 * Represents a request for a patient to employ a medical device. The device may be an implantable device, or an external assistive device, such as a walker. 3120 */ 3121 DEVICEREQUEST, 3122 /** 3123 * A record of a device being used by a patient where the record is the result of a report from the patient or another clinician. 3124 */ 3125 DEVICEUSESTATEMENT, 3126 /** 3127 * The findings and interpretation of diagnostic tests performed on patients, groups of patients, devices, and locations, and/or specimens derived from these. The report includes clinical context such as requesting and provider information, and some mix of atomic results, images, textual and coded interpretations, and formatted representation of diagnostic reports. 3128 */ 3129 DIAGNOSTICREPORT, 3130 /** 3131 * A collection of documents compiled for a purpose together with metadata that applies to the collection. 3132 */ 3133 DOCUMENTMANIFEST, 3134 /** 3135 * A reference to a document of any kind for any purpose. While the term “document” implies a more narrow focus, for this resource this "document" encompasses *any* serialized object with a mime-type, it includes formal patient-centric documents (CDA), clinical notes, scanned paper, non-patient specific documents like policy text, as well as a photo, video, or audio recording acquired or used in healthcare. The DocumentReference resource provides metadata about the document so that the document can be discovered and managed. The actual content may be inline base64 encoded data or provided by direct reference. 3136 */ 3137 DOCUMENTREFERENCE, 3138 /** 3139 * A resource that includes narrative, extensions, and contained resources. 3140 */ 3141 DOMAINRESOURCE, 3142 /** 3143 * An interaction between a patient and healthcare provider(s) for the purpose of providing healthcare service(s) or assessing the health status of a patient. 3144 */ 3145 ENCOUNTER, 3146 /** 3147 * The technical details of an endpoint that can be used for electronic services, such as for web services providing XDS.b or a REST endpoint for another FHIR server. This may include any security context information. 3148 */ 3149 ENDPOINT, 3150 /** 3151 * This resource provides the insurance enrollment details to the insurer regarding a specified coverage. 3152 */ 3153 ENROLLMENTREQUEST, 3154 /** 3155 * This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource. 3156 */ 3157 ENROLLMENTRESPONSE, 3158 /** 3159 * An association between a patient and an organization / healthcare provider(s) during which time encounters may occur. The managing organization assumes a level of responsibility for the patient during this time. 3160 */ 3161 EPISODEOFCARE, 3162 /** 3163 * The EventDefinition resource provides a reusable description of when a particular event can occur. 3164 */ 3165 EVENTDEFINITION, 3166 /** 3167 * This represents statistics, certainty, both the intended and actual population, and evidence variables. 3168 */ 3169 EVIDENCE, 3170 /** 3171 * The EvidenceVariable resource describes a "PICO" element that knowledge (evidence, assertion, recommendation) is about. 3172 */ 3173 EVIDENCEVARIABLE, 3174 /** 3175 * Example of workflow instance. 3176 */ 3177 EXAMPLESCENARIO, 3178 /** 3179 * This resource provides: the claim details; adjudication details from the processing of a Claim; and optionally account balance information, for informing the subscriber of the benefits provided. 3180 */ 3181 EXPLANATIONOFBENEFIT, 3182 /** 3183 * Significant health conditions for a person related to the patient relevant in the context of care for the patient. 3184 */ 3185 FAMILYMEMBERHISTORY, 3186 /** 3187 * Prospective warnings of potential issues when providing care to the patient. 3188 */ 3189 FLAG, 3190 /** 3191 * Describes the intended objective(s) for a patient, group or organization care, for example, weight loss, restoring an activity of daily living, obtaining herd immunity via immunization, meeting a process improvement objective, etc. 3192 */ 3193 GOAL, 3194 /** 3195 * A formal computable definition of a graph of resources - that is, a coherent set of resources that form a graph by following references. The Graph Definition resource defines a set and makes rules about the set. 3196 */ 3197 GRAPHDEFINITION, 3198 /** 3199 * Represents a defined collection of entities that may be discussed or acted upon collectively but which are not expected to act collectively, and are not formally or legally recognized; i.e. a collection of entities that isn't an Organization. 3200 */ 3201 GROUP, 3202 /** 3203 * A guidance response is the formal response to a guidance request, including any output parameters returned by the evaluation, as well as the description of any proposed actions to be taken. 3204 */ 3205 GUIDANCERESPONSE, 3206 /** 3207 * The details of a healthcare service available at a location. 3208 */ 3209 HEALTHCARESERVICE, 3210 /** 3211 * Representation of the content produced in a DICOM imaging study. A study comprises a set of series, each of which includes a set of Service-Object Pair Instances (SOP Instances - images or other data) acquired or produced in a common context. A series is of only one modality (e.g. X-ray, CT, MR, ultrasound), but a study may have multiple series of different modalities. 3212 */ 3213 IMAGINGSTUDY, 3214 /** 3215 * Describes the event of a patient being administered a vaccine or a record of an immunization as reported by a patient, a clinician or another party. 3216 */ 3217 IMMUNIZATION, 3218 /** 3219 * Describes a comparison of an immunization event against published recommendations to determine if the administration is "valid" in relation to those recommendations. 3220 */ 3221 IMMUNIZATIONEVALUATION, 3222 /** 3223 * A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification. 3224 */ 3225 IMMUNIZATIONRECOMMENDATION, 3226 /** 3227 * A set of rules of how a particular interoperability or standards problem is solved - typically through the use of FHIR resources. This resource is used to gather all the parts of an implementation guide into a logical whole and to publish a computable definition of all the parts. 3228 */ 3229 IMPLEMENTATIONGUIDE, 3230 /** 3231 * An ingredient of a manufactured item or pharmaceutical product. 3232 */ 3233 INGREDIENT, 3234 /** 3235 * Details of a Health Insurance product/plan provided by an organization. 3236 */ 3237 INSURANCEPLAN, 3238 /** 3239 * Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose. 3240 */ 3241 INVOICE, 3242 /** 3243 * The Library resource is a general-purpose container for knowledge asset definitions. It can be used to describe and expose existing knowledge assets such as logic libraries and information model descriptions, as well as to describe a collection of knowledge assets. 3244 */ 3245 LIBRARY, 3246 /** 3247 * Identifies two or more records (resource instances) that refer to the same real-world "occurrence". 3248 */ 3249 LINKAGE, 3250 /** 3251 * A list is a curated collection of resources. 3252 */ 3253 LIST, 3254 /** 3255 * Details and position information for a physical place where services are provided and resources and participants may be stored, found, contained, or accommodated. 3256 */ 3257 LOCATION, 3258 /** 3259 * The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product. 3260 */ 3261 MANUFACTUREDITEMDEFINITION, 3262 /** 3263 * The Measure resource provides the definition of a quality measure. 3264 */ 3265 MEASURE, 3266 /** 3267 * The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation. 3268 */ 3269 MEASUREREPORT, 3270 /** 3271 * This resource is primarily used for the identification and definition of a medication for the purposes of prescribing, dispensing, and administering a medication as well as for making statements about medication use. 3272 */ 3273 MEDICATION, 3274 /** 3275 * Describes the event of a patient consuming or otherwise being administered a medication. This may be as simple as swallowing a tablet or it may be a long running infusion. Related resources tie this event to the authorizing prescription, and the specific encounter between patient and health care practitioner. 3276 */ 3277 MEDICATIONADMINISTRATION, 3278 /** 3279 * Indicates that a medication product is to be or has been dispensed for a named person/patient. This includes a description of the medication product (supply) provided and the instructions for administering the medication. The medication dispense is the result of a pharmacy system responding to a medication order. 3280 */ 3281 MEDICATIONDISPENSE, 3282 /** 3283 * Information about a medication that is used to support knowledge. 3284 */ 3285 MEDICATIONKNOWLEDGE, 3286 /** 3287 * An order or request for both supply of the medication and the instructions for administration of the medication to a patient. The resource is called "MedicationRequest" rather than "MedicationPrescription" or "MedicationOrder" to generalize the use across inpatient and outpatient settings, including care plans, etc., and to harmonize with workflow patterns. 3288 */ 3289 MEDICATIONREQUEST, 3290 /** 3291 * A record of a medication that is being consumed by a patient. A MedicationUsage may indicate that the patient may be taking the medication now or has taken the medication in the past or will be taking the medication in the future. The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician. A common scenario where this information is captured is during the history taking process during a patient visit or stay. The medication information may come from sources such as the patient's memory, from a prescription bottle, or from a list of medications the patient, clinician or other party maintains. 3292 3293The primary difference between a medicationusage and a medicationadministration is that the medication administration has complete administration information and is based on actual administration information from the person who administered the medication. A medicationusage is often, if not always, less specific. There is no required date/time when the medication was administered, in fact we only know that a source has reported the patient is taking this medication, where details such as time, quantity, or rate or even medication product may be incomplete or missing or less precise. As stated earlier, the Medication Usage information may come from the patient's memory, from a prescription bottle or from a list of medications the patient, clinician or other party maintains. Medication administration is more formal and is not missing detailed information. 3294 */ 3295 MEDICATIONUSAGE, 3296 /** 3297 * Detailed definition of a medicinal product, typically for uses other than direct patient care (e.g. regulatory use). 3298 */ 3299 MEDICINALPRODUCTDEFINITION, 3300 /** 3301 * Defines the characteristics of a message that can be shared between systems, including the type of event that initiates the message, the content to be transmitted and what response(s), if any, are permitted. 3302 */ 3303 MESSAGEDEFINITION, 3304 /** 3305 * The header for a message exchange that is either requesting or responding to an action. The reference(s) that are the subject of the action as well as other information related to the action are typically transmitted in a bundle in which the MessageHeader resource instance is the first resource in the bundle. 3306 */ 3307 MESSAGEHEADER, 3308 /** 3309 * Raw data describing a biological sequence. 3310 */ 3311 MOLECULARSEQUENCE, 3312 /** 3313 * A curated namespace that issues unique symbols within that namespace for the identification of concepts, people, devices, etc. Represents a "System" used within the Identifier and Coding data types. 3314 */ 3315 NAMINGSYSTEM, 3316 /** 3317 * A record of food or fluid that is being consumed by a patient. A NutritionIntake may indicate that the patient may be consuming the food or fluid now or has consumed the food or fluid in the past. The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician. A common scenario where this information is captured is during the history taking process during a patient visit or stay or through an app that tracks food or fluids consumed. The consumption information may come from sources such as the patient's memory, from a nutrition label, or from a clinician documenting observed intake. 3318 */ 3319 NUTRITIONINTAKE, 3320 /** 3321 * A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident. 3322 */ 3323 NUTRITIONORDER, 3324 /** 3325 * Measurements and simple assertions made about a patient, device or other subject. 3326 */ 3327 OBSERVATION, 3328 /** 3329 * Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service. 3330 */ 3331 OBSERVATIONDEFINITION, 3332 /** 3333 * A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction). 3334 */ 3335 OPERATIONDEFINITION, 3336 /** 3337 * A collection of error, warning, or information messages that result from a system action. 3338 */ 3339 OPERATIONOUTCOME, 3340 /** 3341 * A formally or informally recognized grouping of people or organizations formed for the purpose of achieving some form of collective action. Includes companies, institutions, corporations, departments, community groups, healthcare practice groups, payer/insurer, etc. 3342 */ 3343 ORGANIZATION, 3344 /** 3345 * Defines an affiliation/assotiation/relationship between 2 distinct oganizations, that is not a part-of relationship/sub-division relationship. 3346 */ 3347 ORGANIZATIONAFFILIATION, 3348 /** 3349 * A medicinal product in a container or package. 3350 */ 3351 PACKAGEDPRODUCTDEFINITION, 3352 /** 3353 * This resource is a non-persisted resource used to pass information into and back from an [operation](operations.html). It has no other use, and there is no RESTful endpoint associated with it. 3354 */ 3355 PARAMETERS, 3356 /** 3357 * Demographics and other administrative information about an individual or animal receiving care or other health-related services. 3358 */ 3359 PATIENT, 3360 /** 3361 * This resource provides the status of the payment for goods and services rendered, and the request and response resource references. 3362 */ 3363 PAYMENTNOTICE, 3364 /** 3365 * This resource provides the details including amount of a payment and allocates the payment items being paid. 3366 */ 3367 PAYMENTRECONCILIATION, 3368 /** 3369 * Demographics and administrative information about a person independent of a specific health-related context. 3370 */ 3371 PERSON, 3372 /** 3373 * This resource allows for the definition of various types of plans as a sharable, consumable, and executable artifact. The resource is general enough to support the description of a broad range of clinical artifacts such as clinical decision support rules, order sets and protocols. 3374 */ 3375 PLANDEFINITION, 3376 /** 3377 * A person who is directly or indirectly involved in the provisioning of healthcare. 3378 */ 3379 PRACTITIONER, 3380 /** 3381 * A specific set of Roles/Locations/specialties/services that a practitioner may perform at an organization for a period of time. 3382 */ 3383 PRACTITIONERROLE, 3384 /** 3385 * An action that is or was performed on or for a patient. This can be a physical intervention like an operation, or less invasive like long term services, counseling, or hypnotherapy. 3386 */ 3387 PROCEDURE, 3388 /** 3389 * Provenance of a resource is a record that describes entities and processes involved in producing and delivering or otherwise influencing that resource. Provenance provides a critical foundation for assessing authenticity, enabling trust, and allowing reproducibility. Provenance assertions are a form of contextual metadata and can themselves become important records with their own provenance. Provenance statement indicates clinical significance in terms of confidence in authenticity, reliability, and trustworthiness, integrity, and stage in lifecycle (e.g. Document Completion - has the artifact been legally authenticated), all of which may impact security, privacy, and trust policies. 3390 */ 3391 PROVENANCE, 3392 /** 3393 * A structured set of questions intended to guide the collection of answers from end-users. Questionnaires provide detailed control over order, presentation, phraseology and grouping to allow coherent, consistent data collection. 3394 */ 3395 QUESTIONNAIRE, 3396 /** 3397 * A structured set of questions and their answers. The questions are ordered and grouped into coherent subsets, corresponding to the structure of the grouping of the questionnaire being responded to. 3398 */ 3399 QUESTIONNAIRERESPONSE, 3400 /** 3401 * The regulatory authorization of a medicinal product. 3402 */ 3403 REGULATEDAUTHORIZATION, 3404 /** 3405 * Information about a person that is involved in the care for a patient, but who is not the target of healthcare, nor has a formal responsibility in the care process. 3406 */ 3407 RELATEDPERSON, 3408 /** 3409 * A group of related requests that can be used to capture intended activities that have inter-dependencies such as "give this medication after that one". 3410 */ 3411 REQUESTGROUP, 3412 /** 3413 * A process where a researcher or organization plans and then executes a series of steps intended to increase the field of healthcare-related knowledge. This includes studies of safety, efficacy, comparative effectiveness and other information about medications, devices, therapies and other interventional and investigative techniques. A ResearchStudy involves the gathering of information about human or animal subjects. 3414 */ 3415 RESEARCHSTUDY, 3416 /** 3417 * A physical entity which is the primary unit of operational and/or administrative interest in a study. 3418 */ 3419 RESEARCHSUBJECT, 3420 /** 3421 * This is the base resource type for everything. 3422 */ 3423 RESOURCE, 3424 /** 3425 * An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome. 3426 */ 3427 RISKASSESSMENT, 3428 /** 3429 * A container for slots of time that may be available for booking appointments. 3430 */ 3431 SCHEDULE, 3432 /** 3433 * A search parameter that defines a named search item that can be used to search/filter on a resource. 3434 */ 3435 SEARCHPARAMETER, 3436 /** 3437 * A record of a request for service such as diagnostic investigations, treatments, or operations to be performed. 3438 */ 3439 SERVICEREQUEST, 3440 /** 3441 * A slot of time on a schedule that may be available for booking appointments. 3442 */ 3443 SLOT, 3444 /** 3445 * A sample to be used for analysis. 3446 */ 3447 SPECIMEN, 3448 /** 3449 * A kind of specimen with associated set of requirements. 3450 */ 3451 SPECIMENDEFINITION, 3452 /** 3453 * A definition of a FHIR structure. This resource is used to describe the underlying resources, data types defined in FHIR, and also for describing extensions and constraints on resources and data types. 3454 */ 3455 STRUCTUREDEFINITION, 3456 /** 3457 * A Map of relationships between 2 structures that can be used to transform data. 3458 */ 3459 STRUCTUREMAP, 3460 /** 3461 * The subscription resource describes a particular client's request to be notified about a Topic. 3462 */ 3463 SUBSCRIPTION, 3464 /** 3465 * A homogeneous material with a definite composition. 3466 */ 3467 SUBSTANCE, 3468 /** 3469 * The detailed description of a substance, typically at a level beyond what is used for prescribing. 3470 */ 3471 SUBSTANCEDEFINITION, 3472 /** 3473 * Nucleic acids are defined by three distinct elements: the base, sugar and linkage. Individual substance/moiety IDs will be created for each of these elements. The nucleotide sequence will be always entered in the 5’-3’ direction. 3474 */ 3475 SUBSTANCENUCLEICACID, 3476 /** 3477 * Todo. 3478 */ 3479 SUBSTANCEPOLYMER, 3480 /** 3481 * A SubstanceProtein is defined as a single unit of a linear amino acid sequence, or a combination of subunits that are either covalently linked or have a defined invariant stoichiometric relationship. This includes all synthetic, recombinant and purified SubstanceProteins of defined sequence, whether the use is therapeutic or prophylactic. This set of elements will be used to describe albumins, coagulation factors, cytokines, growth factors, peptide/SubstanceProtein hormones, enzymes, toxins, toxoids, recombinant vaccines, and immunomodulators. 3482 */ 3483 SUBSTANCEPROTEIN, 3484 /** 3485 * Todo. 3486 */ 3487 SUBSTANCEREFERENCEINFORMATION, 3488 /** 3489 * Source material shall capture information on the taxonomic and anatomical origins as well as the fraction of a material that can result in or can be modified to form a substance. This set of data elements shall be used to define polymer substances isolated from biological matrices. Taxonomic and anatomical origins shall be described using a controlled vocabulary as required. This information is captured for naturally derived polymers ( . starch) and structurally diverse substances. For Organisms belonging to the Kingdom Plantae the Substance level defines the fresh material of a single species or infraspecies, the Herbal Drug and the Herbal preparation. For Herbal preparations, the fraction information will be captured at the Substance information level and additional information for herbal extracts will be captured at the Specified Substance Group 1 information level. See for further explanation the Substance Class: Structurally Diverse and the herbal annex. 3490 */ 3491 SUBSTANCESOURCEMATERIAL, 3492 /** 3493 * Record of delivery of what is supplied. 3494 */ 3495 SUPPLYDELIVERY, 3496 /** 3497 * A record of a request for a medication, substance or device used in the healthcare setting. 3498 */ 3499 SUPPLYREQUEST, 3500 /** 3501 * A task to be performed. 3502 */ 3503 TASK, 3504 /** 3505 * A TerminologyCapabilities resource documents a set of capabilities (behaviors) of a FHIR Terminology Server that may be used as a statement of actual server functionality or a statement of required or desired server implementation. 3506 */ 3507 TERMINOLOGYCAPABILITIES, 3508 /** 3509 * A summary of information based on the results of executing a TestScript. 3510 */ 3511 TESTREPORT, 3512 /** 3513 * A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification. 3514 */ 3515 TESTSCRIPT, 3516 /** 3517 * Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic. 3518 */ 3519 TOPIC, 3520 /** 3521 * A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html). 3522 */ 3523 VALUESET, 3524 /** 3525 * Describes validation requirements, source(s), status and dates for one or more elements. 3526 */ 3527 VERIFICATIONRESULT, 3528 /** 3529 * An authorization for the provision of glasses and/or contact lenses to a patient. 3530 */ 3531 VISIONPRESCRIPTION, 3532 /** 3533 * A place holder that means any kind of data type 3534 */ 3535 TYPE, 3536 /** 3537 * A place holder that means any kind of resource 3538 */ 3539 ANY, 3540 /** 3541 * added to help the parsers 3542 */ 3543 NULL; 3544 public static FHIRAllTypes fromCode(String codeString) throws FHIRException { 3545 if (codeString == null || "".equals(codeString)) 3546 return null; 3547 if ("Address".equals(codeString)) 3548 return ADDRESS; 3549 if ("Age".equals(codeString)) 3550 return AGE; 3551 if ("Annotation".equals(codeString)) 3552 return ANNOTATION; 3553 if ("Attachment".equals(codeString)) 3554 return ATTACHMENT; 3555 if ("BackboneElement".equals(codeString)) 3556 return BACKBONEELEMENT; 3557 if ("BackboneType".equals(codeString)) 3558 return BACKBONETYPE; 3559 if ("Base".equals(codeString)) 3560 return BASE; 3561 if ("CodeableConcept".equals(codeString)) 3562 return CODEABLECONCEPT; 3563 if ("CodeableReference".equals(codeString)) 3564 return CODEABLEREFERENCE; 3565 if ("Coding".equals(codeString)) 3566 return CODING; 3567 if ("ContactDetail".equals(codeString)) 3568 return CONTACTDETAIL; 3569 if ("ContactPoint".equals(codeString)) 3570 return CONTACTPOINT; 3571 if ("Contributor".equals(codeString)) 3572 return CONTRIBUTOR; 3573 if ("Count".equals(codeString)) 3574 return COUNT; 3575 if ("DataRequirement".equals(codeString)) 3576 return DATAREQUIREMENT; 3577 if ("DataType".equals(codeString)) 3578 return DATATYPE; 3579 if ("Distance".equals(codeString)) 3580 return DISTANCE; 3581 if ("Dosage".equals(codeString)) 3582 return DOSAGE; 3583 if ("Duration".equals(codeString)) 3584 return DURATION; 3585 if ("Element".equals(codeString)) 3586 return ELEMENT; 3587 if ("ElementDefinition".equals(codeString)) 3588 return ELEMENTDEFINITION; 3589 if ("Expression".equals(codeString)) 3590 return EXPRESSION; 3591 if ("Extension".equals(codeString)) 3592 return EXTENSION; 3593 if ("HumanName".equals(codeString)) 3594 return HUMANNAME; 3595 if ("Identifier".equals(codeString)) 3596 return IDENTIFIER; 3597 if ("MarketingStatus".equals(codeString)) 3598 return MARKETINGSTATUS; 3599 if ("Meta".equals(codeString)) 3600 return META; 3601 if ("Money".equals(codeString)) 3602 return MONEY; 3603 if ("MoneyQuantity".equals(codeString)) 3604 return MONEYQUANTITY; 3605 if ("Narrative".equals(codeString)) 3606 return NARRATIVE; 3607 if ("OrderedDistribution".equals(codeString)) 3608 return ORDEREDDISTRIBUTION; 3609 if ("ParameterDefinition".equals(codeString)) 3610 return PARAMETERDEFINITION; 3611 if ("Period".equals(codeString)) 3612 return PERIOD; 3613 if ("Population".equals(codeString)) 3614 return POPULATION; 3615 if ("PrimitiveType".equals(codeString)) 3616 return PRIMITIVETYPE; 3617 if ("ProdCharacteristic".equals(codeString)) 3618 return PRODCHARACTERISTIC; 3619 if ("ProductShelfLife".equals(codeString)) 3620 return PRODUCTSHELFLIFE; 3621 if ("Quantity".equals(codeString)) 3622 return QUANTITY; 3623 if ("Range".equals(codeString)) 3624 return RANGE; 3625 if ("Ratio".equals(codeString)) 3626 return RATIO; 3627 if ("Reference".equals(codeString)) 3628 return REFERENCE; 3629 if ("RelatedArtifact".equals(codeString)) 3630 return RELATEDARTIFACT; 3631 if ("SampledData".equals(codeString)) 3632 return SAMPLEDDATA; 3633 if ("Signature".equals(codeString)) 3634 return SIGNATURE; 3635 if ("SimpleQuantity".equals(codeString)) 3636 return SIMPLEQUANTITY; 3637 if ("Statistic".equals(codeString)) 3638 return STATISTIC; 3639 if ("SubstanceAmount".equals(codeString)) 3640 return SUBSTANCEAMOUNT; 3641 if ("Timing".equals(codeString)) 3642 return TIMING; 3643 if ("TriggerDefinition".equals(codeString)) 3644 return TRIGGERDEFINITION; 3645 if ("UsageContext".equals(codeString)) 3646 return USAGECONTEXT; 3647 if ("base64Binary".equals(codeString)) 3648 return BASE64BINARY; 3649 if ("boolean".equals(codeString)) 3650 return BOOLEAN; 3651 if ("canonical".equals(codeString)) 3652 return CANONICAL; 3653 if ("code".equals(codeString)) 3654 return CODE; 3655 if ("date".equals(codeString)) 3656 return DATE; 3657 if ("dateTime".equals(codeString)) 3658 return DATETIME; 3659 if ("decimal".equals(codeString)) 3660 return DECIMAL; 3661 if ("id".equals(codeString)) 3662 return ID; 3663 if ("instant".equals(codeString)) 3664 return INSTANT; 3665 if ("integer".equals(codeString)) 3666 return INTEGER; 3667 if ("integer64".equals(codeString)) 3668 return INTEGER64; 3669 if ("markdown".equals(codeString)) 3670 return MARKDOWN; 3671 if ("oid".equals(codeString)) 3672 return OID; 3673 if ("positiveInt".equals(codeString)) 3674 return POSITIVEINT; 3675 if ("string".equals(codeString)) 3676 return STRING; 3677 if ("time".equals(codeString)) 3678 return TIME; 3679 if ("unsignedInt".equals(codeString)) 3680 return UNSIGNEDINT; 3681 if ("uri".equals(codeString)) 3682 return URI; 3683 if ("url".equals(codeString)) 3684 return URL; 3685 if ("uuid".equals(codeString)) 3686 return UUID; 3687 if ("xhtml".equals(codeString)) 3688 return XHTML; 3689 if ("Account".equals(codeString)) 3690 return ACCOUNT; 3691 if ("ActivityDefinition".equals(codeString)) 3692 return ACTIVITYDEFINITION; 3693 if ("AdministrableProductDefinition".equals(codeString)) 3694 return ADMINISTRABLEPRODUCTDEFINITION; 3695 if ("AdverseEvent".equals(codeString)) 3696 return ADVERSEEVENT; 3697 if ("AllergyIntolerance".equals(codeString)) 3698 return ALLERGYINTOLERANCE; 3699 if ("Appointment".equals(codeString)) 3700 return APPOINTMENT; 3701 if ("AppointmentResponse".equals(codeString)) 3702 return APPOINTMENTRESPONSE; 3703 if ("AuditEvent".equals(codeString)) 3704 return AUDITEVENT; 3705 if ("Basic".equals(codeString)) 3706 return BASIC; 3707 if ("Binary".equals(codeString)) 3708 return BINARY; 3709 if ("BiologicallyDerivedProduct".equals(codeString)) 3710 return BIOLOGICALLYDERIVEDPRODUCT; 3711 if ("BodyStructure".equals(codeString)) 3712 return BODYSTRUCTURE; 3713 if ("Bundle".equals(codeString)) 3714 return BUNDLE; 3715 if ("CapabilityStatement".equals(codeString)) 3716 return CAPABILITYSTATEMENT; 3717 if ("CapabilityStatement2".equals(codeString)) 3718 return CAPABILITYSTATEMENT2; 3719 if ("CarePlan".equals(codeString)) 3720 return CAREPLAN; 3721 if ("CareTeam".equals(codeString)) 3722 return CARETEAM; 3723 if ("CatalogEntry".equals(codeString)) 3724 return CATALOGENTRY; 3725 if ("ChargeItem".equals(codeString)) 3726 return CHARGEITEM; 3727 if ("ChargeItemDefinition".equals(codeString)) 3728 return CHARGEITEMDEFINITION; 3729 if ("Claim".equals(codeString)) 3730 return CLAIM; 3731 if ("ClaimResponse".equals(codeString)) 3732 return CLAIMRESPONSE; 3733 if ("ClinicalImpression".equals(codeString)) 3734 return CLINICALIMPRESSION; 3735 if ("ClinicalUseIssue".equals(codeString)) 3736 return CLINICALUSEISSUE; 3737 if ("CodeSystem".equals(codeString)) 3738 return CODESYSTEM; 3739 if ("Communication".equals(codeString)) 3740 return COMMUNICATION; 3741 if ("CommunicationRequest".equals(codeString)) 3742 return COMMUNICATIONREQUEST; 3743 if ("CompartmentDefinition".equals(codeString)) 3744 return COMPARTMENTDEFINITION; 3745 if ("Composition".equals(codeString)) 3746 return COMPOSITION; 3747 if ("ConceptMap".equals(codeString)) 3748 return CONCEPTMAP; 3749 if ("Condition".equals(codeString)) 3750 return CONDITION; 3751 if ("ConditionDefinition".equals(codeString)) 3752 return CONDITIONDEFINITION; 3753 if ("Consent".equals(codeString)) 3754 return CONSENT; 3755 if ("Contract".equals(codeString)) 3756 return CONTRACT; 3757 if ("Coverage".equals(codeString)) 3758 return COVERAGE; 3759 if ("CoverageEligibilityRequest".equals(codeString)) 3760 return COVERAGEELIGIBILITYREQUEST; 3761 if ("CoverageEligibilityResponse".equals(codeString)) 3762 return COVERAGEELIGIBILITYRESPONSE; 3763 if ("DetectedIssue".equals(codeString)) 3764 return DETECTEDISSUE; 3765 if ("Device".equals(codeString)) 3766 return DEVICE; 3767 if ("DeviceDefinition".equals(codeString)) 3768 return DEVICEDEFINITION; 3769 if ("DeviceMetric".equals(codeString)) 3770 return DEVICEMETRIC; 3771 if ("DeviceRequest".equals(codeString)) 3772 return DEVICEREQUEST; 3773 if ("DeviceUseStatement".equals(codeString)) 3774 return DEVICEUSESTATEMENT; 3775 if ("DiagnosticReport".equals(codeString)) 3776 return DIAGNOSTICREPORT; 3777 if ("DocumentManifest".equals(codeString)) 3778 return DOCUMENTMANIFEST; 3779 if ("DocumentReference".equals(codeString)) 3780 return DOCUMENTREFERENCE; 3781 if ("DomainResource".equals(codeString)) 3782 return DOMAINRESOURCE; 3783 if ("Encounter".equals(codeString)) 3784 return ENCOUNTER; 3785 if ("Endpoint".equals(codeString)) 3786 return ENDPOINT; 3787 if ("EnrollmentRequest".equals(codeString)) 3788 return ENROLLMENTREQUEST; 3789 if ("EnrollmentResponse".equals(codeString)) 3790 return ENROLLMENTRESPONSE; 3791 if ("EpisodeOfCare".equals(codeString)) 3792 return EPISODEOFCARE; 3793 if ("EventDefinition".equals(codeString)) 3794 return EVENTDEFINITION; 3795 if ("Evidence".equals(codeString)) 3796 return EVIDENCE; 3797 if ("EvidenceVariable".equals(codeString)) 3798 return EVIDENCEVARIABLE; 3799 if ("ExampleScenario".equals(codeString)) 3800 return EXAMPLESCENARIO; 3801 if ("ExplanationOfBenefit".equals(codeString)) 3802 return EXPLANATIONOFBENEFIT; 3803 if ("FamilyMemberHistory".equals(codeString)) 3804 return FAMILYMEMBERHISTORY; 3805 if ("Flag".equals(codeString)) 3806 return FLAG; 3807 if ("Goal".equals(codeString)) 3808 return GOAL; 3809 if ("GraphDefinition".equals(codeString)) 3810 return GRAPHDEFINITION; 3811 if ("Group".equals(codeString)) 3812 return GROUP; 3813 if ("GuidanceResponse".equals(codeString)) 3814 return GUIDANCERESPONSE; 3815 if ("HealthcareService".equals(codeString)) 3816 return HEALTHCARESERVICE; 3817 if ("ImagingStudy".equals(codeString)) 3818 return IMAGINGSTUDY; 3819 if ("Immunization".equals(codeString)) 3820 return IMMUNIZATION; 3821 if ("ImmunizationEvaluation".equals(codeString)) 3822 return IMMUNIZATIONEVALUATION; 3823 if ("ImmunizationRecommendation".equals(codeString)) 3824 return IMMUNIZATIONRECOMMENDATION; 3825 if ("ImplementationGuide".equals(codeString)) 3826 return IMPLEMENTATIONGUIDE; 3827 if ("Ingredient".equals(codeString)) 3828 return INGREDIENT; 3829 if ("InsurancePlan".equals(codeString)) 3830 return INSURANCEPLAN; 3831 if ("Invoice".equals(codeString)) 3832 return INVOICE; 3833 if ("Library".equals(codeString)) 3834 return LIBRARY; 3835 if ("Linkage".equals(codeString)) 3836 return LINKAGE; 3837 if ("List".equals(codeString)) 3838 return LIST; 3839 if ("Location".equals(codeString)) 3840 return LOCATION; 3841 if ("ManufacturedItemDefinition".equals(codeString)) 3842 return MANUFACTUREDITEMDEFINITION; 3843 if ("Measure".equals(codeString)) 3844 return MEASURE; 3845 if ("MeasureReport".equals(codeString)) 3846 return MEASUREREPORT; 3847 if ("Medication".equals(codeString)) 3848 return MEDICATION; 3849 if ("MedicationAdministration".equals(codeString)) 3850 return MEDICATIONADMINISTRATION; 3851 if ("MedicationDispense".equals(codeString)) 3852 return MEDICATIONDISPENSE; 3853 if ("MedicationKnowledge".equals(codeString)) 3854 return MEDICATIONKNOWLEDGE; 3855 if ("MedicationRequest".equals(codeString)) 3856 return MEDICATIONREQUEST; 3857 if ("MedicationUsage".equals(codeString)) 3858 return MEDICATIONUSAGE; 3859 if ("MedicinalProductDefinition".equals(codeString)) 3860 return MEDICINALPRODUCTDEFINITION; 3861 if ("MessageDefinition".equals(codeString)) 3862 return MESSAGEDEFINITION; 3863 if ("MessageHeader".equals(codeString)) 3864 return MESSAGEHEADER; 3865 if ("MolecularSequence".equals(codeString)) 3866 return MOLECULARSEQUENCE; 3867 if ("NamingSystem".equals(codeString)) 3868 return NAMINGSYSTEM; 3869 if ("NutritionIntake".equals(codeString)) 3870 return NUTRITIONINTAKE; 3871 if ("NutritionOrder".equals(codeString)) 3872 return NUTRITIONORDER; 3873 if ("Observation".equals(codeString)) 3874 return OBSERVATION; 3875 if ("ObservationDefinition".equals(codeString)) 3876 return OBSERVATIONDEFINITION; 3877 if ("OperationDefinition".equals(codeString)) 3878 return OPERATIONDEFINITION; 3879 if ("OperationOutcome".equals(codeString)) 3880 return OPERATIONOUTCOME; 3881 if ("Organization".equals(codeString)) 3882 return ORGANIZATION; 3883 if ("OrganizationAffiliation".equals(codeString)) 3884 return ORGANIZATIONAFFILIATION; 3885 if ("PackagedProductDefinition".equals(codeString)) 3886 return PACKAGEDPRODUCTDEFINITION; 3887 if ("Parameters".equals(codeString)) 3888 return PARAMETERS; 3889 if ("Patient".equals(codeString)) 3890 return PATIENT; 3891 if ("PaymentNotice".equals(codeString)) 3892 return PAYMENTNOTICE; 3893 if ("PaymentReconciliation".equals(codeString)) 3894 return PAYMENTRECONCILIATION; 3895 if ("Person".equals(codeString)) 3896 return PERSON; 3897 if ("PlanDefinition".equals(codeString)) 3898 return PLANDEFINITION; 3899 if ("Practitioner".equals(codeString)) 3900 return PRACTITIONER; 3901 if ("PractitionerRole".equals(codeString)) 3902 return PRACTITIONERROLE; 3903 if ("Procedure".equals(codeString)) 3904 return PROCEDURE; 3905 if ("Provenance".equals(codeString)) 3906 return PROVENANCE; 3907 if ("Questionnaire".equals(codeString)) 3908 return QUESTIONNAIRE; 3909 if ("QuestionnaireResponse".equals(codeString)) 3910 return QUESTIONNAIRERESPONSE; 3911 if ("RegulatedAuthorization".equals(codeString)) 3912 return REGULATEDAUTHORIZATION; 3913 if ("RelatedPerson".equals(codeString)) 3914 return RELATEDPERSON; 3915 if ("RequestGroup".equals(codeString)) 3916 return REQUESTGROUP; 3917 if ("ResearchStudy".equals(codeString)) 3918 return RESEARCHSTUDY; 3919 if ("ResearchSubject".equals(codeString)) 3920 return RESEARCHSUBJECT; 3921 if ("Resource".equals(codeString)) 3922 return RESOURCE; 3923 if ("RiskAssessment".equals(codeString)) 3924 return RISKASSESSMENT; 3925 if ("Schedule".equals(codeString)) 3926 return SCHEDULE; 3927 if ("SearchParameter".equals(codeString)) 3928 return SEARCHPARAMETER; 3929 if ("ServiceRequest".equals(codeString)) 3930 return SERVICEREQUEST; 3931 if ("Slot".equals(codeString)) 3932 return SLOT; 3933 if ("Specimen".equals(codeString)) 3934 return SPECIMEN; 3935 if ("SpecimenDefinition".equals(codeString)) 3936 return SPECIMENDEFINITION; 3937 if ("StructureDefinition".equals(codeString)) 3938 return STRUCTUREDEFINITION; 3939 if ("StructureMap".equals(codeString)) 3940 return STRUCTUREMAP; 3941 if ("Subscription".equals(codeString)) 3942 return SUBSCRIPTION; 3943 if ("Substance".equals(codeString)) 3944 return SUBSTANCE; 3945 if ("SubstanceDefinition".equals(codeString)) 3946 return SUBSTANCEDEFINITION; 3947 if ("SubstanceNucleicAcid".equals(codeString)) 3948 return SUBSTANCENUCLEICACID; 3949 if ("SubstancePolymer".equals(codeString)) 3950 return SUBSTANCEPOLYMER; 3951 if ("SubstanceProtein".equals(codeString)) 3952 return SUBSTANCEPROTEIN; 3953 if ("SubstanceReferenceInformation".equals(codeString)) 3954 return SUBSTANCEREFERENCEINFORMATION; 3955 if ("SubstanceSourceMaterial".equals(codeString)) 3956 return SUBSTANCESOURCEMATERIAL; 3957 if ("SupplyDelivery".equals(codeString)) 3958 return SUPPLYDELIVERY; 3959 if ("SupplyRequest".equals(codeString)) 3960 return SUPPLYREQUEST; 3961 if ("Task".equals(codeString)) 3962 return TASK; 3963 if ("TerminologyCapabilities".equals(codeString)) 3964 return TERMINOLOGYCAPABILITIES; 3965 if ("TestReport".equals(codeString)) 3966 return TESTREPORT; 3967 if ("TestScript".equals(codeString)) 3968 return TESTSCRIPT; 3969 if ("Topic".equals(codeString)) 3970 return TOPIC; 3971 if ("ValueSet".equals(codeString)) 3972 return VALUESET; 3973 if ("VerificationResult".equals(codeString)) 3974 return VERIFICATIONRESULT; 3975 if ("VisionPrescription".equals(codeString)) 3976 return VISIONPRESCRIPTION; 3977 if ("Type".equals(codeString)) 3978 return TYPE; 3979 if ("Any".equals(codeString)) 3980 return ANY; 3981 throw new FHIRException("Unknown FHIRAllTypes code '"+codeString+"'"); 3982 } 3983 public String toCode() { 3984 switch (this) { 3985 case ADDRESS: return "Address"; 3986 case AGE: return "Age"; 3987 case ANNOTATION: return "Annotation"; 3988 case ATTACHMENT: return "Attachment"; 3989 case BACKBONEELEMENT: return "BackboneElement"; 3990 case BACKBONETYPE: return "BackboneType"; 3991 case BASE: return "Base"; 3992 case CODEABLECONCEPT: return "CodeableConcept"; 3993 case CODEABLEREFERENCE: return "CodeableReference"; 3994 case CODING: return "Coding"; 3995 case CONTACTDETAIL: return "ContactDetail"; 3996 case CONTACTPOINT: return "ContactPoint"; 3997 case CONTRIBUTOR: return "Contributor"; 3998 case COUNT: return "Count"; 3999 case DATAREQUIREMENT: return "DataRequirement"; 4000 case DATATYPE: return "DataType"; 4001 case DISTANCE: return "Distance"; 4002 case DOSAGE: return "Dosage"; 4003 case DURATION: return "Duration"; 4004 case ELEMENT: return "Element"; 4005 case ELEMENTDEFINITION: return "ElementDefinition"; 4006 case EXPRESSION: return "Expression"; 4007 case EXTENSION: return "Extension"; 4008 case HUMANNAME: return "HumanName"; 4009 case IDENTIFIER: return "Identifier"; 4010 case MARKETINGSTATUS: return "MarketingStatus"; 4011 case META: return "Meta"; 4012 case MONEY: return "Money"; 4013 case MONEYQUANTITY: return "MoneyQuantity"; 4014 case NARRATIVE: return "Narrative"; 4015 case ORDEREDDISTRIBUTION: return "OrderedDistribution"; 4016 case PARAMETERDEFINITION: return "ParameterDefinition"; 4017 case PERIOD: return "Period"; 4018 case POPULATION: return "Population"; 4019 case PRIMITIVETYPE: return "PrimitiveType"; 4020 case PRODCHARACTERISTIC: return "ProdCharacteristic"; 4021 case PRODUCTSHELFLIFE: return "ProductShelfLife"; 4022 case QUANTITY: return "Quantity"; 4023 case RANGE: return "Range"; 4024 case RATIO: return "Ratio"; 4025 case REFERENCE: return "Reference"; 4026 case RELATEDARTIFACT: return "RelatedArtifact"; 4027 case SAMPLEDDATA: return "SampledData"; 4028 case SIGNATURE: return "Signature"; 4029 case SIMPLEQUANTITY: return "SimpleQuantity"; 4030 case STATISTIC: return "Statistic"; 4031 case SUBSTANCEAMOUNT: return "SubstanceAmount"; 4032 case TIMING: return "Timing"; 4033 case TRIGGERDEFINITION: return "TriggerDefinition"; 4034 case USAGECONTEXT: return "UsageContext"; 4035 case BASE64BINARY: return "base64Binary"; 4036 case BOOLEAN: return "boolean"; 4037 case CANONICAL: return "canonical"; 4038 case CODE: return "code"; 4039 case DATE: return "date"; 4040 case DATETIME: return "dateTime"; 4041 case DECIMAL: return "decimal"; 4042 case ID: return "id"; 4043 case INSTANT: return "instant"; 4044 case INTEGER: return "integer"; 4045 case INTEGER64: return "integer64"; 4046 case MARKDOWN: return "markdown"; 4047 case OID: return "oid"; 4048 case POSITIVEINT: return "positiveInt"; 4049 case STRING: return "string"; 4050 case TIME: return "time"; 4051 case UNSIGNEDINT: return "unsignedInt"; 4052 case URI: return "uri"; 4053 case URL: return "url"; 4054 case UUID: return "uuid"; 4055 case XHTML: return "xhtml"; 4056 case ACCOUNT: return "Account"; 4057 case ACTIVITYDEFINITION: return "ActivityDefinition"; 4058 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 4059 case ADVERSEEVENT: return "AdverseEvent"; 4060 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 4061 case APPOINTMENT: return "Appointment"; 4062 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 4063 case AUDITEVENT: return "AuditEvent"; 4064 case BASIC: return "Basic"; 4065 case BINARY: return "Binary"; 4066 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 4067 case BODYSTRUCTURE: return "BodyStructure"; 4068 case BUNDLE: return "Bundle"; 4069 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 4070 case CAPABILITYSTATEMENT2: return "CapabilityStatement2"; 4071 case CAREPLAN: return "CarePlan"; 4072 case CARETEAM: return "CareTeam"; 4073 case CATALOGENTRY: return "CatalogEntry"; 4074 case CHARGEITEM: return "ChargeItem"; 4075 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 4076 case CLAIM: return "Claim"; 4077 case CLAIMRESPONSE: return "ClaimResponse"; 4078 case CLINICALIMPRESSION: return "ClinicalImpression"; 4079 case CLINICALUSEISSUE: return "ClinicalUseIssue"; 4080 case CODESYSTEM: return "CodeSystem"; 4081 case COMMUNICATION: return "Communication"; 4082 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 4083 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 4084 case COMPOSITION: return "Composition"; 4085 case CONCEPTMAP: return "ConceptMap"; 4086 case CONDITION: return "Condition"; 4087 case CONDITIONDEFINITION: return "ConditionDefinition"; 4088 case CONSENT: return "Consent"; 4089 case CONTRACT: return "Contract"; 4090 case COVERAGE: return "Coverage"; 4091 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 4092 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 4093 case DETECTEDISSUE: return "DetectedIssue"; 4094 case DEVICE: return "Device"; 4095 case DEVICEDEFINITION: return "DeviceDefinition"; 4096 case DEVICEMETRIC: return "DeviceMetric"; 4097 case DEVICEREQUEST: return "DeviceRequest"; 4098 case DEVICEUSESTATEMENT: return "DeviceUseStatement"; 4099 case DIAGNOSTICREPORT: return "DiagnosticReport"; 4100 case DOCUMENTMANIFEST: return "DocumentManifest"; 4101 case DOCUMENTREFERENCE: return "DocumentReference"; 4102 case DOMAINRESOURCE: return "DomainResource"; 4103 case ENCOUNTER: return "Encounter"; 4104 case ENDPOINT: return "Endpoint"; 4105 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 4106 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 4107 case EPISODEOFCARE: return "EpisodeOfCare"; 4108 case EVENTDEFINITION: return "EventDefinition"; 4109 case EVIDENCE: return "Evidence"; 4110 case EVIDENCEVARIABLE: return "EvidenceVariable"; 4111 case EXAMPLESCENARIO: return "ExampleScenario"; 4112 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 4113 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 4114 case FLAG: return "Flag"; 4115 case GOAL: return "Goal"; 4116 case GRAPHDEFINITION: return "GraphDefinition"; 4117 case GROUP: return "Group"; 4118 case GUIDANCERESPONSE: return "GuidanceResponse"; 4119 case HEALTHCARESERVICE: return "HealthcareService"; 4120 case IMAGINGSTUDY: return "ImagingStudy"; 4121 case IMMUNIZATION: return "Immunization"; 4122 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 4123 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 4124 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 4125 case INGREDIENT: return "Ingredient"; 4126 case INSURANCEPLAN: return "InsurancePlan"; 4127 case INVOICE: return "Invoice"; 4128 case LIBRARY: return "Library"; 4129 case LINKAGE: return "Linkage"; 4130 case LIST: return "List"; 4131 case LOCATION: return "Location"; 4132 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 4133 case MEASURE: return "Measure"; 4134 case MEASUREREPORT: return "MeasureReport"; 4135 case MEDICATION: return "Medication"; 4136 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 4137 case MEDICATIONDISPENSE: return "MedicationDispense"; 4138 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 4139 case MEDICATIONREQUEST: return "MedicationRequest"; 4140 case MEDICATIONUSAGE: return "MedicationUsage"; 4141 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 4142 case MESSAGEDEFINITION: return "MessageDefinition"; 4143 case MESSAGEHEADER: return "MessageHeader"; 4144 case MOLECULARSEQUENCE: return "MolecularSequence"; 4145 case NAMINGSYSTEM: return "NamingSystem"; 4146 case NUTRITIONINTAKE: return "NutritionIntake"; 4147 case NUTRITIONORDER: return "NutritionOrder"; 4148 case OBSERVATION: return "Observation"; 4149 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 4150 case OPERATIONDEFINITION: return "OperationDefinition"; 4151 case OPERATIONOUTCOME: return "OperationOutcome"; 4152 case ORGANIZATION: return "Organization"; 4153 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 4154 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 4155 case PARAMETERS: return "Parameters"; 4156 case PATIENT: return "Patient"; 4157 case PAYMENTNOTICE: return "PaymentNotice"; 4158 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 4159 case PERSON: return "Person"; 4160 case PLANDEFINITION: return "PlanDefinition"; 4161 case PRACTITIONER: return "Practitioner"; 4162 case PRACTITIONERROLE: return "PractitionerRole"; 4163 case PROCEDURE: return "Procedure"; 4164 case PROVENANCE: return "Provenance"; 4165 case QUESTIONNAIRE: return "Questionnaire"; 4166 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 4167 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 4168 case RELATEDPERSON: return "RelatedPerson"; 4169 case REQUESTGROUP: return "RequestGroup"; 4170 case RESEARCHSTUDY: return "ResearchStudy"; 4171 case RESEARCHSUBJECT: return "ResearchSubject"; 4172 case RESOURCE: return "Resource"; 4173 case RISKASSESSMENT: return "RiskAssessment"; 4174 case SCHEDULE: return "Schedule"; 4175 case SEARCHPARAMETER: return "SearchParameter"; 4176 case SERVICEREQUEST: return "ServiceRequest"; 4177 case SLOT: return "Slot"; 4178 case SPECIMEN: return "Specimen"; 4179 case SPECIMENDEFINITION: return "SpecimenDefinition"; 4180 case STRUCTUREDEFINITION: return "StructureDefinition"; 4181 case STRUCTUREMAP: return "StructureMap"; 4182 case SUBSCRIPTION: return "Subscription"; 4183 case SUBSTANCE: return "Substance"; 4184 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 4185 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 4186 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 4187 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 4188 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 4189 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 4190 case SUPPLYDELIVERY: return "SupplyDelivery"; 4191 case SUPPLYREQUEST: return "SupplyRequest"; 4192 case TASK: return "Task"; 4193 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 4194 case TESTREPORT: return "TestReport"; 4195 case TESTSCRIPT: return "TestScript"; 4196 case TOPIC: return "Topic"; 4197 case VALUESET: return "ValueSet"; 4198 case VERIFICATIONRESULT: return "VerificationResult"; 4199 case VISIONPRESCRIPTION: return "VisionPrescription"; 4200 case TYPE: return "Type"; 4201 case ANY: return "Any"; 4202 default: return "?"; 4203 } 4204 } 4205 public String getSystem() { 4206 switch (this) { 4207 case ADDRESS: return "http://hl7.org/fhir/data-types"; 4208 case AGE: return "http://hl7.org/fhir/data-types"; 4209 case ANNOTATION: return "http://hl7.org/fhir/data-types"; 4210 case ATTACHMENT: return "http://hl7.org/fhir/data-types"; 4211 case BACKBONEELEMENT: return "http://hl7.org/fhir/data-types"; 4212 case BACKBONETYPE: return "http://hl7.org/fhir/data-types"; 4213 case BASE: return "http://hl7.org/fhir/data-types"; 4214 case CODEABLECONCEPT: return "http://hl7.org/fhir/data-types"; 4215 case CODEABLEREFERENCE: return "http://hl7.org/fhir/data-types"; 4216 case CODING: return "http://hl7.org/fhir/data-types"; 4217 case CONTACTDETAIL: return "http://hl7.org/fhir/data-types"; 4218 case CONTACTPOINT: return "http://hl7.org/fhir/data-types"; 4219 case CONTRIBUTOR: return "http://hl7.org/fhir/data-types"; 4220 case COUNT: return "http://hl7.org/fhir/data-types"; 4221 case DATAREQUIREMENT: return "http://hl7.org/fhir/data-types"; 4222 case DATATYPE: return "http://hl7.org/fhir/data-types"; 4223 case DISTANCE: return "http://hl7.org/fhir/data-types"; 4224 case DOSAGE: return "http://hl7.org/fhir/data-types"; 4225 case DURATION: return "http://hl7.org/fhir/data-types"; 4226 case ELEMENT: return "http://hl7.org/fhir/data-types"; 4227 case ELEMENTDEFINITION: return "http://hl7.org/fhir/data-types"; 4228 case EXPRESSION: return "http://hl7.org/fhir/data-types"; 4229 case EXTENSION: return "http://hl7.org/fhir/data-types"; 4230 case HUMANNAME: return "http://hl7.org/fhir/data-types"; 4231 case IDENTIFIER: return "http://hl7.org/fhir/data-types"; 4232 case MARKETINGSTATUS: return "http://hl7.org/fhir/data-types"; 4233 case META: return "http://hl7.org/fhir/data-types"; 4234 case MONEY: return "http://hl7.org/fhir/data-types"; 4235 case MONEYQUANTITY: return "http://hl7.org/fhir/data-types"; 4236 case NARRATIVE: return "http://hl7.org/fhir/data-types"; 4237 case ORDEREDDISTRIBUTION: return "http://hl7.org/fhir/data-types"; 4238 case PARAMETERDEFINITION: return "http://hl7.org/fhir/data-types"; 4239 case PERIOD: return "http://hl7.org/fhir/data-types"; 4240 case POPULATION: return "http://hl7.org/fhir/data-types"; 4241 case PRIMITIVETYPE: return "http://hl7.org/fhir/data-types"; 4242 case PRODCHARACTERISTIC: return "http://hl7.org/fhir/data-types"; 4243 case PRODUCTSHELFLIFE: return "http://hl7.org/fhir/data-types"; 4244 case QUANTITY: return "http://hl7.org/fhir/data-types"; 4245 case RANGE: return "http://hl7.org/fhir/data-types"; 4246 case RATIO: return "http://hl7.org/fhir/data-types"; 4247 case REFERENCE: return "http://hl7.org/fhir/data-types"; 4248 case RELATEDARTIFACT: return "http://hl7.org/fhir/data-types"; 4249 case SAMPLEDDATA: return "http://hl7.org/fhir/data-types"; 4250 case SIGNATURE: return "http://hl7.org/fhir/data-types"; 4251 case SIMPLEQUANTITY: return "http://hl7.org/fhir/data-types"; 4252 case STATISTIC: return "http://hl7.org/fhir/data-types"; 4253 case SUBSTANCEAMOUNT: return "http://hl7.org/fhir/data-types"; 4254 case TIMING: return "http://hl7.org/fhir/data-types"; 4255 case TRIGGERDEFINITION: return "http://hl7.org/fhir/data-types"; 4256 case USAGECONTEXT: return "http://hl7.org/fhir/data-types"; 4257 case BASE64BINARY: return "http://hl7.org/fhir/data-types"; 4258 case BOOLEAN: return "http://hl7.org/fhir/data-types"; 4259 case CANONICAL: return "http://hl7.org/fhir/data-types"; 4260 case CODE: return "http://hl7.org/fhir/data-types"; 4261 case DATE: return "http://hl7.org/fhir/data-types"; 4262 case DATETIME: return "http://hl7.org/fhir/data-types"; 4263 case DECIMAL: return "http://hl7.org/fhir/data-types"; 4264 case ID: return "http://hl7.org/fhir/data-types"; 4265 case INSTANT: return "http://hl7.org/fhir/data-types"; 4266 case INTEGER: return "http://hl7.org/fhir/data-types"; 4267 case INTEGER64: return "http://hl7.org/fhir/data-types"; 4268 case MARKDOWN: return "http://hl7.org/fhir/data-types"; 4269 case OID: return "http://hl7.org/fhir/data-types"; 4270 case POSITIVEINT: return "http://hl7.org/fhir/data-types"; 4271 case STRING: return "http://hl7.org/fhir/data-types"; 4272 case TIME: return "http://hl7.org/fhir/data-types"; 4273 case UNSIGNEDINT: return "http://hl7.org/fhir/data-types"; 4274 case URI: return "http://hl7.org/fhir/data-types"; 4275 case URL: return "http://hl7.org/fhir/data-types"; 4276 case UUID: return "http://hl7.org/fhir/data-types"; 4277 case XHTML: return "http://hl7.org/fhir/data-types"; 4278 case ACCOUNT: return "http://hl7.org/fhir/resource-types"; 4279 case ACTIVITYDEFINITION: return "http://hl7.org/fhir/resource-types"; 4280 case ADMINISTRABLEPRODUCTDEFINITION: return "http://hl7.org/fhir/resource-types"; 4281 case ADVERSEEVENT: return "http://hl7.org/fhir/resource-types"; 4282 case ALLERGYINTOLERANCE: return "http://hl7.org/fhir/resource-types"; 4283 case APPOINTMENT: return "http://hl7.org/fhir/resource-types"; 4284 case APPOINTMENTRESPONSE: return "http://hl7.org/fhir/resource-types"; 4285 case AUDITEVENT: return "http://hl7.org/fhir/resource-types"; 4286 case BASIC: return "http://hl7.org/fhir/resource-types"; 4287 case BINARY: return "http://hl7.org/fhir/resource-types"; 4288 case BIOLOGICALLYDERIVEDPRODUCT: return "http://hl7.org/fhir/resource-types"; 4289 case BODYSTRUCTURE: return "http://hl7.org/fhir/resource-types"; 4290 case BUNDLE: return "http://hl7.org/fhir/resource-types"; 4291 case CAPABILITYSTATEMENT: return "http://hl7.org/fhir/resource-types"; 4292 case CAPABILITYSTATEMENT2: return "http://hl7.org/fhir/resource-types"; 4293 case CAREPLAN: return "http://hl7.org/fhir/resource-types"; 4294 case CARETEAM: return "http://hl7.org/fhir/resource-types"; 4295 case CATALOGENTRY: return "http://hl7.org/fhir/resource-types"; 4296 case CHARGEITEM: return "http://hl7.org/fhir/resource-types"; 4297 case CHARGEITEMDEFINITION: return "http://hl7.org/fhir/resource-types"; 4298 case CLAIM: return "http://hl7.org/fhir/resource-types"; 4299 case CLAIMRESPONSE: return "http://hl7.org/fhir/resource-types"; 4300 case CLINICALIMPRESSION: return "http://hl7.org/fhir/resource-types"; 4301 case CLINICALUSEISSUE: return "http://hl7.org/fhir/resource-types"; 4302 case CODESYSTEM: return "http://hl7.org/fhir/resource-types"; 4303 case COMMUNICATION: return "http://hl7.org/fhir/resource-types"; 4304 case COMMUNICATIONREQUEST: return "http://hl7.org/fhir/resource-types"; 4305 case COMPARTMENTDEFINITION: return "http://hl7.org/fhir/resource-types"; 4306 case COMPOSITION: return "http://hl7.org/fhir/resource-types"; 4307 case CONCEPTMAP: return "http://hl7.org/fhir/resource-types"; 4308 case CONDITION: return "http://hl7.org/fhir/resource-types"; 4309 case CONDITIONDEFINITION: return "http://hl7.org/fhir/resource-types"; 4310 case CONSENT: return "http://hl7.org/fhir/resource-types"; 4311 case CONTRACT: return "http://hl7.org/fhir/resource-types"; 4312 case COVERAGE: return "http://hl7.org/fhir/resource-types"; 4313 case COVERAGEELIGIBILITYREQUEST: return "http://hl7.org/fhir/resource-types"; 4314 case COVERAGEELIGIBILITYRESPONSE: return "http://hl7.org/fhir/resource-types"; 4315 case DETECTEDISSUE: return "http://hl7.org/fhir/resource-types"; 4316 case DEVICE: return "http://hl7.org/fhir/resource-types"; 4317 case DEVICEDEFINITION: return "http://hl7.org/fhir/resource-types"; 4318 case DEVICEMETRIC: return "http://hl7.org/fhir/resource-types"; 4319 case DEVICEREQUEST: return "http://hl7.org/fhir/resource-types"; 4320 case DEVICEUSESTATEMENT: return "http://hl7.org/fhir/resource-types"; 4321 case DIAGNOSTICREPORT: return "http://hl7.org/fhir/resource-types"; 4322 case DOCUMENTMANIFEST: return "http://hl7.org/fhir/resource-types"; 4323 case DOCUMENTREFERENCE: return "http://hl7.org/fhir/resource-types"; 4324 case DOMAINRESOURCE: return "http://hl7.org/fhir/resource-types"; 4325 case ENCOUNTER: return "http://hl7.org/fhir/resource-types"; 4326 case ENDPOINT: return "http://hl7.org/fhir/resource-types"; 4327 case ENROLLMENTREQUEST: return "http://hl7.org/fhir/resource-types"; 4328 case ENROLLMENTRESPONSE: return "http://hl7.org/fhir/resource-types"; 4329 case EPISODEOFCARE: return "http://hl7.org/fhir/resource-types"; 4330 case EVENTDEFINITION: return "http://hl7.org/fhir/resource-types"; 4331 case EVIDENCE: return "http://hl7.org/fhir/resource-types"; 4332 case EVIDENCEVARIABLE: return "http://hl7.org/fhir/resource-types"; 4333 case EXAMPLESCENARIO: return "http://hl7.org/fhir/resource-types"; 4334 case EXPLANATIONOFBENEFIT: return "http://hl7.org/fhir/resource-types"; 4335 case FAMILYMEMBERHISTORY: return "http://hl7.org/fhir/resource-types"; 4336 case FLAG: return "http://hl7.org/fhir/resource-types"; 4337 case GOAL: return "http://hl7.org/fhir/resource-types"; 4338 case GRAPHDEFINITION: return "http://hl7.org/fhir/resource-types"; 4339 case GROUP: return "http://hl7.org/fhir/resource-types"; 4340 case GUIDANCERESPONSE: return "http://hl7.org/fhir/resource-types"; 4341 case HEALTHCARESERVICE: return "http://hl7.org/fhir/resource-types"; 4342 case IMAGINGSTUDY: return "http://hl7.org/fhir/resource-types"; 4343 case IMMUNIZATION: return "http://hl7.org/fhir/resource-types"; 4344 case IMMUNIZATIONEVALUATION: return "http://hl7.org/fhir/resource-types"; 4345 case IMMUNIZATIONRECOMMENDATION: return "http://hl7.org/fhir/resource-types"; 4346 case IMPLEMENTATIONGUIDE: return "http://hl7.org/fhir/resource-types"; 4347 case INGREDIENT: return "http://hl7.org/fhir/resource-types"; 4348 case INSURANCEPLAN: return "http://hl7.org/fhir/resource-types"; 4349 case INVOICE: return "http://hl7.org/fhir/resource-types"; 4350 case LIBRARY: return "http://hl7.org/fhir/resource-types"; 4351 case LINKAGE: return "http://hl7.org/fhir/resource-types"; 4352 case LIST: return "http://hl7.org/fhir/resource-types"; 4353 case LOCATION: return "http://hl7.org/fhir/resource-types"; 4354 case MANUFACTUREDITEMDEFINITION: return "http://hl7.org/fhir/resource-types"; 4355 case MEASURE: return "http://hl7.org/fhir/resource-types"; 4356 case MEASUREREPORT: return "http://hl7.org/fhir/resource-types"; 4357 case MEDICATION: return "http://hl7.org/fhir/resource-types"; 4358 case MEDICATIONADMINISTRATION: return "http://hl7.org/fhir/resource-types"; 4359 case MEDICATIONDISPENSE: return "http://hl7.org/fhir/resource-types"; 4360 case MEDICATIONKNOWLEDGE: return "http://hl7.org/fhir/resource-types"; 4361 case MEDICATIONREQUEST: return "http://hl7.org/fhir/resource-types"; 4362 case MEDICATIONUSAGE: return "http://hl7.org/fhir/resource-types"; 4363 case MEDICINALPRODUCTDEFINITION: return "http://hl7.org/fhir/resource-types"; 4364 case MESSAGEDEFINITION: return "http://hl7.org/fhir/resource-types"; 4365 case MESSAGEHEADER: return "http://hl7.org/fhir/resource-types"; 4366 case MOLECULARSEQUENCE: return "http://hl7.org/fhir/resource-types"; 4367 case NAMINGSYSTEM: return "http://hl7.org/fhir/resource-types"; 4368 case NUTRITIONINTAKE: return "http://hl7.org/fhir/resource-types"; 4369 case NUTRITIONORDER: return "http://hl7.org/fhir/resource-types"; 4370 case OBSERVATION: return "http://hl7.org/fhir/resource-types"; 4371 case OBSERVATIONDEFINITION: return "http://hl7.org/fhir/resource-types"; 4372 case OPERATIONDEFINITION: return "http://hl7.org/fhir/resource-types"; 4373 case OPERATIONOUTCOME: return "http://hl7.org/fhir/resource-types"; 4374 case ORGANIZATION: return "http://hl7.org/fhir/resource-types"; 4375 case ORGANIZATIONAFFILIATION: return "http://hl7.org/fhir/resource-types"; 4376 case PACKAGEDPRODUCTDEFINITION: return "http://hl7.org/fhir/resource-types"; 4377 case PARAMETERS: return "http://hl7.org/fhir/resource-types"; 4378 case PATIENT: return "http://hl7.org/fhir/resource-types"; 4379 case PAYMENTNOTICE: return "http://hl7.org/fhir/resource-types"; 4380 case PAYMENTRECONCILIATION: return "http://hl7.org/fhir/resource-types"; 4381 case PERSON: return "http://hl7.org/fhir/resource-types"; 4382 case PLANDEFINITION: return "http://hl7.org/fhir/resource-types"; 4383 case PRACTITIONER: return "http://hl7.org/fhir/resource-types"; 4384 case PRACTITIONERROLE: return "http://hl7.org/fhir/resource-types"; 4385 case PROCEDURE: return "http://hl7.org/fhir/resource-types"; 4386 case PROVENANCE: return "http://hl7.org/fhir/resource-types"; 4387 case QUESTIONNAIRE: return "http://hl7.org/fhir/resource-types"; 4388 case QUESTIONNAIRERESPONSE: return "http://hl7.org/fhir/resource-types"; 4389 case REGULATEDAUTHORIZATION: return "http://hl7.org/fhir/resource-types"; 4390 case RELATEDPERSON: return "http://hl7.org/fhir/resource-types"; 4391 case REQUESTGROUP: return "http://hl7.org/fhir/resource-types"; 4392 case RESEARCHSTUDY: return "http://hl7.org/fhir/resource-types"; 4393 case RESEARCHSUBJECT: return "http://hl7.org/fhir/resource-types"; 4394 case RESOURCE: return "http://hl7.org/fhir/resource-types"; 4395 case RISKASSESSMENT: return "http://hl7.org/fhir/resource-types"; 4396 case SCHEDULE: return "http://hl7.org/fhir/resource-types"; 4397 case SEARCHPARAMETER: return "http://hl7.org/fhir/resource-types"; 4398 case SERVICEREQUEST: return "http://hl7.org/fhir/resource-types"; 4399 case SLOT: return "http://hl7.org/fhir/resource-types"; 4400 case SPECIMEN: return "http://hl7.org/fhir/resource-types"; 4401 case SPECIMENDEFINITION: return "http://hl7.org/fhir/resource-types"; 4402 case STRUCTUREDEFINITION: return "http://hl7.org/fhir/resource-types"; 4403 case STRUCTUREMAP: return "http://hl7.org/fhir/resource-types"; 4404 case SUBSCRIPTION: return "http://hl7.org/fhir/resource-types"; 4405 case SUBSTANCE: return "http://hl7.org/fhir/resource-types"; 4406 case SUBSTANCEDEFINITION: return "http://hl7.org/fhir/resource-types"; 4407 case SUBSTANCENUCLEICACID: return "http://hl7.org/fhir/resource-types"; 4408 case SUBSTANCEPOLYMER: return "http://hl7.org/fhir/resource-types"; 4409 case SUBSTANCEPROTEIN: return "http://hl7.org/fhir/resource-types"; 4410 case SUBSTANCEREFERENCEINFORMATION: return "http://hl7.org/fhir/resource-types"; 4411 case SUBSTANCESOURCEMATERIAL: return "http://hl7.org/fhir/resource-types"; 4412 case SUPPLYDELIVERY: return "http://hl7.org/fhir/resource-types"; 4413 case SUPPLYREQUEST: return "http://hl7.org/fhir/resource-types"; 4414 case TASK: return "http://hl7.org/fhir/resource-types"; 4415 case TERMINOLOGYCAPABILITIES: return "http://hl7.org/fhir/resource-types"; 4416 case TESTREPORT: return "http://hl7.org/fhir/resource-types"; 4417 case TESTSCRIPT: return "http://hl7.org/fhir/resource-types"; 4418 case TOPIC: return "http://hl7.org/fhir/resource-types"; 4419 case VALUESET: return "http://hl7.org/fhir/resource-types"; 4420 case VERIFICATIONRESULT: return "http://hl7.org/fhir/resource-types"; 4421 case VISIONPRESCRIPTION: return "http://hl7.org/fhir/resource-types"; 4422 case TYPE: return "http://hl7.org/fhir/abstract-types"; 4423 case ANY: return "http://hl7.org/fhir/abstract-types"; 4424 default: return "?"; 4425 } 4426 } 4427 public String getDefinition() { 4428 switch (this) { 4429 case ADDRESS: return "An address expressed using postal conventions (as opposed to GPS or other location definition formats). This data type may be used to convey addresses for use in delivering mail as well as for visiting locations which might not be valid for mail delivery. There are a variety of postal address formats defined around the world."; 4430 case AGE: return "A duration of time during which an organism (or a process) has existed."; 4431 case ANNOTATION: return "A text note which also contains information about who made the statement and when."; 4432 case ATTACHMENT: return "For referring to data content defined in other formats."; 4433 case BACKBONEELEMENT: return "Base definition for all elements that are defined inside a resource - but not those in a data type."; 4434 case BACKBONETYPE: return "Base definition for the few data types that are allowed to carry modifier extensions."; 4435 case BASE: return "Base definition for all types defined in FHIR type system."; 4436 case CODEABLECONCEPT: return "A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text."; 4437 case CODEABLEREFERENCE: return "A reference to a resource (by instance), or instead, a reference to a cencept defined in a terminology or ontology (by class)."; 4438 case CODING: return "A reference to a code defined by a terminology system."; 4439 case CONTACTDETAIL: return "Specifies contact information for a person or organization."; 4440 case CONTACTPOINT: return "Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc."; 4441 case CONTRIBUTOR: return "A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers."; 4442 case COUNT: return "A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies."; 4443 case DATAREQUIREMENT: return "Describes a required data item for evaluation in terms of the type of data, and optional code or date-based filters of the data."; 4444 case DATATYPE: return "The base class for all re-useable types defined as part of the FHIR Specification."; 4445 case DISTANCE: return "A length - a value with a unit that is a physical distance."; 4446 case DOSAGE: return "Indicates how the medication is/was taken or should be taken by the patient."; 4447 case DURATION: return "A length of time."; 4448 case ELEMENT: return "Base definition for all elements in a resource."; 4449 case ELEMENTDEFINITION: return "Captures constraints on each element within the resource, profile, or extension."; 4450 case EXPRESSION: return "A expression that is evaluated in a specified context and returns a value. The context of use of the expression must specify the context in which the expression is evaluated, and how the result of the expression is used."; 4451 case EXTENSION: return "Optional Extension Element - found in all resources."; 4452 case HUMANNAME: return "A human's name with the ability to identify parts and usage."; 4453 case IDENTIFIER: return "An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers."; 4454 case MARKETINGSTATUS: return "The marketing status describes the date when a medicinal product is actually put on the market or the date as of which it is no longer available."; 4455 case META: return "The metadata about a resource. This is content in the resource that is maintained by the infrastructure. Changes to the content might not always be associated with version changes to the resource."; 4456 case MONEY: return "An amount of economic utility in some recognized currency."; 4457 case MONEYQUANTITY: return ""; 4458 case NARRATIVE: return "A human-readable summary of the resource conveying the essential clinical and business information for the resource."; 4459 case ORDEREDDISTRIBUTION: return "An ordered list (distribution) of statistics."; 4460 case PARAMETERDEFINITION: return "The parameters to the module. This collection specifies both the input and output parameters. Input parameters are provided by the caller as part of the $evaluate operation. Output parameters are included in the GuidanceResponse."; 4461 case PERIOD: return "A time period defined by a start and end date and optionally time."; 4462 case POPULATION: return "A populatioof people with some set of grouping criteria."; 4463 case PRIMITIVETYPE: return "The base type for all re-useable types defined that have a simple property."; 4464 case PRODCHARACTERISTIC: return "The marketing status describes the date when a medicinal product is actually put on the market or the date as of which it is no longer available."; 4465 case PRODUCTSHELFLIFE: return "The shelf-life and storage information for a medicinal product item or container can be described using this class."; 4466 case QUANTITY: return "A measured amount (or an amount that can potentially be measured). Note that measured amounts include amounts that are not precisely quantified, including amounts involving arbitrary units and floating currencies."; 4467 case RANGE: return "A set of ordered Quantities defined by a low and high limit."; 4468 case RATIO: return "A relationship of two Quantity values - expressed as a numerator and a denominator."; 4469 case REFERENCE: return "A reference from one resource to another."; 4470 case RELATEDARTIFACT: return "Related artifacts such as additional documentation, justification, or bibliographic references."; 4471 case SAMPLEDDATA: return "A series of measurements taken by a device, with upper and lower limits. There may be more than one dimension in the data."; 4472 case SIGNATURE: return "A signature along with supporting context. The signature may be a digital signature that is cryptographic in nature, or some other signature acceptable to the domain. This other signature may be as simple as a graphical image representing a hand-written signature, or a signature ceremony Different signature approaches have different utilities."; 4473 case SIMPLEQUANTITY: return ""; 4474 case STATISTIC: return "A fact or piece of data from a study of a large quantity of numerical data. A mathematical or quantified characteristic of a group of observations."; 4475 case SUBSTANCEAMOUNT: return "Chemical substances are a single substance type whose primary defining element is the molecular structure. Chemical substances shall be defined on the basis of their complete covalent molecular structure; the presence of a salt (counter-ion) and/or solvates (water, alcohols) is also captured. Purity, grade, physical form or particle size are not taken into account in the definition of a chemical substance or in the assignment of a Substance ID."; 4476 case TIMING: return "Specifies an event that may occur multiple times. Timing schedules are used to record when things are planned, expected or requested to occur. The most common usage is in dosage instructions for medications. They are also used when planning care of various kinds, and may be used for reporting the schedule to which past regular activities were carried out."; 4477 case TRIGGERDEFINITION: return "A description of a triggering event. Triggering events can be named events, data events, or periodic, as determined by the type element."; 4478 case USAGECONTEXT: return "Specifies clinical/business/etc. metadata that can be used to retrieve, index and/or categorize an artifact. This metadata can either be specific to the applicable population (e.g., age category, DRG) or the specific context of care (e.g., venue, care setting, provider of care)."; 4479 case BASE64BINARY: return "A stream of bytes"; 4480 case BOOLEAN: return "Value of \"true\" or \"false\""; 4481 case CANONICAL: return "A URI that is a reference to a canonical URL on a FHIR resource"; 4482 case CODE: return "A string which has at least one character and no leading or trailing whitespace and where there is no whitespace other than single spaces in the contents"; 4483 case DATE: return "A date or partial date (e.g. just year or year + month). There is no time zone. The format is a union of the schema types gYear, gYearMonth and date. Dates SHALL be valid dates."; 4484 case DATETIME: return "A date, date-time or partial date (e.g. just year or year + month). If hours and minutes are specified, a time zone SHALL be populated. The format is a union of the schema types gYear, gYearMonth, date and dateTime. Seconds must be provided due to schema type constraints but may be zero-filled and may be ignored. Dates SHALL be valid dates."; 4485 case DECIMAL: return "A rational number with implicit precision"; 4486 case ID: return "Any combination of letters, numerals, \"-\" and \".\", with a length limit of 64 characters. (This might be an integer, an unprefixed OID, UUID or any other identifier pattern that meets these constraints.) Ids are case-insensitive."; 4487 case INSTANT: return "An instant in time - known at least to the second"; 4488 case INTEGER: return "A whole number"; 4489 case INTEGER64: return "A very large whole number"; 4490 case MARKDOWN: return "A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine"; 4491 case OID: return "An OID represented as a URI"; 4492 case POSITIVEINT: return "An integer with a value that is positive (e.g. >0)"; 4493 case STRING: return "A sequence of Unicode characters"; 4494 case TIME: return "A time during the day, with no date specified"; 4495 case UNSIGNEDINT: return "An integer with a value that is not negative (e.g. >= 0)"; 4496 case URI: return "String of characters used to identify a name or a resource"; 4497 case URL: return "A URI that is a literal reference"; 4498 case UUID: return "A UUID, represented as a URI"; 4499 case XHTML: return "XHTML format, as defined by W3C, but restricted usage (mainly, no active content)"; 4500 case ACCOUNT: return "A financial tool for tracking value accrued for a particular purpose. In the healthcare field, used to track charges for a patient, cost centers, etc."; 4501 case ACTIVITYDEFINITION: return "This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context."; 4502 case ADMINISTRABLEPRODUCTDEFINITION: return "A pharmaceutical product described in terms of its composition and dose form."; 4503 case ADVERSEEVENT: return "An event (i.e. any change to current patient status) that may be related to unintended effects on a patient or research subject. The unintended effects may require additional monitoring, treatment or hospitalization or may result in death. The AdverseEvent resource also extends to potential or avoided events that could have had such effects."; 4504 case ALLERGYINTOLERANCE: return "Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance."; 4505 case APPOINTMENT: return "A booking of a healthcare event among patient(s), practitioner(s), related person(s) and/or device(s) for a specific date/time. This may result in one or more Encounter(s)."; 4506 case APPOINTMENTRESPONSE: return "A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection."; 4507 case AUDITEVENT: return "A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis."; 4508 case BASIC: return "Basic is used for handling concepts not yet defined in FHIR, narrative-only resources that don't map to an existing resource, and custom resources not appropriate for inclusion in the FHIR specification."; 4509 case BINARY: return "A resource that represents the data of a single raw artifact as digital content accessible in its native format. A Binary resource can contain any content, whether text, image, pdf, zip archive, etc."; 4510 case BIOLOGICALLYDERIVEDPRODUCT: return "A material substance originating from a biological entity intended to be transplanted or infused\ninto another (possibly the same) biological entity."; 4511 case BODYSTRUCTURE: return "Record details about an anatomical structure. This resource may be used when a coded concept does not provide the necessary detail needed for the use case."; 4512 case BUNDLE: return "A container for a collection of resources."; 4513 case CAPABILITYSTATEMENT: return "A Capability Statement documents a set of capabilities (behaviors) of a FHIR Server for a particular version of FHIR that may be used as a statement of actual server functionality or a statement of required or desired server implementation."; 4514 case CAPABILITYSTATEMENT2: return "A Capability Statement documents a set of capabilities (behaviors) of a FHIR Server for a particular version of FHIR that may be used as a statement of actual server functionality or a statement of required or desired server implementation."; 4515 case CAREPLAN: return "Describes the intention of how one or more practitioners intend to deliver care for a particular patient, group or community for a period of time, possibly limited to care for a specific condition or set of conditions."; 4516 case CARETEAM: return "The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care."; 4517 case CATALOGENTRY: return "Catalog entries are wrappers that contextualize items included in a catalog."; 4518 case CHARGEITEM: return "The resource ChargeItem describes the provision of healthcare provider products for a certain patient, therefore referring not only to the product, but containing in addition details of the provision, like date, time, amounts and participating organizations and persons. Main Usage of the ChargeItem is to enable the billing process and internal cost allocation."; 4519 case CHARGEITEMDEFINITION: return "The ChargeItemDefinition resource provides the properties that apply to the (billing) codes necessary to calculate costs and prices. The properties may differ largely depending on type and realm, therefore this resource gives only a rough structure and requires profiling for each type of billing code system."; 4520 case CLAIM: return "A provider issued list of professional services and products which have been provided, or are to be provided, to a patient which is sent to an insurer for reimbursement."; 4521 case CLAIMRESPONSE: return "This resource provides the adjudication details from the processing of a Claim resource."; 4522 case CLINICALIMPRESSION: return "A record of a clinical assessment performed to determine what problem(s) may affect the patient and before planning the treatments or management strategies that are best to manage a patient's condition. Assessments are often 1:1 with a clinical consultation / encounter, but this varies greatly depending on the clinical workflow. This resource is called \"ClinicalImpression\" rather than \"ClinicalAssessment\" to avoid confusion with the recording of assessment tools such as Apgar score."; 4523 case CLINICALUSEISSUE: return "A single usage issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure."; 4524 case CODESYSTEM: return "The CodeSystem resource is used to declare the existence of and describe a code system or code system supplement and its key properties, and optionally define a part or all of its content."; 4525 case COMMUNICATION: return "An occurrence of information being transmitted; e.g. an alert that was sent to a responsible provider, a public health agency communication to a provider/reporter in response to a case report for a reportable condition."; 4526 case COMMUNICATIONREQUEST: return "A request to convey information; e.g. the CDS system proposes that an alert be sent to a responsible provider, the CDS system proposes that the public health agency be notified about a reportable condition."; 4527 case COMPARTMENTDEFINITION: return "A compartment definition that defines how resources are accessed on a server."; 4528 case COMPOSITION: return "A set of healthcare-related information that is assembled together into a single logical package that provides a single coherent statement of meaning, establishes its own context and that has clinical attestation with regard to who is making the statement. A Composition defines the structure and narrative content necessary for a document. However, a Composition alone does not constitute a document. Rather, the Composition must be the first entry in a Bundle where Bundle.type=document, and any other resources referenced from Composition must be included as subsequent entries in the Bundle (for example Patient, Practitioner, Encounter, etc.)."; 4529 case CONCEPTMAP: return "A statement of relationships from one set of concepts to one or more other concepts - either concepts in code systems, or data element/data element concepts, or classes in class models."; 4530 case CONDITION: return "A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern."; 4531 case CONDITIONDEFINITION: return "A definition of a condition and information relevant to managing it."; 4532 case CONSENT: return "A record of a healthcare consumer’s choices or choices made on their behalf by a third party, which permits or denies identified recipient(s) or recipient role(s) to perform one or more actions within a given policy context, for specific purposes and periods of time."; 4533 case CONTRACT: return "Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement."; 4534 case COVERAGE: return "Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment."; 4535 case COVERAGEELIGIBILITYREQUEST: return "The CoverageEligibilityRequest provides patient and insurance coverage information to an insurer for them to respond, in the form of an CoverageEligibilityResponse, with information regarding whether the stated coverage is valid and in-force and optionally to provide the insurance details of the policy."; 4536 case COVERAGEELIGIBILITYRESPONSE: return "This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource."; 4537 case DETECTEDISSUE: return "Indicates an actual or potential clinical issue with or between one or more active or proposed clinical actions for a patient; e.g. Drug-drug interaction, Ineffective treatment frequency, Procedure-condition conflict, etc."; 4538 case DEVICE: return "A type of a manufactured item that is used in the provision of healthcare without being substantially changed through that activity. The device may be a medical or non-medical device."; 4539 case DEVICEDEFINITION: return "The characteristics, operational status and capabilities of a medical-related component of a medical device."; 4540 case DEVICEMETRIC: return "Describes a measurement, calculation or setting capability of a medical device."; 4541 case DEVICEREQUEST: return "Represents a request for a patient to employ a medical device. The device may be an implantable device, or an external assistive device, such as a walker."; 4542 case DEVICEUSESTATEMENT: return "A record of a device being used by a patient where the record is the result of a report from the patient or another clinician."; 4543 case DIAGNOSTICREPORT: return "The findings and interpretation of diagnostic tests performed on patients, groups of patients, devices, and locations, and/or specimens derived from these. The report includes clinical context such as requesting and provider information, and some mix of atomic results, images, textual and coded interpretations, and formatted representation of diagnostic reports."; 4544 case DOCUMENTMANIFEST: return "A collection of documents compiled for a purpose together with metadata that applies to the collection."; 4545 case DOCUMENTREFERENCE: return "A reference to a document of any kind for any purpose. While the term “document” implies a more narrow focus, for this resource this \"document\" encompasses *any* serialized object with a mime-type, it includes formal patient-centric documents (CDA), clinical notes, scanned paper, non-patient specific documents like policy text, as well as a photo, video, or audio recording acquired or used in healthcare. The DocumentReference resource provides metadata about the document so that the document can be discovered and managed. The actual content may be inline base64 encoded data or provided by direct reference."; 4546 case DOMAINRESOURCE: return "A resource that includes narrative, extensions, and contained resources."; 4547 case ENCOUNTER: return "An interaction between a patient and healthcare provider(s) for the purpose of providing healthcare service(s) or assessing the health status of a patient."; 4548 case ENDPOINT: return "The technical details of an endpoint that can be used for electronic services, such as for web services providing XDS.b or a REST endpoint for another FHIR server. This may include any security context information."; 4549 case ENROLLMENTREQUEST: return "This resource provides the insurance enrollment details to the insurer regarding a specified coverage."; 4550 case ENROLLMENTRESPONSE: return "This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource."; 4551 case EPISODEOFCARE: return "An association between a patient and an organization / healthcare provider(s) during which time encounters may occur. The managing organization assumes a level of responsibility for the patient during this time."; 4552 case EVENTDEFINITION: return "The EventDefinition resource provides a reusable description of when a particular event can occur."; 4553 case EVIDENCE: return "This represents statistics, certainty, both the intended and actual population, and evidence variables."; 4554 case EVIDENCEVARIABLE: return "The EvidenceVariable resource describes a \"PICO\" element that knowledge (evidence, assertion, recommendation) is about."; 4555 case EXAMPLESCENARIO: return "Example of workflow instance."; 4556 case EXPLANATIONOFBENEFIT: return "This resource provides: the claim details; adjudication details from the processing of a Claim; and optionally account balance information, for informing the subscriber of the benefits provided."; 4557 case FAMILYMEMBERHISTORY: return "Significant health conditions for a person related to the patient relevant in the context of care for the patient."; 4558 case FLAG: return "Prospective warnings of potential issues when providing care to the patient."; 4559 case GOAL: return "Describes the intended objective(s) for a patient, group or organization care, for example, weight loss, restoring an activity of daily living, obtaining herd immunity via immunization, meeting a process improvement objective, etc."; 4560 case GRAPHDEFINITION: return "A formal computable definition of a graph of resources - that is, a coherent set of resources that form a graph by following references. The Graph Definition resource defines a set and makes rules about the set."; 4561 case GROUP: return "Represents a defined collection of entities that may be discussed or acted upon collectively but which are not expected to act collectively, and are not formally or legally recognized; i.e. a collection of entities that isn't an Organization."; 4562 case GUIDANCERESPONSE: return "A guidance response is the formal response to a guidance request, including any output parameters returned by the evaluation, as well as the description of any proposed actions to be taken."; 4563 case HEALTHCARESERVICE: return "The details of a healthcare service available at a location."; 4564 case IMAGINGSTUDY: return "Representation of the content produced in a DICOM imaging study. A study comprises a set of series, each of which includes a set of Service-Object Pair Instances (SOP Instances - images or other data) acquired or produced in a common context. A series is of only one modality (e.g. X-ray, CT, MR, ultrasound), but a study may have multiple series of different modalities."; 4565 case IMMUNIZATION: return "Describes the event of a patient being administered a vaccine or a record of an immunization as reported by a patient, a clinician or another party."; 4566 case IMMUNIZATIONEVALUATION: return "Describes a comparison of an immunization event against published recommendations to determine if the administration is \"valid\" in relation to those recommendations."; 4567 case IMMUNIZATIONRECOMMENDATION: return "A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification."; 4568 case IMPLEMENTATIONGUIDE: return "A set of rules of how a particular interoperability or standards problem is solved - typically through the use of FHIR resources. This resource is used to gather all the parts of an implementation guide into a logical whole and to publish a computable definition of all the parts."; 4569 case INGREDIENT: return "An ingredient of a manufactured item or pharmaceutical product."; 4570 case INSURANCEPLAN: return "Details of a Health Insurance product/plan provided by an organization."; 4571 case INVOICE: return "Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose."; 4572 case LIBRARY: return "The Library resource is a general-purpose container for knowledge asset definitions. It can be used to describe and expose existing knowledge assets such as logic libraries and information model descriptions, as well as to describe a collection of knowledge assets."; 4573 case LINKAGE: return "Identifies two or more records (resource instances) that refer to the same real-world \"occurrence\"."; 4574 case LIST: return "A list is a curated collection of resources."; 4575 case LOCATION: return "Details and position information for a physical place where services are provided and resources and participants may be stored, found, contained, or accommodated."; 4576 case MANUFACTUREDITEMDEFINITION: return "The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product."; 4577 case MEASURE: return "The Measure resource provides the definition of a quality measure."; 4578 case MEASUREREPORT: return "The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation."; 4579 case MEDICATION: return "This resource is primarily used for the identification and definition of a medication for the purposes of prescribing, dispensing, and administering a medication as well as for making statements about medication use."; 4580 case MEDICATIONADMINISTRATION: return "Describes the event of a patient consuming or otherwise being administered a medication. This may be as simple as swallowing a tablet or it may be a long running infusion. Related resources tie this event to the authorizing prescription, and the specific encounter between patient and health care practitioner."; 4581 case MEDICATIONDISPENSE: return "Indicates that a medication product is to be or has been dispensed for a named person/patient. This includes a description of the medication product (supply) provided and the instructions for administering the medication. The medication dispense is the result of a pharmacy system responding to a medication order."; 4582 case MEDICATIONKNOWLEDGE: return "Information about a medication that is used to support knowledge."; 4583 case MEDICATIONREQUEST: return "An order or request for both supply of the medication and the instructions for administration of the medication to a patient. The resource is called \"MedicationRequest\" rather than \"MedicationPrescription\" or \"MedicationOrder\" to generalize the use across inpatient and outpatient settings, including care plans, etc., and to harmonize with workflow patterns."; 4584 case MEDICATIONUSAGE: return "A record of a medication that is being consumed by a patient. A MedicationUsage may indicate that the patient may be taking the medication now or has taken the medication in the past or will be taking the medication in the future. The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician. A common scenario where this information is captured is during the history taking process during a patient visit or stay. The medication information may come from sources such as the patient's memory, from a prescription bottle, or from a list of medications the patient, clinician or other party maintains. \n\nThe primary difference between a medicationusage and a medicationadministration is that the medication administration has complete administration information and is based on actual administration information from the person who administered the medication. A medicationusage is often, if not always, less specific. There is no required date/time when the medication was administered, in fact we only know that a source has reported the patient is taking this medication, where details such as time, quantity, or rate or even medication product may be incomplete or missing or less precise. As stated earlier, the Medication Usage information may come from the patient's memory, from a prescription bottle or from a list of medications the patient, clinician or other party maintains. Medication administration is more formal and is not missing detailed information."; 4585 case MEDICINALPRODUCTDEFINITION: return "Detailed definition of a medicinal product, typically for uses other than direct patient care (e.g. regulatory use)."; 4586 case MESSAGEDEFINITION: return "Defines the characteristics of a message that can be shared between systems, including the type of event that initiates the message, the content to be transmitted and what response(s), if any, are permitted."; 4587 case MESSAGEHEADER: return "The header for a message exchange that is either requesting or responding to an action. The reference(s) that are the subject of the action as well as other information related to the action are typically transmitted in a bundle in which the MessageHeader resource instance is the first resource in the bundle."; 4588 case MOLECULARSEQUENCE: return "Raw data describing a biological sequence."; 4589 case NAMINGSYSTEM: return "A curated namespace that issues unique symbols within that namespace for the identification of concepts, people, devices, etc. Represents a \"System\" used within the Identifier and Coding data types."; 4590 case NUTRITIONINTAKE: return "A record of food or fluid that is being consumed by a patient. A NutritionIntake may indicate that the patient may be consuming the food or fluid now or has consumed the food or fluid in the past. The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician. A common scenario where this information is captured is during the history taking process during a patient visit or stay or through an app that tracks food or fluids consumed. The consumption information may come from sources such as the patient's memory, from a nutrition label, or from a clinician documenting observed intake."; 4591 case NUTRITIONORDER: return "A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident."; 4592 case OBSERVATION: return "Measurements and simple assertions made about a patient, device or other subject."; 4593 case OBSERVATIONDEFINITION: return "Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service."; 4594 case OPERATIONDEFINITION: return "A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction)."; 4595 case OPERATIONOUTCOME: return "A collection of error, warning, or information messages that result from a system action."; 4596 case ORGANIZATION: return "A formally or informally recognized grouping of people or organizations formed for the purpose of achieving some form of collective action. Includes companies, institutions, corporations, departments, community groups, healthcare practice groups, payer/insurer, etc."; 4597 case ORGANIZATIONAFFILIATION: return "Defines an affiliation/assotiation/relationship between 2 distinct oganizations, that is not a part-of relationship/sub-division relationship."; 4598 case PACKAGEDPRODUCTDEFINITION: return "A medicinal product in a container or package."; 4599 case PARAMETERS: return "This resource is a non-persisted resource used to pass information into and back from an [operation](operations.html). It has no other use, and there is no RESTful endpoint associated with it."; 4600 case PATIENT: return "Demographics and other administrative information about an individual or animal receiving care or other health-related services."; 4601 case PAYMENTNOTICE: return "This resource provides the status of the payment for goods and services rendered, and the request and response resource references."; 4602 case PAYMENTRECONCILIATION: return "This resource provides the details including amount of a payment and allocates the payment items being paid."; 4603 case PERSON: return "Demographics and administrative information about a person independent of a specific health-related context."; 4604 case PLANDEFINITION: return "This resource allows for the definition of various types of plans as a sharable, consumable, and executable artifact. The resource is general enough to support the description of a broad range of clinical artifacts such as clinical decision support rules, order sets and protocols."; 4605 case PRACTITIONER: return "A person who is directly or indirectly involved in the provisioning of healthcare."; 4606 case PRACTITIONERROLE: return "A specific set of Roles/Locations/specialties/services that a practitioner may perform at an organization for a period of time."; 4607 case PROCEDURE: return "An action that is or was performed on or for a patient. This can be a physical intervention like an operation, or less invasive like long term services, counseling, or hypnotherapy."; 4608 case PROVENANCE: return "Provenance of a resource is a record that describes entities and processes involved in producing and delivering or otherwise influencing that resource. Provenance provides a critical foundation for assessing authenticity, enabling trust, and allowing reproducibility. Provenance assertions are a form of contextual metadata and can themselves become important records with their own provenance. Provenance statement indicates clinical significance in terms of confidence in authenticity, reliability, and trustworthiness, integrity, and stage in lifecycle (e.g. Document Completion - has the artifact been legally authenticated), all of which may impact security, privacy, and trust policies."; 4609 case QUESTIONNAIRE: return "A structured set of questions intended to guide the collection of answers from end-users. Questionnaires provide detailed control over order, presentation, phraseology and grouping to allow coherent, consistent data collection."; 4610 case QUESTIONNAIRERESPONSE: return "A structured set of questions and their answers. The questions are ordered and grouped into coherent subsets, corresponding to the structure of the grouping of the questionnaire being responded to."; 4611 case REGULATEDAUTHORIZATION: return "The regulatory authorization of a medicinal product."; 4612 case RELATEDPERSON: return "Information about a person that is involved in the care for a patient, but who is not the target of healthcare, nor has a formal responsibility in the care process."; 4613 case REQUESTGROUP: return "A group of related requests that can be used to capture intended activities that have inter-dependencies such as \"give this medication after that one\"."; 4614 case RESEARCHSTUDY: return "A process where a researcher or organization plans and then executes a series of steps intended to increase the field of healthcare-related knowledge. This includes studies of safety, efficacy, comparative effectiveness and other information about medications, devices, therapies and other interventional and investigative techniques. A ResearchStudy involves the gathering of information about human or animal subjects."; 4615 case RESEARCHSUBJECT: return "A physical entity which is the primary unit of operational and/or administrative interest in a study."; 4616 case RESOURCE: return "This is the base resource type for everything."; 4617 case RISKASSESSMENT: return "An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome."; 4618 case SCHEDULE: return "A container for slots of time that may be available for booking appointments."; 4619 case SEARCHPARAMETER: return "A search parameter that defines a named search item that can be used to search/filter on a resource."; 4620 case SERVICEREQUEST: return "A record of a request for service such as diagnostic investigations, treatments, or operations to be performed."; 4621 case SLOT: return "A slot of time on a schedule that may be available for booking appointments."; 4622 case SPECIMEN: return "A sample to be used for analysis."; 4623 case SPECIMENDEFINITION: return "A kind of specimen with associated set of requirements."; 4624 case STRUCTUREDEFINITION: return "A definition of a FHIR structure. This resource is used to describe the underlying resources, data types defined in FHIR, and also for describing extensions and constraints on resources and data types."; 4625 case STRUCTUREMAP: return "A Map of relationships between 2 structures that can be used to transform data."; 4626 case SUBSCRIPTION: return "The subscription resource describes a particular client's request to be notified about a Topic."; 4627 case SUBSTANCE: return "A homogeneous material with a definite composition."; 4628 case SUBSTANCEDEFINITION: return "The detailed description of a substance, typically at a level beyond what is used for prescribing."; 4629 case SUBSTANCENUCLEICACID: return "Nucleic acids are defined by three distinct elements: the base, sugar and linkage. Individual substance/moiety IDs will be created for each of these elements. The nucleotide sequence will be always entered in the 5’-3’ direction."; 4630 case SUBSTANCEPOLYMER: return "Todo."; 4631 case SUBSTANCEPROTEIN: return "A SubstanceProtein is defined as a single unit of a linear amino acid sequence, or a combination of subunits that are either covalently linked or have a defined invariant stoichiometric relationship. This includes all synthetic, recombinant and purified SubstanceProteins of defined sequence, whether the use is therapeutic or prophylactic. This set of elements will be used to describe albumins, coagulation factors, cytokines, growth factors, peptide/SubstanceProtein hormones, enzymes, toxins, toxoids, recombinant vaccines, and immunomodulators."; 4632 case SUBSTANCEREFERENCEINFORMATION: return "Todo."; 4633 case SUBSTANCESOURCEMATERIAL: return "Source material shall capture information on the taxonomic and anatomical origins as well as the fraction of a material that can result in or can be modified to form a substance. This set of data elements shall be used to define polymer substances isolated from biological matrices. Taxonomic and anatomical origins shall be described using a controlled vocabulary as required. This information is captured for naturally derived polymers ( . starch) and structurally diverse substances. For Organisms belonging to the Kingdom Plantae the Substance level defines the fresh material of a single species or infraspecies, the Herbal Drug and the Herbal preparation. For Herbal preparations, the fraction information will be captured at the Substance information level and additional information for herbal extracts will be captured at the Specified Substance Group 1 information level. See for further explanation the Substance Class: Structurally Diverse and the herbal annex."; 4634 case SUPPLYDELIVERY: return "Record of delivery of what is supplied."; 4635 case SUPPLYREQUEST: return "A record of a request for a medication, substance or device used in the healthcare setting."; 4636 case TASK: return "A task to be performed."; 4637 case TERMINOLOGYCAPABILITIES: return "A TerminologyCapabilities resource documents a set of capabilities (behaviors) of a FHIR Terminology Server that may be used as a statement of actual server functionality or a statement of required or desired server implementation."; 4638 case TESTREPORT: return "A summary of information based on the results of executing a TestScript."; 4639 case TESTSCRIPT: return "A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification."; 4640 case TOPIC: return "Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic."; 4641 case VALUESET: return "A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html)."; 4642 case VERIFICATIONRESULT: return "Describes validation requirements, source(s), status and dates for one or more elements."; 4643 case VISIONPRESCRIPTION: return "An authorization for the provision of glasses and/or contact lenses to a patient."; 4644 case TYPE: return "A place holder that means any kind of data type"; 4645 case ANY: return "A place holder that means any kind of resource"; 4646 default: return "?"; 4647 } 4648 } 4649 public String getDisplay() { 4650 switch (this) { 4651 case ADDRESS: return "Address"; 4652 case AGE: return "Age"; 4653 case ANNOTATION: return "Annotation"; 4654 case ATTACHMENT: return "Attachment"; 4655 case BACKBONEELEMENT: return "BackboneElement"; 4656 case BACKBONETYPE: return "BackboneType"; 4657 case BASE: return "Base"; 4658 case CODEABLECONCEPT: return "CodeableConcept"; 4659 case CODEABLEREFERENCE: return "CodeableReference"; 4660 case CODING: return "Coding"; 4661 case CONTACTDETAIL: return "ContactDetail"; 4662 case CONTACTPOINT: return "ContactPoint"; 4663 case CONTRIBUTOR: return "Contributor"; 4664 case COUNT: return "Count"; 4665 case DATAREQUIREMENT: return "DataRequirement"; 4666 case DATATYPE: return "DataType"; 4667 case DISTANCE: return "Distance"; 4668 case DOSAGE: return "Dosage"; 4669 case DURATION: return "Duration"; 4670 case ELEMENT: return "Element"; 4671 case ELEMENTDEFINITION: return "ElementDefinition"; 4672 case EXPRESSION: return "Expression"; 4673 case EXTENSION: return "Extension"; 4674 case HUMANNAME: return "HumanName"; 4675 case IDENTIFIER: return "Identifier"; 4676 case MARKETINGSTATUS: return "MarketingStatus"; 4677 case META: return "Meta"; 4678 case MONEY: return "Money"; 4679 case MONEYQUANTITY: return "MoneyQuantity"; 4680 case NARRATIVE: return "Narrative"; 4681 case ORDEREDDISTRIBUTION: return "OrderedDistribution"; 4682 case PARAMETERDEFINITION: return "ParameterDefinition"; 4683 case PERIOD: return "Period"; 4684 case POPULATION: return "Population"; 4685 case PRIMITIVETYPE: return "PrimitiveType"; 4686 case PRODCHARACTERISTIC: return "ProdCharacteristic"; 4687 case PRODUCTSHELFLIFE: return "ProductShelfLife"; 4688 case QUANTITY: return "Quantity"; 4689 case RANGE: return "Range"; 4690 case RATIO: return "Ratio"; 4691 case REFERENCE: return "Reference"; 4692 case RELATEDARTIFACT: return "RelatedArtifact"; 4693 case SAMPLEDDATA: return "SampledData"; 4694 case SIGNATURE: return "Signature"; 4695 case SIMPLEQUANTITY: return "SimpleQuantity"; 4696 case STATISTIC: return "Statistic"; 4697 case SUBSTANCEAMOUNT: return "SubstanceAmount"; 4698 case TIMING: return "Timing"; 4699 case TRIGGERDEFINITION: return "TriggerDefinition"; 4700 case USAGECONTEXT: return "UsageContext"; 4701 case BASE64BINARY: return "base64Binary"; 4702 case BOOLEAN: return "boolean"; 4703 case CANONICAL: return "canonical"; 4704 case CODE: return "code"; 4705 case DATE: return "date"; 4706 case DATETIME: return "dateTime"; 4707 case DECIMAL: return "decimal"; 4708 case ID: return "id"; 4709 case INSTANT: return "instant"; 4710 case INTEGER: return "integer"; 4711 case INTEGER64: return "integer64"; 4712 case MARKDOWN: return "markdown"; 4713 case OID: return "oid"; 4714 case POSITIVEINT: return "positiveInt"; 4715 case STRING: return "string"; 4716 case TIME: return "time"; 4717 case UNSIGNEDINT: return "unsignedInt"; 4718 case URI: return "uri"; 4719 case URL: return "url"; 4720 case UUID: return "uuid"; 4721 case XHTML: return "XHTML"; 4722 case ACCOUNT: return "Account"; 4723 case ACTIVITYDEFINITION: return "ActivityDefinition"; 4724 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 4725 case ADVERSEEVENT: return "AdverseEvent"; 4726 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 4727 case APPOINTMENT: return "Appointment"; 4728 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 4729 case AUDITEVENT: return "AuditEvent"; 4730 case BASIC: return "Basic"; 4731 case BINARY: return "Binary"; 4732 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 4733 case BODYSTRUCTURE: return "BodyStructure"; 4734 case BUNDLE: return "Bundle"; 4735 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 4736 case CAPABILITYSTATEMENT2: return "CapabilityStatement2"; 4737 case CAREPLAN: return "CarePlan"; 4738 case CARETEAM: return "CareTeam"; 4739 case CATALOGENTRY: return "CatalogEntry"; 4740 case CHARGEITEM: return "ChargeItem"; 4741 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 4742 case CLAIM: return "Claim"; 4743 case CLAIMRESPONSE: return "ClaimResponse"; 4744 case CLINICALIMPRESSION: return "ClinicalImpression"; 4745 case CLINICALUSEISSUE: return "ClinicalUseIssue"; 4746 case CODESYSTEM: return "CodeSystem"; 4747 case COMMUNICATION: return "Communication"; 4748 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 4749 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 4750 case COMPOSITION: return "Composition"; 4751 case CONCEPTMAP: return "ConceptMap"; 4752 case CONDITION: return "Condition"; 4753 case CONDITIONDEFINITION: return "ConditionDefinition"; 4754 case CONSENT: return "Consent"; 4755 case CONTRACT: return "Contract"; 4756 case COVERAGE: return "Coverage"; 4757 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 4758 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 4759 case DETECTEDISSUE: return "DetectedIssue"; 4760 case DEVICE: return "Device"; 4761 case DEVICEDEFINITION: return "DeviceDefinition"; 4762 case DEVICEMETRIC: return "DeviceMetric"; 4763 case DEVICEREQUEST: return "DeviceRequest"; 4764 case DEVICEUSESTATEMENT: return "DeviceUseStatement"; 4765 case DIAGNOSTICREPORT: return "DiagnosticReport"; 4766 case DOCUMENTMANIFEST: return "DocumentManifest"; 4767 case DOCUMENTREFERENCE: return "DocumentReference"; 4768 case DOMAINRESOURCE: return "DomainResource"; 4769 case ENCOUNTER: return "Encounter"; 4770 case ENDPOINT: return "Endpoint"; 4771 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 4772 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 4773 case EPISODEOFCARE: return "EpisodeOfCare"; 4774 case EVENTDEFINITION: return "EventDefinition"; 4775 case EVIDENCE: return "Evidence"; 4776 case EVIDENCEVARIABLE: return "EvidenceVariable"; 4777 case EXAMPLESCENARIO: return "ExampleScenario"; 4778 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 4779 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 4780 case FLAG: return "Flag"; 4781 case GOAL: return "Goal"; 4782 case GRAPHDEFINITION: return "GraphDefinition"; 4783 case GROUP: return "Group"; 4784 case GUIDANCERESPONSE: return "GuidanceResponse"; 4785 case HEALTHCARESERVICE: return "HealthcareService"; 4786 case IMAGINGSTUDY: return "ImagingStudy"; 4787 case IMMUNIZATION: return "Immunization"; 4788 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 4789 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 4790 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 4791 case INGREDIENT: return "Ingredient"; 4792 case INSURANCEPLAN: return "InsurancePlan"; 4793 case INVOICE: return "Invoice"; 4794 case LIBRARY: return "Library"; 4795 case LINKAGE: return "Linkage"; 4796 case LIST: return "List"; 4797 case LOCATION: return "Location"; 4798 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 4799 case MEASURE: return "Measure"; 4800 case MEASUREREPORT: return "MeasureReport"; 4801 case MEDICATION: return "Medication"; 4802 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 4803 case MEDICATIONDISPENSE: return "MedicationDispense"; 4804 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 4805 case MEDICATIONREQUEST: return "MedicationRequest"; 4806 case MEDICATIONUSAGE: return "MedicationUsage"; 4807 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 4808 case MESSAGEDEFINITION: return "MessageDefinition"; 4809 case MESSAGEHEADER: return "MessageHeader"; 4810 case MOLECULARSEQUENCE: return "MolecularSequence"; 4811 case NAMINGSYSTEM: return "NamingSystem"; 4812 case NUTRITIONINTAKE: return "NutritionIntake"; 4813 case NUTRITIONORDER: return "NutritionOrder"; 4814 case OBSERVATION: return "Observation"; 4815 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 4816 case OPERATIONDEFINITION: return "OperationDefinition"; 4817 case OPERATIONOUTCOME: return "OperationOutcome"; 4818 case ORGANIZATION: return "Organization"; 4819 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 4820 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 4821 case PARAMETERS: return "Parameters"; 4822 case PATIENT: return "Patient"; 4823 case PAYMENTNOTICE: return "PaymentNotice"; 4824 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 4825 case PERSON: return "Person"; 4826 case PLANDEFINITION: return "PlanDefinition"; 4827 case PRACTITIONER: return "Practitioner"; 4828 case PRACTITIONERROLE: return "PractitionerRole"; 4829 case PROCEDURE: return "Procedure"; 4830 case PROVENANCE: return "Provenance"; 4831 case QUESTIONNAIRE: return "Questionnaire"; 4832 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 4833 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 4834 case RELATEDPERSON: return "RelatedPerson"; 4835 case REQUESTGROUP: return "RequestGroup"; 4836 case RESEARCHSTUDY: return "ResearchStudy"; 4837 case RESEARCHSUBJECT: return "ResearchSubject"; 4838 case RESOURCE: return "Resource"; 4839 case RISKASSESSMENT: return "RiskAssessment"; 4840 case SCHEDULE: return "Schedule"; 4841 case SEARCHPARAMETER: return "SearchParameter"; 4842 case SERVICEREQUEST: return "ServiceRequest"; 4843 case SLOT: return "Slot"; 4844 case SPECIMEN: return "Specimen"; 4845 case SPECIMENDEFINITION: return "SpecimenDefinition"; 4846 case STRUCTUREDEFINITION: return "StructureDefinition"; 4847 case STRUCTUREMAP: return "StructureMap"; 4848 case SUBSCRIPTION: return "Subscription"; 4849 case SUBSTANCE: return "Substance"; 4850 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 4851 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 4852 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 4853 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 4854 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 4855 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 4856 case SUPPLYDELIVERY: return "SupplyDelivery"; 4857 case SUPPLYREQUEST: return "SupplyRequest"; 4858 case TASK: return "Task"; 4859 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 4860 case TESTREPORT: return "TestReport"; 4861 case TESTSCRIPT: return "TestScript"; 4862 case TOPIC: return "Topic"; 4863 case VALUESET: return "ValueSet"; 4864 case VERIFICATIONRESULT: return "VerificationResult"; 4865 case VISIONPRESCRIPTION: return "VisionPrescription"; 4866 case TYPE: return "Type"; 4867 case ANY: return "Any"; 4868 default: return "?"; 4869 } 4870 } 4871 } 4872 4873 public static class FHIRAllTypesEnumFactory implements EnumFactory<FHIRAllTypes> { 4874 public FHIRAllTypes fromCode(String codeString) throws IllegalArgumentException { 4875 if (codeString == null || "".equals(codeString)) 4876 if (codeString == null || "".equals(codeString)) 4877 return null; 4878 if ("Address".equals(codeString)) 4879 return FHIRAllTypes.ADDRESS; 4880 if ("Age".equals(codeString)) 4881 return FHIRAllTypes.AGE; 4882 if ("Annotation".equals(codeString)) 4883 return FHIRAllTypes.ANNOTATION; 4884 if ("Attachment".equals(codeString)) 4885 return FHIRAllTypes.ATTACHMENT; 4886 if ("BackboneElement".equals(codeString)) 4887 return FHIRAllTypes.BACKBONEELEMENT; 4888 if ("BackboneType".equals(codeString)) 4889 return FHIRAllTypes.BACKBONETYPE; 4890 if ("Base".equals(codeString)) 4891 return FHIRAllTypes.BASE; 4892 if ("CodeableConcept".equals(codeString)) 4893 return FHIRAllTypes.CODEABLECONCEPT; 4894 if ("CodeableReference".equals(codeString)) 4895 return FHIRAllTypes.CODEABLEREFERENCE; 4896 if ("Coding".equals(codeString)) 4897 return FHIRAllTypes.CODING; 4898 if ("ContactDetail".equals(codeString)) 4899 return FHIRAllTypes.CONTACTDETAIL; 4900 if ("ContactPoint".equals(codeString)) 4901 return FHIRAllTypes.CONTACTPOINT; 4902 if ("Contributor".equals(codeString)) 4903 return FHIRAllTypes.CONTRIBUTOR; 4904 if ("Count".equals(codeString)) 4905 return FHIRAllTypes.COUNT; 4906 if ("DataRequirement".equals(codeString)) 4907 return FHIRAllTypes.DATAREQUIREMENT; 4908 if ("DataType".equals(codeString)) 4909 return FHIRAllTypes.DATATYPE; 4910 if ("Distance".equals(codeString)) 4911 return FHIRAllTypes.DISTANCE; 4912 if ("Dosage".equals(codeString)) 4913 return FHIRAllTypes.DOSAGE; 4914 if ("Duration".equals(codeString)) 4915 return FHIRAllTypes.DURATION; 4916 if ("Element".equals(codeString)) 4917 return FHIRAllTypes.ELEMENT; 4918 if ("ElementDefinition".equals(codeString)) 4919 return FHIRAllTypes.ELEMENTDEFINITION; 4920 if ("Expression".equals(codeString)) 4921 return FHIRAllTypes.EXPRESSION; 4922 if ("Extension".equals(codeString)) 4923 return FHIRAllTypes.EXTENSION; 4924 if ("HumanName".equals(codeString)) 4925 return FHIRAllTypes.HUMANNAME; 4926 if ("Identifier".equals(codeString)) 4927 return FHIRAllTypes.IDENTIFIER; 4928 if ("MarketingStatus".equals(codeString)) 4929 return FHIRAllTypes.MARKETINGSTATUS; 4930 if ("Meta".equals(codeString)) 4931 return FHIRAllTypes.META; 4932 if ("Money".equals(codeString)) 4933 return FHIRAllTypes.MONEY; 4934 if ("MoneyQuantity".equals(codeString)) 4935 return FHIRAllTypes.MONEYQUANTITY; 4936 if ("Narrative".equals(codeString)) 4937 return FHIRAllTypes.NARRATIVE; 4938 if ("OrderedDistribution".equals(codeString)) 4939 return FHIRAllTypes.ORDEREDDISTRIBUTION; 4940 if ("ParameterDefinition".equals(codeString)) 4941 return FHIRAllTypes.PARAMETERDEFINITION; 4942 if ("Period".equals(codeString)) 4943 return FHIRAllTypes.PERIOD; 4944 if ("Population".equals(codeString)) 4945 return FHIRAllTypes.POPULATION; 4946 if ("PrimitiveType".equals(codeString)) 4947 return FHIRAllTypes.PRIMITIVETYPE; 4948 if ("ProdCharacteristic".equals(codeString)) 4949 return FHIRAllTypes.PRODCHARACTERISTIC; 4950 if ("ProductShelfLife".equals(codeString)) 4951 return FHIRAllTypes.PRODUCTSHELFLIFE; 4952 if ("Quantity".equals(codeString)) 4953 return FHIRAllTypes.QUANTITY; 4954 if ("Range".equals(codeString)) 4955 return FHIRAllTypes.RANGE; 4956 if ("Ratio".equals(codeString)) 4957 return FHIRAllTypes.RATIO; 4958 if ("Reference".equals(codeString)) 4959 return FHIRAllTypes.REFERENCE; 4960 if ("RelatedArtifact".equals(codeString)) 4961 return FHIRAllTypes.RELATEDARTIFACT; 4962 if ("SampledData".equals(codeString)) 4963 return FHIRAllTypes.SAMPLEDDATA; 4964 if ("Signature".equals(codeString)) 4965 return FHIRAllTypes.SIGNATURE; 4966 if ("SimpleQuantity".equals(codeString)) 4967 return FHIRAllTypes.SIMPLEQUANTITY; 4968 if ("Statistic".equals(codeString)) 4969 return FHIRAllTypes.STATISTIC; 4970 if ("SubstanceAmount".equals(codeString)) 4971 return FHIRAllTypes.SUBSTANCEAMOUNT; 4972 if ("Timing".equals(codeString)) 4973 return FHIRAllTypes.TIMING; 4974 if ("TriggerDefinition".equals(codeString)) 4975 return FHIRAllTypes.TRIGGERDEFINITION; 4976 if ("UsageContext".equals(codeString)) 4977 return FHIRAllTypes.USAGECONTEXT; 4978 if ("base64Binary".equals(codeString)) 4979 return FHIRAllTypes.BASE64BINARY; 4980 if ("boolean".equals(codeString)) 4981 return FHIRAllTypes.BOOLEAN; 4982 if ("canonical".equals(codeString)) 4983 return FHIRAllTypes.CANONICAL; 4984 if ("code".equals(codeString)) 4985 return FHIRAllTypes.CODE; 4986 if ("date".equals(codeString)) 4987 return FHIRAllTypes.DATE; 4988 if ("dateTime".equals(codeString)) 4989 return FHIRAllTypes.DATETIME; 4990 if ("decimal".equals(codeString)) 4991 return FHIRAllTypes.DECIMAL; 4992 if ("id".equals(codeString)) 4993 return FHIRAllTypes.ID; 4994 if ("instant".equals(codeString)) 4995 return FHIRAllTypes.INSTANT; 4996 if ("integer".equals(codeString)) 4997 return FHIRAllTypes.INTEGER; 4998 if ("integer64".equals(codeString)) 4999 return FHIRAllTypes.INTEGER64; 5000 if ("markdown".equals(codeString)) 5001 return FHIRAllTypes.MARKDOWN; 5002 if ("oid".equals(codeString)) 5003 return FHIRAllTypes.OID; 5004 if ("positiveInt".equals(codeString)) 5005 return FHIRAllTypes.POSITIVEINT; 5006 if ("string".equals(codeString)) 5007 return FHIRAllTypes.STRING; 5008 if ("time".equals(codeString)) 5009 return FHIRAllTypes.TIME; 5010 if ("unsignedInt".equals(codeString)) 5011 return FHIRAllTypes.UNSIGNEDINT; 5012 if ("uri".equals(codeString)) 5013 return FHIRAllTypes.URI; 5014 if ("url".equals(codeString)) 5015 return FHIRAllTypes.URL; 5016 if ("uuid".equals(codeString)) 5017 return FHIRAllTypes.UUID; 5018 if ("xhtml".equals(codeString)) 5019 return FHIRAllTypes.XHTML; 5020 if ("Account".equals(codeString)) 5021 return FHIRAllTypes.ACCOUNT; 5022 if ("ActivityDefinition".equals(codeString)) 5023 return FHIRAllTypes.ACTIVITYDEFINITION; 5024 if ("AdministrableProductDefinition".equals(codeString)) 5025 return FHIRAllTypes.ADMINISTRABLEPRODUCTDEFINITION; 5026 if ("AdverseEvent".equals(codeString)) 5027 return FHIRAllTypes.ADVERSEEVENT; 5028 if ("AllergyIntolerance".equals(codeString)) 5029 return FHIRAllTypes.ALLERGYINTOLERANCE; 5030 if ("Appointment".equals(codeString)) 5031 return FHIRAllTypes.APPOINTMENT; 5032 if ("AppointmentResponse".equals(codeString)) 5033 return FHIRAllTypes.APPOINTMENTRESPONSE; 5034 if ("AuditEvent".equals(codeString)) 5035 return FHIRAllTypes.AUDITEVENT; 5036 if ("Basic".equals(codeString)) 5037 return FHIRAllTypes.BASIC; 5038 if ("Binary".equals(codeString)) 5039 return FHIRAllTypes.BINARY; 5040 if ("BiologicallyDerivedProduct".equals(codeString)) 5041 return FHIRAllTypes.BIOLOGICALLYDERIVEDPRODUCT; 5042 if ("BodyStructure".equals(codeString)) 5043 return FHIRAllTypes.BODYSTRUCTURE; 5044 if ("Bundle".equals(codeString)) 5045 return FHIRAllTypes.BUNDLE; 5046 if ("CapabilityStatement".equals(codeString)) 5047 return FHIRAllTypes.CAPABILITYSTATEMENT; 5048 if ("CapabilityStatement2".equals(codeString)) 5049 return FHIRAllTypes.CAPABILITYSTATEMENT2; 5050 if ("CarePlan".equals(codeString)) 5051 return FHIRAllTypes.CAREPLAN; 5052 if ("CareTeam".equals(codeString)) 5053 return FHIRAllTypes.CARETEAM; 5054 if ("CatalogEntry".equals(codeString)) 5055 return FHIRAllTypes.CATALOGENTRY; 5056 if ("ChargeItem".equals(codeString)) 5057 return FHIRAllTypes.CHARGEITEM; 5058 if ("ChargeItemDefinition".equals(codeString)) 5059 return FHIRAllTypes.CHARGEITEMDEFINITION; 5060 if ("Claim".equals(codeString)) 5061 return FHIRAllTypes.CLAIM; 5062 if ("ClaimResponse".equals(codeString)) 5063 return FHIRAllTypes.CLAIMRESPONSE; 5064 if ("ClinicalImpression".equals(codeString)) 5065 return FHIRAllTypes.CLINICALIMPRESSION; 5066 if ("ClinicalUseIssue".equals(codeString)) 5067 return FHIRAllTypes.CLINICALUSEISSUE; 5068 if ("CodeSystem".equals(codeString)) 5069 return FHIRAllTypes.CODESYSTEM; 5070 if ("Communication".equals(codeString)) 5071 return FHIRAllTypes.COMMUNICATION; 5072 if ("CommunicationRequest".equals(codeString)) 5073 return FHIRAllTypes.COMMUNICATIONREQUEST; 5074 if ("CompartmentDefinition".equals(codeString)) 5075 return FHIRAllTypes.COMPARTMENTDEFINITION; 5076 if ("Composition".equals(codeString)) 5077 return FHIRAllTypes.COMPOSITION; 5078 if ("ConceptMap".equals(codeString)) 5079 return FHIRAllTypes.CONCEPTMAP; 5080 if ("Condition".equals(codeString)) 5081 return FHIRAllTypes.CONDITION; 5082 if ("ConditionDefinition".equals(codeString)) 5083 return FHIRAllTypes.CONDITIONDEFINITION; 5084 if ("Consent".equals(codeString)) 5085 return FHIRAllTypes.CONSENT; 5086 if ("Contract".equals(codeString)) 5087 return FHIRAllTypes.CONTRACT; 5088 if ("Coverage".equals(codeString)) 5089 return FHIRAllTypes.COVERAGE; 5090 if ("CoverageEligibilityRequest".equals(codeString)) 5091 return FHIRAllTypes.COVERAGEELIGIBILITYREQUEST; 5092 if ("CoverageEligibilityResponse".equals(codeString)) 5093 return FHIRAllTypes.COVERAGEELIGIBILITYRESPONSE; 5094 if ("DetectedIssue".equals(codeString)) 5095 return FHIRAllTypes.DETECTEDISSUE; 5096 if ("Device".equals(codeString)) 5097 return FHIRAllTypes.DEVICE; 5098 if ("DeviceDefinition".equals(codeString)) 5099 return FHIRAllTypes.DEVICEDEFINITION; 5100 if ("DeviceMetric".equals(codeString)) 5101 return FHIRAllTypes.DEVICEMETRIC; 5102 if ("DeviceRequest".equals(codeString)) 5103 return FHIRAllTypes.DEVICEREQUEST; 5104 if ("DeviceUseStatement".equals(codeString)) 5105 return FHIRAllTypes.DEVICEUSESTATEMENT; 5106 if ("DiagnosticReport".equals(codeString)) 5107 return FHIRAllTypes.DIAGNOSTICREPORT; 5108 if ("DocumentManifest".equals(codeString)) 5109 return FHIRAllTypes.DOCUMENTMANIFEST; 5110 if ("DocumentReference".equals(codeString)) 5111 return FHIRAllTypes.DOCUMENTREFERENCE; 5112 if ("DomainResource".equals(codeString)) 5113 return FHIRAllTypes.DOMAINRESOURCE; 5114 if ("Encounter".equals(codeString)) 5115 return FHIRAllTypes.ENCOUNTER; 5116 if ("Endpoint".equals(codeString)) 5117 return FHIRAllTypes.ENDPOINT; 5118 if ("EnrollmentRequest".equals(codeString)) 5119 return FHIRAllTypes.ENROLLMENTREQUEST; 5120 if ("EnrollmentResponse".equals(codeString)) 5121 return FHIRAllTypes.ENROLLMENTRESPONSE; 5122 if ("EpisodeOfCare".equals(codeString)) 5123 return FHIRAllTypes.EPISODEOFCARE; 5124 if ("EventDefinition".equals(codeString)) 5125 return FHIRAllTypes.EVENTDEFINITION; 5126 if ("Evidence".equals(codeString)) 5127 return FHIRAllTypes.EVIDENCE; 5128 if ("EvidenceVariable".equals(codeString)) 5129 return FHIRAllTypes.EVIDENCEVARIABLE; 5130 if ("ExampleScenario".equals(codeString)) 5131 return FHIRAllTypes.EXAMPLESCENARIO; 5132 if ("ExplanationOfBenefit".equals(codeString)) 5133 return FHIRAllTypes.EXPLANATIONOFBENEFIT; 5134 if ("FamilyMemberHistory".equals(codeString)) 5135 return FHIRAllTypes.FAMILYMEMBERHISTORY; 5136 if ("Flag".equals(codeString)) 5137 return FHIRAllTypes.FLAG; 5138 if ("Goal".equals(codeString)) 5139 return FHIRAllTypes.GOAL; 5140 if ("GraphDefinition".equals(codeString)) 5141 return FHIRAllTypes.GRAPHDEFINITION; 5142 if ("Group".equals(codeString)) 5143 return FHIRAllTypes.GROUP; 5144 if ("GuidanceResponse".equals(codeString)) 5145 return FHIRAllTypes.GUIDANCERESPONSE; 5146 if ("HealthcareService".equals(codeString)) 5147 return FHIRAllTypes.HEALTHCARESERVICE; 5148 if ("ImagingStudy".equals(codeString)) 5149 return FHIRAllTypes.IMAGINGSTUDY; 5150 if ("Immunization".equals(codeString)) 5151 return FHIRAllTypes.IMMUNIZATION; 5152 if ("ImmunizationEvaluation".equals(codeString)) 5153 return FHIRAllTypes.IMMUNIZATIONEVALUATION; 5154 if ("ImmunizationRecommendation".equals(codeString)) 5155 return FHIRAllTypes.IMMUNIZATIONRECOMMENDATION; 5156 if ("ImplementationGuide".equals(codeString)) 5157 return FHIRAllTypes.IMPLEMENTATIONGUIDE; 5158 if ("Ingredient".equals(codeString)) 5159 return FHIRAllTypes.INGREDIENT; 5160 if ("InsurancePlan".equals(codeString)) 5161 return FHIRAllTypes.INSURANCEPLAN; 5162 if ("Invoice".equals(codeString)) 5163 return FHIRAllTypes.INVOICE; 5164 if ("Library".equals(codeString)) 5165 return FHIRAllTypes.LIBRARY; 5166 if ("Linkage".equals(codeString)) 5167 return FHIRAllTypes.LINKAGE; 5168 if ("List".equals(codeString)) 5169 return FHIRAllTypes.LIST; 5170 if ("Location".equals(codeString)) 5171 return FHIRAllTypes.LOCATION; 5172 if ("ManufacturedItemDefinition".equals(codeString)) 5173 return FHIRAllTypes.MANUFACTUREDITEMDEFINITION; 5174 if ("Measure".equals(codeString)) 5175 return FHIRAllTypes.MEASURE; 5176 if ("MeasureReport".equals(codeString)) 5177 return FHIRAllTypes.MEASUREREPORT; 5178 if ("Medication".equals(codeString)) 5179 return FHIRAllTypes.MEDICATION; 5180 if ("MedicationAdministration".equals(codeString)) 5181 return FHIRAllTypes.MEDICATIONADMINISTRATION; 5182 if ("MedicationDispense".equals(codeString)) 5183 return FHIRAllTypes.MEDICATIONDISPENSE; 5184 if ("MedicationKnowledge".equals(codeString)) 5185 return FHIRAllTypes.MEDICATIONKNOWLEDGE; 5186 if ("MedicationRequest".equals(codeString)) 5187 return FHIRAllTypes.MEDICATIONREQUEST; 5188 if ("MedicationUsage".equals(codeString)) 5189 return FHIRAllTypes.MEDICATIONUSAGE; 5190 if ("MedicinalProductDefinition".equals(codeString)) 5191 return FHIRAllTypes.MEDICINALPRODUCTDEFINITION; 5192 if ("MessageDefinition".equals(codeString)) 5193 return FHIRAllTypes.MESSAGEDEFINITION; 5194 if ("MessageHeader".equals(codeString)) 5195 return FHIRAllTypes.MESSAGEHEADER; 5196 if ("MolecularSequence".equals(codeString)) 5197 return FHIRAllTypes.MOLECULARSEQUENCE; 5198 if ("NamingSystem".equals(codeString)) 5199 return FHIRAllTypes.NAMINGSYSTEM; 5200 if ("NutritionIntake".equals(codeString)) 5201 return FHIRAllTypes.NUTRITIONINTAKE; 5202 if ("NutritionOrder".equals(codeString)) 5203 return FHIRAllTypes.NUTRITIONORDER; 5204 if ("Observation".equals(codeString)) 5205 return FHIRAllTypes.OBSERVATION; 5206 if ("ObservationDefinition".equals(codeString)) 5207 return FHIRAllTypes.OBSERVATIONDEFINITION; 5208 if ("OperationDefinition".equals(codeString)) 5209 return FHIRAllTypes.OPERATIONDEFINITION; 5210 if ("OperationOutcome".equals(codeString)) 5211 return FHIRAllTypes.OPERATIONOUTCOME; 5212 if ("Organization".equals(codeString)) 5213 return FHIRAllTypes.ORGANIZATION; 5214 if ("OrganizationAffiliation".equals(codeString)) 5215 return FHIRAllTypes.ORGANIZATIONAFFILIATION; 5216 if ("PackagedProductDefinition".equals(codeString)) 5217 return FHIRAllTypes.PACKAGEDPRODUCTDEFINITION; 5218 if ("Parameters".equals(codeString)) 5219 return FHIRAllTypes.PARAMETERS; 5220 if ("Patient".equals(codeString)) 5221 return FHIRAllTypes.PATIENT; 5222 if ("PaymentNotice".equals(codeString)) 5223 return FHIRAllTypes.PAYMENTNOTICE; 5224 if ("PaymentReconciliation".equals(codeString)) 5225 return FHIRAllTypes.PAYMENTRECONCILIATION; 5226 if ("Person".equals(codeString)) 5227 return FHIRAllTypes.PERSON; 5228 if ("PlanDefinition".equals(codeString)) 5229 return FHIRAllTypes.PLANDEFINITION; 5230 if ("Practitioner".equals(codeString)) 5231 return FHIRAllTypes.PRACTITIONER; 5232 if ("PractitionerRole".equals(codeString)) 5233 return FHIRAllTypes.PRACTITIONERROLE; 5234 if ("Procedure".equals(codeString)) 5235 return FHIRAllTypes.PROCEDURE; 5236 if ("Provenance".equals(codeString)) 5237 return FHIRAllTypes.PROVENANCE; 5238 if ("Questionnaire".equals(codeString)) 5239 return FHIRAllTypes.QUESTIONNAIRE; 5240 if ("QuestionnaireResponse".equals(codeString)) 5241 return FHIRAllTypes.QUESTIONNAIRERESPONSE; 5242 if ("RegulatedAuthorization".equals(codeString)) 5243 return FHIRAllTypes.REGULATEDAUTHORIZATION; 5244 if ("RelatedPerson".equals(codeString)) 5245 return FHIRAllTypes.RELATEDPERSON; 5246 if ("RequestGroup".equals(codeString)) 5247 return FHIRAllTypes.REQUESTGROUP; 5248 if ("ResearchStudy".equals(codeString)) 5249 return FHIRAllTypes.RESEARCHSTUDY; 5250 if ("ResearchSubject".equals(codeString)) 5251 return FHIRAllTypes.RESEARCHSUBJECT; 5252 if ("Resource".equals(codeString)) 5253 return FHIRAllTypes.RESOURCE; 5254 if ("RiskAssessment".equals(codeString)) 5255 return FHIRAllTypes.RISKASSESSMENT; 5256 if ("Schedule".equals(codeString)) 5257 return FHIRAllTypes.SCHEDULE; 5258 if ("SearchParameter".equals(codeString)) 5259 return FHIRAllTypes.SEARCHPARAMETER; 5260 if ("ServiceRequest".equals(codeString)) 5261 return FHIRAllTypes.SERVICEREQUEST; 5262 if ("Slot".equals(codeString)) 5263 return FHIRAllTypes.SLOT; 5264 if ("Specimen".equals(codeString)) 5265 return FHIRAllTypes.SPECIMEN; 5266 if ("SpecimenDefinition".equals(codeString)) 5267 return FHIRAllTypes.SPECIMENDEFINITION; 5268 if ("StructureDefinition".equals(codeString)) 5269 return FHIRAllTypes.STRUCTUREDEFINITION; 5270 if ("StructureMap".equals(codeString)) 5271 return FHIRAllTypes.STRUCTUREMAP; 5272 if ("Subscription".equals(codeString)) 5273 return FHIRAllTypes.SUBSCRIPTION; 5274 if ("Substance".equals(codeString)) 5275 return FHIRAllTypes.SUBSTANCE; 5276 if ("SubstanceDefinition".equals(codeString)) 5277 return FHIRAllTypes.SUBSTANCEDEFINITION; 5278 if ("SubstanceNucleicAcid".equals(codeString)) 5279 return FHIRAllTypes.SUBSTANCENUCLEICACID; 5280 if ("SubstancePolymer".equals(codeString)) 5281 return FHIRAllTypes.SUBSTANCEPOLYMER; 5282 if ("SubstanceProtein".equals(codeString)) 5283 return FHIRAllTypes.SUBSTANCEPROTEIN; 5284 if ("SubstanceReferenceInformation".equals(codeString)) 5285 return FHIRAllTypes.SUBSTANCEREFERENCEINFORMATION; 5286 if ("SubstanceSourceMaterial".equals(codeString)) 5287 return FHIRAllTypes.SUBSTANCESOURCEMATERIAL; 5288 if ("SupplyDelivery".equals(codeString)) 5289 return FHIRAllTypes.SUPPLYDELIVERY; 5290 if ("SupplyRequest".equals(codeString)) 5291 return FHIRAllTypes.SUPPLYREQUEST; 5292 if ("Task".equals(codeString)) 5293 return FHIRAllTypes.TASK; 5294 if ("TerminologyCapabilities".equals(codeString)) 5295 return FHIRAllTypes.TERMINOLOGYCAPABILITIES; 5296 if ("TestReport".equals(codeString)) 5297 return FHIRAllTypes.TESTREPORT; 5298 if ("TestScript".equals(codeString)) 5299 return FHIRAllTypes.TESTSCRIPT; 5300 if ("Topic".equals(codeString)) 5301 return FHIRAllTypes.TOPIC; 5302 if ("ValueSet".equals(codeString)) 5303 return FHIRAllTypes.VALUESET; 5304 if ("VerificationResult".equals(codeString)) 5305 return FHIRAllTypes.VERIFICATIONRESULT; 5306 if ("VisionPrescription".equals(codeString)) 5307 return FHIRAllTypes.VISIONPRESCRIPTION; 5308 if ("Type".equals(codeString)) 5309 return FHIRAllTypes.TYPE; 5310 if ("Any".equals(codeString)) 5311 return FHIRAllTypes.ANY; 5312 throw new IllegalArgumentException("Unknown FHIRAllTypes code '"+codeString+"'"); 5313 } 5314 public Enumeration<FHIRAllTypes> fromType(Base code) throws FHIRException { 5315 if (code == null) 5316 return null; 5317 if (code.isEmpty()) 5318 return new Enumeration<FHIRAllTypes>(this); 5319 String codeString = ((PrimitiveType) code).asStringValue(); 5320 if (codeString == null || "".equals(codeString)) 5321 return null; 5322 if ("Address".equals(codeString)) 5323 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ADDRESS); 5324 if ("Age".equals(codeString)) 5325 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.AGE); 5326 if ("Annotation".equals(codeString)) 5327 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ANNOTATION); 5328 if ("Attachment".equals(codeString)) 5329 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ATTACHMENT); 5330 if ("BackboneElement".equals(codeString)) 5331 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BACKBONEELEMENT); 5332 if ("BackboneType".equals(codeString)) 5333 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BACKBONETYPE); 5334 if ("Base".equals(codeString)) 5335 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BASE); 5336 if ("CodeableConcept".equals(codeString)) 5337 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CODEABLECONCEPT); 5338 if ("CodeableReference".equals(codeString)) 5339 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CODEABLEREFERENCE); 5340 if ("Coding".equals(codeString)) 5341 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CODING); 5342 if ("ContactDetail".equals(codeString)) 5343 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONTACTDETAIL); 5344 if ("ContactPoint".equals(codeString)) 5345 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONTACTPOINT); 5346 if ("Contributor".equals(codeString)) 5347 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONTRIBUTOR); 5348 if ("Count".equals(codeString)) 5349 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COUNT); 5350 if ("DataRequirement".equals(codeString)) 5351 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DATAREQUIREMENT); 5352 if ("DataType".equals(codeString)) 5353 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DATATYPE); 5354 if ("Distance".equals(codeString)) 5355 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DISTANCE); 5356 if ("Dosage".equals(codeString)) 5357 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DOSAGE); 5358 if ("Duration".equals(codeString)) 5359 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DURATION); 5360 if ("Element".equals(codeString)) 5361 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ELEMENT); 5362 if ("ElementDefinition".equals(codeString)) 5363 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ELEMENTDEFINITION); 5364 if ("Expression".equals(codeString)) 5365 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EXPRESSION); 5366 if ("Extension".equals(codeString)) 5367 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EXTENSION); 5368 if ("HumanName".equals(codeString)) 5369 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.HUMANNAME); 5370 if ("Identifier".equals(codeString)) 5371 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.IDENTIFIER); 5372 if ("MarketingStatus".equals(codeString)) 5373 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MARKETINGSTATUS); 5374 if ("Meta".equals(codeString)) 5375 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.META); 5376 if ("Money".equals(codeString)) 5377 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MONEY); 5378 if ("MoneyQuantity".equals(codeString)) 5379 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MONEYQUANTITY); 5380 if ("Narrative".equals(codeString)) 5381 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.NARRATIVE); 5382 if ("OrderedDistribution".equals(codeString)) 5383 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ORDEREDDISTRIBUTION); 5384 if ("ParameterDefinition".equals(codeString)) 5385 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PARAMETERDEFINITION); 5386 if ("Period".equals(codeString)) 5387 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PERIOD); 5388 if ("Population".equals(codeString)) 5389 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.POPULATION); 5390 if ("PrimitiveType".equals(codeString)) 5391 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PRIMITIVETYPE); 5392 if ("ProdCharacteristic".equals(codeString)) 5393 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PRODCHARACTERISTIC); 5394 if ("ProductShelfLife".equals(codeString)) 5395 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PRODUCTSHELFLIFE); 5396 if ("Quantity".equals(codeString)) 5397 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.QUANTITY); 5398 if ("Range".equals(codeString)) 5399 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RANGE); 5400 if ("Ratio".equals(codeString)) 5401 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RATIO); 5402 if ("Reference".equals(codeString)) 5403 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.REFERENCE); 5404 if ("RelatedArtifact".equals(codeString)) 5405 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RELATEDARTIFACT); 5406 if ("SampledData".equals(codeString)) 5407 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SAMPLEDDATA); 5408 if ("Signature".equals(codeString)) 5409 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SIGNATURE); 5410 if ("SimpleQuantity".equals(codeString)) 5411 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SIMPLEQUANTITY); 5412 if ("Statistic".equals(codeString)) 5413 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.STATISTIC); 5414 if ("SubstanceAmount".equals(codeString)) 5415 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCEAMOUNT); 5416 if ("Timing".equals(codeString)) 5417 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TIMING); 5418 if ("TriggerDefinition".equals(codeString)) 5419 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TRIGGERDEFINITION); 5420 if ("UsageContext".equals(codeString)) 5421 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.USAGECONTEXT); 5422 if ("base64Binary".equals(codeString)) 5423 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BASE64BINARY); 5424 if ("boolean".equals(codeString)) 5425 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BOOLEAN); 5426 if ("canonical".equals(codeString)) 5427 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CANONICAL); 5428 if ("code".equals(codeString)) 5429 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CODE); 5430 if ("date".equals(codeString)) 5431 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DATE); 5432 if ("dateTime".equals(codeString)) 5433 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DATETIME); 5434 if ("decimal".equals(codeString)) 5435 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DECIMAL); 5436 if ("id".equals(codeString)) 5437 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ID); 5438 if ("instant".equals(codeString)) 5439 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.INSTANT); 5440 if ("integer".equals(codeString)) 5441 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.INTEGER); 5442 if ("integer64".equals(codeString)) 5443 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.INTEGER64); 5444 if ("markdown".equals(codeString)) 5445 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MARKDOWN); 5446 if ("oid".equals(codeString)) 5447 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.OID); 5448 if ("positiveInt".equals(codeString)) 5449 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.POSITIVEINT); 5450 if ("string".equals(codeString)) 5451 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.STRING); 5452 if ("time".equals(codeString)) 5453 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TIME); 5454 if ("unsignedInt".equals(codeString)) 5455 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.UNSIGNEDINT); 5456 if ("uri".equals(codeString)) 5457 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.URI); 5458 if ("url".equals(codeString)) 5459 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.URL); 5460 if ("uuid".equals(codeString)) 5461 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.UUID); 5462 if ("xhtml".equals(codeString)) 5463 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.XHTML); 5464 if ("Account".equals(codeString)) 5465 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ACCOUNT); 5466 if ("ActivityDefinition".equals(codeString)) 5467 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ACTIVITYDEFINITION); 5468 if ("AdministrableProductDefinition".equals(codeString)) 5469 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ADMINISTRABLEPRODUCTDEFINITION); 5470 if ("AdverseEvent".equals(codeString)) 5471 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ADVERSEEVENT); 5472 if ("AllergyIntolerance".equals(codeString)) 5473 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ALLERGYINTOLERANCE); 5474 if ("Appointment".equals(codeString)) 5475 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.APPOINTMENT); 5476 if ("AppointmentResponse".equals(codeString)) 5477 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.APPOINTMENTRESPONSE); 5478 if ("AuditEvent".equals(codeString)) 5479 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.AUDITEVENT); 5480 if ("Basic".equals(codeString)) 5481 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BASIC); 5482 if ("Binary".equals(codeString)) 5483 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BINARY); 5484 if ("BiologicallyDerivedProduct".equals(codeString)) 5485 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BIOLOGICALLYDERIVEDPRODUCT); 5486 if ("BodyStructure".equals(codeString)) 5487 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BODYSTRUCTURE); 5488 if ("Bundle".equals(codeString)) 5489 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.BUNDLE); 5490 if ("CapabilityStatement".equals(codeString)) 5491 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CAPABILITYSTATEMENT); 5492 if ("CapabilityStatement2".equals(codeString)) 5493 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CAPABILITYSTATEMENT2); 5494 if ("CarePlan".equals(codeString)) 5495 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CAREPLAN); 5496 if ("CareTeam".equals(codeString)) 5497 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CARETEAM); 5498 if ("CatalogEntry".equals(codeString)) 5499 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CATALOGENTRY); 5500 if ("ChargeItem".equals(codeString)) 5501 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CHARGEITEM); 5502 if ("ChargeItemDefinition".equals(codeString)) 5503 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CHARGEITEMDEFINITION); 5504 if ("Claim".equals(codeString)) 5505 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CLAIM); 5506 if ("ClaimResponse".equals(codeString)) 5507 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CLAIMRESPONSE); 5508 if ("ClinicalImpression".equals(codeString)) 5509 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CLINICALIMPRESSION); 5510 if ("ClinicalUseIssue".equals(codeString)) 5511 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CLINICALUSEISSUE); 5512 if ("CodeSystem".equals(codeString)) 5513 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CODESYSTEM); 5514 if ("Communication".equals(codeString)) 5515 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COMMUNICATION); 5516 if ("CommunicationRequest".equals(codeString)) 5517 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COMMUNICATIONREQUEST); 5518 if ("CompartmentDefinition".equals(codeString)) 5519 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COMPARTMENTDEFINITION); 5520 if ("Composition".equals(codeString)) 5521 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COMPOSITION); 5522 if ("ConceptMap".equals(codeString)) 5523 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONCEPTMAP); 5524 if ("Condition".equals(codeString)) 5525 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONDITION); 5526 if ("ConditionDefinition".equals(codeString)) 5527 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONDITIONDEFINITION); 5528 if ("Consent".equals(codeString)) 5529 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONSENT); 5530 if ("Contract".equals(codeString)) 5531 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.CONTRACT); 5532 if ("Coverage".equals(codeString)) 5533 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COVERAGE); 5534 if ("CoverageEligibilityRequest".equals(codeString)) 5535 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COVERAGEELIGIBILITYREQUEST); 5536 if ("CoverageEligibilityResponse".equals(codeString)) 5537 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.COVERAGEELIGIBILITYRESPONSE); 5538 if ("DetectedIssue".equals(codeString)) 5539 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DETECTEDISSUE); 5540 if ("Device".equals(codeString)) 5541 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DEVICE); 5542 if ("DeviceDefinition".equals(codeString)) 5543 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DEVICEDEFINITION); 5544 if ("DeviceMetric".equals(codeString)) 5545 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DEVICEMETRIC); 5546 if ("DeviceRequest".equals(codeString)) 5547 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DEVICEREQUEST); 5548 if ("DeviceUseStatement".equals(codeString)) 5549 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DEVICEUSESTATEMENT); 5550 if ("DiagnosticReport".equals(codeString)) 5551 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DIAGNOSTICREPORT); 5552 if ("DocumentManifest".equals(codeString)) 5553 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DOCUMENTMANIFEST); 5554 if ("DocumentReference".equals(codeString)) 5555 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DOCUMENTREFERENCE); 5556 if ("DomainResource".equals(codeString)) 5557 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.DOMAINRESOURCE); 5558 if ("Encounter".equals(codeString)) 5559 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ENCOUNTER); 5560 if ("Endpoint".equals(codeString)) 5561 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ENDPOINT); 5562 if ("EnrollmentRequest".equals(codeString)) 5563 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ENROLLMENTREQUEST); 5564 if ("EnrollmentResponse".equals(codeString)) 5565 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ENROLLMENTRESPONSE); 5566 if ("EpisodeOfCare".equals(codeString)) 5567 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EPISODEOFCARE); 5568 if ("EventDefinition".equals(codeString)) 5569 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EVENTDEFINITION); 5570 if ("Evidence".equals(codeString)) 5571 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EVIDENCE); 5572 if ("EvidenceVariable".equals(codeString)) 5573 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EVIDENCEVARIABLE); 5574 if ("ExampleScenario".equals(codeString)) 5575 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EXAMPLESCENARIO); 5576 if ("ExplanationOfBenefit".equals(codeString)) 5577 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.EXPLANATIONOFBENEFIT); 5578 if ("FamilyMemberHistory".equals(codeString)) 5579 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.FAMILYMEMBERHISTORY); 5580 if ("Flag".equals(codeString)) 5581 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.FLAG); 5582 if ("Goal".equals(codeString)) 5583 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.GOAL); 5584 if ("GraphDefinition".equals(codeString)) 5585 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.GRAPHDEFINITION); 5586 if ("Group".equals(codeString)) 5587 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.GROUP); 5588 if ("GuidanceResponse".equals(codeString)) 5589 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.GUIDANCERESPONSE); 5590 if ("HealthcareService".equals(codeString)) 5591 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.HEALTHCARESERVICE); 5592 if ("ImagingStudy".equals(codeString)) 5593 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.IMAGINGSTUDY); 5594 if ("Immunization".equals(codeString)) 5595 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.IMMUNIZATION); 5596 if ("ImmunizationEvaluation".equals(codeString)) 5597 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.IMMUNIZATIONEVALUATION); 5598 if ("ImmunizationRecommendation".equals(codeString)) 5599 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.IMMUNIZATIONRECOMMENDATION); 5600 if ("ImplementationGuide".equals(codeString)) 5601 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.IMPLEMENTATIONGUIDE); 5602 if ("Ingredient".equals(codeString)) 5603 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.INGREDIENT); 5604 if ("InsurancePlan".equals(codeString)) 5605 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.INSURANCEPLAN); 5606 if ("Invoice".equals(codeString)) 5607 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.INVOICE); 5608 if ("Library".equals(codeString)) 5609 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.LIBRARY); 5610 if ("Linkage".equals(codeString)) 5611 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.LINKAGE); 5612 if ("List".equals(codeString)) 5613 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.LIST); 5614 if ("Location".equals(codeString)) 5615 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.LOCATION); 5616 if ("ManufacturedItemDefinition".equals(codeString)) 5617 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MANUFACTUREDITEMDEFINITION); 5618 if ("Measure".equals(codeString)) 5619 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEASURE); 5620 if ("MeasureReport".equals(codeString)) 5621 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEASUREREPORT); 5622 if ("Medication".equals(codeString)) 5623 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICATION); 5624 if ("MedicationAdministration".equals(codeString)) 5625 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICATIONADMINISTRATION); 5626 if ("MedicationDispense".equals(codeString)) 5627 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICATIONDISPENSE); 5628 if ("MedicationKnowledge".equals(codeString)) 5629 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICATIONKNOWLEDGE); 5630 if ("MedicationRequest".equals(codeString)) 5631 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICATIONREQUEST); 5632 if ("MedicationUsage".equals(codeString)) 5633 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICATIONUSAGE); 5634 if ("MedicinalProductDefinition".equals(codeString)) 5635 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MEDICINALPRODUCTDEFINITION); 5636 if ("MessageDefinition".equals(codeString)) 5637 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MESSAGEDEFINITION); 5638 if ("MessageHeader".equals(codeString)) 5639 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MESSAGEHEADER); 5640 if ("MolecularSequence".equals(codeString)) 5641 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.MOLECULARSEQUENCE); 5642 if ("NamingSystem".equals(codeString)) 5643 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.NAMINGSYSTEM); 5644 if ("NutritionIntake".equals(codeString)) 5645 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.NUTRITIONINTAKE); 5646 if ("NutritionOrder".equals(codeString)) 5647 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.NUTRITIONORDER); 5648 if ("Observation".equals(codeString)) 5649 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.OBSERVATION); 5650 if ("ObservationDefinition".equals(codeString)) 5651 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.OBSERVATIONDEFINITION); 5652 if ("OperationDefinition".equals(codeString)) 5653 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.OPERATIONDEFINITION); 5654 if ("OperationOutcome".equals(codeString)) 5655 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.OPERATIONOUTCOME); 5656 if ("Organization".equals(codeString)) 5657 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ORGANIZATION); 5658 if ("OrganizationAffiliation".equals(codeString)) 5659 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ORGANIZATIONAFFILIATION); 5660 if ("PackagedProductDefinition".equals(codeString)) 5661 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PACKAGEDPRODUCTDEFINITION); 5662 if ("Parameters".equals(codeString)) 5663 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PARAMETERS); 5664 if ("Patient".equals(codeString)) 5665 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PATIENT); 5666 if ("PaymentNotice".equals(codeString)) 5667 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PAYMENTNOTICE); 5668 if ("PaymentReconciliation".equals(codeString)) 5669 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PAYMENTRECONCILIATION); 5670 if ("Person".equals(codeString)) 5671 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PERSON); 5672 if ("PlanDefinition".equals(codeString)) 5673 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PLANDEFINITION); 5674 if ("Practitioner".equals(codeString)) 5675 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PRACTITIONER); 5676 if ("PractitionerRole".equals(codeString)) 5677 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PRACTITIONERROLE); 5678 if ("Procedure".equals(codeString)) 5679 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PROCEDURE); 5680 if ("Provenance".equals(codeString)) 5681 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.PROVENANCE); 5682 if ("Questionnaire".equals(codeString)) 5683 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.QUESTIONNAIRE); 5684 if ("QuestionnaireResponse".equals(codeString)) 5685 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.QUESTIONNAIRERESPONSE); 5686 if ("RegulatedAuthorization".equals(codeString)) 5687 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.REGULATEDAUTHORIZATION); 5688 if ("RelatedPerson".equals(codeString)) 5689 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RELATEDPERSON); 5690 if ("RequestGroup".equals(codeString)) 5691 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.REQUESTGROUP); 5692 if ("ResearchStudy".equals(codeString)) 5693 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RESEARCHSTUDY); 5694 if ("ResearchSubject".equals(codeString)) 5695 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RESEARCHSUBJECT); 5696 if ("Resource".equals(codeString)) 5697 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RESOURCE); 5698 if ("RiskAssessment".equals(codeString)) 5699 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.RISKASSESSMENT); 5700 if ("Schedule".equals(codeString)) 5701 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SCHEDULE); 5702 if ("SearchParameter".equals(codeString)) 5703 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SEARCHPARAMETER); 5704 if ("ServiceRequest".equals(codeString)) 5705 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SERVICEREQUEST); 5706 if ("Slot".equals(codeString)) 5707 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SLOT); 5708 if ("Specimen".equals(codeString)) 5709 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SPECIMEN); 5710 if ("SpecimenDefinition".equals(codeString)) 5711 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SPECIMENDEFINITION); 5712 if ("StructureDefinition".equals(codeString)) 5713 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.STRUCTUREDEFINITION); 5714 if ("StructureMap".equals(codeString)) 5715 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.STRUCTUREMAP); 5716 if ("Subscription".equals(codeString)) 5717 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSCRIPTION); 5718 if ("Substance".equals(codeString)) 5719 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCE); 5720 if ("SubstanceDefinition".equals(codeString)) 5721 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCEDEFINITION); 5722 if ("SubstanceNucleicAcid".equals(codeString)) 5723 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCENUCLEICACID); 5724 if ("SubstancePolymer".equals(codeString)) 5725 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCEPOLYMER); 5726 if ("SubstanceProtein".equals(codeString)) 5727 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCEPROTEIN); 5728 if ("SubstanceReferenceInformation".equals(codeString)) 5729 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCEREFERENCEINFORMATION); 5730 if ("SubstanceSourceMaterial".equals(codeString)) 5731 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUBSTANCESOURCEMATERIAL); 5732 if ("SupplyDelivery".equals(codeString)) 5733 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUPPLYDELIVERY); 5734 if ("SupplyRequest".equals(codeString)) 5735 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.SUPPLYREQUEST); 5736 if ("Task".equals(codeString)) 5737 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TASK); 5738 if ("TerminologyCapabilities".equals(codeString)) 5739 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TERMINOLOGYCAPABILITIES); 5740 if ("TestReport".equals(codeString)) 5741 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TESTREPORT); 5742 if ("TestScript".equals(codeString)) 5743 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TESTSCRIPT); 5744 if ("Topic".equals(codeString)) 5745 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TOPIC); 5746 if ("ValueSet".equals(codeString)) 5747 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.VALUESET); 5748 if ("VerificationResult".equals(codeString)) 5749 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.VERIFICATIONRESULT); 5750 if ("VisionPrescription".equals(codeString)) 5751 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.VISIONPRESCRIPTION); 5752 if ("Type".equals(codeString)) 5753 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.TYPE); 5754 if ("Any".equals(codeString)) 5755 return new Enumeration<FHIRAllTypes>(this, FHIRAllTypes.ANY); 5756 throw new FHIRException("Unknown FHIRAllTypes code '"+codeString+"'"); 5757 } 5758 public String toCode(FHIRAllTypes code) { 5759 if (code == FHIRAllTypes.ADDRESS) 5760 return "Address"; 5761 if (code == FHIRAllTypes.AGE) 5762 return "Age"; 5763 if (code == FHIRAllTypes.ANNOTATION) 5764 return "Annotation"; 5765 if (code == FHIRAllTypes.ATTACHMENT) 5766 return "Attachment"; 5767 if (code == FHIRAllTypes.BACKBONEELEMENT) 5768 return "BackboneElement"; 5769 if (code == FHIRAllTypes.BACKBONETYPE) 5770 return "BackboneType"; 5771 if (code == FHIRAllTypes.BASE) 5772 return "Base"; 5773 if (code == FHIRAllTypes.CODEABLECONCEPT) 5774 return "CodeableConcept"; 5775 if (code == FHIRAllTypes.CODEABLEREFERENCE) 5776 return "CodeableReference"; 5777 if (code == FHIRAllTypes.CODING) 5778 return "Coding"; 5779 if (code == FHIRAllTypes.CONTACTDETAIL) 5780 return "ContactDetail"; 5781 if (code == FHIRAllTypes.CONTACTPOINT) 5782 return "ContactPoint"; 5783 if (code == FHIRAllTypes.CONTRIBUTOR) 5784 return "Contributor"; 5785 if (code == FHIRAllTypes.COUNT) 5786 return "Count"; 5787 if (code == FHIRAllTypes.DATAREQUIREMENT) 5788 return "DataRequirement"; 5789 if (code == FHIRAllTypes.DATATYPE) 5790 return "DataType"; 5791 if (code == FHIRAllTypes.DISTANCE) 5792 return "Distance"; 5793 if (code == FHIRAllTypes.DOSAGE) 5794 return "Dosage"; 5795 if (code == FHIRAllTypes.DURATION) 5796 return "Duration"; 5797 if (code == FHIRAllTypes.ELEMENT) 5798 return "Element"; 5799 if (code == FHIRAllTypes.ELEMENTDEFINITION) 5800 return "ElementDefinition"; 5801 if (code == FHIRAllTypes.EXPRESSION) 5802 return "Expression"; 5803 if (code == FHIRAllTypes.EXTENSION) 5804 return "Extension"; 5805 if (code == FHIRAllTypes.HUMANNAME) 5806 return "HumanName"; 5807 if (code == FHIRAllTypes.IDENTIFIER) 5808 return "Identifier"; 5809 if (code == FHIRAllTypes.MARKETINGSTATUS) 5810 return "MarketingStatus"; 5811 if (code == FHIRAllTypes.META) 5812 return "Meta"; 5813 if (code == FHIRAllTypes.MONEY) 5814 return "Money"; 5815 if (code == FHIRAllTypes.MONEYQUANTITY) 5816 return "MoneyQuantity"; 5817 if (code == FHIRAllTypes.NARRATIVE) 5818 return "Narrative"; 5819 if (code == FHIRAllTypes.ORDEREDDISTRIBUTION) 5820 return "OrderedDistribution"; 5821 if (code == FHIRAllTypes.PARAMETERDEFINITION) 5822 return "ParameterDefinition"; 5823 if (code == FHIRAllTypes.PERIOD) 5824 return "Period"; 5825 if (code == FHIRAllTypes.POPULATION) 5826 return "Population"; 5827 if (code == FHIRAllTypes.PRIMITIVETYPE) 5828 return "PrimitiveType"; 5829 if (code == FHIRAllTypes.PRODCHARACTERISTIC) 5830 return "ProdCharacteristic"; 5831 if (code == FHIRAllTypes.PRODUCTSHELFLIFE) 5832 return "ProductShelfLife"; 5833 if (code == FHIRAllTypes.QUANTITY) 5834 return "Quantity"; 5835 if (code == FHIRAllTypes.RANGE) 5836 return "Range"; 5837 if (code == FHIRAllTypes.RATIO) 5838 return "Ratio"; 5839 if (code == FHIRAllTypes.REFERENCE) 5840 return "Reference"; 5841 if (code == FHIRAllTypes.RELATEDARTIFACT) 5842 return "RelatedArtifact"; 5843 if (code == FHIRAllTypes.SAMPLEDDATA) 5844 return "SampledData"; 5845 if (code == FHIRAllTypes.SIGNATURE) 5846 return "Signature"; 5847 if (code == FHIRAllTypes.SIMPLEQUANTITY) 5848 return "SimpleQuantity"; 5849 if (code == FHIRAllTypes.STATISTIC) 5850 return "Statistic"; 5851 if (code == FHIRAllTypes.SUBSTANCEAMOUNT) 5852 return "SubstanceAmount"; 5853 if (code == FHIRAllTypes.TIMING) 5854 return "Timing"; 5855 if (code == FHIRAllTypes.TRIGGERDEFINITION) 5856 return "TriggerDefinition"; 5857 if (code == FHIRAllTypes.USAGECONTEXT) 5858 return "UsageContext"; 5859 if (code == FHIRAllTypes.BASE64BINARY) 5860 return "base64Binary"; 5861 if (code == FHIRAllTypes.BOOLEAN) 5862 return "boolean"; 5863 if (code == FHIRAllTypes.CANONICAL) 5864 return "canonical"; 5865 if (code == FHIRAllTypes.CODE) 5866 return "code"; 5867 if (code == FHIRAllTypes.DATE) 5868 return "date"; 5869 if (code == FHIRAllTypes.DATETIME) 5870 return "dateTime"; 5871 if (code == FHIRAllTypes.DECIMAL) 5872 return "decimal"; 5873 if (code == FHIRAllTypes.ID) 5874 return "id"; 5875 if (code == FHIRAllTypes.INSTANT) 5876 return "instant"; 5877 if (code == FHIRAllTypes.INTEGER) 5878 return "integer"; 5879 if (code == FHIRAllTypes.INTEGER64) 5880 return "integer64"; 5881 if (code == FHIRAllTypes.MARKDOWN) 5882 return "markdown"; 5883 if (code == FHIRAllTypes.OID) 5884 return "oid"; 5885 if (code == FHIRAllTypes.POSITIVEINT) 5886 return "positiveInt"; 5887 if (code == FHIRAllTypes.STRING) 5888 return "string"; 5889 if (code == FHIRAllTypes.TIME) 5890 return "time"; 5891 if (code == FHIRAllTypes.UNSIGNEDINT) 5892 return "unsignedInt"; 5893 if (code == FHIRAllTypes.URI) 5894 return "uri"; 5895 if (code == FHIRAllTypes.URL) 5896 return "url"; 5897 if (code == FHIRAllTypes.UUID) 5898 return "uuid"; 5899 if (code == FHIRAllTypes.XHTML) 5900 return "xhtml"; 5901 if (code == FHIRAllTypes.ACCOUNT) 5902 return "Account"; 5903 if (code == FHIRAllTypes.ACTIVITYDEFINITION) 5904 return "ActivityDefinition"; 5905 if (code == FHIRAllTypes.ADMINISTRABLEPRODUCTDEFINITION) 5906 return "AdministrableProductDefinition"; 5907 if (code == FHIRAllTypes.ADVERSEEVENT) 5908 return "AdverseEvent"; 5909 if (code == FHIRAllTypes.ALLERGYINTOLERANCE) 5910 return "AllergyIntolerance"; 5911 if (code == FHIRAllTypes.APPOINTMENT) 5912 return "Appointment"; 5913 if (code == FHIRAllTypes.APPOINTMENTRESPONSE) 5914 return "AppointmentResponse"; 5915 if (code == FHIRAllTypes.AUDITEVENT) 5916 return "AuditEvent"; 5917 if (code == FHIRAllTypes.BASIC) 5918 return "Basic"; 5919 if (code == FHIRAllTypes.BINARY) 5920 return "Binary"; 5921 if (code == FHIRAllTypes.BIOLOGICALLYDERIVEDPRODUCT) 5922 return "BiologicallyDerivedProduct"; 5923 if (code == FHIRAllTypes.BODYSTRUCTURE) 5924 return "BodyStructure"; 5925 if (code == FHIRAllTypes.BUNDLE) 5926 return "Bundle"; 5927 if (code == FHIRAllTypes.CAPABILITYSTATEMENT) 5928 return "CapabilityStatement"; 5929 if (code == FHIRAllTypes.CAPABILITYSTATEMENT2) 5930 return "CapabilityStatement2"; 5931 if (code == FHIRAllTypes.CAREPLAN) 5932 return "CarePlan"; 5933 if (code == FHIRAllTypes.CARETEAM) 5934 return "CareTeam"; 5935 if (code == FHIRAllTypes.CATALOGENTRY) 5936 return "CatalogEntry"; 5937 if (code == FHIRAllTypes.CHARGEITEM) 5938 return "ChargeItem"; 5939 if (code == FHIRAllTypes.CHARGEITEMDEFINITION) 5940 return "ChargeItemDefinition"; 5941 if (code == FHIRAllTypes.CLAIM) 5942 return "Claim"; 5943 if (code == FHIRAllTypes.CLAIMRESPONSE) 5944 return "ClaimResponse"; 5945 if (code == FHIRAllTypes.CLINICALIMPRESSION) 5946 return "ClinicalImpression"; 5947 if (code == FHIRAllTypes.CLINICALUSEISSUE) 5948 return "ClinicalUseIssue"; 5949 if (code == FHIRAllTypes.CODESYSTEM) 5950 return "CodeSystem"; 5951 if (code == FHIRAllTypes.COMMUNICATION) 5952 return "Communication"; 5953 if (code == FHIRAllTypes.COMMUNICATIONREQUEST) 5954 return "CommunicationRequest"; 5955 if (code == FHIRAllTypes.COMPARTMENTDEFINITION) 5956 return "CompartmentDefinition"; 5957 if (code == FHIRAllTypes.COMPOSITION) 5958 return "Composition"; 5959 if (code == FHIRAllTypes.CONCEPTMAP) 5960 return "ConceptMap"; 5961 if (code == FHIRAllTypes.CONDITION) 5962 return "Condition"; 5963 if (code == FHIRAllTypes.CONDITIONDEFINITION) 5964 return "ConditionDefinition"; 5965 if (code == FHIRAllTypes.CONSENT) 5966 return "Consent"; 5967 if (code == FHIRAllTypes.CONTRACT) 5968 return "Contract"; 5969 if (code == FHIRAllTypes.COVERAGE) 5970 return "Coverage"; 5971 if (code == FHIRAllTypes.COVERAGEELIGIBILITYREQUEST) 5972 return "CoverageEligibilityRequest"; 5973 if (code == FHIRAllTypes.COVERAGEELIGIBILITYRESPONSE) 5974 return "CoverageEligibilityResponse"; 5975 if (code == FHIRAllTypes.DETECTEDISSUE) 5976 return "DetectedIssue"; 5977 if (code == FHIRAllTypes.DEVICE) 5978 return "Device"; 5979 if (code == FHIRAllTypes.DEVICEDEFINITION) 5980 return "DeviceDefinition"; 5981 if (code == FHIRAllTypes.DEVICEMETRIC) 5982 return "DeviceMetric"; 5983 if (code == FHIRAllTypes.DEVICEREQUEST) 5984 return "DeviceRequest"; 5985 if (code == FHIRAllTypes.DEVICEUSESTATEMENT) 5986 return "DeviceUseStatement"; 5987 if (code == FHIRAllTypes.DIAGNOSTICREPORT) 5988 return "DiagnosticReport"; 5989 if (code == FHIRAllTypes.DOCUMENTMANIFEST) 5990 return "DocumentManifest"; 5991 if (code == FHIRAllTypes.DOCUMENTREFERENCE) 5992 return "DocumentReference"; 5993 if (code == FHIRAllTypes.DOMAINRESOURCE) 5994 return "DomainResource"; 5995 if (code == FHIRAllTypes.ENCOUNTER) 5996 return "Encounter"; 5997 if (code == FHIRAllTypes.ENDPOINT) 5998 return "Endpoint"; 5999 if (code == FHIRAllTypes.ENROLLMENTREQUEST) 6000 return "EnrollmentRequest"; 6001 if (code == FHIRAllTypes.ENROLLMENTRESPONSE) 6002 return "EnrollmentResponse"; 6003 if (code == FHIRAllTypes.EPISODEOFCARE) 6004 return "EpisodeOfCare"; 6005 if (code == FHIRAllTypes.EVENTDEFINITION) 6006 return "EventDefinition"; 6007 if (code == FHIRAllTypes.EVIDENCE) 6008 return "Evidence"; 6009 if (code == FHIRAllTypes.EVIDENCEVARIABLE) 6010 return "EvidenceVariable"; 6011 if (code == FHIRAllTypes.EXAMPLESCENARIO) 6012 return "ExampleScenario"; 6013 if (code == FHIRAllTypes.EXPLANATIONOFBENEFIT) 6014 return "ExplanationOfBenefit"; 6015 if (code == FHIRAllTypes.FAMILYMEMBERHISTORY) 6016 return "FamilyMemberHistory"; 6017 if (code == FHIRAllTypes.FLAG) 6018 return "Flag"; 6019 if (code == FHIRAllTypes.GOAL) 6020 return "Goal"; 6021 if (code == FHIRAllTypes.GRAPHDEFINITION) 6022 return "GraphDefinition"; 6023 if (code == FHIRAllTypes.GROUP) 6024 return "Group"; 6025 if (code == FHIRAllTypes.GUIDANCERESPONSE) 6026 return "GuidanceResponse"; 6027 if (code == FHIRAllTypes.HEALTHCARESERVICE) 6028 return "HealthcareService"; 6029 if (code == FHIRAllTypes.IMAGINGSTUDY) 6030 return "ImagingStudy"; 6031 if (code == FHIRAllTypes.IMMUNIZATION) 6032 return "Immunization"; 6033 if (code == FHIRAllTypes.IMMUNIZATIONEVALUATION) 6034 return "ImmunizationEvaluation"; 6035 if (code == FHIRAllTypes.IMMUNIZATIONRECOMMENDATION) 6036 return "ImmunizationRecommendation"; 6037 if (code == FHIRAllTypes.IMPLEMENTATIONGUIDE) 6038 return "ImplementationGuide"; 6039 if (code == FHIRAllTypes.INGREDIENT) 6040 return "Ingredient"; 6041 if (code == FHIRAllTypes.INSURANCEPLAN) 6042 return "InsurancePlan"; 6043 if (code == FHIRAllTypes.INVOICE) 6044 return "Invoice"; 6045 if (code == FHIRAllTypes.LIBRARY) 6046 return "Library"; 6047 if (code == FHIRAllTypes.LINKAGE) 6048 return "Linkage"; 6049 if (code == FHIRAllTypes.LIST) 6050 return "List"; 6051 if (code == FHIRAllTypes.LOCATION) 6052 return "Location"; 6053 if (code == FHIRAllTypes.MANUFACTUREDITEMDEFINITION) 6054 return "ManufacturedItemDefinition"; 6055 if (code == FHIRAllTypes.MEASURE) 6056 return "Measure"; 6057 if (code == FHIRAllTypes.MEASUREREPORT) 6058 return "MeasureReport"; 6059 if (code == FHIRAllTypes.MEDICATION) 6060 return "Medication"; 6061 if (code == FHIRAllTypes.MEDICATIONADMINISTRATION) 6062 return "MedicationAdministration"; 6063 if (code == FHIRAllTypes.MEDICATIONDISPENSE) 6064 return "MedicationDispense"; 6065 if (code == FHIRAllTypes.MEDICATIONKNOWLEDGE) 6066 return "MedicationKnowledge"; 6067 if (code == FHIRAllTypes.MEDICATIONREQUEST) 6068 return "MedicationRequest"; 6069 if (code == FHIRAllTypes.MEDICATIONUSAGE) 6070 return "MedicationUsage"; 6071 if (code == FHIRAllTypes.MEDICINALPRODUCTDEFINITION) 6072 return "MedicinalProductDefinition"; 6073 if (code == FHIRAllTypes.MESSAGEDEFINITION) 6074 return "MessageDefinition"; 6075 if (code == FHIRAllTypes.MESSAGEHEADER) 6076 return "MessageHeader"; 6077 if (code == FHIRAllTypes.MOLECULARSEQUENCE) 6078 return "MolecularSequence"; 6079 if (code == FHIRAllTypes.NAMINGSYSTEM) 6080 return "NamingSystem"; 6081 if (code == FHIRAllTypes.NUTRITIONINTAKE) 6082 return "NutritionIntake"; 6083 if (code == FHIRAllTypes.NUTRITIONORDER) 6084 return "NutritionOrder"; 6085 if (code == FHIRAllTypes.OBSERVATION) 6086 return "Observation"; 6087 if (code == FHIRAllTypes.OBSERVATIONDEFINITION) 6088 return "ObservationDefinition"; 6089 if (code == FHIRAllTypes.OPERATIONDEFINITION) 6090 return "OperationDefinition"; 6091 if (code == FHIRAllTypes.OPERATIONOUTCOME) 6092 return "OperationOutcome"; 6093 if (code == FHIRAllTypes.ORGANIZATION) 6094 return "Organization"; 6095 if (code == FHIRAllTypes.ORGANIZATIONAFFILIATION) 6096 return "OrganizationAffiliation"; 6097 if (code == FHIRAllTypes.PACKAGEDPRODUCTDEFINITION) 6098 return "PackagedProductDefinition"; 6099 if (code == FHIRAllTypes.PARAMETERS) 6100 return "Parameters"; 6101 if (code == FHIRAllTypes.PATIENT) 6102 return "Patient"; 6103 if (code == FHIRAllTypes.PAYMENTNOTICE) 6104 return "PaymentNotice"; 6105 if (code == FHIRAllTypes.PAYMENTRECONCILIATION) 6106 return "PaymentReconciliation"; 6107 if (code == FHIRAllTypes.PERSON) 6108 return "Person"; 6109 if (code == FHIRAllTypes.PLANDEFINITION) 6110 return "PlanDefinition"; 6111 if (code == FHIRAllTypes.PRACTITIONER) 6112 return "Practitioner"; 6113 if (code == FHIRAllTypes.PRACTITIONERROLE) 6114 return "PractitionerRole"; 6115 if (code == FHIRAllTypes.PROCEDURE) 6116 return "Procedure"; 6117 if (code == FHIRAllTypes.PROVENANCE) 6118 return "Provenance"; 6119 if (code == FHIRAllTypes.QUESTIONNAIRE) 6120 return "Questionnaire"; 6121 if (code == FHIRAllTypes.QUESTIONNAIRERESPONSE) 6122 return "QuestionnaireResponse"; 6123 if (code == FHIRAllTypes.REGULATEDAUTHORIZATION) 6124 return "RegulatedAuthorization"; 6125 if (code == FHIRAllTypes.RELATEDPERSON) 6126 return "RelatedPerson"; 6127 if (code == FHIRAllTypes.REQUESTGROUP) 6128 return "RequestGroup"; 6129 if (code == FHIRAllTypes.RESEARCHSTUDY) 6130 return "ResearchStudy"; 6131 if (code == FHIRAllTypes.RESEARCHSUBJECT) 6132 return "ResearchSubject"; 6133 if (code == FHIRAllTypes.RESOURCE) 6134 return "Resource"; 6135 if (code == FHIRAllTypes.RISKASSESSMENT) 6136 return "RiskAssessment"; 6137 if (code == FHIRAllTypes.SCHEDULE) 6138 return "Schedule"; 6139 if (code == FHIRAllTypes.SEARCHPARAMETER) 6140 return "SearchParameter"; 6141 if (code == FHIRAllTypes.SERVICEREQUEST) 6142 return "ServiceRequest"; 6143 if (code == FHIRAllTypes.SLOT) 6144 return "Slot"; 6145 if (code == FHIRAllTypes.SPECIMEN) 6146 return "Specimen"; 6147 if (code == FHIRAllTypes.SPECIMENDEFINITION) 6148 return "SpecimenDefinition"; 6149 if (code == FHIRAllTypes.STRUCTUREDEFINITION) 6150 return "StructureDefinition"; 6151 if (code == FHIRAllTypes.STRUCTUREMAP) 6152 return "StructureMap"; 6153 if (code == FHIRAllTypes.SUBSCRIPTION) 6154 return "Subscription"; 6155 if (code == FHIRAllTypes.SUBSTANCE) 6156 return "Substance"; 6157 if (code == FHIRAllTypes.SUBSTANCEDEFINITION) 6158 return "SubstanceDefinition"; 6159 if (code == FHIRAllTypes.SUBSTANCENUCLEICACID) 6160 return "SubstanceNucleicAcid"; 6161 if (code == FHIRAllTypes.SUBSTANCEPOLYMER) 6162 return "SubstancePolymer"; 6163 if (code == FHIRAllTypes.SUBSTANCEPROTEIN) 6164 return "SubstanceProtein"; 6165 if (code == FHIRAllTypes.SUBSTANCEREFERENCEINFORMATION) 6166 return "SubstanceReferenceInformation"; 6167 if (code == FHIRAllTypes.SUBSTANCESOURCEMATERIAL) 6168 return "SubstanceSourceMaterial"; 6169 if (code == FHIRAllTypes.SUPPLYDELIVERY) 6170 return "SupplyDelivery"; 6171 if (code == FHIRAllTypes.SUPPLYREQUEST) 6172 return "SupplyRequest"; 6173 if (code == FHIRAllTypes.TASK) 6174 return "Task"; 6175 if (code == FHIRAllTypes.TERMINOLOGYCAPABILITIES) 6176 return "TerminologyCapabilities"; 6177 if (code == FHIRAllTypes.TESTREPORT) 6178 return "TestReport"; 6179 if (code == FHIRAllTypes.TESTSCRIPT) 6180 return "TestScript"; 6181 if (code == FHIRAllTypes.TOPIC) 6182 return "Topic"; 6183 if (code == FHIRAllTypes.VALUESET) 6184 return "ValueSet"; 6185 if (code == FHIRAllTypes.VERIFICATIONRESULT) 6186 return "VerificationResult"; 6187 if (code == FHIRAllTypes.VISIONPRESCRIPTION) 6188 return "VisionPrescription"; 6189 if (code == FHIRAllTypes.TYPE) 6190 return "Type"; 6191 if (code == FHIRAllTypes.ANY) 6192 return "Any"; 6193 return "?"; 6194 } 6195 public String toSystem(FHIRAllTypes code) { 6196 return code.getSystem(); 6197 } 6198 } 6199 6200 public enum FHIRVersion { 6201 /** 6202 * Oldest archived version of FHIR. 6203 */ 6204 _0_01, 6205 /** 6206 * 1st Draft for Comment (Sept 2012 Ballot). 6207 */ 6208 _0_05, 6209 /** 6210 * 2nd Draft for Comment (January 2013 Ballot). 6211 */ 6212 _0_06, 6213 /** 6214 * DSTU 1 Ballot version. 6215 */ 6216 _0_11, 6217 /** 6218 * DSTU 1 Official version. 6219 */ 6220 _0_0_80, 6221 /** 6222 * DSTU 1 Official version Technical Errata #1. 6223 */ 6224 _0_0_81, 6225 /** 6226 * DSTU 1 Official version Technical Errata #2. 6227 */ 6228 _0_0_82, 6229 /** 6230 * Draft For Comment (January 2015 Ballot). 6231 */ 6232 _0_4_0, 6233 /** 6234 * DSTU 2 Ballot version (May 2015 Ballot). 6235 */ 6236 _0_5_0, 6237 /** 6238 * DSTU 2 QA Preview + CQIF Ballot (Sep 2015). 6239 */ 6240 _1_0_0, 6241 /** 6242 * DSTU 2 (Official version). 6243 */ 6244 _1_0_1, 6245 /** 6246 * DSTU 2 (Official version) with 1 technical errata. 6247 */ 6248 _1_0_2, 6249 /** 6250 * GAO Ballot + draft changes to main FHIR standard. 6251 */ 6252 _1_1_0, 6253 /** 6254 * CQF on FHIR Ballot + Connectathon 12 (Montreal). 6255 */ 6256 _1_4_0, 6257 /** 6258 * FHIR STU3 Ballot + Connectathon 13 (Baltimore). 6259 */ 6260 _1_6_0, 6261 /** 6262 * FHIR STU3 Candidate + Connectathon 14 (San Antonio). 6263 */ 6264 _1_8_0, 6265 /** 6266 * FHIR Release 3 (STU). 6267 */ 6268 _3_0_0, 6269 /** 6270 * FHIR Release 3 (STU) with 1 technical errata. 6271 */ 6272 _3_0_1, 6273 /** 6274 * FHIR Release 3 (STU) with 2 technical errata. 6275 */ 6276 _3_0_2, 6277 /** 6278 * R4 Ballot #1. 6279 */ 6280 _3_3_0, 6281 /** 6282 * R4 Ballot #2. 6283 */ 6284 _3_5_0, 6285 /** 6286 * FHIR Release 4 (Normative + STU). 6287 */ 6288 _4_0_0, 6289 /** 6290 * FHIR Release 4 (Normative + STU) with 1 technical errata. 6291 */ 6292 _4_0_1, 6293 /** 6294 * R5 Preview #1. 6295 */ 6296 _4_2_0, 6297 /** 6298 * added to help the parsers 6299 */ 6300 NULL; 6301 public static FHIRVersion fromCode(String codeString) throws FHIRException { 6302 if (codeString == null || "".equals(codeString)) 6303 return null; 6304 if ("0.01".equals(codeString)) 6305 return _0_01; 6306 if ("0.05".equals(codeString)) 6307 return _0_05; 6308 if ("0.06".equals(codeString)) 6309 return _0_06; 6310 if ("0.11".equals(codeString)) 6311 return _0_11; 6312 if ("0.0.80".equals(codeString)) 6313 return _0_0_80; 6314 if ("0.0.81".equals(codeString)) 6315 return _0_0_81; 6316 if ("0.0.82".equals(codeString)) 6317 return _0_0_82; 6318 if ("0.4.0".equals(codeString)) 6319 return _0_4_0; 6320 if ("0.5.0".equals(codeString)) 6321 return _0_5_0; 6322 if ("1.0.0".equals(codeString)) 6323 return _1_0_0; 6324 if ("1.0.1".equals(codeString)) 6325 return _1_0_1; 6326 if ("1.0.2".equals(codeString)) 6327 return _1_0_2; 6328 if ("1.1.0".equals(codeString)) 6329 return _1_1_0; 6330 if ("1.4.0".equals(codeString)) 6331 return _1_4_0; 6332 if ("1.6.0".equals(codeString)) 6333 return _1_6_0; 6334 if ("1.8.0".equals(codeString)) 6335 return _1_8_0; 6336 if ("3.0.0".equals(codeString)) 6337 return _3_0_0; 6338 if ("3.0.1".equals(codeString)) 6339 return _3_0_1; 6340 if ("3.0.2".equals(codeString)) 6341 return _3_0_2; 6342 if ("3.3.0".equals(codeString)) 6343 return _3_3_0; 6344 if ("3.5.0".equals(codeString)) 6345 return _3_5_0; 6346 if ("4.0.0".equals(codeString)) 6347 return _4_0_0; 6348 if ("4.0.1".equals(codeString)) 6349 return _4_0_1; 6350 if ("4.2.0".equals(codeString)) 6351 return _4_2_0; 6352 throw new FHIRException("Unknown FHIRVersion code '"+codeString+"'"); 6353 } 6354 public String toCode() { 6355 switch (this) { 6356 case _0_01: return "0.01"; 6357 case _0_05: return "0.05"; 6358 case _0_06: return "0.06"; 6359 case _0_11: return "0.11"; 6360 case _0_0_80: return "0.0.80"; 6361 case _0_0_81: return "0.0.81"; 6362 case _0_0_82: return "0.0.82"; 6363 case _0_4_0: return "0.4.0"; 6364 case _0_5_0: return "0.5.0"; 6365 case _1_0_0: return "1.0.0"; 6366 case _1_0_1: return "1.0.1"; 6367 case _1_0_2: return "1.0.2"; 6368 case _1_1_0: return "1.1.0"; 6369 case _1_4_0: return "1.4.0"; 6370 case _1_6_0: return "1.6.0"; 6371 case _1_8_0: return "1.8.0"; 6372 case _3_0_0: return "3.0.0"; 6373 case _3_0_1: return "3.0.1"; 6374 case _3_0_2: return "3.0.2"; 6375 case _3_3_0: return "3.3.0"; 6376 case _3_5_0: return "3.5.0"; 6377 case _4_0_0: return "4.0.0"; 6378 case _4_0_1: return "4.0.1"; 6379 case _4_2_0: return "4.2.0"; 6380 default: return "?"; 6381 } 6382 } 6383 public String getSystem() { 6384 switch (this) { 6385 case _0_01: return "http://hl7.org/fhir/FHIR-version"; 6386 case _0_05: return "http://hl7.org/fhir/FHIR-version"; 6387 case _0_06: return "http://hl7.org/fhir/FHIR-version"; 6388 case _0_11: return "http://hl7.org/fhir/FHIR-version"; 6389 case _0_0_80: return "http://hl7.org/fhir/FHIR-version"; 6390 case _0_0_81: return "http://hl7.org/fhir/FHIR-version"; 6391 case _0_0_82: return "http://hl7.org/fhir/FHIR-version"; 6392 case _0_4_0: return "http://hl7.org/fhir/FHIR-version"; 6393 case _0_5_0: return "http://hl7.org/fhir/FHIR-version"; 6394 case _1_0_0: return "http://hl7.org/fhir/FHIR-version"; 6395 case _1_0_1: return "http://hl7.org/fhir/FHIR-version"; 6396 case _1_0_2: return "http://hl7.org/fhir/FHIR-version"; 6397 case _1_1_0: return "http://hl7.org/fhir/FHIR-version"; 6398 case _1_4_0: return "http://hl7.org/fhir/FHIR-version"; 6399 case _1_6_0: return "http://hl7.org/fhir/FHIR-version"; 6400 case _1_8_0: return "http://hl7.org/fhir/FHIR-version"; 6401 case _3_0_0: return "http://hl7.org/fhir/FHIR-version"; 6402 case _3_0_1: return "http://hl7.org/fhir/FHIR-version"; 6403 case _3_0_2: return "http://hl7.org/fhir/FHIR-version"; 6404 case _3_3_0: return "http://hl7.org/fhir/FHIR-version"; 6405 case _3_5_0: return "http://hl7.org/fhir/FHIR-version"; 6406 case _4_0_0: return "http://hl7.org/fhir/FHIR-version"; 6407 case _4_0_1: return "http://hl7.org/fhir/FHIR-version"; 6408 case _4_2_0: return "http://hl7.org/fhir/FHIR-version"; 6409 default: return "?"; 6410 } 6411 } 6412 public String getDefinition() { 6413 switch (this) { 6414 case _0_01: return "Oldest archived version of FHIR."; 6415 case _0_05: return "1st Draft for Comment (Sept 2012 Ballot)."; 6416 case _0_06: return "2nd Draft for Comment (January 2013 Ballot)."; 6417 case _0_11: return "DSTU 1 Ballot version."; 6418 case _0_0_80: return "DSTU 1 Official version."; 6419 case _0_0_81: return "DSTU 1 Official version Technical Errata #1."; 6420 case _0_0_82: return "DSTU 1 Official version Technical Errata #2."; 6421 case _0_4_0: return "Draft For Comment (January 2015 Ballot)."; 6422 case _0_5_0: return "DSTU 2 Ballot version (May 2015 Ballot)."; 6423 case _1_0_0: return "DSTU 2 QA Preview + CQIF Ballot (Sep 2015)."; 6424 case _1_0_1: return "DSTU 2 (Official version)."; 6425 case _1_0_2: return "DSTU 2 (Official version) with 1 technical errata."; 6426 case _1_1_0: return "GAO Ballot + draft changes to main FHIR standard."; 6427 case _1_4_0: return "CQF on FHIR Ballot + Connectathon 12 (Montreal)."; 6428 case _1_6_0: return "FHIR STU3 Ballot + Connectathon 13 (Baltimore)."; 6429 case _1_8_0: return "FHIR STU3 Candidate + Connectathon 14 (San Antonio)."; 6430 case _3_0_0: return "FHIR Release 3 (STU)."; 6431 case _3_0_1: return "FHIR Release 3 (STU) with 1 technical errata."; 6432 case _3_0_2: return "FHIR Release 3 (STU) with 2 technical errata."; 6433 case _3_3_0: return "R4 Ballot #1."; 6434 case _3_5_0: return "R4 Ballot #2."; 6435 case _4_0_0: return "FHIR Release 4 (Normative + STU)."; 6436 case _4_0_1: return "FHIR Release 4 (Normative + STU) with 1 technical errata."; 6437 case _4_2_0: return "R5 Preview #1."; 6438 default: return "?"; 6439 } 6440 } 6441 public String getDisplay() { 6442 switch (this) { 6443 case _0_01: return "0.01"; 6444 case _0_05: return "0.05"; 6445 case _0_06: return "0.06"; 6446 case _0_11: return "0.11"; 6447 case _0_0_80: return "0.0.80"; 6448 case _0_0_81: return "0.0.81"; 6449 case _0_0_82: return "0.0.82"; 6450 case _0_4_0: return "0.4.0"; 6451 case _0_5_0: return "0.5.0"; 6452 case _1_0_0: return "1.0.0"; 6453 case _1_0_1: return "1.0.1"; 6454 case _1_0_2: return "1.0.2"; 6455 case _1_1_0: return "1.1.0"; 6456 case _1_4_0: return "1.4.0"; 6457 case _1_6_0: return "1.6.0"; 6458 case _1_8_0: return "1.8.0"; 6459 case _3_0_0: return "3.0.0"; 6460 case _3_0_1: return "3.0.1"; 6461 case _3_0_2: return "3.0.2"; 6462 case _3_3_0: return "3.3.0"; 6463 case _3_5_0: return "3.5.0"; 6464 case _4_0_0: return "4.0.0"; 6465 case _4_0_1: return "4.0.1"; 6466 case _4_2_0: return "4.2.0"; 6467 default: return "?"; 6468 } 6469 } 6470// manual code from configuration.txt: 6471 public String toCode(int len) { 6472 return toCode().substring(0, len); 6473 } 6474 6475 public static boolean isR4Plus(String version) { 6476 return version != null && (version.startsWith("4.") || version.startsWith("5.") || "current".equals(version)); 6477 } 6478 6479 public static boolean isValidCode(String codeString) { 6480 if (codeString == null || "".equals(codeString)) 6481 return false; 6482 if ("0.01".equals(codeString)) 6483 return true; 6484 if ("0.05".equals(codeString)) 6485 return true; 6486 if ("0.06".equals(codeString)) 6487 return true; 6488 if ("0.11".equals(codeString)) 6489 return true; 6490 if ("0.0.80".equals(codeString)) 6491 return true; 6492 if ("0.0.81".equals(codeString)) 6493 return true; 6494 if ("0.0.82".equals(codeString)) 6495 return true; 6496 if ("0.4.0".equals(codeString)) 6497 return true; 6498 if ("0.5.0".equals(codeString)) 6499 return true; 6500 if ("1.0.0".equals(codeString)) 6501 return true; 6502 if ("1.0.1".equals(codeString)) 6503 return true; 6504 if ("1.0.2".equals(codeString)) 6505 return true; 6506 if ("1.1.0".equals(codeString)) 6507 return true; 6508 if ("1.4.0".equals(codeString)) 6509 return true; 6510 if ("1.6.0".equals(codeString)) 6511 return true; 6512 if ("1.8.0".equals(codeString)) 6513 return true; 6514 if ("3.0.0".equals(codeString)) 6515 return true; 6516 if ("3.0.1".equals(codeString)) 6517 return true; 6518 if ("3.3.0".equals(codeString)) 6519 return true; 6520 if ("3.5.0".equals(codeString)) 6521 return true; 6522 if ("4.0.0".equals(codeString)) 6523 return true; 6524 if ("4.2.0".equals(codeString)) 6525 return true; 6526 return false; 6527 } 6528 6529 @Override 6530 public String toString() { 6531 return toCode(); 6532 } 6533 6534// end addition 6535 } 6536 6537 public static class FHIRVersionEnumFactory implements EnumFactory<FHIRVersion> { 6538 public FHIRVersion fromCode(String codeString) throws IllegalArgumentException { 6539 if (codeString == null || "".equals(codeString)) 6540 if (codeString == null || "".equals(codeString)) 6541 return null; 6542 if ("0.01".equals(codeString)) 6543 return FHIRVersion._0_01; 6544 if ("0.05".equals(codeString)) 6545 return FHIRVersion._0_05; 6546 if ("0.06".equals(codeString)) 6547 return FHIRVersion._0_06; 6548 if ("0.11".equals(codeString)) 6549 return FHIRVersion._0_11; 6550 if ("0.0.80".equals(codeString)) 6551 return FHIRVersion._0_0_80; 6552 if ("0.0.81".equals(codeString)) 6553 return FHIRVersion._0_0_81; 6554 if ("0.0.82".equals(codeString)) 6555 return FHIRVersion._0_0_82; 6556 if ("0.4.0".equals(codeString)) 6557 return FHIRVersion._0_4_0; 6558 if ("0.5.0".equals(codeString)) 6559 return FHIRVersion._0_5_0; 6560 if ("1.0.0".equals(codeString)) 6561 return FHIRVersion._1_0_0; 6562 if ("1.0.1".equals(codeString)) 6563 return FHIRVersion._1_0_1; 6564 if ("1.0.2".equals(codeString)) 6565 return FHIRVersion._1_0_2; 6566 if ("1.1.0".equals(codeString)) 6567 return FHIRVersion._1_1_0; 6568 if ("1.4.0".equals(codeString)) 6569 return FHIRVersion._1_4_0; 6570 if ("1.6.0".equals(codeString)) 6571 return FHIRVersion._1_6_0; 6572 if ("1.8.0".equals(codeString)) 6573 return FHIRVersion._1_8_0; 6574 if ("3.0.0".equals(codeString)) 6575 return FHIRVersion._3_0_0; 6576 if ("3.0.1".equals(codeString)) 6577 return FHIRVersion._3_0_1; 6578 if ("3.0.2".equals(codeString)) 6579 return FHIRVersion._3_0_2; 6580 if ("3.3.0".equals(codeString)) 6581 return FHIRVersion._3_3_0; 6582 if ("3.5.0".equals(codeString)) 6583 return FHIRVersion._3_5_0; 6584 if ("4.0.0".equals(codeString)) 6585 return FHIRVersion._4_0_0; 6586 if ("4.0.1".equals(codeString)) 6587 return FHIRVersion._4_0_1; 6588 if ("4.2.0".equals(codeString)) 6589 return FHIRVersion._4_2_0; 6590 throw new IllegalArgumentException("Unknown FHIRVersion code '"+codeString+"'"); 6591 } 6592 public Enumeration<FHIRVersion> fromType(Base code) throws FHIRException { 6593 if (code == null) 6594 return null; 6595 if (code.isEmpty()) 6596 return new Enumeration<FHIRVersion>(this); 6597 String codeString = ((PrimitiveType) code).asStringValue(); 6598 if (codeString == null || "".equals(codeString)) 6599 return null; 6600 if ("0.01".equals(codeString)) 6601 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_01); 6602 if ("0.05".equals(codeString)) 6603 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_05); 6604 if ("0.06".equals(codeString)) 6605 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_06); 6606 if ("0.11".equals(codeString)) 6607 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_11); 6608 if ("0.0.80".equals(codeString)) 6609 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_0_80); 6610 if ("0.0.81".equals(codeString)) 6611 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_0_81); 6612 if ("0.0.82".equals(codeString)) 6613 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_0_82); 6614 if ("0.4.0".equals(codeString)) 6615 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_4_0); 6616 if ("0.5.0".equals(codeString)) 6617 return new Enumeration<FHIRVersion>(this, FHIRVersion._0_5_0); 6618 if ("1.0.0".equals(codeString)) 6619 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_0_0); 6620 if ("1.0.1".equals(codeString)) 6621 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_0_1); 6622 if ("1.0.2".equals(codeString)) 6623 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_0_2); 6624 if ("1.1.0".equals(codeString)) 6625 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_1_0); 6626 if ("1.4.0".equals(codeString)) 6627 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_4_0); 6628 if ("1.6.0".equals(codeString)) 6629 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_6_0); 6630 if ("1.8.0".equals(codeString)) 6631 return new Enumeration<FHIRVersion>(this, FHIRVersion._1_8_0); 6632 if ("3.0.0".equals(codeString)) 6633 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_0_0); 6634 if ("3.0.1".equals(codeString)) 6635 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_0_1); 6636 if ("3.0.2".equals(codeString)) 6637 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_0_2); 6638 if ("3.3.0".equals(codeString)) 6639 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_3_0); 6640 if ("3.5.0".equals(codeString)) 6641 return new Enumeration<FHIRVersion>(this, FHIRVersion._3_5_0); 6642 if ("4.0.0".equals(codeString)) 6643 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_0_0); 6644 if ("4.0.1".equals(codeString)) 6645 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_0_1); 6646 if ("4.2.0".equals(codeString)) 6647 return new Enumeration<FHIRVersion>(this, FHIRVersion._4_2_0); 6648 throw new FHIRException("Unknown FHIRVersion code '"+codeString+"'"); 6649 } 6650 public String toCode(FHIRVersion code) { 6651 if (code == FHIRVersion._0_01) 6652 return "0.01"; 6653 if (code == FHIRVersion._0_05) 6654 return "0.05"; 6655 if (code == FHIRVersion._0_06) 6656 return "0.06"; 6657 if (code == FHIRVersion._0_11) 6658 return "0.11"; 6659 if (code == FHIRVersion._0_0_80) 6660 return "0.0.80"; 6661 if (code == FHIRVersion._0_0_81) 6662 return "0.0.81"; 6663 if (code == FHIRVersion._0_0_82) 6664 return "0.0.82"; 6665 if (code == FHIRVersion._0_4_0) 6666 return "0.4.0"; 6667 if (code == FHIRVersion._0_5_0) 6668 return "0.5.0"; 6669 if (code == FHIRVersion._1_0_0) 6670 return "1.0.0"; 6671 if (code == FHIRVersion._1_0_1) 6672 return "1.0.1"; 6673 if (code == FHIRVersion._1_0_2) 6674 return "1.0.2"; 6675 if (code == FHIRVersion._1_1_0) 6676 return "1.1.0"; 6677 if (code == FHIRVersion._1_4_0) 6678 return "1.4.0"; 6679 if (code == FHIRVersion._1_6_0) 6680 return "1.6.0"; 6681 if (code == FHIRVersion._1_8_0) 6682 return "1.8.0"; 6683 if (code == FHIRVersion._3_0_0) 6684 return "3.0.0"; 6685 if (code == FHIRVersion._3_0_1) 6686 return "3.0.1"; 6687 if (code == FHIRVersion._3_0_2) 6688 return "3.0.2"; 6689 if (code == FHIRVersion._3_3_0) 6690 return "3.3.0"; 6691 if (code == FHIRVersion._3_5_0) 6692 return "3.5.0"; 6693 if (code == FHIRVersion._4_0_0) 6694 return "4.0.0"; 6695 if (code == FHIRVersion._4_0_1) 6696 return "4.0.1"; 6697 if (code == FHIRVersion._4_2_0) 6698 return "4.2.0"; 6699 return "?"; 6700 } 6701 public String toSystem(FHIRVersion code) { 6702 return code.getSystem(); 6703 } 6704 } 6705 6706 public enum FilterOperator { 6707 /** 6708 * The specified property of the code equals the provided value. 6709 */ 6710 EQUAL, 6711 /** 6712 * Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, including the provided concept itself (include descendant codes and self). 6713 */ 6714 ISA, 6715 /** 6716 * Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, excluding the provided concept itself i.e. include descendant codes only). 6717 */ 6718 DESCENDENTOF, 6719 /** 6720 * The specified property of the code does not have an is-a relationship with the provided value. 6721 */ 6722 ISNOTA, 6723 /** 6724 * The specified property of the code matches the regex specified in the provided value. 6725 */ 6726 REGEX, 6727 /** 6728 * The specified property of the code is in the set of codes or concepts specified in the provided value (comma separated list). 6729 */ 6730 IN, 6731 /** 6732 * The specified property of the code is not in the set of codes or concepts specified in the provided value (comma separated list). 6733 */ 6734 NOTIN, 6735 /** 6736 * Includes all concept ids that have a transitive is-a relationship from the concept Id provided as the value, including the provided concept itself (i.e. include ancestor codes and self). 6737 */ 6738 GENERALIZES, 6739 /** 6740 * The specified property of the code has at least one value (if the specified value is true; if the specified value is false, then matches when the specified property of the code has no values). 6741 */ 6742 EXISTS, 6743 /** 6744 * added to help the parsers 6745 */ 6746 NULL; 6747 public static FilterOperator fromCode(String codeString) throws FHIRException { 6748 if (codeString == null || "".equals(codeString)) 6749 return null; 6750 if ("=".equals(codeString)) 6751 return EQUAL; 6752 if ("is-a".equals(codeString)) 6753 return ISA; 6754 if ("descendent-of".equals(codeString)) 6755 return DESCENDENTOF; 6756 if ("is-not-a".equals(codeString)) 6757 return ISNOTA; 6758 if ("regex".equals(codeString)) 6759 return REGEX; 6760 if ("in".equals(codeString)) 6761 return IN; 6762 if ("not-in".equals(codeString)) 6763 return NOTIN; 6764 if ("generalizes".equals(codeString)) 6765 return GENERALIZES; 6766 if ("exists".equals(codeString)) 6767 return EXISTS; 6768 throw new FHIRException("Unknown FilterOperator code '"+codeString+"'"); 6769 } 6770 public String toCode() { 6771 switch (this) { 6772 case EQUAL: return "="; 6773 case ISA: return "is-a"; 6774 case DESCENDENTOF: return "descendent-of"; 6775 case ISNOTA: return "is-not-a"; 6776 case REGEX: return "regex"; 6777 case IN: return "in"; 6778 case NOTIN: return "not-in"; 6779 case GENERALIZES: return "generalizes"; 6780 case EXISTS: return "exists"; 6781 default: return "?"; 6782 } 6783 } 6784 public String getSystem() { 6785 switch (this) { 6786 case EQUAL: return "http://hl7.org/fhir/filter-operator"; 6787 case ISA: return "http://hl7.org/fhir/filter-operator"; 6788 case DESCENDENTOF: return "http://hl7.org/fhir/filter-operator"; 6789 case ISNOTA: return "http://hl7.org/fhir/filter-operator"; 6790 case REGEX: return "http://hl7.org/fhir/filter-operator"; 6791 case IN: return "http://hl7.org/fhir/filter-operator"; 6792 case NOTIN: return "http://hl7.org/fhir/filter-operator"; 6793 case GENERALIZES: return "http://hl7.org/fhir/filter-operator"; 6794 case EXISTS: return "http://hl7.org/fhir/filter-operator"; 6795 default: return "?"; 6796 } 6797 } 6798 public String getDefinition() { 6799 switch (this) { 6800 case EQUAL: return "The specified property of the code equals the provided value."; 6801 case ISA: return "Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, including the provided concept itself (include descendant codes and self)."; 6802 case DESCENDENTOF: return "Includes all concept ids that have a transitive is-a relationship with the concept Id provided as the value, excluding the provided concept itself i.e. include descendant codes only)."; 6803 case ISNOTA: return "The specified property of the code does not have an is-a relationship with the provided value."; 6804 case REGEX: return "The specified property of the code matches the regex specified in the provided value."; 6805 case IN: return "The specified property of the code is in the set of codes or concepts specified in the provided value (comma separated list)."; 6806 case NOTIN: return "The specified property of the code is not in the set of codes or concepts specified in the provided value (comma separated list)."; 6807 case GENERALIZES: return "Includes all concept ids that have a transitive is-a relationship from the concept Id provided as the value, including the provided concept itself (i.e. include ancestor codes and self)."; 6808 case EXISTS: return "The specified property of the code has at least one value (if the specified value is true; if the specified value is false, then matches when the specified property of the code has no values)."; 6809 default: return "?"; 6810 } 6811 } 6812 public String getDisplay() { 6813 switch (this) { 6814 case EQUAL: return "Equals"; 6815 case ISA: return "Is A (by subsumption)"; 6816 case DESCENDENTOF: return "Descendent Of (by subsumption)"; 6817 case ISNOTA: return "Not (Is A) (by subsumption)"; 6818 case REGEX: return "Regular Expression"; 6819 case IN: return "In Set"; 6820 case NOTIN: return "Not in Set"; 6821 case GENERALIZES: return "Generalizes (by Subsumption)"; 6822 case EXISTS: return "Exists"; 6823 default: return "?"; 6824 } 6825 } 6826 } 6827 6828 public static class FilterOperatorEnumFactory implements EnumFactory<FilterOperator> { 6829 public FilterOperator fromCode(String codeString) throws IllegalArgumentException { 6830 if (codeString == null || "".equals(codeString)) 6831 if (codeString == null || "".equals(codeString)) 6832 return null; 6833 if ("=".equals(codeString)) 6834 return FilterOperator.EQUAL; 6835 if ("is-a".equals(codeString)) 6836 return FilterOperator.ISA; 6837 if ("descendent-of".equals(codeString)) 6838 return FilterOperator.DESCENDENTOF; 6839 if ("is-not-a".equals(codeString)) 6840 return FilterOperator.ISNOTA; 6841 if ("regex".equals(codeString)) 6842 return FilterOperator.REGEX; 6843 if ("in".equals(codeString)) 6844 return FilterOperator.IN; 6845 if ("not-in".equals(codeString)) 6846 return FilterOperator.NOTIN; 6847 if ("generalizes".equals(codeString)) 6848 return FilterOperator.GENERALIZES; 6849 if ("exists".equals(codeString)) 6850 return FilterOperator.EXISTS; 6851 throw new IllegalArgumentException("Unknown FilterOperator code '"+codeString+"'"); 6852 } 6853 public Enumeration<FilterOperator> fromType(Base code) throws FHIRException { 6854 if (code == null) 6855 return null; 6856 if (code.isEmpty()) 6857 return new Enumeration<FilterOperator>(this); 6858 String codeString = ((PrimitiveType) code).asStringValue(); 6859 if (codeString == null || "".equals(codeString)) 6860 return null; 6861 if ("=".equals(codeString)) 6862 return new Enumeration<FilterOperator>(this, FilterOperator.EQUAL); 6863 if ("is-a".equals(codeString)) 6864 return new Enumeration<FilterOperator>(this, FilterOperator.ISA); 6865 if ("descendent-of".equals(codeString)) 6866 return new Enumeration<FilterOperator>(this, FilterOperator.DESCENDENTOF); 6867 if ("is-not-a".equals(codeString)) 6868 return new Enumeration<FilterOperator>(this, FilterOperator.ISNOTA); 6869 if ("regex".equals(codeString)) 6870 return new Enumeration<FilterOperator>(this, FilterOperator.REGEX); 6871 if ("in".equals(codeString)) 6872 return new Enumeration<FilterOperator>(this, FilterOperator.IN); 6873 if ("not-in".equals(codeString)) 6874 return new Enumeration<FilterOperator>(this, FilterOperator.NOTIN); 6875 if ("generalizes".equals(codeString)) 6876 return new Enumeration<FilterOperator>(this, FilterOperator.GENERALIZES); 6877 if ("exists".equals(codeString)) 6878 return new Enumeration<FilterOperator>(this, FilterOperator.EXISTS); 6879 throw new FHIRException("Unknown FilterOperator code '"+codeString+"'"); 6880 } 6881 public String toCode(FilterOperator code) { 6882 if (code == FilterOperator.EQUAL) 6883 return "="; 6884 if (code == FilterOperator.ISA) 6885 return "is-a"; 6886 if (code == FilterOperator.DESCENDENTOF) 6887 return "descendent-of"; 6888 if (code == FilterOperator.ISNOTA) 6889 return "is-not-a"; 6890 if (code == FilterOperator.REGEX) 6891 return "regex"; 6892 if (code == FilterOperator.IN) 6893 return "in"; 6894 if (code == FilterOperator.NOTIN) 6895 return "not-in"; 6896 if (code == FilterOperator.GENERALIZES) 6897 return "generalizes"; 6898 if (code == FilterOperator.EXISTS) 6899 return "exists"; 6900 return "?"; 6901 } 6902 public String toSystem(FilterOperator code) { 6903 return code.getSystem(); 6904 } 6905 } 6906 6907 public enum FinancialResourceStatusCodes { 6908 /** 6909 * The instance is currently in-force. 6910 */ 6911 ACTIVE, 6912 /** 6913 * The instance is withdrawn, rescinded or reversed. 6914 */ 6915 CANCELLED, 6916 /** 6917 * A new instance the contents of which is not complete. 6918 */ 6919 DRAFT, 6920 /** 6921 * The instance was entered in error. 6922 */ 6923 ENTEREDINERROR, 6924 /** 6925 * added to help the parsers 6926 */ 6927 NULL; 6928 public static FinancialResourceStatusCodes fromCode(String codeString) throws FHIRException { 6929 if (codeString == null || "".equals(codeString)) 6930 return null; 6931 if ("active".equals(codeString)) 6932 return ACTIVE; 6933 if ("cancelled".equals(codeString)) 6934 return CANCELLED; 6935 if ("draft".equals(codeString)) 6936 return DRAFT; 6937 if ("entered-in-error".equals(codeString)) 6938 return ENTEREDINERROR; 6939 throw new FHIRException("Unknown FinancialResourceStatusCodes code '"+codeString+"'"); 6940 } 6941 public String toCode() { 6942 switch (this) { 6943 case ACTIVE: return "active"; 6944 case CANCELLED: return "cancelled"; 6945 case DRAFT: return "draft"; 6946 case ENTEREDINERROR: return "entered-in-error"; 6947 default: return "?"; 6948 } 6949 } 6950 public String getSystem() { 6951 switch (this) { 6952 case ACTIVE: return "http://hl7.org/fhir/fm-status"; 6953 case CANCELLED: return "http://hl7.org/fhir/fm-status"; 6954 case DRAFT: return "http://hl7.org/fhir/fm-status"; 6955 case ENTEREDINERROR: return "http://hl7.org/fhir/fm-status"; 6956 default: return "?"; 6957 } 6958 } 6959 public String getDefinition() { 6960 switch (this) { 6961 case ACTIVE: return "The instance is currently in-force."; 6962 case CANCELLED: return "The instance is withdrawn, rescinded or reversed."; 6963 case DRAFT: return "A new instance the contents of which is not complete."; 6964 case ENTEREDINERROR: return "The instance was entered in error."; 6965 default: return "?"; 6966 } 6967 } 6968 public String getDisplay() { 6969 switch (this) { 6970 case ACTIVE: return "Active"; 6971 case CANCELLED: return "Cancelled"; 6972 case DRAFT: return "Draft"; 6973 case ENTEREDINERROR: return "Entered in Error"; 6974 default: return "?"; 6975 } 6976 } 6977 } 6978 6979 public static class FinancialResourceStatusCodesEnumFactory implements EnumFactory<FinancialResourceStatusCodes> { 6980 public FinancialResourceStatusCodes fromCode(String codeString) throws IllegalArgumentException { 6981 if (codeString == null || "".equals(codeString)) 6982 if (codeString == null || "".equals(codeString)) 6983 return null; 6984 if ("active".equals(codeString)) 6985 return FinancialResourceStatusCodes.ACTIVE; 6986 if ("cancelled".equals(codeString)) 6987 return FinancialResourceStatusCodes.CANCELLED; 6988 if ("draft".equals(codeString)) 6989 return FinancialResourceStatusCodes.DRAFT; 6990 if ("entered-in-error".equals(codeString)) 6991 return FinancialResourceStatusCodes.ENTEREDINERROR; 6992 throw new IllegalArgumentException("Unknown FinancialResourceStatusCodes code '"+codeString+"'"); 6993 } 6994 public Enumeration<FinancialResourceStatusCodes> fromType(Base code) throws FHIRException { 6995 if (code == null) 6996 return null; 6997 if (code.isEmpty()) 6998 return new Enumeration<FinancialResourceStatusCodes>(this); 6999 String codeString = ((PrimitiveType) code).asStringValue(); 7000 if (codeString == null || "".equals(codeString)) 7001 return null; 7002 if ("active".equals(codeString)) 7003 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.ACTIVE); 7004 if ("cancelled".equals(codeString)) 7005 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.CANCELLED); 7006 if ("draft".equals(codeString)) 7007 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.DRAFT); 7008 if ("entered-in-error".equals(codeString)) 7009 return new Enumeration<FinancialResourceStatusCodes>(this, FinancialResourceStatusCodes.ENTEREDINERROR); 7010 throw new FHIRException("Unknown FinancialResourceStatusCodes code '"+codeString+"'"); 7011 } 7012 public String toCode(FinancialResourceStatusCodes code) { 7013 if (code == FinancialResourceStatusCodes.ACTIVE) 7014 return "active"; 7015 if (code == FinancialResourceStatusCodes.CANCELLED) 7016 return "cancelled"; 7017 if (code == FinancialResourceStatusCodes.DRAFT) 7018 return "draft"; 7019 if (code == FinancialResourceStatusCodes.ENTEREDINERROR) 7020 return "entered-in-error"; 7021 return "?"; 7022 } 7023 public String toSystem(FinancialResourceStatusCodes code) { 7024 return code.getSystem(); 7025 } 7026 } 7027 7028 public enum InvoicePriceComponentType { 7029 /** 7030 * the amount is the base price used for calculating the total price before applying surcharges, discount or taxes. 7031 */ 7032 BASE, 7033 /** 7034 * the amount is a surcharge applied on the base price. 7035 */ 7036 SURCHARGE, 7037 /** 7038 * the amount is a deduction applied on the base price. 7039 */ 7040 DEDUCTION, 7041 /** 7042 * the amount is a discount applied on the base price. 7043 */ 7044 DISCOUNT, 7045 /** 7046 * the amount is the tax component of the total price. 7047 */ 7048 TAX, 7049 /** 7050 * the amount is of informational character, it has not been applied in the calculation of the total price. 7051 */ 7052 INFORMATIONAL, 7053 /** 7054 * added to help the parsers 7055 */ 7056 NULL; 7057 public static InvoicePriceComponentType fromCode(String codeString) throws FHIRException { 7058 if (codeString == null || "".equals(codeString)) 7059 return null; 7060 if ("base".equals(codeString)) 7061 return BASE; 7062 if ("surcharge".equals(codeString)) 7063 return SURCHARGE; 7064 if ("deduction".equals(codeString)) 7065 return DEDUCTION; 7066 if ("discount".equals(codeString)) 7067 return DISCOUNT; 7068 if ("tax".equals(codeString)) 7069 return TAX; 7070 if ("informational".equals(codeString)) 7071 return INFORMATIONAL; 7072 throw new FHIRException("Unknown InvoicePriceComponentType code '"+codeString+"'"); 7073 } 7074 public String toCode() { 7075 switch (this) { 7076 case BASE: return "base"; 7077 case SURCHARGE: return "surcharge"; 7078 case DEDUCTION: return "deduction"; 7079 case DISCOUNT: return "discount"; 7080 case TAX: return "tax"; 7081 case INFORMATIONAL: return "informational"; 7082 default: return "?"; 7083 } 7084 } 7085 public String getSystem() { 7086 switch (this) { 7087 case BASE: return "http://hl7.org/fhir/invoice-priceComponentType"; 7088 case SURCHARGE: return "http://hl7.org/fhir/invoice-priceComponentType"; 7089 case DEDUCTION: return "http://hl7.org/fhir/invoice-priceComponentType"; 7090 case DISCOUNT: return "http://hl7.org/fhir/invoice-priceComponentType"; 7091 case TAX: return "http://hl7.org/fhir/invoice-priceComponentType"; 7092 case INFORMATIONAL: return "http://hl7.org/fhir/invoice-priceComponentType"; 7093 default: return "?"; 7094 } 7095 } 7096 public String getDefinition() { 7097 switch (this) { 7098 case BASE: return "the amount is the base price used for calculating the total price before applying surcharges, discount or taxes."; 7099 case SURCHARGE: return "the amount is a surcharge applied on the base price."; 7100 case DEDUCTION: return "the amount is a deduction applied on the base price."; 7101 case DISCOUNT: return "the amount is a discount applied on the base price."; 7102 case TAX: return "the amount is the tax component of the total price."; 7103 case INFORMATIONAL: return "the amount is of informational character, it has not been applied in the calculation of the total price."; 7104 default: return "?"; 7105 } 7106 } 7107 public String getDisplay() { 7108 switch (this) { 7109 case BASE: return "base price"; 7110 case SURCHARGE: return "surcharge"; 7111 case DEDUCTION: return "deduction"; 7112 case DISCOUNT: return "discount"; 7113 case TAX: return "tax"; 7114 case INFORMATIONAL: return "informational"; 7115 default: return "?"; 7116 } 7117 } 7118 } 7119 7120 public static class InvoicePriceComponentTypeEnumFactory implements EnumFactory<InvoicePriceComponentType> { 7121 public InvoicePriceComponentType fromCode(String codeString) throws IllegalArgumentException { 7122 if (codeString == null || "".equals(codeString)) 7123 if (codeString == null || "".equals(codeString)) 7124 return null; 7125 if ("base".equals(codeString)) 7126 return InvoicePriceComponentType.BASE; 7127 if ("surcharge".equals(codeString)) 7128 return InvoicePriceComponentType.SURCHARGE; 7129 if ("deduction".equals(codeString)) 7130 return InvoicePriceComponentType.DEDUCTION; 7131 if ("discount".equals(codeString)) 7132 return InvoicePriceComponentType.DISCOUNT; 7133 if ("tax".equals(codeString)) 7134 return InvoicePriceComponentType.TAX; 7135 if ("informational".equals(codeString)) 7136 return InvoicePriceComponentType.INFORMATIONAL; 7137 throw new IllegalArgumentException("Unknown InvoicePriceComponentType code '"+codeString+"'"); 7138 } 7139 public Enumeration<InvoicePriceComponentType> fromType(Base code) throws FHIRException { 7140 if (code == null) 7141 return null; 7142 if (code.isEmpty()) 7143 return new Enumeration<InvoicePriceComponentType>(this); 7144 String codeString = ((PrimitiveType) code).asStringValue(); 7145 if (codeString == null || "".equals(codeString)) 7146 return null; 7147 if ("base".equals(codeString)) 7148 return new Enumeration<InvoicePriceComponentType>(this, InvoicePriceComponentType.BASE); 7149 if ("surcharge".equals(codeString)) 7150 return new Enumeration<InvoicePriceComponentType>(this, InvoicePriceComponentType.SURCHARGE); 7151 if ("deduction".equals(codeString)) 7152 return new Enumeration<InvoicePriceComponentType>(this, InvoicePriceComponentType.DEDUCTION); 7153 if ("discount".equals(codeString)) 7154 return new Enumeration<InvoicePriceComponentType>(this, InvoicePriceComponentType.DISCOUNT); 7155 if ("tax".equals(codeString)) 7156 return new Enumeration<InvoicePriceComponentType>(this, InvoicePriceComponentType.TAX); 7157 if ("informational".equals(codeString)) 7158 return new Enumeration<InvoicePriceComponentType>(this, InvoicePriceComponentType.INFORMATIONAL); 7159 throw new FHIRException("Unknown InvoicePriceComponentType code '"+codeString+"'"); 7160 } 7161 public String toCode(InvoicePriceComponentType code) { 7162 if (code == InvoicePriceComponentType.BASE) 7163 return "base"; 7164 if (code == InvoicePriceComponentType.SURCHARGE) 7165 return "surcharge"; 7166 if (code == InvoicePriceComponentType.DEDUCTION) 7167 return "deduction"; 7168 if (code == InvoicePriceComponentType.DISCOUNT) 7169 return "discount"; 7170 if (code == InvoicePriceComponentType.TAX) 7171 return "tax"; 7172 if (code == InvoicePriceComponentType.INFORMATIONAL) 7173 return "informational"; 7174 return "?"; 7175 } 7176 public String toSystem(InvoicePriceComponentType code) { 7177 return code.getSystem(); 7178 } 7179 } 7180 7181 public enum ListMode { 7182 /** 7183 * This list is the master list, maintained in an ongoing fashion with regular updates as the real world list it is tracking changes. 7184 */ 7185 WORKING, 7186 /** 7187 * This list was prepared as a snapshot. It should not be assumed to be current. 7188 */ 7189 SNAPSHOT, 7190 /** 7191 * A point-in-time list that shows what changes have been made or recommended. E.g. a discharge medication list showing what was added and removed during an encounter. 7192 */ 7193 CHANGES, 7194 /** 7195 * added to help the parsers 7196 */ 7197 NULL; 7198 public static ListMode fromCode(String codeString) throws FHIRException { 7199 if (codeString == null || "".equals(codeString)) 7200 return null; 7201 if ("working".equals(codeString)) 7202 return WORKING; 7203 if ("snapshot".equals(codeString)) 7204 return SNAPSHOT; 7205 if ("changes".equals(codeString)) 7206 return CHANGES; 7207 throw new FHIRException("Unknown ListMode code '"+codeString+"'"); 7208 } 7209 public String toCode() { 7210 switch (this) { 7211 case WORKING: return "working"; 7212 case SNAPSHOT: return "snapshot"; 7213 case CHANGES: return "changes"; 7214 default: return "?"; 7215 } 7216 } 7217 public String getSystem() { 7218 switch (this) { 7219 case WORKING: return "http://hl7.org/fhir/list-mode"; 7220 case SNAPSHOT: return "http://hl7.org/fhir/list-mode"; 7221 case CHANGES: return "http://hl7.org/fhir/list-mode"; 7222 default: return "?"; 7223 } 7224 } 7225 public String getDefinition() { 7226 switch (this) { 7227 case WORKING: return "This list is the master list, maintained in an ongoing fashion with regular updates as the real world list it is tracking changes."; 7228 case SNAPSHOT: return "This list was prepared as a snapshot. It should not be assumed to be current."; 7229 case CHANGES: return "A point-in-time list that shows what changes have been made or recommended. E.g. a discharge medication list showing what was added and removed during an encounter."; 7230 default: return "?"; 7231 } 7232 } 7233 public String getDisplay() { 7234 switch (this) { 7235 case WORKING: return "Working List"; 7236 case SNAPSHOT: return "Snapshot List"; 7237 case CHANGES: return "Change List"; 7238 default: return "?"; 7239 } 7240 } 7241 } 7242 7243 public static class ListModeEnumFactory implements EnumFactory<ListMode> { 7244 public ListMode fromCode(String codeString) throws IllegalArgumentException { 7245 if (codeString == null || "".equals(codeString)) 7246 if (codeString == null || "".equals(codeString)) 7247 return null; 7248 if ("working".equals(codeString)) 7249 return ListMode.WORKING; 7250 if ("snapshot".equals(codeString)) 7251 return ListMode.SNAPSHOT; 7252 if ("changes".equals(codeString)) 7253 return ListMode.CHANGES; 7254 throw new IllegalArgumentException("Unknown ListMode code '"+codeString+"'"); 7255 } 7256 public Enumeration<ListMode> fromType(Base code) throws FHIRException { 7257 if (code == null) 7258 return null; 7259 if (code.isEmpty()) 7260 return new Enumeration<ListMode>(this); 7261 String codeString = ((PrimitiveType) code).asStringValue(); 7262 if (codeString == null || "".equals(codeString)) 7263 return null; 7264 if ("working".equals(codeString)) 7265 return new Enumeration<ListMode>(this, ListMode.WORKING); 7266 if ("snapshot".equals(codeString)) 7267 return new Enumeration<ListMode>(this, ListMode.SNAPSHOT); 7268 if ("changes".equals(codeString)) 7269 return new Enumeration<ListMode>(this, ListMode.CHANGES); 7270 throw new FHIRException("Unknown ListMode code '"+codeString+"'"); 7271 } 7272 public String toCode(ListMode code) { 7273 if (code == ListMode.WORKING) 7274 return "working"; 7275 if (code == ListMode.SNAPSHOT) 7276 return "snapshot"; 7277 if (code == ListMode.CHANGES) 7278 return "changes"; 7279 return "?"; 7280 } 7281 public String toSystem(ListMode code) { 7282 return code.getSystem(); 7283 } 7284 } 7285 7286 public enum MeasureImprovementNotation { 7287 /** 7288 * Improvement is indicated as an increase in the score or measurement (e.g. Higher score indicates better quality). 7289 */ 7290 INCREASE, 7291 /** 7292 * Improvement is indicated as a decrease in the score or measurement (e.g. Lower score indicates better quality). 7293 */ 7294 DECREASE, 7295 /** 7296 * added to help the parsers 7297 */ 7298 NULL; 7299 public static MeasureImprovementNotation fromCode(String codeString) throws FHIRException { 7300 if (codeString == null || "".equals(codeString)) 7301 return null; 7302 if ("increase".equals(codeString)) 7303 return INCREASE; 7304 if ("decrease".equals(codeString)) 7305 return DECREASE; 7306 throw new FHIRException("Unknown MeasureImprovementNotation code '"+codeString+"'"); 7307 } 7308 public String toCode() { 7309 switch (this) { 7310 case INCREASE: return "increase"; 7311 case DECREASE: return "decrease"; 7312 default: return "?"; 7313 } 7314 } 7315 public String getSystem() { 7316 switch (this) { 7317 case INCREASE: return "http://terminology.hl7.org/CodeSystem/measure-improvement-notation"; 7318 case DECREASE: return "http://terminology.hl7.org/CodeSystem/measure-improvement-notation"; 7319 default: return "?"; 7320 } 7321 } 7322 public String getDefinition() { 7323 switch (this) { 7324 case INCREASE: return "Improvement is indicated as an increase in the score or measurement (e.g. Higher score indicates better quality)."; 7325 case DECREASE: return "Improvement is indicated as a decrease in the score or measurement (e.g. Lower score indicates better quality)."; 7326 default: return "?"; 7327 } 7328 } 7329 public String getDisplay() { 7330 switch (this) { 7331 case INCREASE: return "Increased score indicates improvement"; 7332 case DECREASE: return "Decreased score indicates improvement"; 7333 default: return "?"; 7334 } 7335 } 7336 } 7337 7338 public static class MeasureImprovementNotationEnumFactory implements EnumFactory<MeasureImprovementNotation> { 7339 public MeasureImprovementNotation fromCode(String codeString) throws IllegalArgumentException { 7340 if (codeString == null || "".equals(codeString)) 7341 if (codeString == null || "".equals(codeString)) 7342 return null; 7343 if ("increase".equals(codeString)) 7344 return MeasureImprovementNotation.INCREASE; 7345 if ("decrease".equals(codeString)) 7346 return MeasureImprovementNotation.DECREASE; 7347 throw new IllegalArgumentException("Unknown MeasureImprovementNotation code '"+codeString+"'"); 7348 } 7349 public Enumeration<MeasureImprovementNotation> fromType(Base code) throws FHIRException { 7350 if (code == null) 7351 return null; 7352 if (code.isEmpty()) 7353 return new Enumeration<MeasureImprovementNotation>(this); 7354 String codeString = ((PrimitiveType) code).asStringValue(); 7355 if (codeString == null || "".equals(codeString)) 7356 return null; 7357 if ("increase".equals(codeString)) 7358 return new Enumeration<MeasureImprovementNotation>(this, MeasureImprovementNotation.INCREASE); 7359 if ("decrease".equals(codeString)) 7360 return new Enumeration<MeasureImprovementNotation>(this, MeasureImprovementNotation.DECREASE); 7361 throw new FHIRException("Unknown MeasureImprovementNotation code '"+codeString+"'"); 7362 } 7363 public String toCode(MeasureImprovementNotation code) { 7364 if (code == MeasureImprovementNotation.INCREASE) 7365 return "increase"; 7366 if (code == MeasureImprovementNotation.DECREASE) 7367 return "decrease"; 7368 return "?"; 7369 } 7370 public String toSystem(MeasureImprovementNotation code) { 7371 return code.getSystem(); 7372 } 7373 } 7374 7375 public enum MimeTypes { 7376 /** 7377 * added to help the parsers 7378 */ 7379 NULL; 7380 public static MimeTypes fromCode(String codeString) throws FHIRException { 7381 if (codeString == null || "".equals(codeString)) 7382 return null; 7383 throw new FHIRException("Unknown MimeTypes code '"+codeString+"'"); 7384 } 7385 public String toCode() { 7386 switch (this) { 7387 default: return "?"; 7388 } 7389 } 7390 public String getSystem() { 7391 switch (this) { 7392 default: return "?"; 7393 } 7394 } 7395 public String getDefinition() { 7396 switch (this) { 7397 default: return "?"; 7398 } 7399 } 7400 public String getDisplay() { 7401 switch (this) { 7402 default: return "?"; 7403 } 7404 } 7405 } 7406 7407 public static class MimeTypesEnumFactory implements EnumFactory<MimeTypes> { 7408 public MimeTypes fromCode(String codeString) throws IllegalArgumentException { 7409 if (codeString == null || "".equals(codeString)) 7410 if (codeString == null || "".equals(codeString)) 7411 return null; 7412 throw new IllegalArgumentException("Unknown MimeTypes code '"+codeString+"'"); 7413 } 7414 public Enumeration<MimeTypes> fromType(Base code) throws FHIRException { 7415 if (code == null) 7416 return null; 7417 if (code.isEmpty()) 7418 return new Enumeration<MimeTypes>(this); 7419 String codeString = ((PrimitiveType) code).asStringValue(); 7420 if (codeString == null || "".equals(codeString)) 7421 return null; 7422 throw new FHIRException("Unknown MimeTypes code '"+codeString+"'"); 7423 } 7424 public String toCode(MimeTypes code) { 7425 return "?"; 7426 } 7427 public String toSystem(MimeTypes code) { 7428 return code.getSystem(); 7429 } 7430 } 7431 7432 public enum NoteType { 7433 /** 7434 * Display the note. 7435 */ 7436 DISPLAY, 7437 /** 7438 * Print the note on the form. 7439 */ 7440 PRINT, 7441 /** 7442 * Print the note for the operator. 7443 */ 7444 PRINTOPER, 7445 /** 7446 * added to help the parsers 7447 */ 7448 NULL; 7449 public static NoteType fromCode(String codeString) throws FHIRException { 7450 if (codeString == null || "".equals(codeString)) 7451 return null; 7452 if ("display".equals(codeString)) 7453 return DISPLAY; 7454 if ("print".equals(codeString)) 7455 return PRINT; 7456 if ("printoper".equals(codeString)) 7457 return PRINTOPER; 7458 throw new FHIRException("Unknown NoteType code '"+codeString+"'"); 7459 } 7460 public String toCode() { 7461 switch (this) { 7462 case DISPLAY: return "display"; 7463 case PRINT: return "print"; 7464 case PRINTOPER: return "printoper"; 7465 default: return "?"; 7466 } 7467 } 7468 public String getSystem() { 7469 switch (this) { 7470 case DISPLAY: return "http://hl7.org/fhir/note-type"; 7471 case PRINT: return "http://hl7.org/fhir/note-type"; 7472 case PRINTOPER: return "http://hl7.org/fhir/note-type"; 7473 default: return "?"; 7474 } 7475 } 7476 public String getDefinition() { 7477 switch (this) { 7478 case DISPLAY: return "Display the note."; 7479 case PRINT: return "Print the note on the form."; 7480 case PRINTOPER: return "Print the note for the operator."; 7481 default: return "?"; 7482 } 7483 } 7484 public String getDisplay() { 7485 switch (this) { 7486 case DISPLAY: return "Display"; 7487 case PRINT: return "Print (Form)"; 7488 case PRINTOPER: return "Print (Operator)"; 7489 default: return "?"; 7490 } 7491 } 7492 } 7493 7494 public static class NoteTypeEnumFactory implements EnumFactory<NoteType> { 7495 public NoteType fromCode(String codeString) throws IllegalArgumentException { 7496 if (codeString == null || "".equals(codeString)) 7497 if (codeString == null || "".equals(codeString)) 7498 return null; 7499 if ("display".equals(codeString)) 7500 return NoteType.DISPLAY; 7501 if ("print".equals(codeString)) 7502 return NoteType.PRINT; 7503 if ("printoper".equals(codeString)) 7504 return NoteType.PRINTOPER; 7505 throw new IllegalArgumentException("Unknown NoteType code '"+codeString+"'"); 7506 } 7507 public Enumeration<NoteType> fromType(Base code) throws FHIRException { 7508 if (code == null) 7509 return null; 7510 if (code.isEmpty()) 7511 return new Enumeration<NoteType>(this); 7512 String codeString = ((PrimitiveType) code).asStringValue(); 7513 if (codeString == null || "".equals(codeString)) 7514 return null; 7515 if ("display".equals(codeString)) 7516 return new Enumeration<NoteType>(this, NoteType.DISPLAY); 7517 if ("print".equals(codeString)) 7518 return new Enumeration<NoteType>(this, NoteType.PRINT); 7519 if ("printoper".equals(codeString)) 7520 return new Enumeration<NoteType>(this, NoteType.PRINTOPER); 7521 throw new FHIRException("Unknown NoteType code '"+codeString+"'"); 7522 } 7523 public String toCode(NoteType code) { 7524 if (code == NoteType.DISPLAY) 7525 return "display"; 7526 if (code == NoteType.PRINT) 7527 return "print"; 7528 if (code == NoteType.PRINTOPER) 7529 return "printoper"; 7530 return "?"; 7531 } 7532 public String toSystem(NoteType code) { 7533 return code.getSystem(); 7534 } 7535 } 7536 7537 public enum ObservationStatus { 7538 /** 7539 * The existence of the observation is registered, but there is no result yet available. 7540 */ 7541 REGISTERED, 7542 /** 7543 * This is an initial or interim observation: data may be incomplete or unverified. 7544 */ 7545 PRELIMINARY, 7546 /** 7547 * The observation is complete and there are no further actions needed. Additional information such "released", "signed", etc would be represented using [Provenance](provenance.html) which provides not only the act but also the actors and dates and other related data. These act states would be associated with an observation status of `preliminary` until they are all completed and then a status of `final` would be applied. 7548 */ 7549 FINAL, 7550 /** 7551 * Subsequent to being Final, the observation has been modified subsequent. This includes updates/new information and corrections. 7552 */ 7553 AMENDED, 7554 /** 7555 * Subsequent to being Final, the observation has been modified to correct an error in the test result. 7556 */ 7557 CORRECTED, 7558 /** 7559 * The observation is unavailable because the measurement was not started or not completed (also sometimes called "aborted"). 7560 */ 7561 CANCELLED, 7562 /** 7563 * The observation has been withdrawn following previous final release. This electronic record should never have existed, though it is possible that real-world decisions were based on it. (If real-world activity has occurred, the status should be "cancelled" rather than "entered-in-error".). 7564 */ 7565 ENTEREDINERROR, 7566 /** 7567 * The authoring/source system does not know which of the status values currently applies for this observation. Note: This concept is not to be used for "other" - one of the listed statuses is presumed to apply, but the authoring/source system does not know which. 7568 */ 7569 UNKNOWN, 7570 /** 7571 * added to help the parsers 7572 */ 7573 NULL; 7574 public static ObservationStatus fromCode(String codeString) throws FHIRException { 7575 if (codeString == null || "".equals(codeString)) 7576 return null; 7577 if ("registered".equals(codeString)) 7578 return REGISTERED; 7579 if ("preliminary".equals(codeString)) 7580 return PRELIMINARY; 7581 if ("final".equals(codeString)) 7582 return FINAL; 7583 if ("amended".equals(codeString)) 7584 return AMENDED; 7585 if ("corrected".equals(codeString)) 7586 return CORRECTED; 7587 if ("cancelled".equals(codeString)) 7588 return CANCELLED; 7589 if ("entered-in-error".equals(codeString)) 7590 return ENTEREDINERROR; 7591 if ("unknown".equals(codeString)) 7592 return UNKNOWN; 7593 throw new FHIRException("Unknown ObservationStatus code '"+codeString+"'"); 7594 } 7595 public String toCode() { 7596 switch (this) { 7597 case REGISTERED: return "registered"; 7598 case PRELIMINARY: return "preliminary"; 7599 case FINAL: return "final"; 7600 case AMENDED: return "amended"; 7601 case CORRECTED: return "corrected"; 7602 case CANCELLED: return "cancelled"; 7603 case ENTEREDINERROR: return "entered-in-error"; 7604 case UNKNOWN: return "unknown"; 7605 default: return "?"; 7606 } 7607 } 7608 public String getSystem() { 7609 switch (this) { 7610 case REGISTERED: return "http://hl7.org/fhir/observation-status"; 7611 case PRELIMINARY: return "http://hl7.org/fhir/observation-status"; 7612 case FINAL: return "http://hl7.org/fhir/observation-status"; 7613 case AMENDED: return "http://hl7.org/fhir/observation-status"; 7614 case CORRECTED: return "http://hl7.org/fhir/observation-status"; 7615 case CANCELLED: return "http://hl7.org/fhir/observation-status"; 7616 case ENTEREDINERROR: return "http://hl7.org/fhir/observation-status"; 7617 case UNKNOWN: return "http://hl7.org/fhir/observation-status"; 7618 default: return "?"; 7619 } 7620 } 7621 public String getDefinition() { 7622 switch (this) { 7623 case REGISTERED: return "The existence of the observation is registered, but there is no result yet available."; 7624 case PRELIMINARY: return "This is an initial or interim observation: data may be incomplete or unverified."; 7625 case FINAL: return "The observation is complete and there are no further actions needed. Additional information such \"released\", \"signed\", etc would be represented using [Provenance](provenance.html) which provides not only the act but also the actors and dates and other related data. These act states would be associated with an observation status of `preliminary` until they are all completed and then a status of `final` would be applied."; 7626 case AMENDED: return "Subsequent to being Final, the observation has been modified subsequent. This includes updates/new information and corrections."; 7627 case CORRECTED: return "Subsequent to being Final, the observation has been modified to correct an error in the test result."; 7628 case CANCELLED: return "The observation is unavailable because the measurement was not started or not completed (also sometimes called \"aborted\")."; 7629 case ENTEREDINERROR: return "The observation has been withdrawn following previous final release. This electronic record should never have existed, though it is possible that real-world decisions were based on it. (If real-world activity has occurred, the status should be \"cancelled\" rather than \"entered-in-error\".)."; 7630 case UNKNOWN: return "The authoring/source system does not know which of the status values currently applies for this observation. Note: This concept is not to be used for \"other\" - one of the listed statuses is presumed to apply, but the authoring/source system does not know which."; 7631 default: return "?"; 7632 } 7633 } 7634 public String getDisplay() { 7635 switch (this) { 7636 case REGISTERED: return "Registered"; 7637 case PRELIMINARY: return "Preliminary"; 7638 case FINAL: return "Final"; 7639 case AMENDED: return "Amended"; 7640 case CORRECTED: return "Corrected"; 7641 case CANCELLED: return "Cancelled"; 7642 case ENTEREDINERROR: return "Entered in Error"; 7643 case UNKNOWN: return "Unknown"; 7644 default: return "?"; 7645 } 7646 } 7647 } 7648 7649 public static class ObservationStatusEnumFactory implements EnumFactory<ObservationStatus> { 7650 public ObservationStatus fromCode(String codeString) throws IllegalArgumentException { 7651 if (codeString == null || "".equals(codeString)) 7652 if (codeString == null || "".equals(codeString)) 7653 return null; 7654 if ("registered".equals(codeString)) 7655 return ObservationStatus.REGISTERED; 7656 if ("preliminary".equals(codeString)) 7657 return ObservationStatus.PRELIMINARY; 7658 if ("final".equals(codeString)) 7659 return ObservationStatus.FINAL; 7660 if ("amended".equals(codeString)) 7661 return ObservationStatus.AMENDED; 7662 if ("corrected".equals(codeString)) 7663 return ObservationStatus.CORRECTED; 7664 if ("cancelled".equals(codeString)) 7665 return ObservationStatus.CANCELLED; 7666 if ("entered-in-error".equals(codeString)) 7667 return ObservationStatus.ENTEREDINERROR; 7668 if ("unknown".equals(codeString)) 7669 return ObservationStatus.UNKNOWN; 7670 throw new IllegalArgumentException("Unknown ObservationStatus code '"+codeString+"'"); 7671 } 7672 public Enumeration<ObservationStatus> fromType(Base code) throws FHIRException { 7673 if (code == null) 7674 return null; 7675 if (code.isEmpty()) 7676 return new Enumeration<ObservationStatus>(this); 7677 String codeString = ((PrimitiveType) code).asStringValue(); 7678 if (codeString == null || "".equals(codeString)) 7679 return null; 7680 if ("registered".equals(codeString)) 7681 return new Enumeration<ObservationStatus>(this, ObservationStatus.REGISTERED); 7682 if ("preliminary".equals(codeString)) 7683 return new Enumeration<ObservationStatus>(this, ObservationStatus.PRELIMINARY); 7684 if ("final".equals(codeString)) 7685 return new Enumeration<ObservationStatus>(this, ObservationStatus.FINAL); 7686 if ("amended".equals(codeString)) 7687 return new Enumeration<ObservationStatus>(this, ObservationStatus.AMENDED); 7688 if ("corrected".equals(codeString)) 7689 return new Enumeration<ObservationStatus>(this, ObservationStatus.CORRECTED); 7690 if ("cancelled".equals(codeString)) 7691 return new Enumeration<ObservationStatus>(this, ObservationStatus.CANCELLED); 7692 if ("entered-in-error".equals(codeString)) 7693 return new Enumeration<ObservationStatus>(this, ObservationStatus.ENTEREDINERROR); 7694 if ("unknown".equals(codeString)) 7695 return new Enumeration<ObservationStatus>(this, ObservationStatus.UNKNOWN); 7696 throw new FHIRException("Unknown ObservationStatus code '"+codeString+"'"); 7697 } 7698 public String toCode(ObservationStatus code) { 7699 if (code == ObservationStatus.REGISTERED) 7700 return "registered"; 7701 if (code == ObservationStatus.PRELIMINARY) 7702 return "preliminary"; 7703 if (code == ObservationStatus.FINAL) 7704 return "final"; 7705 if (code == ObservationStatus.AMENDED) 7706 return "amended"; 7707 if (code == ObservationStatus.CORRECTED) 7708 return "corrected"; 7709 if (code == ObservationStatus.CANCELLED) 7710 return "cancelled"; 7711 if (code == ObservationStatus.ENTEREDINERROR) 7712 return "entered-in-error"; 7713 if (code == ObservationStatus.UNKNOWN) 7714 return "unknown"; 7715 return "?"; 7716 } 7717 public String toSystem(ObservationStatus code) { 7718 return code.getSystem(); 7719 } 7720 } 7721 7722 public enum OperationParameterUse { 7723 /** 7724 * This is an input parameter. 7725 */ 7726 IN, 7727 /** 7728 * This is an output parameter. 7729 */ 7730 OUT, 7731 /** 7732 * added to help the parsers 7733 */ 7734 NULL; 7735 public static OperationParameterUse fromCode(String codeString) throws FHIRException { 7736 if (codeString == null || "".equals(codeString)) 7737 return null; 7738 if ("in".equals(codeString)) 7739 return IN; 7740 if ("out".equals(codeString)) 7741 return OUT; 7742 throw new FHIRException("Unknown OperationParameterUse code '"+codeString+"'"); 7743 } 7744 public String toCode() { 7745 switch (this) { 7746 case IN: return "in"; 7747 case OUT: return "out"; 7748 default: return "?"; 7749 } 7750 } 7751 public String getSystem() { 7752 switch (this) { 7753 case IN: return "http://hl7.org/fhir/operation-parameter-use"; 7754 case OUT: return "http://hl7.org/fhir/operation-parameter-use"; 7755 default: return "?"; 7756 } 7757 } 7758 public String getDefinition() { 7759 switch (this) { 7760 case IN: return "This is an input parameter."; 7761 case OUT: return "This is an output parameter."; 7762 default: return "?"; 7763 } 7764 } 7765 public String getDisplay() { 7766 switch (this) { 7767 case IN: return "In"; 7768 case OUT: return "Out"; 7769 default: return "?"; 7770 } 7771 } 7772 } 7773 7774 public static class OperationParameterUseEnumFactory implements EnumFactory<OperationParameterUse> { 7775 public OperationParameterUse fromCode(String codeString) throws IllegalArgumentException { 7776 if (codeString == null || "".equals(codeString)) 7777 if (codeString == null || "".equals(codeString)) 7778 return null; 7779 if ("in".equals(codeString)) 7780 return OperationParameterUse.IN; 7781 if ("out".equals(codeString)) 7782 return OperationParameterUse.OUT; 7783 throw new IllegalArgumentException("Unknown OperationParameterUse code '"+codeString+"'"); 7784 } 7785 public Enumeration<OperationParameterUse> fromType(Base code) throws FHIRException { 7786 if (code == null) 7787 return null; 7788 if (code.isEmpty()) 7789 return new Enumeration<OperationParameterUse>(this); 7790 String codeString = ((PrimitiveType) code).asStringValue(); 7791 if (codeString == null || "".equals(codeString)) 7792 return null; 7793 if ("in".equals(codeString)) 7794 return new Enumeration<OperationParameterUse>(this, OperationParameterUse.IN); 7795 if ("out".equals(codeString)) 7796 return new Enumeration<OperationParameterUse>(this, OperationParameterUse.OUT); 7797 throw new FHIRException("Unknown OperationParameterUse code '"+codeString+"'"); 7798 } 7799 public String toCode(OperationParameterUse code) { 7800 if (code == OperationParameterUse.IN) 7801 return "in"; 7802 if (code == OperationParameterUse.OUT) 7803 return "out"; 7804 return "?"; 7805 } 7806 public String toSystem(OperationParameterUse code) { 7807 return code.getSystem(); 7808 } 7809 } 7810 7811 public enum ParticipationStatus { 7812 /** 7813 * The participant has accepted the appointment. 7814 */ 7815 ACCEPTED, 7816 /** 7817 * The participant has declined the appointment and will not participate in the appointment. 7818 */ 7819 DECLINED, 7820 /** 7821 * The participant has tentatively accepted the appointment. This could be automatically created by a system and requires further processing before it can be accepted. There is no commitment that attendance will occur. 7822 */ 7823 TENTATIVE, 7824 /** 7825 * The participant needs to indicate if they accept the appointment by changing this status to one of the other statuses. 7826 */ 7827 NEEDSACTION, 7828 /** 7829 * added to help the parsers 7830 */ 7831 NULL; 7832 public static ParticipationStatus fromCode(String codeString) throws FHIRException { 7833 if (codeString == null || "".equals(codeString)) 7834 return null; 7835 if ("accepted".equals(codeString)) 7836 return ACCEPTED; 7837 if ("declined".equals(codeString)) 7838 return DECLINED; 7839 if ("tentative".equals(codeString)) 7840 return TENTATIVE; 7841 if ("needs-action".equals(codeString)) 7842 return NEEDSACTION; 7843 throw new FHIRException("Unknown ParticipationStatus code '"+codeString+"'"); 7844 } 7845 public String toCode() { 7846 switch (this) { 7847 case ACCEPTED: return "accepted"; 7848 case DECLINED: return "declined"; 7849 case TENTATIVE: return "tentative"; 7850 case NEEDSACTION: return "needs-action"; 7851 default: return "?"; 7852 } 7853 } 7854 public String getSystem() { 7855 switch (this) { 7856 case ACCEPTED: return "http://hl7.org/fhir/participationstatus"; 7857 case DECLINED: return "http://hl7.org/fhir/participationstatus"; 7858 case TENTATIVE: return "http://hl7.org/fhir/participationstatus"; 7859 case NEEDSACTION: return "http://hl7.org/fhir/participationstatus"; 7860 default: return "?"; 7861 } 7862 } 7863 public String getDefinition() { 7864 switch (this) { 7865 case ACCEPTED: return "The participant has accepted the appointment."; 7866 case DECLINED: return "The participant has declined the appointment and will not participate in the appointment."; 7867 case TENTATIVE: return "The participant has tentatively accepted the appointment. This could be automatically created by a system and requires further processing before it can be accepted. There is no commitment that attendance will occur."; 7868 case NEEDSACTION: return "The participant needs to indicate if they accept the appointment by changing this status to one of the other statuses."; 7869 default: return "?"; 7870 } 7871 } 7872 public String getDisplay() { 7873 switch (this) { 7874 case ACCEPTED: return "Accepted"; 7875 case DECLINED: return "Declined"; 7876 case TENTATIVE: return "Tentative"; 7877 case NEEDSACTION: return "Needs Action"; 7878 default: return "?"; 7879 } 7880 } 7881 } 7882 7883 public static class ParticipationStatusEnumFactory implements EnumFactory<ParticipationStatus> { 7884 public ParticipationStatus fromCode(String codeString) throws IllegalArgumentException { 7885 if (codeString == null || "".equals(codeString)) 7886 if (codeString == null || "".equals(codeString)) 7887 return null; 7888 if ("accepted".equals(codeString)) 7889 return ParticipationStatus.ACCEPTED; 7890 if ("declined".equals(codeString)) 7891 return ParticipationStatus.DECLINED; 7892 if ("tentative".equals(codeString)) 7893 return ParticipationStatus.TENTATIVE; 7894 if ("needs-action".equals(codeString)) 7895 return ParticipationStatus.NEEDSACTION; 7896 throw new IllegalArgumentException("Unknown ParticipationStatus code '"+codeString+"'"); 7897 } 7898 public Enumeration<ParticipationStatus> fromType(Base code) throws FHIRException { 7899 if (code == null) 7900 return null; 7901 if (code.isEmpty()) 7902 return new Enumeration<ParticipationStatus>(this); 7903 String codeString = ((PrimitiveType) code).asStringValue(); 7904 if (codeString == null || "".equals(codeString)) 7905 return null; 7906 if ("accepted".equals(codeString)) 7907 return new Enumeration<ParticipationStatus>(this, ParticipationStatus.ACCEPTED); 7908 if ("declined".equals(codeString)) 7909 return new Enumeration<ParticipationStatus>(this, ParticipationStatus.DECLINED); 7910 if ("tentative".equals(codeString)) 7911 return new Enumeration<ParticipationStatus>(this, ParticipationStatus.TENTATIVE); 7912 if ("needs-action".equals(codeString)) 7913 return new Enumeration<ParticipationStatus>(this, ParticipationStatus.NEEDSACTION); 7914 throw new FHIRException("Unknown ParticipationStatus code '"+codeString+"'"); 7915 } 7916 public String toCode(ParticipationStatus code) { 7917 if (code == ParticipationStatus.ACCEPTED) 7918 return "accepted"; 7919 if (code == ParticipationStatus.DECLINED) 7920 return "declined"; 7921 if (code == ParticipationStatus.TENTATIVE) 7922 return "tentative"; 7923 if (code == ParticipationStatus.NEEDSACTION) 7924 return "needs-action"; 7925 return "?"; 7926 } 7927 public String toSystem(ParticipationStatus code) { 7928 return code.getSystem(); 7929 } 7930 } 7931 7932 public enum PublicationStatus { 7933 /** 7934 * This resource is still under development and is not yet considered to be ready for normal use. 7935 */ 7936 DRAFT, 7937 /** 7938 * This resource is ready for normal use. 7939 */ 7940 ACTIVE, 7941 /** 7942 * This resource has been withdrawn or superseded and should no longer be used. 7943 */ 7944 RETIRED, 7945 /** 7946 * The authoring system does not know which of the status values currently applies for this resource. Note: This concept is not to be used for "other" - one of the listed statuses is presumed to apply, it's just not known which one. 7947 */ 7948 UNKNOWN, 7949 /** 7950 * added to help the parsers 7951 */ 7952 NULL; 7953 public static PublicationStatus fromCode(String codeString) throws FHIRException { 7954 if (codeString == null || "".equals(codeString)) 7955 return null; 7956 if ("draft".equals(codeString)) 7957 return DRAFT; 7958 if ("active".equals(codeString)) 7959 return ACTIVE; 7960 if ("retired".equals(codeString)) 7961 return RETIRED; 7962 if ("unknown".equals(codeString)) 7963 return UNKNOWN; 7964 throw new FHIRException("Unknown PublicationStatus code '"+codeString+"'"); 7965 } 7966 public String toCode() { 7967 switch (this) { 7968 case DRAFT: return "draft"; 7969 case ACTIVE: return "active"; 7970 case RETIRED: return "retired"; 7971 case UNKNOWN: return "unknown"; 7972 default: return "?"; 7973 } 7974 } 7975 public String getSystem() { 7976 switch (this) { 7977 case DRAFT: return "http://hl7.org/fhir/publication-status"; 7978 case ACTIVE: return "http://hl7.org/fhir/publication-status"; 7979 case RETIRED: return "http://hl7.org/fhir/publication-status"; 7980 case UNKNOWN: return "http://hl7.org/fhir/publication-status"; 7981 default: return "?"; 7982 } 7983 } 7984 public String getDefinition() { 7985 switch (this) { 7986 case DRAFT: return "This resource is still under development and is not yet considered to be ready for normal use."; 7987 case ACTIVE: return "This resource is ready for normal use."; 7988 case RETIRED: return "This resource has been withdrawn or superseded and should no longer be used."; 7989 case UNKNOWN: return "The authoring system does not know which of the status values currently applies for this resource. Note: This concept is not to be used for \"other\" - one of the listed statuses is presumed to apply, it's just not known which one."; 7990 default: return "?"; 7991 } 7992 } 7993 public String getDisplay() { 7994 switch (this) { 7995 case DRAFT: return "Draft"; 7996 case ACTIVE: return "Active"; 7997 case RETIRED: return "Retired"; 7998 case UNKNOWN: return "Unknown"; 7999 default: return "?"; 8000 } 8001 } 8002 } 8003 8004 public static class PublicationStatusEnumFactory implements EnumFactory<PublicationStatus> { 8005 public PublicationStatus fromCode(String codeString) throws IllegalArgumentException { 8006 if (codeString == null || "".equals(codeString)) 8007 if (codeString == null || "".equals(codeString)) 8008 return null; 8009 if ("draft".equals(codeString)) 8010 return PublicationStatus.DRAFT; 8011 if ("active".equals(codeString)) 8012 return PublicationStatus.ACTIVE; 8013 if ("retired".equals(codeString)) 8014 return PublicationStatus.RETIRED; 8015 if ("unknown".equals(codeString)) 8016 return PublicationStatus.UNKNOWN; 8017 throw new IllegalArgumentException("Unknown PublicationStatus code '"+codeString+"'"); 8018 } 8019 public Enumeration<PublicationStatus> fromType(Base code) throws FHIRException { 8020 if (code == null) 8021 return null; 8022 if (code.isEmpty()) 8023 return new Enumeration<PublicationStatus>(this); 8024 String codeString = ((PrimitiveType) code).asStringValue(); 8025 if (codeString == null || "".equals(codeString)) 8026 return null; 8027 if ("draft".equals(codeString)) 8028 return new Enumeration<PublicationStatus>(this, PublicationStatus.DRAFT); 8029 if ("active".equals(codeString)) 8030 return new Enumeration<PublicationStatus>(this, PublicationStatus.ACTIVE); 8031 if ("retired".equals(codeString)) 8032 return new Enumeration<PublicationStatus>(this, PublicationStatus.RETIRED); 8033 if ("unknown".equals(codeString)) 8034 return new Enumeration<PublicationStatus>(this, PublicationStatus.UNKNOWN); 8035 throw new FHIRException("Unknown PublicationStatus code '"+codeString+"'"); 8036 } 8037 public String toCode(PublicationStatus code) { 8038 if (code == PublicationStatus.DRAFT) 8039 return "draft"; 8040 if (code == PublicationStatus.ACTIVE) 8041 return "active"; 8042 if (code == PublicationStatus.RETIRED) 8043 return "retired"; 8044 if (code == PublicationStatus.UNKNOWN) 8045 return "unknown"; 8046 return "?"; 8047 } 8048 public String toSystem(PublicationStatus code) { 8049 return code.getSystem(); 8050 } 8051 } 8052 8053 public enum QuantityComparator { 8054 /** 8055 * The actual value is less than the given value. 8056 */ 8057 LESS_THAN, 8058 /** 8059 * The actual value is less than or equal to the given value. 8060 */ 8061 LESS_OR_EQUAL, 8062 /** 8063 * The actual value is greater than or equal to the given value. 8064 */ 8065 GREATER_OR_EQUAL, 8066 /** 8067 * The actual value is greater than the given value. 8068 */ 8069 GREATER_THAN, 8070 /** 8071 * added to help the parsers 8072 */ 8073 NULL; 8074 public static QuantityComparator fromCode(String codeString) throws FHIRException { 8075 if (codeString == null || "".equals(codeString)) 8076 return null; 8077 if ("<".equals(codeString)) 8078 return LESS_THAN; 8079 if ("<=".equals(codeString)) 8080 return LESS_OR_EQUAL; 8081 if (">=".equals(codeString)) 8082 return GREATER_OR_EQUAL; 8083 if (">".equals(codeString)) 8084 return GREATER_THAN; 8085 throw new FHIRException("Unknown QuantityComparator code '"+codeString+"'"); 8086 } 8087 public String toCode() { 8088 switch (this) { 8089 case LESS_THAN: return "<"; 8090 case LESS_OR_EQUAL: return "<="; 8091 case GREATER_OR_EQUAL: return ">="; 8092 case GREATER_THAN: return ">"; 8093 default: return "?"; 8094 } 8095 } 8096 public String getSystem() { 8097 switch (this) { 8098 case LESS_THAN: return "http://hl7.org/fhir/quantity-comparator"; 8099 case LESS_OR_EQUAL: return "http://hl7.org/fhir/quantity-comparator"; 8100 case GREATER_OR_EQUAL: return "http://hl7.org/fhir/quantity-comparator"; 8101 case GREATER_THAN: return "http://hl7.org/fhir/quantity-comparator"; 8102 default: return "?"; 8103 } 8104 } 8105 public String getDefinition() { 8106 switch (this) { 8107 case LESS_THAN: return "The actual value is less than the given value."; 8108 case LESS_OR_EQUAL: return "The actual value is less than or equal to the given value."; 8109 case GREATER_OR_EQUAL: return "The actual value is greater than or equal to the given value."; 8110 case GREATER_THAN: return "The actual value is greater than the given value."; 8111 default: return "?"; 8112 } 8113 } 8114 public String getDisplay() { 8115 switch (this) { 8116 case LESS_THAN: return "Less than"; 8117 case LESS_OR_EQUAL: return "Less or Equal to"; 8118 case GREATER_OR_EQUAL: return "Greater or Equal to"; 8119 case GREATER_THAN: return "Greater than"; 8120 default: return "?"; 8121 } 8122 } 8123 } 8124 8125 public static class QuantityComparatorEnumFactory implements EnumFactory<QuantityComparator> { 8126 public QuantityComparator fromCode(String codeString) throws IllegalArgumentException { 8127 if (codeString == null || "".equals(codeString)) 8128 if (codeString == null || "".equals(codeString)) 8129 return null; 8130 if ("<".equals(codeString)) 8131 return QuantityComparator.LESS_THAN; 8132 if ("<=".equals(codeString)) 8133 return QuantityComparator.LESS_OR_EQUAL; 8134 if (">=".equals(codeString)) 8135 return QuantityComparator.GREATER_OR_EQUAL; 8136 if (">".equals(codeString)) 8137 return QuantityComparator.GREATER_THAN; 8138 throw new IllegalArgumentException("Unknown QuantityComparator code '"+codeString+"'"); 8139 } 8140 public Enumeration<QuantityComparator> fromType(Base code) throws FHIRException { 8141 if (code == null) 8142 return null; 8143 if (code.isEmpty()) 8144 return new Enumeration<QuantityComparator>(this); 8145 String codeString = ((PrimitiveType) code).asStringValue(); 8146 if (codeString == null || "".equals(codeString)) 8147 return null; 8148 if ("<".equals(codeString)) 8149 return new Enumeration<QuantityComparator>(this, QuantityComparator.LESS_THAN); 8150 if ("<=".equals(codeString)) 8151 return new Enumeration<QuantityComparator>(this, QuantityComparator.LESS_OR_EQUAL); 8152 if (">=".equals(codeString)) 8153 return new Enumeration<QuantityComparator>(this, QuantityComparator.GREATER_OR_EQUAL); 8154 if (">".equals(codeString)) 8155 return new Enumeration<QuantityComparator>(this, QuantityComparator.GREATER_THAN); 8156 throw new FHIRException("Unknown QuantityComparator code '"+codeString+"'"); 8157 } 8158 public String toCode(QuantityComparator code) { 8159 if (code == QuantityComparator.LESS_THAN) 8160 return "<"; 8161 if (code == QuantityComparator.LESS_OR_EQUAL) 8162 return "<="; 8163 if (code == QuantityComparator.GREATER_OR_EQUAL) 8164 return ">="; 8165 if (code == QuantityComparator.GREATER_THAN) 8166 return ">"; 8167 return "?"; 8168 } 8169 public String toSystem(QuantityComparator code) { 8170 return code.getSystem(); 8171 } 8172 } 8173 8174 public enum RequestIntent { 8175 /** 8176 * The request is a suggestion made by someone/something that does not have an intention to ensure it occurs and without providing an authorization to act. 8177 */ 8178 PROPOSAL, 8179 /** 8180 * The request represents an intention to ensure something occurs without providing an authorization for others to act. 8181 */ 8182 PLAN, 8183 /** 8184 * The request represents a legally binding instruction authored by a Patient or RelatedPerson. 8185 */ 8186 DIRECTIVE, 8187 /** 8188 * The request represents a request/demand and authorization for action by a Practitioner. 8189 */ 8190 ORDER, 8191 /** 8192 * The request represents an original authorization for action. 8193 */ 8194 ORIGINALORDER, 8195 /** 8196 * The request represents an automatically generated supplemental authorization for action based on a parent authorization together with initial results of the action taken against that parent authorization. 8197 */ 8198 REFLEXORDER, 8199 /** 8200 * The request represents the view of an authorization instantiated by a fulfilling system representing the details of the fulfiller's intention to act upon a submitted order. 8201 */ 8202 FILLERORDER, 8203 /** 8204 * An order created in fulfillment of a broader order that represents the authorization for a single activity occurrence. E.g. The administration of a single dose of a drug. 8205 */ 8206 INSTANCEORDER, 8207 /** 8208 * The request represents a component or option for a RequestGroup that establishes timing, conditionality and/or other constraints among a set of requests. Refer to [[[RequestGroup]]] for additional information on how this status is used. 8209 */ 8210 OPTION, 8211 /** 8212 * added to help the parsers 8213 */ 8214 NULL; 8215 public static RequestIntent fromCode(String codeString) throws FHIRException { 8216 if (codeString == null || "".equals(codeString)) 8217 return null; 8218 if ("proposal".equals(codeString)) 8219 return PROPOSAL; 8220 if ("plan".equals(codeString)) 8221 return PLAN; 8222 if ("directive".equals(codeString)) 8223 return DIRECTIVE; 8224 if ("order".equals(codeString)) 8225 return ORDER; 8226 if ("original-order".equals(codeString)) 8227 return ORIGINALORDER; 8228 if ("reflex-order".equals(codeString)) 8229 return REFLEXORDER; 8230 if ("filler-order".equals(codeString)) 8231 return FILLERORDER; 8232 if ("instance-order".equals(codeString)) 8233 return INSTANCEORDER; 8234 if ("option".equals(codeString)) 8235 return OPTION; 8236 throw new FHIRException("Unknown RequestIntent code '"+codeString+"'"); 8237 } 8238 public String toCode() { 8239 switch (this) { 8240 case PROPOSAL: return "proposal"; 8241 case PLAN: return "plan"; 8242 case DIRECTIVE: return "directive"; 8243 case ORDER: return "order"; 8244 case ORIGINALORDER: return "original-order"; 8245 case REFLEXORDER: return "reflex-order"; 8246 case FILLERORDER: return "filler-order"; 8247 case INSTANCEORDER: return "instance-order"; 8248 case OPTION: return "option"; 8249 default: return "?"; 8250 } 8251 } 8252 public String getSystem() { 8253 switch (this) { 8254 case PROPOSAL: return "http://hl7.org/fhir/request-intent"; 8255 case PLAN: return "http://hl7.org/fhir/request-intent"; 8256 case DIRECTIVE: return "http://hl7.org/fhir/request-intent"; 8257 case ORDER: return "http://hl7.org/fhir/request-intent"; 8258 case ORIGINALORDER: return "http://hl7.org/fhir/request-intent"; 8259 case REFLEXORDER: return "http://hl7.org/fhir/request-intent"; 8260 case FILLERORDER: return "http://hl7.org/fhir/request-intent"; 8261 case INSTANCEORDER: return "http://hl7.org/fhir/request-intent"; 8262 case OPTION: return "http://hl7.org/fhir/request-intent"; 8263 default: return "?"; 8264 } 8265 } 8266 public String getDefinition() { 8267 switch (this) { 8268 case PROPOSAL: return "The request is a suggestion made by someone/something that does not have an intention to ensure it occurs and without providing an authorization to act."; 8269 case PLAN: return "The request represents an intention to ensure something occurs without providing an authorization for others to act."; 8270 case DIRECTIVE: return "The request represents a legally binding instruction authored by a Patient or RelatedPerson."; 8271 case ORDER: return "The request represents a request/demand and authorization for action by a Practitioner."; 8272 case ORIGINALORDER: return "The request represents an original authorization for action."; 8273 case REFLEXORDER: return "The request represents an automatically generated supplemental authorization for action based on a parent authorization together with initial results of the action taken against that parent authorization."; 8274 case FILLERORDER: return "The request represents the view of an authorization instantiated by a fulfilling system representing the details of the fulfiller's intention to act upon a submitted order."; 8275 case INSTANCEORDER: return "An order created in fulfillment of a broader order that represents the authorization for a single activity occurrence. E.g. The administration of a single dose of a drug."; 8276 case OPTION: return "The request represents a component or option for a RequestGroup that establishes timing, conditionality and/or other constraints among a set of requests. Refer to [[[RequestGroup]]] for additional information on how this status is used."; 8277 default: return "?"; 8278 } 8279 } 8280 public String getDisplay() { 8281 switch (this) { 8282 case PROPOSAL: return "Proposal"; 8283 case PLAN: return "Plan"; 8284 case DIRECTIVE: return "Directive"; 8285 case ORDER: return "Order"; 8286 case ORIGINALORDER: return "Original Order"; 8287 case REFLEXORDER: return "Reflex Order"; 8288 case FILLERORDER: return "Filler Order"; 8289 case INSTANCEORDER: return "Instance Order"; 8290 case OPTION: return "Option"; 8291 default: return "?"; 8292 } 8293 } 8294 } 8295 8296 public static class RequestIntentEnumFactory implements EnumFactory<RequestIntent> { 8297 public RequestIntent fromCode(String codeString) throws IllegalArgumentException { 8298 if (codeString == null || "".equals(codeString)) 8299 if (codeString == null || "".equals(codeString)) 8300 return null; 8301 if ("proposal".equals(codeString)) 8302 return RequestIntent.PROPOSAL; 8303 if ("plan".equals(codeString)) 8304 return RequestIntent.PLAN; 8305 if ("directive".equals(codeString)) 8306 return RequestIntent.DIRECTIVE; 8307 if ("order".equals(codeString)) 8308 return RequestIntent.ORDER; 8309 if ("original-order".equals(codeString)) 8310 return RequestIntent.ORIGINALORDER; 8311 if ("reflex-order".equals(codeString)) 8312 return RequestIntent.REFLEXORDER; 8313 if ("filler-order".equals(codeString)) 8314 return RequestIntent.FILLERORDER; 8315 if ("instance-order".equals(codeString)) 8316 return RequestIntent.INSTANCEORDER; 8317 if ("option".equals(codeString)) 8318 return RequestIntent.OPTION; 8319 throw new IllegalArgumentException("Unknown RequestIntent code '"+codeString+"'"); 8320 } 8321 public Enumeration<RequestIntent> fromType(Base code) throws FHIRException { 8322 if (code == null) 8323 return null; 8324 if (code.isEmpty()) 8325 return new Enumeration<RequestIntent>(this); 8326 String codeString = ((PrimitiveType) code).asStringValue(); 8327 if (codeString == null || "".equals(codeString)) 8328 return null; 8329 if ("proposal".equals(codeString)) 8330 return new Enumeration<RequestIntent>(this, RequestIntent.PROPOSAL); 8331 if ("plan".equals(codeString)) 8332 return new Enumeration<RequestIntent>(this, RequestIntent.PLAN); 8333 if ("directive".equals(codeString)) 8334 return new Enumeration<RequestIntent>(this, RequestIntent.DIRECTIVE); 8335 if ("order".equals(codeString)) 8336 return new Enumeration<RequestIntent>(this, RequestIntent.ORDER); 8337 if ("original-order".equals(codeString)) 8338 return new Enumeration<RequestIntent>(this, RequestIntent.ORIGINALORDER); 8339 if ("reflex-order".equals(codeString)) 8340 return new Enumeration<RequestIntent>(this, RequestIntent.REFLEXORDER); 8341 if ("filler-order".equals(codeString)) 8342 return new Enumeration<RequestIntent>(this, RequestIntent.FILLERORDER); 8343 if ("instance-order".equals(codeString)) 8344 return new Enumeration<RequestIntent>(this, RequestIntent.INSTANCEORDER); 8345 if ("option".equals(codeString)) 8346 return new Enumeration<RequestIntent>(this, RequestIntent.OPTION); 8347 throw new FHIRException("Unknown RequestIntent code '"+codeString+"'"); 8348 } 8349 public String toCode(RequestIntent code) { 8350 if (code == RequestIntent.PROPOSAL) 8351 return "proposal"; 8352 if (code == RequestIntent.PLAN) 8353 return "plan"; 8354 if (code == RequestIntent.DIRECTIVE) 8355 return "directive"; 8356 if (code == RequestIntent.ORDER) 8357 return "order"; 8358 if (code == RequestIntent.ORIGINALORDER) 8359 return "original-order"; 8360 if (code == RequestIntent.REFLEXORDER) 8361 return "reflex-order"; 8362 if (code == RequestIntent.FILLERORDER) 8363 return "filler-order"; 8364 if (code == RequestIntent.INSTANCEORDER) 8365 return "instance-order"; 8366 if (code == RequestIntent.OPTION) 8367 return "option"; 8368 return "?"; 8369 } 8370 public String toSystem(RequestIntent code) { 8371 return code.getSystem(); 8372 } 8373 } 8374 8375 public enum RequestPriority { 8376 /** 8377 * The request has normal priority. 8378 */ 8379 ROUTINE, 8380 /** 8381 * The request should be actioned promptly - higher priority than routine. 8382 */ 8383 URGENT, 8384 /** 8385 * The request should be actioned as soon as possible - higher priority than urgent. 8386 */ 8387 ASAP, 8388 /** 8389 * The request should be actioned immediately - highest possible priority. E.g. an emergency. 8390 */ 8391 STAT, 8392 /** 8393 * added to help the parsers 8394 */ 8395 NULL; 8396 public static RequestPriority fromCode(String codeString) throws FHIRException { 8397 if (codeString == null || "".equals(codeString)) 8398 return null; 8399 if ("routine".equals(codeString)) 8400 return ROUTINE; 8401 if ("urgent".equals(codeString)) 8402 return URGENT; 8403 if ("asap".equals(codeString)) 8404 return ASAP; 8405 if ("stat".equals(codeString)) 8406 return STAT; 8407 throw new FHIRException("Unknown RequestPriority code '"+codeString+"'"); 8408 } 8409 public String toCode() { 8410 switch (this) { 8411 case ROUTINE: return "routine"; 8412 case URGENT: return "urgent"; 8413 case ASAP: return "asap"; 8414 case STAT: return "stat"; 8415 default: return "?"; 8416 } 8417 } 8418 public String getSystem() { 8419 switch (this) { 8420 case ROUTINE: return "http://hl7.org/fhir/request-priority"; 8421 case URGENT: return "http://hl7.org/fhir/request-priority"; 8422 case ASAP: return "http://hl7.org/fhir/request-priority"; 8423 case STAT: return "http://hl7.org/fhir/request-priority"; 8424 default: return "?"; 8425 } 8426 } 8427 public String getDefinition() { 8428 switch (this) { 8429 case ROUTINE: return "The request has normal priority."; 8430 case URGENT: return "The request should be actioned promptly - higher priority than routine."; 8431 case ASAP: return "The request should be actioned as soon as possible - higher priority than urgent."; 8432 case STAT: return "The request should be actioned immediately - highest possible priority. E.g. an emergency."; 8433 default: return "?"; 8434 } 8435 } 8436 public String getDisplay() { 8437 switch (this) { 8438 case ROUTINE: return "Routine"; 8439 case URGENT: return "Urgent"; 8440 case ASAP: return "ASAP"; 8441 case STAT: return "STAT"; 8442 default: return "?"; 8443 } 8444 } 8445 } 8446 8447 public static class RequestPriorityEnumFactory implements EnumFactory<RequestPriority> { 8448 public RequestPriority fromCode(String codeString) throws IllegalArgumentException { 8449 if (codeString == null || "".equals(codeString)) 8450 if (codeString == null || "".equals(codeString)) 8451 return null; 8452 if ("routine".equals(codeString)) 8453 return RequestPriority.ROUTINE; 8454 if ("urgent".equals(codeString)) 8455 return RequestPriority.URGENT; 8456 if ("asap".equals(codeString)) 8457 return RequestPriority.ASAP; 8458 if ("stat".equals(codeString)) 8459 return RequestPriority.STAT; 8460 throw new IllegalArgumentException("Unknown RequestPriority code '"+codeString+"'"); 8461 } 8462 public Enumeration<RequestPriority> fromType(Base code) throws FHIRException { 8463 if (code == null) 8464 return null; 8465 if (code.isEmpty()) 8466 return new Enumeration<RequestPriority>(this); 8467 String codeString = ((PrimitiveType) code).asStringValue(); 8468 if (codeString == null || "".equals(codeString)) 8469 return null; 8470 if ("routine".equals(codeString)) 8471 return new Enumeration<RequestPriority>(this, RequestPriority.ROUTINE); 8472 if ("urgent".equals(codeString)) 8473 return new Enumeration<RequestPriority>(this, RequestPriority.URGENT); 8474 if ("asap".equals(codeString)) 8475 return new Enumeration<RequestPriority>(this, RequestPriority.ASAP); 8476 if ("stat".equals(codeString)) 8477 return new Enumeration<RequestPriority>(this, RequestPriority.STAT); 8478 throw new FHIRException("Unknown RequestPriority code '"+codeString+"'"); 8479 } 8480 public String toCode(RequestPriority code) { 8481 if (code == RequestPriority.ROUTINE) 8482 return "routine"; 8483 if (code == RequestPriority.URGENT) 8484 return "urgent"; 8485 if (code == RequestPriority.ASAP) 8486 return "asap"; 8487 if (code == RequestPriority.STAT) 8488 return "stat"; 8489 return "?"; 8490 } 8491 public String toSystem(RequestPriority code) { 8492 return code.getSystem(); 8493 } 8494 } 8495 8496 public enum RequestStatus { 8497 /** 8498 * The request has been created but is not yet complete or ready for action. 8499 */ 8500 DRAFT, 8501 /** 8502 * The request is in force and ready to be acted upon. 8503 */ 8504 ACTIVE, 8505 /** 8506 * The request (and any implicit authorization to act) has been temporarily withdrawn but is expected to resume in the future. 8507 */ 8508 ONHOLD, 8509 /** 8510 * The request (and any implicit authorization to act) has been terminated prior to the known full completion of the intended actions. No further activity should occur. 8511 */ 8512 REVOKED, 8513 /** 8514 * The activity described by the request has been fully performed. No further activity will occur. 8515 */ 8516 COMPLETED, 8517 /** 8518 * This request should never have existed and should be considered 'void'. (It is possible that real-world decisions were based on it. If real-world activity has occurred, the status should be "revoked" rather than "entered-in-error".). 8519 */ 8520 ENTEREDINERROR, 8521 /** 8522 * The authoring/source system does not know which of the status values currently applies for this request. Note: This concept is not to be used for "other" - one of the listed statuses is presumed to apply, but the authoring/source system does not know which. 8523 */ 8524 UNKNOWN, 8525 /** 8526 * added to help the parsers 8527 */ 8528 NULL; 8529 public static RequestStatus fromCode(String codeString) throws FHIRException { 8530 if (codeString == null || "".equals(codeString)) 8531 return null; 8532 if ("draft".equals(codeString)) 8533 return DRAFT; 8534 if ("active".equals(codeString)) 8535 return ACTIVE; 8536 if ("on-hold".equals(codeString)) 8537 return ONHOLD; 8538 if ("revoked".equals(codeString)) 8539 return REVOKED; 8540 if ("completed".equals(codeString)) 8541 return COMPLETED; 8542 if ("entered-in-error".equals(codeString)) 8543 return ENTEREDINERROR; 8544 if ("unknown".equals(codeString)) 8545 return UNKNOWN; 8546 throw new FHIRException("Unknown RequestStatus code '"+codeString+"'"); 8547 } 8548 public String toCode() { 8549 switch (this) { 8550 case DRAFT: return "draft"; 8551 case ACTIVE: return "active"; 8552 case ONHOLD: return "on-hold"; 8553 case REVOKED: return "revoked"; 8554 case COMPLETED: return "completed"; 8555 case ENTEREDINERROR: return "entered-in-error"; 8556 case UNKNOWN: return "unknown"; 8557 default: return "?"; 8558 } 8559 } 8560 public String getSystem() { 8561 switch (this) { 8562 case DRAFT: return "http://hl7.org/fhir/request-status"; 8563 case ACTIVE: return "http://hl7.org/fhir/request-status"; 8564 case ONHOLD: return "http://hl7.org/fhir/request-status"; 8565 case REVOKED: return "http://hl7.org/fhir/request-status"; 8566 case COMPLETED: return "http://hl7.org/fhir/request-status"; 8567 case ENTEREDINERROR: return "http://hl7.org/fhir/request-status"; 8568 case UNKNOWN: return "http://hl7.org/fhir/request-status"; 8569 default: return "?"; 8570 } 8571 } 8572 public String getDefinition() { 8573 switch (this) { 8574 case DRAFT: return "The request has been created but is not yet complete or ready for action."; 8575 case ACTIVE: return "The request is in force and ready to be acted upon."; 8576 case ONHOLD: return "The request (and any implicit authorization to act) has been temporarily withdrawn but is expected to resume in the future."; 8577 case REVOKED: return "The request (and any implicit authorization to act) has been terminated prior to the known full completion of the intended actions. No further activity should occur."; 8578 case COMPLETED: return "The activity described by the request has been fully performed. No further activity will occur."; 8579 case ENTEREDINERROR: return "This request should never have existed and should be considered 'void'. (It is possible that real-world decisions were based on it. If real-world activity has occurred, the status should be \"revoked\" rather than \"entered-in-error\".)."; 8580 case UNKNOWN: return "The authoring/source system does not know which of the status values currently applies for this request. Note: This concept is not to be used for \"other\" - one of the listed statuses is presumed to apply, but the authoring/source system does not know which."; 8581 default: return "?"; 8582 } 8583 } 8584 public String getDisplay() { 8585 switch (this) { 8586 case DRAFT: return "Draft"; 8587 case ACTIVE: return "Active"; 8588 case ONHOLD: return "On Hold"; 8589 case REVOKED: return "Revoked"; 8590 case COMPLETED: return "Completed"; 8591 case ENTEREDINERROR: return "Entered in Error"; 8592 case UNKNOWN: return "Unknown"; 8593 default: return "?"; 8594 } 8595 } 8596 } 8597 8598 public static class RequestStatusEnumFactory implements EnumFactory<RequestStatus> { 8599 public RequestStatus fromCode(String codeString) throws IllegalArgumentException { 8600 if (codeString == null || "".equals(codeString)) 8601 if (codeString == null || "".equals(codeString)) 8602 return null; 8603 if ("draft".equals(codeString)) 8604 return RequestStatus.DRAFT; 8605 if ("active".equals(codeString)) 8606 return RequestStatus.ACTIVE; 8607 if ("on-hold".equals(codeString)) 8608 return RequestStatus.ONHOLD; 8609 if ("revoked".equals(codeString)) 8610 return RequestStatus.REVOKED; 8611 if ("completed".equals(codeString)) 8612 return RequestStatus.COMPLETED; 8613 if ("entered-in-error".equals(codeString)) 8614 return RequestStatus.ENTEREDINERROR; 8615 if ("unknown".equals(codeString)) 8616 return RequestStatus.UNKNOWN; 8617 throw new IllegalArgumentException("Unknown RequestStatus code '"+codeString+"'"); 8618 } 8619 public Enumeration<RequestStatus> fromType(Base code) throws FHIRException { 8620 if (code == null) 8621 return null; 8622 if (code.isEmpty()) 8623 return new Enumeration<RequestStatus>(this); 8624 String codeString = ((PrimitiveType) code).asStringValue(); 8625 if (codeString == null || "".equals(codeString)) 8626 return null; 8627 if ("draft".equals(codeString)) 8628 return new Enumeration<RequestStatus>(this, RequestStatus.DRAFT); 8629 if ("active".equals(codeString)) 8630 return new Enumeration<RequestStatus>(this, RequestStatus.ACTIVE); 8631 if ("on-hold".equals(codeString)) 8632 return new Enumeration<RequestStatus>(this, RequestStatus.ONHOLD); 8633 if ("revoked".equals(codeString)) 8634 return new Enumeration<RequestStatus>(this, RequestStatus.REVOKED); 8635 if ("completed".equals(codeString)) 8636 return new Enumeration<RequestStatus>(this, RequestStatus.COMPLETED); 8637 if ("entered-in-error".equals(codeString)) 8638 return new Enumeration<RequestStatus>(this, RequestStatus.ENTEREDINERROR); 8639 if ("unknown".equals(codeString)) 8640 return new Enumeration<RequestStatus>(this, RequestStatus.UNKNOWN); 8641 throw new FHIRException("Unknown RequestStatus code '"+codeString+"'"); 8642 } 8643 public String toCode(RequestStatus code) { 8644 if (code == RequestStatus.DRAFT) 8645 return "draft"; 8646 if (code == RequestStatus.ACTIVE) 8647 return "active"; 8648 if (code == RequestStatus.ONHOLD) 8649 return "on-hold"; 8650 if (code == RequestStatus.REVOKED) 8651 return "revoked"; 8652 if (code == RequestStatus.COMPLETED) 8653 return "completed"; 8654 if (code == RequestStatus.ENTEREDINERROR) 8655 return "entered-in-error"; 8656 if (code == RequestStatus.UNKNOWN) 8657 return "unknown"; 8658 return "?"; 8659 } 8660 public String toSystem(RequestStatus code) { 8661 return code.getSystem(); 8662 } 8663 } 8664 8665 public enum ResourceTypeEnum { 8666 /** 8667 * A financial tool for tracking value accrued for a particular purpose. In the healthcare field, used to track charges for a patient, cost centers, etc. 8668 */ 8669 ACCOUNT, 8670 /** 8671 * This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context. 8672 */ 8673 ACTIVITYDEFINITION, 8674 /** 8675 * A pharmaceutical product described in terms of its composition and dose form. 8676 */ 8677 ADMINISTRABLEPRODUCTDEFINITION, 8678 /** 8679 * An event (i.e. any change to current patient status) that may be related to unintended effects on a patient or research subject. The unintended effects may require additional monitoring, treatment or hospitalization or may result in death. The AdverseEvent resource also extends to potential or avoided events that could have had such effects. 8680 */ 8681 ADVERSEEVENT, 8682 /** 8683 * Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance. 8684 */ 8685 ALLERGYINTOLERANCE, 8686 /** 8687 * A booking of a healthcare event among patient(s), practitioner(s), related person(s) and/or device(s) for a specific date/time. This may result in one or more Encounter(s). 8688 */ 8689 APPOINTMENT, 8690 /** 8691 * A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection. 8692 */ 8693 APPOINTMENTRESPONSE, 8694 /** 8695 * A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis. 8696 */ 8697 AUDITEVENT, 8698 /** 8699 * Basic is used for handling concepts not yet defined in FHIR, narrative-only resources that don't map to an existing resource, and custom resources not appropriate for inclusion in the FHIR specification. 8700 */ 8701 BASIC, 8702 /** 8703 * A resource that represents the data of a single raw artifact as digital content accessible in its native format. A Binary resource can contain any content, whether text, image, pdf, zip archive, etc. 8704 */ 8705 BINARY, 8706 /** 8707 * A material substance originating from a biological entity intended to be transplanted or infused 8708into another (possibly the same) biological entity. 8709 */ 8710 BIOLOGICALLYDERIVEDPRODUCT, 8711 /** 8712 * Record details about an anatomical structure. This resource may be used when a coded concept does not provide the necessary detail needed for the use case. 8713 */ 8714 BODYSTRUCTURE, 8715 /** 8716 * A container for a collection of resources. 8717 */ 8718 BUNDLE, 8719 /** 8720 * A Capability Statement documents a set of capabilities (behaviors) of a FHIR Server for a particular version of FHIR that may be used as a statement of actual server functionality or a statement of required or desired server implementation. 8721 */ 8722 CAPABILITYSTATEMENT, 8723 /** 8724 * A Capability Statement documents a set of capabilities (behaviors) of a FHIR Server for a particular version of FHIR that may be used as a statement of actual server functionality or a statement of required or desired server implementation. 8725 */ 8726 CAPABILITYSTATEMENT2, 8727 /** 8728 * Describes the intention of how one or more practitioners intend to deliver care for a particular patient, group or community for a period of time, possibly limited to care for a specific condition or set of conditions. 8729 */ 8730 CAREPLAN, 8731 /** 8732 * The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care. 8733 */ 8734 CARETEAM, 8735 /** 8736 * Catalog entries are wrappers that contextualize items included in a catalog. 8737 */ 8738 CATALOGENTRY, 8739 /** 8740 * The resource ChargeItem describes the provision of healthcare provider products for a certain patient, therefore referring not only to the product, but containing in addition details of the provision, like date, time, amounts and participating organizations and persons. Main Usage of the ChargeItem is to enable the billing process and internal cost allocation. 8741 */ 8742 CHARGEITEM, 8743 /** 8744 * The ChargeItemDefinition resource provides the properties that apply to the (billing) codes necessary to calculate costs and prices. The properties may differ largely depending on type and realm, therefore this resource gives only a rough structure and requires profiling for each type of billing code system. 8745 */ 8746 CHARGEITEMDEFINITION, 8747 /** 8748 * A provider issued list of professional services and products which have been provided, or are to be provided, to a patient which is sent to an insurer for reimbursement. 8749 */ 8750 CLAIM, 8751 /** 8752 * This resource provides the adjudication details from the processing of a Claim resource. 8753 */ 8754 CLAIMRESPONSE, 8755 /** 8756 * A record of a clinical assessment performed to determine what problem(s) may affect the patient and before planning the treatments or management strategies that are best to manage a patient's condition. Assessments are often 1:1 with a clinical consultation / encounter, but this varies greatly depending on the clinical workflow. This resource is called "ClinicalImpression" rather than "ClinicalAssessment" to avoid confusion with the recording of assessment tools such as Apgar score. 8757 */ 8758 CLINICALIMPRESSION, 8759 /** 8760 * A single usage issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure. 8761 */ 8762 CLINICALUSEISSUE, 8763 /** 8764 * The CodeSystem resource is used to declare the existence of and describe a code system or code system supplement and its key properties, and optionally define a part or all of its content. 8765 */ 8766 CODESYSTEM, 8767 /** 8768 * An occurrence of information being transmitted; e.g. an alert that was sent to a responsible provider, a public health agency communication to a provider/reporter in response to a case report for a reportable condition. 8769 */ 8770 COMMUNICATION, 8771 /** 8772 * A request to convey information; e.g. the CDS system proposes that an alert be sent to a responsible provider, the CDS system proposes that the public health agency be notified about a reportable condition. 8773 */ 8774 COMMUNICATIONREQUEST, 8775 /** 8776 * A compartment definition that defines how resources are accessed on a server. 8777 */ 8778 COMPARTMENTDEFINITION, 8779 /** 8780 * A set of healthcare-related information that is assembled together into a single logical package that provides a single coherent statement of meaning, establishes its own context and that has clinical attestation with regard to who is making the statement. A Composition defines the structure and narrative content necessary for a document. However, a Composition alone does not constitute a document. Rather, the Composition must be the first entry in a Bundle where Bundle.type=document, and any other resources referenced from Composition must be included as subsequent entries in the Bundle (for example Patient, Practitioner, Encounter, etc.). 8781 */ 8782 COMPOSITION, 8783 /** 8784 * A statement of relationships from one set of concepts to one or more other concepts - either concepts in code systems, or data element/data element concepts, or classes in class models. 8785 */ 8786 CONCEPTMAP, 8787 /** 8788 * A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern. 8789 */ 8790 CONDITION, 8791 /** 8792 * A definition of a condition and information relevant to managing it. 8793 */ 8794 CONDITIONDEFINITION, 8795 /** 8796 * A record of a healthcare consumer’s choices or choices made on their behalf by a third party, which permits or denies identified recipient(s) or recipient role(s) to perform one or more actions within a given policy context, for specific purposes and periods of time. 8797 */ 8798 CONSENT, 8799 /** 8800 * Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement. 8801 */ 8802 CONTRACT, 8803 /** 8804 * Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment. 8805 */ 8806 COVERAGE, 8807 /** 8808 * The CoverageEligibilityRequest provides patient and insurance coverage information to an insurer for them to respond, in the form of an CoverageEligibilityResponse, with information regarding whether the stated coverage is valid and in-force and optionally to provide the insurance details of the policy. 8809 */ 8810 COVERAGEELIGIBILITYREQUEST, 8811 /** 8812 * This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource. 8813 */ 8814 COVERAGEELIGIBILITYRESPONSE, 8815 /** 8816 * Indicates an actual or potential clinical issue with or between one or more active or proposed clinical actions for a patient; e.g. Drug-drug interaction, Ineffective treatment frequency, Procedure-condition conflict, etc. 8817 */ 8818 DETECTEDISSUE, 8819 /** 8820 * A type of a manufactured item that is used in the provision of healthcare without being substantially changed through that activity. The device may be a medical or non-medical device. 8821 */ 8822 DEVICE, 8823 /** 8824 * The characteristics, operational status and capabilities of a medical-related component of a medical device. 8825 */ 8826 DEVICEDEFINITION, 8827 /** 8828 * Describes a measurement, calculation or setting capability of a medical device. 8829 */ 8830 DEVICEMETRIC, 8831 /** 8832 * Represents a request for a patient to employ a medical device. The device may be an implantable device, or an external assistive device, such as a walker. 8833 */ 8834 DEVICEREQUEST, 8835 /** 8836 * A record of a device being used by a patient where the record is the result of a report from the patient or another clinician. 8837 */ 8838 DEVICEUSESTATEMENT, 8839 /** 8840 * The findings and interpretation of diagnostic tests performed on patients, groups of patients, devices, and locations, and/or specimens derived from these. The report includes clinical context such as requesting and provider information, and some mix of atomic results, images, textual and coded interpretations, and formatted representation of diagnostic reports. 8841 */ 8842 DIAGNOSTICREPORT, 8843 /** 8844 * A collection of documents compiled for a purpose together with metadata that applies to the collection. 8845 */ 8846 DOCUMENTMANIFEST, 8847 /** 8848 * A reference to a document of any kind for any purpose. While the term “document” implies a more narrow focus, for this resource this "document" encompasses *any* serialized object with a mime-type, it includes formal patient-centric documents (CDA), clinical notes, scanned paper, non-patient specific documents like policy text, as well as a photo, video, or audio recording acquired or used in healthcare. The DocumentReference resource provides metadata about the document so that the document can be discovered and managed. The actual content may be inline base64 encoded data or provided by direct reference. 8849 */ 8850 DOCUMENTREFERENCE, 8851 /** 8852 * A resource that includes narrative, extensions, and contained resources. 8853 */ 8854 DOMAINRESOURCE, 8855 /** 8856 * An interaction between a patient and healthcare provider(s) for the purpose of providing healthcare service(s) or assessing the health status of a patient. 8857 */ 8858 ENCOUNTER, 8859 /** 8860 * The technical details of an endpoint that can be used for electronic services, such as for web services providing XDS.b or a REST endpoint for another FHIR server. This may include any security context information. 8861 */ 8862 ENDPOINT, 8863 /** 8864 * This resource provides the insurance enrollment details to the insurer regarding a specified coverage. 8865 */ 8866 ENROLLMENTREQUEST, 8867 /** 8868 * This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource. 8869 */ 8870 ENROLLMENTRESPONSE, 8871 /** 8872 * An association between a patient and an organization / healthcare provider(s) during which time encounters may occur. The managing organization assumes a level of responsibility for the patient during this time. 8873 */ 8874 EPISODEOFCARE, 8875 /** 8876 * The EventDefinition resource provides a reusable description of when a particular event can occur. 8877 */ 8878 EVENTDEFINITION, 8879 /** 8880 * This represents statistics, certainty, both the intended and actual population, and evidence variables. 8881 */ 8882 EVIDENCE, 8883 /** 8884 * The EvidenceVariable resource describes a "PICO" element that knowledge (evidence, assertion, recommendation) is about. 8885 */ 8886 EVIDENCEVARIABLE, 8887 /** 8888 * Example of workflow instance. 8889 */ 8890 EXAMPLESCENARIO, 8891 /** 8892 * This resource provides: the claim details; adjudication details from the processing of a Claim; and optionally account balance information, for informing the subscriber of the benefits provided. 8893 */ 8894 EXPLANATIONOFBENEFIT, 8895 /** 8896 * Significant health conditions for a person related to the patient relevant in the context of care for the patient. 8897 */ 8898 FAMILYMEMBERHISTORY, 8899 /** 8900 * Prospective warnings of potential issues when providing care to the patient. 8901 */ 8902 FLAG, 8903 /** 8904 * Describes the intended objective(s) for a patient, group or organization care, for example, weight loss, restoring an activity of daily living, obtaining herd immunity via immunization, meeting a process improvement objective, etc. 8905 */ 8906 GOAL, 8907 /** 8908 * A formal computable definition of a graph of resources - that is, a coherent set of resources that form a graph by following references. The Graph Definition resource defines a set and makes rules about the set. 8909 */ 8910 GRAPHDEFINITION, 8911 /** 8912 * Represents a defined collection of entities that may be discussed or acted upon collectively but which are not expected to act collectively, and are not formally or legally recognized; i.e. a collection of entities that isn't an Organization. 8913 */ 8914 GROUP, 8915 /** 8916 * A guidance response is the formal response to a guidance request, including any output parameters returned by the evaluation, as well as the description of any proposed actions to be taken. 8917 */ 8918 GUIDANCERESPONSE, 8919 /** 8920 * The details of a healthcare service available at a location. 8921 */ 8922 HEALTHCARESERVICE, 8923 /** 8924 * Representation of the content produced in a DICOM imaging study. A study comprises a set of series, each of which includes a set of Service-Object Pair Instances (SOP Instances - images or other data) acquired or produced in a common context. A series is of only one modality (e.g. X-ray, CT, MR, ultrasound), but a study may have multiple series of different modalities. 8925 */ 8926 IMAGINGSTUDY, 8927 /** 8928 * Describes the event of a patient being administered a vaccine or a record of an immunization as reported by a patient, a clinician or another party. 8929 */ 8930 IMMUNIZATION, 8931 /** 8932 * Describes a comparison of an immunization event against published recommendations to determine if the administration is "valid" in relation to those recommendations. 8933 */ 8934 IMMUNIZATIONEVALUATION, 8935 /** 8936 * A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification. 8937 */ 8938 IMMUNIZATIONRECOMMENDATION, 8939 /** 8940 * A set of rules of how a particular interoperability or standards problem is solved - typically through the use of FHIR resources. This resource is used to gather all the parts of an implementation guide into a logical whole and to publish a computable definition of all the parts. 8941 */ 8942 IMPLEMENTATIONGUIDE, 8943 /** 8944 * An ingredient of a manufactured item or pharmaceutical product. 8945 */ 8946 INGREDIENT, 8947 /** 8948 * Details of a Health Insurance product/plan provided by an organization. 8949 */ 8950 INSURANCEPLAN, 8951 /** 8952 * Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose. 8953 */ 8954 INVOICE, 8955 /** 8956 * The Library resource is a general-purpose container for knowledge asset definitions. It can be used to describe and expose existing knowledge assets such as logic libraries and information model descriptions, as well as to describe a collection of knowledge assets. 8957 */ 8958 LIBRARY, 8959 /** 8960 * Identifies two or more records (resource instances) that refer to the same real-world "occurrence". 8961 */ 8962 LINKAGE, 8963 /** 8964 * A list is a curated collection of resources. 8965 */ 8966 LIST, 8967 /** 8968 * Details and position information for a physical place where services are provided and resources and participants may be stored, found, contained, or accommodated. 8969 */ 8970 LOCATION, 8971 /** 8972 * The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product. 8973 */ 8974 MANUFACTUREDITEMDEFINITION, 8975 /** 8976 * The Measure resource provides the definition of a quality measure. 8977 */ 8978 MEASURE, 8979 /** 8980 * The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation. 8981 */ 8982 MEASUREREPORT, 8983 /** 8984 * This resource is primarily used for the identification and definition of a medication for the purposes of prescribing, dispensing, and administering a medication as well as for making statements about medication use. 8985 */ 8986 MEDICATION, 8987 /** 8988 * Describes the event of a patient consuming or otherwise being administered a medication. This may be as simple as swallowing a tablet or it may be a long running infusion. Related resources tie this event to the authorizing prescription, and the specific encounter between patient and health care practitioner. 8989 */ 8990 MEDICATIONADMINISTRATION, 8991 /** 8992 * Indicates that a medication product is to be or has been dispensed for a named person/patient. This includes a description of the medication product (supply) provided and the instructions for administering the medication. The medication dispense is the result of a pharmacy system responding to a medication order. 8993 */ 8994 MEDICATIONDISPENSE, 8995 /** 8996 * Information about a medication that is used to support knowledge. 8997 */ 8998 MEDICATIONKNOWLEDGE, 8999 /** 9000 * An order or request for both supply of the medication and the instructions for administration of the medication to a patient. The resource is called "MedicationRequest" rather than "MedicationPrescription" or "MedicationOrder" to generalize the use across inpatient and outpatient settings, including care plans, etc., and to harmonize with workflow patterns. 9001 */ 9002 MEDICATIONREQUEST, 9003 /** 9004 * A record of a medication that is being consumed by a patient. A MedicationUsage may indicate that the patient may be taking the medication now or has taken the medication in the past or will be taking the medication in the future. The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician. A common scenario where this information is captured is during the history taking process during a patient visit or stay. The medication information may come from sources such as the patient's memory, from a prescription bottle, or from a list of medications the patient, clinician or other party maintains. 9005 9006The primary difference between a medicationusage and a medicationadministration is that the medication administration has complete administration information and is based on actual administration information from the person who administered the medication. A medicationusage is often, if not always, less specific. There is no required date/time when the medication was administered, in fact we only know that a source has reported the patient is taking this medication, where details such as time, quantity, or rate or even medication product may be incomplete or missing or less precise. As stated earlier, the Medication Usage information may come from the patient's memory, from a prescription bottle or from a list of medications the patient, clinician or other party maintains. Medication administration is more formal and is not missing detailed information. 9007 */ 9008 MEDICATIONUSAGE, 9009 /** 9010 * Detailed definition of a medicinal product, typically for uses other than direct patient care (e.g. regulatory use). 9011 */ 9012 MEDICINALPRODUCTDEFINITION, 9013 /** 9014 * Defines the characteristics of a message that can be shared between systems, including the type of event that initiates the message, the content to be transmitted and what response(s), if any, are permitted. 9015 */ 9016 MESSAGEDEFINITION, 9017 /** 9018 * The header for a message exchange that is either requesting or responding to an action. The reference(s) that are the subject of the action as well as other information related to the action are typically transmitted in a bundle in which the MessageHeader resource instance is the first resource in the bundle. 9019 */ 9020 MESSAGEHEADER, 9021 /** 9022 * Raw data describing a biological sequence. 9023 */ 9024 MOLECULARSEQUENCE, 9025 /** 9026 * A curated namespace that issues unique symbols within that namespace for the identification of concepts, people, devices, etc. Represents a "System" used within the Identifier and Coding data types. 9027 */ 9028 NAMINGSYSTEM, 9029 /** 9030 * A record of food or fluid that is being consumed by a patient. A NutritionIntake may indicate that the patient may be consuming the food or fluid now or has consumed the food or fluid in the past. The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician. A common scenario where this information is captured is during the history taking process during a patient visit or stay or through an app that tracks food or fluids consumed. The consumption information may come from sources such as the patient's memory, from a nutrition label, or from a clinician documenting observed intake. 9031 */ 9032 NUTRITIONINTAKE, 9033 /** 9034 * A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident. 9035 */ 9036 NUTRITIONORDER, 9037 /** 9038 * Measurements and simple assertions made about a patient, device or other subject. 9039 */ 9040 OBSERVATION, 9041 /** 9042 * Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service. 9043 */ 9044 OBSERVATIONDEFINITION, 9045 /** 9046 * A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction). 9047 */ 9048 OPERATIONDEFINITION, 9049 /** 9050 * A collection of error, warning, or information messages that result from a system action. 9051 */ 9052 OPERATIONOUTCOME, 9053 /** 9054 * A formally or informally recognized grouping of people or organizations formed for the purpose of achieving some form of collective action. Includes companies, institutions, corporations, departments, community groups, healthcare practice groups, payer/insurer, etc. 9055 */ 9056 ORGANIZATION, 9057 /** 9058 * Defines an affiliation/assotiation/relationship between 2 distinct oganizations, that is not a part-of relationship/sub-division relationship. 9059 */ 9060 ORGANIZATIONAFFILIATION, 9061 /** 9062 * A medicinal product in a container or package. 9063 */ 9064 PACKAGEDPRODUCTDEFINITION, 9065 /** 9066 * This resource is a non-persisted resource used to pass information into and back from an [operation](operations.html). It has no other use, and there is no RESTful endpoint associated with it. 9067 */ 9068 PARAMETERS, 9069 /** 9070 * Demographics and other administrative information about an individual or animal receiving care or other health-related services. 9071 */ 9072 PATIENT, 9073 /** 9074 * This resource provides the status of the payment for goods and services rendered, and the request and response resource references. 9075 */ 9076 PAYMENTNOTICE, 9077 /** 9078 * This resource provides the details including amount of a payment and allocates the payment items being paid. 9079 */ 9080 PAYMENTRECONCILIATION, 9081 /** 9082 * Demographics and administrative information about a person independent of a specific health-related context. 9083 */ 9084 PERSON, 9085 /** 9086 * This resource allows for the definition of various types of plans as a sharable, consumable, and executable artifact. The resource is general enough to support the description of a broad range of clinical artifacts such as clinical decision support rules, order sets and protocols. 9087 */ 9088 PLANDEFINITION, 9089 /** 9090 * A person who is directly or indirectly involved in the provisioning of healthcare. 9091 */ 9092 PRACTITIONER, 9093 /** 9094 * A specific set of Roles/Locations/specialties/services that a practitioner may perform at an organization for a period of time. 9095 */ 9096 PRACTITIONERROLE, 9097 /** 9098 * An action that is or was performed on or for a patient. This can be a physical intervention like an operation, or less invasive like long term services, counseling, or hypnotherapy. 9099 */ 9100 PROCEDURE, 9101 /** 9102 * Provenance of a resource is a record that describes entities and processes involved in producing and delivering or otherwise influencing that resource. Provenance provides a critical foundation for assessing authenticity, enabling trust, and allowing reproducibility. Provenance assertions are a form of contextual metadata and can themselves become important records with their own provenance. Provenance statement indicates clinical significance in terms of confidence in authenticity, reliability, and trustworthiness, integrity, and stage in lifecycle (e.g. Document Completion - has the artifact been legally authenticated), all of which may impact security, privacy, and trust policies. 9103 */ 9104 PROVENANCE, 9105 /** 9106 * A structured set of questions intended to guide the collection of answers from end-users. Questionnaires provide detailed control over order, presentation, phraseology and grouping to allow coherent, consistent data collection. 9107 */ 9108 QUESTIONNAIRE, 9109 /** 9110 * A structured set of questions and their answers. The questions are ordered and grouped into coherent subsets, corresponding to the structure of the grouping of the questionnaire being responded to. 9111 */ 9112 QUESTIONNAIRERESPONSE, 9113 /** 9114 * The regulatory authorization of a medicinal product. 9115 */ 9116 REGULATEDAUTHORIZATION, 9117 /** 9118 * Information about a person that is involved in the care for a patient, but who is not the target of healthcare, nor has a formal responsibility in the care process. 9119 */ 9120 RELATEDPERSON, 9121 /** 9122 * A group of related requests that can be used to capture intended activities that have inter-dependencies such as "give this medication after that one". 9123 */ 9124 REQUESTGROUP, 9125 /** 9126 * A process where a researcher or organization plans and then executes a series of steps intended to increase the field of healthcare-related knowledge. This includes studies of safety, efficacy, comparative effectiveness and other information about medications, devices, therapies and other interventional and investigative techniques. A ResearchStudy involves the gathering of information about human or animal subjects. 9127 */ 9128 RESEARCHSTUDY, 9129 /** 9130 * A physical entity which is the primary unit of operational and/or administrative interest in a study. 9131 */ 9132 RESEARCHSUBJECT, 9133 /** 9134 * This is the base resource type for everything. 9135 */ 9136 RESOURCE, 9137 /** 9138 * An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome. 9139 */ 9140 RISKASSESSMENT, 9141 /** 9142 * A container for slots of time that may be available for booking appointments. 9143 */ 9144 SCHEDULE, 9145 /** 9146 * A search parameter that defines a named search item that can be used to search/filter on a resource. 9147 */ 9148 SEARCHPARAMETER, 9149 /** 9150 * A record of a request for service such as diagnostic investigations, treatments, or operations to be performed. 9151 */ 9152 SERVICEREQUEST, 9153 /** 9154 * A slot of time on a schedule that may be available for booking appointments. 9155 */ 9156 SLOT, 9157 /** 9158 * A sample to be used for analysis. 9159 */ 9160 SPECIMEN, 9161 /** 9162 * A kind of specimen with associated set of requirements. 9163 */ 9164 SPECIMENDEFINITION, 9165 /** 9166 * A definition of a FHIR structure. This resource is used to describe the underlying resources, data types defined in FHIR, and also for describing extensions and constraints on resources and data types. 9167 */ 9168 STRUCTUREDEFINITION, 9169 /** 9170 * A Map of relationships between 2 structures that can be used to transform data. 9171 */ 9172 STRUCTUREMAP, 9173 /** 9174 * The subscription resource describes a particular client's request to be notified about a Topic. 9175 */ 9176 SUBSCRIPTION, 9177 /** 9178 * A homogeneous material with a definite composition. 9179 */ 9180 SUBSTANCE, 9181 /** 9182 * The detailed description of a substance, typically at a level beyond what is used for prescribing. 9183 */ 9184 SUBSTANCEDEFINITION, 9185 /** 9186 * Nucleic acids are defined by three distinct elements: the base, sugar and linkage. Individual substance/moiety IDs will be created for each of these elements. The nucleotide sequence will be always entered in the 5’-3’ direction. 9187 */ 9188 SUBSTANCENUCLEICACID, 9189 /** 9190 * Todo. 9191 */ 9192 SUBSTANCEPOLYMER, 9193 /** 9194 * A SubstanceProtein is defined as a single unit of a linear amino acid sequence, or a combination of subunits that are either covalently linked or have a defined invariant stoichiometric relationship. This includes all synthetic, recombinant and purified SubstanceProteins of defined sequence, whether the use is therapeutic or prophylactic. This set of elements will be used to describe albumins, coagulation factors, cytokines, growth factors, peptide/SubstanceProtein hormones, enzymes, toxins, toxoids, recombinant vaccines, and immunomodulators. 9195 */ 9196 SUBSTANCEPROTEIN, 9197 /** 9198 * Todo. 9199 */ 9200 SUBSTANCEREFERENCEINFORMATION, 9201 /** 9202 * Source material shall capture information on the taxonomic and anatomical origins as well as the fraction of a material that can result in or can be modified to form a substance. This set of data elements shall be used to define polymer substances isolated from biological matrices. Taxonomic and anatomical origins shall be described using a controlled vocabulary as required. This information is captured for naturally derived polymers ( . starch) and structurally diverse substances. For Organisms belonging to the Kingdom Plantae the Substance level defines the fresh material of a single species or infraspecies, the Herbal Drug and the Herbal preparation. For Herbal preparations, the fraction information will be captured at the Substance information level and additional information for herbal extracts will be captured at the Specified Substance Group 1 information level. See for further explanation the Substance Class: Structurally Diverse and the herbal annex. 9203 */ 9204 SUBSTANCESOURCEMATERIAL, 9205 /** 9206 * Record of delivery of what is supplied. 9207 */ 9208 SUPPLYDELIVERY, 9209 /** 9210 * A record of a request for a medication, substance or device used in the healthcare setting. 9211 */ 9212 SUPPLYREQUEST, 9213 /** 9214 * A task to be performed. 9215 */ 9216 TASK, 9217 /** 9218 * A TerminologyCapabilities resource documents a set of capabilities (behaviors) of a FHIR Terminology Server that may be used as a statement of actual server functionality or a statement of required or desired server implementation. 9219 */ 9220 TERMINOLOGYCAPABILITIES, 9221 /** 9222 * A summary of information based on the results of executing a TestScript. 9223 */ 9224 TESTREPORT, 9225 /** 9226 * A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification. 9227 */ 9228 TESTSCRIPT, 9229 /** 9230 * Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic. 9231 */ 9232 TOPIC, 9233 /** 9234 * A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html). 9235 */ 9236 VALUESET, 9237 /** 9238 * Describes validation requirements, source(s), status and dates for one or more elements. 9239 */ 9240 VERIFICATIONRESULT, 9241 /** 9242 * An authorization for the provision of glasses and/or contact lenses to a patient. 9243 */ 9244 VISIONPRESCRIPTION, 9245 /** 9246 * added to help the parsers 9247 */ 9248 NULL; 9249 public static ResourceTypeEnum fromCode(String codeString) throws FHIRException { 9250 if (codeString == null || "".equals(codeString)) 9251 return null; 9252 if ("Account".equals(codeString)) 9253 return ACCOUNT; 9254 if ("ActivityDefinition".equals(codeString)) 9255 return ACTIVITYDEFINITION; 9256 if ("AdministrableProductDefinition".equals(codeString)) 9257 return ADMINISTRABLEPRODUCTDEFINITION; 9258 if ("AdverseEvent".equals(codeString)) 9259 return ADVERSEEVENT; 9260 if ("AllergyIntolerance".equals(codeString)) 9261 return ALLERGYINTOLERANCE; 9262 if ("Appointment".equals(codeString)) 9263 return APPOINTMENT; 9264 if ("AppointmentResponse".equals(codeString)) 9265 return APPOINTMENTRESPONSE; 9266 if ("AuditEvent".equals(codeString)) 9267 return AUDITEVENT; 9268 if ("Basic".equals(codeString)) 9269 return BASIC; 9270 if ("Binary".equals(codeString)) 9271 return BINARY; 9272 if ("BiologicallyDerivedProduct".equals(codeString)) 9273 return BIOLOGICALLYDERIVEDPRODUCT; 9274 if ("BodyStructure".equals(codeString)) 9275 return BODYSTRUCTURE; 9276 if ("Bundle".equals(codeString)) 9277 return BUNDLE; 9278 if ("CapabilityStatement".equals(codeString)) 9279 return CAPABILITYSTATEMENT; 9280 if ("CapabilityStatement2".equals(codeString)) 9281 return CAPABILITYSTATEMENT2; 9282 if ("CarePlan".equals(codeString)) 9283 return CAREPLAN; 9284 if ("CareTeam".equals(codeString)) 9285 return CARETEAM; 9286 if ("CatalogEntry".equals(codeString)) 9287 return CATALOGENTRY; 9288 if ("ChargeItem".equals(codeString)) 9289 return CHARGEITEM; 9290 if ("ChargeItemDefinition".equals(codeString)) 9291 return CHARGEITEMDEFINITION; 9292 if ("Claim".equals(codeString)) 9293 return CLAIM; 9294 if ("ClaimResponse".equals(codeString)) 9295 return CLAIMRESPONSE; 9296 if ("ClinicalImpression".equals(codeString)) 9297 return CLINICALIMPRESSION; 9298 if ("ClinicalUseIssue".equals(codeString)) 9299 return CLINICALUSEISSUE; 9300 if ("CodeSystem".equals(codeString)) 9301 return CODESYSTEM; 9302 if ("Communication".equals(codeString)) 9303 return COMMUNICATION; 9304 if ("CommunicationRequest".equals(codeString)) 9305 return COMMUNICATIONREQUEST; 9306 if ("CompartmentDefinition".equals(codeString)) 9307 return COMPARTMENTDEFINITION; 9308 if ("Composition".equals(codeString)) 9309 return COMPOSITION; 9310 if ("ConceptMap".equals(codeString)) 9311 return CONCEPTMAP; 9312 if ("Condition".equals(codeString)) 9313 return CONDITION; 9314 if ("ConditionDefinition".equals(codeString)) 9315 return CONDITIONDEFINITION; 9316 if ("Consent".equals(codeString)) 9317 return CONSENT; 9318 if ("Contract".equals(codeString)) 9319 return CONTRACT; 9320 if ("Coverage".equals(codeString)) 9321 return COVERAGE; 9322 if ("CoverageEligibilityRequest".equals(codeString)) 9323 return COVERAGEELIGIBILITYREQUEST; 9324 if ("CoverageEligibilityResponse".equals(codeString)) 9325 return COVERAGEELIGIBILITYRESPONSE; 9326 if ("DetectedIssue".equals(codeString)) 9327 return DETECTEDISSUE; 9328 if ("Device".equals(codeString)) 9329 return DEVICE; 9330 if ("DeviceDefinition".equals(codeString)) 9331 return DEVICEDEFINITION; 9332 if ("DeviceMetric".equals(codeString)) 9333 return DEVICEMETRIC; 9334 if ("DeviceRequest".equals(codeString)) 9335 return DEVICEREQUEST; 9336 if ("DeviceUseStatement".equals(codeString)) 9337 return DEVICEUSESTATEMENT; 9338 if ("DiagnosticReport".equals(codeString)) 9339 return DIAGNOSTICREPORT; 9340 if ("DocumentManifest".equals(codeString)) 9341 return DOCUMENTMANIFEST; 9342 if ("DocumentReference".equals(codeString)) 9343 return DOCUMENTREFERENCE; 9344 if ("DomainResource".equals(codeString)) 9345 return DOMAINRESOURCE; 9346 if ("Encounter".equals(codeString)) 9347 return ENCOUNTER; 9348 if ("Endpoint".equals(codeString)) 9349 return ENDPOINT; 9350 if ("EnrollmentRequest".equals(codeString)) 9351 return ENROLLMENTREQUEST; 9352 if ("EnrollmentResponse".equals(codeString)) 9353 return ENROLLMENTRESPONSE; 9354 if ("EpisodeOfCare".equals(codeString)) 9355 return EPISODEOFCARE; 9356 if ("EventDefinition".equals(codeString)) 9357 return EVENTDEFINITION; 9358 if ("Evidence".equals(codeString)) 9359 return EVIDENCE; 9360 if ("EvidenceVariable".equals(codeString)) 9361 return EVIDENCEVARIABLE; 9362 if ("ExampleScenario".equals(codeString)) 9363 return EXAMPLESCENARIO; 9364 if ("ExplanationOfBenefit".equals(codeString)) 9365 return EXPLANATIONOFBENEFIT; 9366 if ("FamilyMemberHistory".equals(codeString)) 9367 return FAMILYMEMBERHISTORY; 9368 if ("Flag".equals(codeString)) 9369 return FLAG; 9370 if ("Goal".equals(codeString)) 9371 return GOAL; 9372 if ("GraphDefinition".equals(codeString)) 9373 return GRAPHDEFINITION; 9374 if ("Group".equals(codeString)) 9375 return GROUP; 9376 if ("GuidanceResponse".equals(codeString)) 9377 return GUIDANCERESPONSE; 9378 if ("HealthcareService".equals(codeString)) 9379 return HEALTHCARESERVICE; 9380 if ("ImagingStudy".equals(codeString)) 9381 return IMAGINGSTUDY; 9382 if ("Immunization".equals(codeString)) 9383 return IMMUNIZATION; 9384 if ("ImmunizationEvaluation".equals(codeString)) 9385 return IMMUNIZATIONEVALUATION; 9386 if ("ImmunizationRecommendation".equals(codeString)) 9387 return IMMUNIZATIONRECOMMENDATION; 9388 if ("ImplementationGuide".equals(codeString)) 9389 return IMPLEMENTATIONGUIDE; 9390 if ("Ingredient".equals(codeString)) 9391 return INGREDIENT; 9392 if ("InsurancePlan".equals(codeString)) 9393 return INSURANCEPLAN; 9394 if ("Invoice".equals(codeString)) 9395 return INVOICE; 9396 if ("Library".equals(codeString)) 9397 return LIBRARY; 9398 if ("Linkage".equals(codeString)) 9399 return LINKAGE; 9400 if ("List".equals(codeString)) 9401 return LIST; 9402 if ("Location".equals(codeString)) 9403 return LOCATION; 9404 if ("ManufacturedItemDefinition".equals(codeString)) 9405 return MANUFACTUREDITEMDEFINITION; 9406 if ("Measure".equals(codeString)) 9407 return MEASURE; 9408 if ("MeasureReport".equals(codeString)) 9409 return MEASUREREPORT; 9410 if ("Medication".equals(codeString)) 9411 return MEDICATION; 9412 if ("MedicationAdministration".equals(codeString)) 9413 return MEDICATIONADMINISTRATION; 9414 if ("MedicationDispense".equals(codeString)) 9415 return MEDICATIONDISPENSE; 9416 if ("MedicationKnowledge".equals(codeString)) 9417 return MEDICATIONKNOWLEDGE; 9418 if ("MedicationRequest".equals(codeString)) 9419 return MEDICATIONREQUEST; 9420 if ("MedicationUsage".equals(codeString)) 9421 return MEDICATIONUSAGE; 9422 if ("MedicinalProductDefinition".equals(codeString)) 9423 return MEDICINALPRODUCTDEFINITION; 9424 if ("MessageDefinition".equals(codeString)) 9425 return MESSAGEDEFINITION; 9426 if ("MessageHeader".equals(codeString)) 9427 return MESSAGEHEADER; 9428 if ("MolecularSequence".equals(codeString)) 9429 return MOLECULARSEQUENCE; 9430 if ("NamingSystem".equals(codeString)) 9431 return NAMINGSYSTEM; 9432 if ("NutritionIntake".equals(codeString)) 9433 return NUTRITIONINTAKE; 9434 if ("NutritionOrder".equals(codeString)) 9435 return NUTRITIONORDER; 9436 if ("Observation".equals(codeString)) 9437 return OBSERVATION; 9438 if ("ObservationDefinition".equals(codeString)) 9439 return OBSERVATIONDEFINITION; 9440 if ("OperationDefinition".equals(codeString)) 9441 return OPERATIONDEFINITION; 9442 if ("OperationOutcome".equals(codeString)) 9443 return OPERATIONOUTCOME; 9444 if ("Organization".equals(codeString)) 9445 return ORGANIZATION; 9446 if ("OrganizationAffiliation".equals(codeString)) 9447 return ORGANIZATIONAFFILIATION; 9448 if ("PackagedProductDefinition".equals(codeString)) 9449 return PACKAGEDPRODUCTDEFINITION; 9450 if ("Parameters".equals(codeString)) 9451 return PARAMETERS; 9452 if ("Patient".equals(codeString)) 9453 return PATIENT; 9454 if ("PaymentNotice".equals(codeString)) 9455 return PAYMENTNOTICE; 9456 if ("PaymentReconciliation".equals(codeString)) 9457 return PAYMENTRECONCILIATION; 9458 if ("Person".equals(codeString)) 9459 return PERSON; 9460 if ("PlanDefinition".equals(codeString)) 9461 return PLANDEFINITION; 9462 if ("Practitioner".equals(codeString)) 9463 return PRACTITIONER; 9464 if ("PractitionerRole".equals(codeString)) 9465 return PRACTITIONERROLE; 9466 if ("Procedure".equals(codeString)) 9467 return PROCEDURE; 9468 if ("Provenance".equals(codeString)) 9469 return PROVENANCE; 9470 if ("Questionnaire".equals(codeString)) 9471 return QUESTIONNAIRE; 9472 if ("QuestionnaireResponse".equals(codeString)) 9473 return QUESTIONNAIRERESPONSE; 9474 if ("RegulatedAuthorization".equals(codeString)) 9475 return REGULATEDAUTHORIZATION; 9476 if ("RelatedPerson".equals(codeString)) 9477 return RELATEDPERSON; 9478 if ("RequestGroup".equals(codeString)) 9479 return REQUESTGROUP; 9480 if ("ResearchStudy".equals(codeString)) 9481 return RESEARCHSTUDY; 9482 if ("ResearchSubject".equals(codeString)) 9483 return RESEARCHSUBJECT; 9484 if ("Resource".equals(codeString)) 9485 return RESOURCE; 9486 if ("RiskAssessment".equals(codeString)) 9487 return RISKASSESSMENT; 9488 if ("Schedule".equals(codeString)) 9489 return SCHEDULE; 9490 if ("SearchParameter".equals(codeString)) 9491 return SEARCHPARAMETER; 9492 if ("ServiceRequest".equals(codeString)) 9493 return SERVICEREQUEST; 9494 if ("Slot".equals(codeString)) 9495 return SLOT; 9496 if ("Specimen".equals(codeString)) 9497 return SPECIMEN; 9498 if ("SpecimenDefinition".equals(codeString)) 9499 return SPECIMENDEFINITION; 9500 if ("StructureDefinition".equals(codeString)) 9501 return STRUCTUREDEFINITION; 9502 if ("StructureMap".equals(codeString)) 9503 return STRUCTUREMAP; 9504 if ("Subscription".equals(codeString)) 9505 return SUBSCRIPTION; 9506 if ("Substance".equals(codeString)) 9507 return SUBSTANCE; 9508 if ("SubstanceDefinition".equals(codeString)) 9509 return SUBSTANCEDEFINITION; 9510 if ("SubstanceNucleicAcid".equals(codeString)) 9511 return SUBSTANCENUCLEICACID; 9512 if ("SubstancePolymer".equals(codeString)) 9513 return SUBSTANCEPOLYMER; 9514 if ("SubstanceProtein".equals(codeString)) 9515 return SUBSTANCEPROTEIN; 9516 if ("SubstanceReferenceInformation".equals(codeString)) 9517 return SUBSTANCEREFERENCEINFORMATION; 9518 if ("SubstanceSourceMaterial".equals(codeString)) 9519 return SUBSTANCESOURCEMATERIAL; 9520 if ("SupplyDelivery".equals(codeString)) 9521 return SUPPLYDELIVERY; 9522 if ("SupplyRequest".equals(codeString)) 9523 return SUPPLYREQUEST; 9524 if ("Task".equals(codeString)) 9525 return TASK; 9526 if ("TerminologyCapabilities".equals(codeString)) 9527 return TERMINOLOGYCAPABILITIES; 9528 if ("TestReport".equals(codeString)) 9529 return TESTREPORT; 9530 if ("TestScript".equals(codeString)) 9531 return TESTSCRIPT; 9532 if ("Topic".equals(codeString)) 9533 return TOPIC; 9534 if ("ValueSet".equals(codeString)) 9535 return VALUESET; 9536 if ("VerificationResult".equals(codeString)) 9537 return VERIFICATIONRESULT; 9538 if ("VisionPrescription".equals(codeString)) 9539 return VISIONPRESCRIPTION; 9540 throw new FHIRException("Unknown ResourceTypeEnum code '"+codeString+"'"); 9541 } 9542 public String toCode() { 9543 switch (this) { 9544 case ACCOUNT: return "Account"; 9545 case ACTIVITYDEFINITION: return "ActivityDefinition"; 9546 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 9547 case ADVERSEEVENT: return "AdverseEvent"; 9548 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 9549 case APPOINTMENT: return "Appointment"; 9550 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 9551 case AUDITEVENT: return "AuditEvent"; 9552 case BASIC: return "Basic"; 9553 case BINARY: return "Binary"; 9554 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 9555 case BODYSTRUCTURE: return "BodyStructure"; 9556 case BUNDLE: return "Bundle"; 9557 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 9558 case CAPABILITYSTATEMENT2: return "CapabilityStatement2"; 9559 case CAREPLAN: return "CarePlan"; 9560 case CARETEAM: return "CareTeam"; 9561 case CATALOGENTRY: return "CatalogEntry"; 9562 case CHARGEITEM: return "ChargeItem"; 9563 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 9564 case CLAIM: return "Claim"; 9565 case CLAIMRESPONSE: return "ClaimResponse"; 9566 case CLINICALIMPRESSION: return "ClinicalImpression"; 9567 case CLINICALUSEISSUE: return "ClinicalUseIssue"; 9568 case CODESYSTEM: return "CodeSystem"; 9569 case COMMUNICATION: return "Communication"; 9570 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 9571 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 9572 case COMPOSITION: return "Composition"; 9573 case CONCEPTMAP: return "ConceptMap"; 9574 case CONDITION: return "Condition"; 9575 case CONDITIONDEFINITION: return "ConditionDefinition"; 9576 case CONSENT: return "Consent"; 9577 case CONTRACT: return "Contract"; 9578 case COVERAGE: return "Coverage"; 9579 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 9580 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 9581 case DETECTEDISSUE: return "DetectedIssue"; 9582 case DEVICE: return "Device"; 9583 case DEVICEDEFINITION: return "DeviceDefinition"; 9584 case DEVICEMETRIC: return "DeviceMetric"; 9585 case DEVICEREQUEST: return "DeviceRequest"; 9586 case DEVICEUSESTATEMENT: return "DeviceUseStatement"; 9587 case DIAGNOSTICREPORT: return "DiagnosticReport"; 9588 case DOCUMENTMANIFEST: return "DocumentManifest"; 9589 case DOCUMENTREFERENCE: return "DocumentReference"; 9590 case DOMAINRESOURCE: return "DomainResource"; 9591 case ENCOUNTER: return "Encounter"; 9592 case ENDPOINT: return "Endpoint"; 9593 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 9594 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 9595 case EPISODEOFCARE: return "EpisodeOfCare"; 9596 case EVENTDEFINITION: return "EventDefinition"; 9597 case EVIDENCE: return "Evidence"; 9598 case EVIDENCEVARIABLE: return "EvidenceVariable"; 9599 case EXAMPLESCENARIO: return "ExampleScenario"; 9600 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 9601 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 9602 case FLAG: return "Flag"; 9603 case GOAL: return "Goal"; 9604 case GRAPHDEFINITION: return "GraphDefinition"; 9605 case GROUP: return "Group"; 9606 case GUIDANCERESPONSE: return "GuidanceResponse"; 9607 case HEALTHCARESERVICE: return "HealthcareService"; 9608 case IMAGINGSTUDY: return "ImagingStudy"; 9609 case IMMUNIZATION: return "Immunization"; 9610 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 9611 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 9612 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 9613 case INGREDIENT: return "Ingredient"; 9614 case INSURANCEPLAN: return "InsurancePlan"; 9615 case INVOICE: return "Invoice"; 9616 case LIBRARY: return "Library"; 9617 case LINKAGE: return "Linkage"; 9618 case LIST: return "List"; 9619 case LOCATION: return "Location"; 9620 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 9621 case MEASURE: return "Measure"; 9622 case MEASUREREPORT: return "MeasureReport"; 9623 case MEDICATION: return "Medication"; 9624 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 9625 case MEDICATIONDISPENSE: return "MedicationDispense"; 9626 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 9627 case MEDICATIONREQUEST: return "MedicationRequest"; 9628 case MEDICATIONUSAGE: return "MedicationUsage"; 9629 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 9630 case MESSAGEDEFINITION: return "MessageDefinition"; 9631 case MESSAGEHEADER: return "MessageHeader"; 9632 case MOLECULARSEQUENCE: return "MolecularSequence"; 9633 case NAMINGSYSTEM: return "NamingSystem"; 9634 case NUTRITIONINTAKE: return "NutritionIntake"; 9635 case NUTRITIONORDER: return "NutritionOrder"; 9636 case OBSERVATION: return "Observation"; 9637 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 9638 case OPERATIONDEFINITION: return "OperationDefinition"; 9639 case OPERATIONOUTCOME: return "OperationOutcome"; 9640 case ORGANIZATION: return "Organization"; 9641 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 9642 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 9643 case PARAMETERS: return "Parameters"; 9644 case PATIENT: return "Patient"; 9645 case PAYMENTNOTICE: return "PaymentNotice"; 9646 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 9647 case PERSON: return "Person"; 9648 case PLANDEFINITION: return "PlanDefinition"; 9649 case PRACTITIONER: return "Practitioner"; 9650 case PRACTITIONERROLE: return "PractitionerRole"; 9651 case PROCEDURE: return "Procedure"; 9652 case PROVENANCE: return "Provenance"; 9653 case QUESTIONNAIRE: return "Questionnaire"; 9654 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 9655 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 9656 case RELATEDPERSON: return "RelatedPerson"; 9657 case REQUESTGROUP: return "RequestGroup"; 9658 case RESEARCHSTUDY: return "ResearchStudy"; 9659 case RESEARCHSUBJECT: return "ResearchSubject"; 9660 case RESOURCE: return "Resource"; 9661 case RISKASSESSMENT: return "RiskAssessment"; 9662 case SCHEDULE: return "Schedule"; 9663 case SEARCHPARAMETER: return "SearchParameter"; 9664 case SERVICEREQUEST: return "ServiceRequest"; 9665 case SLOT: return "Slot"; 9666 case SPECIMEN: return "Specimen"; 9667 case SPECIMENDEFINITION: return "SpecimenDefinition"; 9668 case STRUCTUREDEFINITION: return "StructureDefinition"; 9669 case STRUCTUREMAP: return "StructureMap"; 9670 case SUBSCRIPTION: return "Subscription"; 9671 case SUBSTANCE: return "Substance"; 9672 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 9673 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 9674 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 9675 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 9676 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 9677 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 9678 case SUPPLYDELIVERY: return "SupplyDelivery"; 9679 case SUPPLYREQUEST: return "SupplyRequest"; 9680 case TASK: return "Task"; 9681 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 9682 case TESTREPORT: return "TestReport"; 9683 case TESTSCRIPT: return "TestScript"; 9684 case TOPIC: return "Topic"; 9685 case VALUESET: return "ValueSet"; 9686 case VERIFICATIONRESULT: return "VerificationResult"; 9687 case VISIONPRESCRIPTION: return "VisionPrescription"; 9688 default: return "?"; 9689 } 9690 } 9691 public String getSystem() { 9692 switch (this) { 9693 case ACCOUNT: return "http://hl7.org/fhir/resource-types"; 9694 case ACTIVITYDEFINITION: return "http://hl7.org/fhir/resource-types"; 9695 case ADMINISTRABLEPRODUCTDEFINITION: return "http://hl7.org/fhir/resource-types"; 9696 case ADVERSEEVENT: return "http://hl7.org/fhir/resource-types"; 9697 case ALLERGYINTOLERANCE: return "http://hl7.org/fhir/resource-types"; 9698 case APPOINTMENT: return "http://hl7.org/fhir/resource-types"; 9699 case APPOINTMENTRESPONSE: return "http://hl7.org/fhir/resource-types"; 9700 case AUDITEVENT: return "http://hl7.org/fhir/resource-types"; 9701 case BASIC: return "http://hl7.org/fhir/resource-types"; 9702 case BINARY: return "http://hl7.org/fhir/resource-types"; 9703 case BIOLOGICALLYDERIVEDPRODUCT: return "http://hl7.org/fhir/resource-types"; 9704 case BODYSTRUCTURE: return "http://hl7.org/fhir/resource-types"; 9705 case BUNDLE: return "http://hl7.org/fhir/resource-types"; 9706 case CAPABILITYSTATEMENT: return "http://hl7.org/fhir/resource-types"; 9707 case CAPABILITYSTATEMENT2: return "http://hl7.org/fhir/resource-types"; 9708 case CAREPLAN: return "http://hl7.org/fhir/resource-types"; 9709 case CARETEAM: return "http://hl7.org/fhir/resource-types"; 9710 case CATALOGENTRY: return "http://hl7.org/fhir/resource-types"; 9711 case CHARGEITEM: return "http://hl7.org/fhir/resource-types"; 9712 case CHARGEITEMDEFINITION: return "http://hl7.org/fhir/resource-types"; 9713 case CLAIM: return "http://hl7.org/fhir/resource-types"; 9714 case CLAIMRESPONSE: return "http://hl7.org/fhir/resource-types"; 9715 case CLINICALIMPRESSION: return "http://hl7.org/fhir/resource-types"; 9716 case CLINICALUSEISSUE: return "http://hl7.org/fhir/resource-types"; 9717 case CODESYSTEM: return "http://hl7.org/fhir/resource-types"; 9718 case COMMUNICATION: return "http://hl7.org/fhir/resource-types"; 9719 case COMMUNICATIONREQUEST: return "http://hl7.org/fhir/resource-types"; 9720 case COMPARTMENTDEFINITION: return "http://hl7.org/fhir/resource-types"; 9721 case COMPOSITION: return "http://hl7.org/fhir/resource-types"; 9722 case CONCEPTMAP: return "http://hl7.org/fhir/resource-types"; 9723 case CONDITION: return "http://hl7.org/fhir/resource-types"; 9724 case CONDITIONDEFINITION: return "http://hl7.org/fhir/resource-types"; 9725 case CONSENT: return "http://hl7.org/fhir/resource-types"; 9726 case CONTRACT: return "http://hl7.org/fhir/resource-types"; 9727 case COVERAGE: return "http://hl7.org/fhir/resource-types"; 9728 case COVERAGEELIGIBILITYREQUEST: return "http://hl7.org/fhir/resource-types"; 9729 case COVERAGEELIGIBILITYRESPONSE: return "http://hl7.org/fhir/resource-types"; 9730 case DETECTEDISSUE: return "http://hl7.org/fhir/resource-types"; 9731 case DEVICE: return "http://hl7.org/fhir/resource-types"; 9732 case DEVICEDEFINITION: return "http://hl7.org/fhir/resource-types"; 9733 case DEVICEMETRIC: return "http://hl7.org/fhir/resource-types"; 9734 case DEVICEREQUEST: return "http://hl7.org/fhir/resource-types"; 9735 case DEVICEUSESTATEMENT: return "http://hl7.org/fhir/resource-types"; 9736 case DIAGNOSTICREPORT: return "http://hl7.org/fhir/resource-types"; 9737 case DOCUMENTMANIFEST: return "http://hl7.org/fhir/resource-types"; 9738 case DOCUMENTREFERENCE: return "http://hl7.org/fhir/resource-types"; 9739 case DOMAINRESOURCE: return "http://hl7.org/fhir/resource-types"; 9740 case ENCOUNTER: return "http://hl7.org/fhir/resource-types"; 9741 case ENDPOINT: return "http://hl7.org/fhir/resource-types"; 9742 case ENROLLMENTREQUEST: return "http://hl7.org/fhir/resource-types"; 9743 case ENROLLMENTRESPONSE: return "http://hl7.org/fhir/resource-types"; 9744 case EPISODEOFCARE: return "http://hl7.org/fhir/resource-types"; 9745 case EVENTDEFINITION: return "http://hl7.org/fhir/resource-types"; 9746 case EVIDENCE: return "http://hl7.org/fhir/resource-types"; 9747 case EVIDENCEVARIABLE: return "http://hl7.org/fhir/resource-types"; 9748 case EXAMPLESCENARIO: return "http://hl7.org/fhir/resource-types"; 9749 case EXPLANATIONOFBENEFIT: return "http://hl7.org/fhir/resource-types"; 9750 case FAMILYMEMBERHISTORY: return "http://hl7.org/fhir/resource-types"; 9751 case FLAG: return "http://hl7.org/fhir/resource-types"; 9752 case GOAL: return "http://hl7.org/fhir/resource-types"; 9753 case GRAPHDEFINITION: return "http://hl7.org/fhir/resource-types"; 9754 case GROUP: return "http://hl7.org/fhir/resource-types"; 9755 case GUIDANCERESPONSE: return "http://hl7.org/fhir/resource-types"; 9756 case HEALTHCARESERVICE: return "http://hl7.org/fhir/resource-types"; 9757 case IMAGINGSTUDY: return "http://hl7.org/fhir/resource-types"; 9758 case IMMUNIZATION: return "http://hl7.org/fhir/resource-types"; 9759 case IMMUNIZATIONEVALUATION: return "http://hl7.org/fhir/resource-types"; 9760 case IMMUNIZATIONRECOMMENDATION: return "http://hl7.org/fhir/resource-types"; 9761 case IMPLEMENTATIONGUIDE: return "http://hl7.org/fhir/resource-types"; 9762 case INGREDIENT: return "http://hl7.org/fhir/resource-types"; 9763 case INSURANCEPLAN: return "http://hl7.org/fhir/resource-types"; 9764 case INVOICE: return "http://hl7.org/fhir/resource-types"; 9765 case LIBRARY: return "http://hl7.org/fhir/resource-types"; 9766 case LINKAGE: return "http://hl7.org/fhir/resource-types"; 9767 case LIST: return "http://hl7.org/fhir/resource-types"; 9768 case LOCATION: return "http://hl7.org/fhir/resource-types"; 9769 case MANUFACTUREDITEMDEFINITION: return "http://hl7.org/fhir/resource-types"; 9770 case MEASURE: return "http://hl7.org/fhir/resource-types"; 9771 case MEASUREREPORT: return "http://hl7.org/fhir/resource-types"; 9772 case MEDICATION: return "http://hl7.org/fhir/resource-types"; 9773 case MEDICATIONADMINISTRATION: return "http://hl7.org/fhir/resource-types"; 9774 case MEDICATIONDISPENSE: return "http://hl7.org/fhir/resource-types"; 9775 case MEDICATIONKNOWLEDGE: return "http://hl7.org/fhir/resource-types"; 9776 case MEDICATIONREQUEST: return "http://hl7.org/fhir/resource-types"; 9777 case MEDICATIONUSAGE: return "http://hl7.org/fhir/resource-types"; 9778 case MEDICINALPRODUCTDEFINITION: return "http://hl7.org/fhir/resource-types"; 9779 case MESSAGEDEFINITION: return "http://hl7.org/fhir/resource-types"; 9780 case MESSAGEHEADER: return "http://hl7.org/fhir/resource-types"; 9781 case MOLECULARSEQUENCE: return "http://hl7.org/fhir/resource-types"; 9782 case NAMINGSYSTEM: return "http://hl7.org/fhir/resource-types"; 9783 case NUTRITIONINTAKE: return "http://hl7.org/fhir/resource-types"; 9784 case NUTRITIONORDER: return "http://hl7.org/fhir/resource-types"; 9785 case OBSERVATION: return "http://hl7.org/fhir/resource-types"; 9786 case OBSERVATIONDEFINITION: return "http://hl7.org/fhir/resource-types"; 9787 case OPERATIONDEFINITION: return "http://hl7.org/fhir/resource-types"; 9788 case OPERATIONOUTCOME: return "http://hl7.org/fhir/resource-types"; 9789 case ORGANIZATION: return "http://hl7.org/fhir/resource-types"; 9790 case ORGANIZATIONAFFILIATION: return "http://hl7.org/fhir/resource-types"; 9791 case PACKAGEDPRODUCTDEFINITION: return "http://hl7.org/fhir/resource-types"; 9792 case PARAMETERS: return "http://hl7.org/fhir/resource-types"; 9793 case PATIENT: return "http://hl7.org/fhir/resource-types"; 9794 case PAYMENTNOTICE: return "http://hl7.org/fhir/resource-types"; 9795 case PAYMENTRECONCILIATION: return "http://hl7.org/fhir/resource-types"; 9796 case PERSON: return "http://hl7.org/fhir/resource-types"; 9797 case PLANDEFINITION: return "http://hl7.org/fhir/resource-types"; 9798 case PRACTITIONER: return "http://hl7.org/fhir/resource-types"; 9799 case PRACTITIONERROLE: return "http://hl7.org/fhir/resource-types"; 9800 case PROCEDURE: return "http://hl7.org/fhir/resource-types"; 9801 case PROVENANCE: return "http://hl7.org/fhir/resource-types"; 9802 case QUESTIONNAIRE: return "http://hl7.org/fhir/resource-types"; 9803 case QUESTIONNAIRERESPONSE: return "http://hl7.org/fhir/resource-types"; 9804 case REGULATEDAUTHORIZATION: return "http://hl7.org/fhir/resource-types"; 9805 case RELATEDPERSON: return "http://hl7.org/fhir/resource-types"; 9806 case REQUESTGROUP: return "http://hl7.org/fhir/resource-types"; 9807 case RESEARCHSTUDY: return "http://hl7.org/fhir/resource-types"; 9808 case RESEARCHSUBJECT: return "http://hl7.org/fhir/resource-types"; 9809 case RESOURCE: return "http://hl7.org/fhir/resource-types"; 9810 case RISKASSESSMENT: return "http://hl7.org/fhir/resource-types"; 9811 case SCHEDULE: return "http://hl7.org/fhir/resource-types"; 9812 case SEARCHPARAMETER: return "http://hl7.org/fhir/resource-types"; 9813 case SERVICEREQUEST: return "http://hl7.org/fhir/resource-types"; 9814 case SLOT: return "http://hl7.org/fhir/resource-types"; 9815 case SPECIMEN: return "http://hl7.org/fhir/resource-types"; 9816 case SPECIMENDEFINITION: return "http://hl7.org/fhir/resource-types"; 9817 case STRUCTUREDEFINITION: return "http://hl7.org/fhir/resource-types"; 9818 case STRUCTUREMAP: return "http://hl7.org/fhir/resource-types"; 9819 case SUBSCRIPTION: return "http://hl7.org/fhir/resource-types"; 9820 case SUBSTANCE: return "http://hl7.org/fhir/resource-types"; 9821 case SUBSTANCEDEFINITION: return "http://hl7.org/fhir/resource-types"; 9822 case SUBSTANCENUCLEICACID: return "http://hl7.org/fhir/resource-types"; 9823 case SUBSTANCEPOLYMER: return "http://hl7.org/fhir/resource-types"; 9824 case SUBSTANCEPROTEIN: return "http://hl7.org/fhir/resource-types"; 9825 case SUBSTANCEREFERENCEINFORMATION: return "http://hl7.org/fhir/resource-types"; 9826 case SUBSTANCESOURCEMATERIAL: return "http://hl7.org/fhir/resource-types"; 9827 case SUPPLYDELIVERY: return "http://hl7.org/fhir/resource-types"; 9828 case SUPPLYREQUEST: return "http://hl7.org/fhir/resource-types"; 9829 case TASK: return "http://hl7.org/fhir/resource-types"; 9830 case TERMINOLOGYCAPABILITIES: return "http://hl7.org/fhir/resource-types"; 9831 case TESTREPORT: return "http://hl7.org/fhir/resource-types"; 9832 case TESTSCRIPT: return "http://hl7.org/fhir/resource-types"; 9833 case TOPIC: return "http://hl7.org/fhir/resource-types"; 9834 case VALUESET: return "http://hl7.org/fhir/resource-types"; 9835 case VERIFICATIONRESULT: return "http://hl7.org/fhir/resource-types"; 9836 case VISIONPRESCRIPTION: return "http://hl7.org/fhir/resource-types"; 9837 default: return "?"; 9838 } 9839 } 9840 public String getDefinition() { 9841 switch (this) { 9842 case ACCOUNT: return "A financial tool for tracking value accrued for a particular purpose. In the healthcare field, used to track charges for a patient, cost centers, etc."; 9843 case ACTIVITYDEFINITION: return "This resource allows for the definition of some activity to be performed, independent of a particular patient, practitioner, or other performance context."; 9844 case ADMINISTRABLEPRODUCTDEFINITION: return "A pharmaceutical product described in terms of its composition and dose form."; 9845 case ADVERSEEVENT: return "An event (i.e. any change to current patient status) that may be related to unintended effects on a patient or research subject. The unintended effects may require additional monitoring, treatment or hospitalization or may result in death. The AdverseEvent resource also extends to potential or avoided events that could have had such effects."; 9846 case ALLERGYINTOLERANCE: return "Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance."; 9847 case APPOINTMENT: return "A booking of a healthcare event among patient(s), practitioner(s), related person(s) and/or device(s) for a specific date/time. This may result in one or more Encounter(s)."; 9848 case APPOINTMENTRESPONSE: return "A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection."; 9849 case AUDITEVENT: return "A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis."; 9850 case BASIC: return "Basic is used for handling concepts not yet defined in FHIR, narrative-only resources that don't map to an existing resource, and custom resources not appropriate for inclusion in the FHIR specification."; 9851 case BINARY: return "A resource that represents the data of a single raw artifact as digital content accessible in its native format. A Binary resource can contain any content, whether text, image, pdf, zip archive, etc."; 9852 case BIOLOGICALLYDERIVEDPRODUCT: return "A material substance originating from a biological entity intended to be transplanted or infused\ninto another (possibly the same) biological entity."; 9853 case BODYSTRUCTURE: return "Record details about an anatomical structure. This resource may be used when a coded concept does not provide the necessary detail needed for the use case."; 9854 case BUNDLE: return "A container for a collection of resources."; 9855 case CAPABILITYSTATEMENT: return "A Capability Statement documents a set of capabilities (behaviors) of a FHIR Server for a particular version of FHIR that may be used as a statement of actual server functionality or a statement of required or desired server implementation."; 9856 case CAPABILITYSTATEMENT2: return "A Capability Statement documents a set of capabilities (behaviors) of a FHIR Server for a particular version of FHIR that may be used as a statement of actual server functionality or a statement of required or desired server implementation."; 9857 case CAREPLAN: return "Describes the intention of how one or more practitioners intend to deliver care for a particular patient, group or community for a period of time, possibly limited to care for a specific condition or set of conditions."; 9858 case CARETEAM: return "The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care."; 9859 case CATALOGENTRY: return "Catalog entries are wrappers that contextualize items included in a catalog."; 9860 case CHARGEITEM: return "The resource ChargeItem describes the provision of healthcare provider products for a certain patient, therefore referring not only to the product, but containing in addition details of the provision, like date, time, amounts and participating organizations and persons. Main Usage of the ChargeItem is to enable the billing process and internal cost allocation."; 9861 case CHARGEITEMDEFINITION: return "The ChargeItemDefinition resource provides the properties that apply to the (billing) codes necessary to calculate costs and prices. The properties may differ largely depending on type and realm, therefore this resource gives only a rough structure and requires profiling for each type of billing code system."; 9862 case CLAIM: return "A provider issued list of professional services and products which have been provided, or are to be provided, to a patient which is sent to an insurer for reimbursement."; 9863 case CLAIMRESPONSE: return "This resource provides the adjudication details from the processing of a Claim resource."; 9864 case CLINICALIMPRESSION: return "A record of a clinical assessment performed to determine what problem(s) may affect the patient and before planning the treatments or management strategies that are best to manage a patient's condition. Assessments are often 1:1 with a clinical consultation / encounter, but this varies greatly depending on the clinical workflow. This resource is called \"ClinicalImpression\" rather than \"ClinicalAssessment\" to avoid confusion with the recording of assessment tools such as Apgar score."; 9865 case CLINICALUSEISSUE: return "A single usage issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure."; 9866 case CODESYSTEM: return "The CodeSystem resource is used to declare the existence of and describe a code system or code system supplement and its key properties, and optionally define a part or all of its content."; 9867 case COMMUNICATION: return "An occurrence of information being transmitted; e.g. an alert that was sent to a responsible provider, a public health agency communication to a provider/reporter in response to a case report for a reportable condition."; 9868 case COMMUNICATIONREQUEST: return "A request to convey information; e.g. the CDS system proposes that an alert be sent to a responsible provider, the CDS system proposes that the public health agency be notified about a reportable condition."; 9869 case COMPARTMENTDEFINITION: return "A compartment definition that defines how resources are accessed on a server."; 9870 case COMPOSITION: return "A set of healthcare-related information that is assembled together into a single logical package that provides a single coherent statement of meaning, establishes its own context and that has clinical attestation with regard to who is making the statement. A Composition defines the structure and narrative content necessary for a document. However, a Composition alone does not constitute a document. Rather, the Composition must be the first entry in a Bundle where Bundle.type=document, and any other resources referenced from Composition must be included as subsequent entries in the Bundle (for example Patient, Practitioner, Encounter, etc.)."; 9871 case CONCEPTMAP: return "A statement of relationships from one set of concepts to one or more other concepts - either concepts in code systems, or data element/data element concepts, or classes in class models."; 9872 case CONDITION: return "A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern."; 9873 case CONDITIONDEFINITION: return "A definition of a condition and information relevant to managing it."; 9874 case CONSENT: return "A record of a healthcare consumer’s choices or choices made on their behalf by a third party, which permits or denies identified recipient(s) or recipient role(s) to perform one or more actions within a given policy context, for specific purposes and periods of time."; 9875 case CONTRACT: return "Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement."; 9876 case COVERAGE: return "Financial instrument which may be used to reimburse or pay for health care products and services. Includes both insurance and self-payment."; 9877 case COVERAGEELIGIBILITYREQUEST: return "The CoverageEligibilityRequest provides patient and insurance coverage information to an insurer for them to respond, in the form of an CoverageEligibilityResponse, with information regarding whether the stated coverage is valid and in-force and optionally to provide the insurance details of the policy."; 9878 case COVERAGEELIGIBILITYRESPONSE: return "This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource."; 9879 case DETECTEDISSUE: return "Indicates an actual or potential clinical issue with or between one or more active or proposed clinical actions for a patient; e.g. Drug-drug interaction, Ineffective treatment frequency, Procedure-condition conflict, etc."; 9880 case DEVICE: return "A type of a manufactured item that is used in the provision of healthcare without being substantially changed through that activity. The device may be a medical or non-medical device."; 9881 case DEVICEDEFINITION: return "The characteristics, operational status and capabilities of a medical-related component of a medical device."; 9882 case DEVICEMETRIC: return "Describes a measurement, calculation or setting capability of a medical device."; 9883 case DEVICEREQUEST: return "Represents a request for a patient to employ a medical device. The device may be an implantable device, or an external assistive device, such as a walker."; 9884 case DEVICEUSESTATEMENT: return "A record of a device being used by a patient where the record is the result of a report from the patient or another clinician."; 9885 case DIAGNOSTICREPORT: return "The findings and interpretation of diagnostic tests performed on patients, groups of patients, devices, and locations, and/or specimens derived from these. The report includes clinical context such as requesting and provider information, and some mix of atomic results, images, textual and coded interpretations, and formatted representation of diagnostic reports."; 9886 case DOCUMENTMANIFEST: return "A collection of documents compiled for a purpose together with metadata that applies to the collection."; 9887 case DOCUMENTREFERENCE: return "A reference to a document of any kind for any purpose. While the term “document” implies a more narrow focus, for this resource this \"document\" encompasses *any* serialized object with a mime-type, it includes formal patient-centric documents (CDA), clinical notes, scanned paper, non-patient specific documents like policy text, as well as a photo, video, or audio recording acquired or used in healthcare. The DocumentReference resource provides metadata about the document so that the document can be discovered and managed. The actual content may be inline base64 encoded data or provided by direct reference."; 9888 case DOMAINRESOURCE: return "A resource that includes narrative, extensions, and contained resources."; 9889 case ENCOUNTER: return "An interaction between a patient and healthcare provider(s) for the purpose of providing healthcare service(s) or assessing the health status of a patient."; 9890 case ENDPOINT: return "The technical details of an endpoint that can be used for electronic services, such as for web services providing XDS.b or a REST endpoint for another FHIR server. This may include any security context information."; 9891 case ENROLLMENTREQUEST: return "This resource provides the insurance enrollment details to the insurer regarding a specified coverage."; 9892 case ENROLLMENTRESPONSE: return "This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource."; 9893 case EPISODEOFCARE: return "An association between a patient and an organization / healthcare provider(s) during which time encounters may occur. The managing organization assumes a level of responsibility for the patient during this time."; 9894 case EVENTDEFINITION: return "The EventDefinition resource provides a reusable description of when a particular event can occur."; 9895 case EVIDENCE: return "This represents statistics, certainty, both the intended and actual population, and evidence variables."; 9896 case EVIDENCEVARIABLE: return "The EvidenceVariable resource describes a \"PICO\" element that knowledge (evidence, assertion, recommendation) is about."; 9897 case EXAMPLESCENARIO: return "Example of workflow instance."; 9898 case EXPLANATIONOFBENEFIT: return "This resource provides: the claim details; adjudication details from the processing of a Claim; and optionally account balance information, for informing the subscriber of the benefits provided."; 9899 case FAMILYMEMBERHISTORY: return "Significant health conditions for a person related to the patient relevant in the context of care for the patient."; 9900 case FLAG: return "Prospective warnings of potential issues when providing care to the patient."; 9901 case GOAL: return "Describes the intended objective(s) for a patient, group or organization care, for example, weight loss, restoring an activity of daily living, obtaining herd immunity via immunization, meeting a process improvement objective, etc."; 9902 case GRAPHDEFINITION: return "A formal computable definition of a graph of resources - that is, a coherent set of resources that form a graph by following references. The Graph Definition resource defines a set and makes rules about the set."; 9903 case GROUP: return "Represents a defined collection of entities that may be discussed or acted upon collectively but which are not expected to act collectively, and are not formally or legally recognized; i.e. a collection of entities that isn't an Organization."; 9904 case GUIDANCERESPONSE: return "A guidance response is the formal response to a guidance request, including any output parameters returned by the evaluation, as well as the description of any proposed actions to be taken."; 9905 case HEALTHCARESERVICE: return "The details of a healthcare service available at a location."; 9906 case IMAGINGSTUDY: return "Representation of the content produced in a DICOM imaging study. A study comprises a set of series, each of which includes a set of Service-Object Pair Instances (SOP Instances - images or other data) acquired or produced in a common context. A series is of only one modality (e.g. X-ray, CT, MR, ultrasound), but a study may have multiple series of different modalities."; 9907 case IMMUNIZATION: return "Describes the event of a patient being administered a vaccine or a record of an immunization as reported by a patient, a clinician or another party."; 9908 case IMMUNIZATIONEVALUATION: return "Describes a comparison of an immunization event against published recommendations to determine if the administration is \"valid\" in relation to those recommendations."; 9909 case IMMUNIZATIONRECOMMENDATION: return "A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification."; 9910 case IMPLEMENTATIONGUIDE: return "A set of rules of how a particular interoperability or standards problem is solved - typically through the use of FHIR resources. This resource is used to gather all the parts of an implementation guide into a logical whole and to publish a computable definition of all the parts."; 9911 case INGREDIENT: return "An ingredient of a manufactured item or pharmaceutical product."; 9912 case INSURANCEPLAN: return "Details of a Health Insurance product/plan provided by an organization."; 9913 case INVOICE: return "Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose."; 9914 case LIBRARY: return "The Library resource is a general-purpose container for knowledge asset definitions. It can be used to describe and expose existing knowledge assets such as logic libraries and information model descriptions, as well as to describe a collection of knowledge assets."; 9915 case LINKAGE: return "Identifies two or more records (resource instances) that refer to the same real-world \"occurrence\"."; 9916 case LIST: return "A list is a curated collection of resources."; 9917 case LOCATION: return "Details and position information for a physical place where services are provided and resources and participants may be stored, found, contained, or accommodated."; 9918 case MANUFACTUREDITEMDEFINITION: return "The definition and characteristics of a medicinal manufactured item, such as a tablet or capsule, as contained in a packaged medicinal product."; 9919 case MEASURE: return "The Measure resource provides the definition of a quality measure."; 9920 case MEASUREREPORT: return "The MeasureReport resource contains the results of the calculation of a measure; and optionally a reference to the resources involved in that calculation."; 9921 case MEDICATION: return "This resource is primarily used for the identification and definition of a medication for the purposes of prescribing, dispensing, and administering a medication as well as for making statements about medication use."; 9922 case MEDICATIONADMINISTRATION: return "Describes the event of a patient consuming or otherwise being administered a medication. This may be as simple as swallowing a tablet or it may be a long running infusion. Related resources tie this event to the authorizing prescription, and the specific encounter between patient and health care practitioner."; 9923 case MEDICATIONDISPENSE: return "Indicates that a medication product is to be or has been dispensed for a named person/patient. This includes a description of the medication product (supply) provided and the instructions for administering the medication. The medication dispense is the result of a pharmacy system responding to a medication order."; 9924 case MEDICATIONKNOWLEDGE: return "Information about a medication that is used to support knowledge."; 9925 case MEDICATIONREQUEST: return "An order or request for both supply of the medication and the instructions for administration of the medication to a patient. The resource is called \"MedicationRequest\" rather than \"MedicationPrescription\" or \"MedicationOrder\" to generalize the use across inpatient and outpatient settings, including care plans, etc., and to harmonize with workflow patterns."; 9926 case MEDICATIONUSAGE: return "A record of a medication that is being consumed by a patient. A MedicationUsage may indicate that the patient may be taking the medication now or has taken the medication in the past or will be taking the medication in the future. The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician. A common scenario where this information is captured is during the history taking process during a patient visit or stay. The medication information may come from sources such as the patient's memory, from a prescription bottle, or from a list of medications the patient, clinician or other party maintains. \n\nThe primary difference between a medicationusage and a medicationadministration is that the medication administration has complete administration information and is based on actual administration information from the person who administered the medication. A medicationusage is often, if not always, less specific. There is no required date/time when the medication was administered, in fact we only know that a source has reported the patient is taking this medication, where details such as time, quantity, or rate or even medication product may be incomplete or missing or less precise. As stated earlier, the Medication Usage information may come from the patient's memory, from a prescription bottle or from a list of medications the patient, clinician or other party maintains. Medication administration is more formal and is not missing detailed information."; 9927 case MEDICINALPRODUCTDEFINITION: return "Detailed definition of a medicinal product, typically for uses other than direct patient care (e.g. regulatory use)."; 9928 case MESSAGEDEFINITION: return "Defines the characteristics of a message that can be shared between systems, including the type of event that initiates the message, the content to be transmitted and what response(s), if any, are permitted."; 9929 case MESSAGEHEADER: return "The header for a message exchange that is either requesting or responding to an action. The reference(s) that are the subject of the action as well as other information related to the action are typically transmitted in a bundle in which the MessageHeader resource instance is the first resource in the bundle."; 9930 case MOLECULARSEQUENCE: return "Raw data describing a biological sequence."; 9931 case NAMINGSYSTEM: return "A curated namespace that issues unique symbols within that namespace for the identification of concepts, people, devices, etc. Represents a \"System\" used within the Identifier and Coding data types."; 9932 case NUTRITIONINTAKE: return "A record of food or fluid that is being consumed by a patient. A NutritionIntake may indicate that the patient may be consuming the food or fluid now or has consumed the food or fluid in the past. The source of this information can be the patient, significant other (such as a family member or spouse), or a clinician. A common scenario where this information is captured is during the history taking process during a patient visit or stay or through an app that tracks food or fluids consumed. The consumption information may come from sources such as the patient's memory, from a nutrition label, or from a clinician documenting observed intake."; 9933 case NUTRITIONORDER: return "A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident."; 9934 case OBSERVATION: return "Measurements and simple assertions made about a patient, device or other subject."; 9935 case OBSERVATIONDEFINITION: return "Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service."; 9936 case OPERATIONDEFINITION: return "A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction)."; 9937 case OPERATIONOUTCOME: return "A collection of error, warning, or information messages that result from a system action."; 9938 case ORGANIZATION: return "A formally or informally recognized grouping of people or organizations formed for the purpose of achieving some form of collective action. Includes companies, institutions, corporations, departments, community groups, healthcare practice groups, payer/insurer, etc."; 9939 case ORGANIZATIONAFFILIATION: return "Defines an affiliation/assotiation/relationship between 2 distinct oganizations, that is not a part-of relationship/sub-division relationship."; 9940 case PACKAGEDPRODUCTDEFINITION: return "A medicinal product in a container or package."; 9941 case PARAMETERS: return "This resource is a non-persisted resource used to pass information into and back from an [operation](operations.html). It has no other use, and there is no RESTful endpoint associated with it."; 9942 case PATIENT: return "Demographics and other administrative information about an individual or animal receiving care or other health-related services."; 9943 case PAYMENTNOTICE: return "This resource provides the status of the payment for goods and services rendered, and the request and response resource references."; 9944 case PAYMENTRECONCILIATION: return "This resource provides the details including amount of a payment and allocates the payment items being paid."; 9945 case PERSON: return "Demographics and administrative information about a person independent of a specific health-related context."; 9946 case PLANDEFINITION: return "This resource allows for the definition of various types of plans as a sharable, consumable, and executable artifact. The resource is general enough to support the description of a broad range of clinical artifacts such as clinical decision support rules, order sets and protocols."; 9947 case PRACTITIONER: return "A person who is directly or indirectly involved in the provisioning of healthcare."; 9948 case PRACTITIONERROLE: return "A specific set of Roles/Locations/specialties/services that a practitioner may perform at an organization for a period of time."; 9949 case PROCEDURE: return "An action that is or was performed on or for a patient. This can be a physical intervention like an operation, or less invasive like long term services, counseling, or hypnotherapy."; 9950 case PROVENANCE: return "Provenance of a resource is a record that describes entities and processes involved in producing and delivering or otherwise influencing that resource. Provenance provides a critical foundation for assessing authenticity, enabling trust, and allowing reproducibility. Provenance assertions are a form of contextual metadata and can themselves become important records with their own provenance. Provenance statement indicates clinical significance in terms of confidence in authenticity, reliability, and trustworthiness, integrity, and stage in lifecycle (e.g. Document Completion - has the artifact been legally authenticated), all of which may impact security, privacy, and trust policies."; 9951 case QUESTIONNAIRE: return "A structured set of questions intended to guide the collection of answers from end-users. Questionnaires provide detailed control over order, presentation, phraseology and grouping to allow coherent, consistent data collection."; 9952 case QUESTIONNAIRERESPONSE: return "A structured set of questions and their answers. The questions are ordered and grouped into coherent subsets, corresponding to the structure of the grouping of the questionnaire being responded to."; 9953 case REGULATEDAUTHORIZATION: return "The regulatory authorization of a medicinal product."; 9954 case RELATEDPERSON: return "Information about a person that is involved in the care for a patient, but who is not the target of healthcare, nor has a formal responsibility in the care process."; 9955 case REQUESTGROUP: return "A group of related requests that can be used to capture intended activities that have inter-dependencies such as \"give this medication after that one\"."; 9956 case RESEARCHSTUDY: return "A process where a researcher or organization plans and then executes a series of steps intended to increase the field of healthcare-related knowledge. This includes studies of safety, efficacy, comparative effectiveness and other information about medications, devices, therapies and other interventional and investigative techniques. A ResearchStudy involves the gathering of information about human or animal subjects."; 9957 case RESEARCHSUBJECT: return "A physical entity which is the primary unit of operational and/or administrative interest in a study."; 9958 case RESOURCE: return "This is the base resource type for everything."; 9959 case RISKASSESSMENT: return "An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome."; 9960 case SCHEDULE: return "A container for slots of time that may be available for booking appointments."; 9961 case SEARCHPARAMETER: return "A search parameter that defines a named search item that can be used to search/filter on a resource."; 9962 case SERVICEREQUEST: return "A record of a request for service such as diagnostic investigations, treatments, or operations to be performed."; 9963 case SLOT: return "A slot of time on a schedule that may be available for booking appointments."; 9964 case SPECIMEN: return "A sample to be used for analysis."; 9965 case SPECIMENDEFINITION: return "A kind of specimen with associated set of requirements."; 9966 case STRUCTUREDEFINITION: return "A definition of a FHIR structure. This resource is used to describe the underlying resources, data types defined in FHIR, and also for describing extensions and constraints on resources and data types."; 9967 case STRUCTUREMAP: return "A Map of relationships between 2 structures that can be used to transform data."; 9968 case SUBSCRIPTION: return "The subscription resource describes a particular client's request to be notified about a Topic."; 9969 case SUBSTANCE: return "A homogeneous material with a definite composition."; 9970 case SUBSTANCEDEFINITION: return "The detailed description of a substance, typically at a level beyond what is used for prescribing."; 9971 case SUBSTANCENUCLEICACID: return "Nucleic acids are defined by three distinct elements: the base, sugar and linkage. Individual substance/moiety IDs will be created for each of these elements. The nucleotide sequence will be always entered in the 5’-3’ direction."; 9972 case SUBSTANCEPOLYMER: return "Todo."; 9973 case SUBSTANCEPROTEIN: return "A SubstanceProtein is defined as a single unit of a linear amino acid sequence, or a combination of subunits that are either covalently linked or have a defined invariant stoichiometric relationship. This includes all synthetic, recombinant and purified SubstanceProteins of defined sequence, whether the use is therapeutic or prophylactic. This set of elements will be used to describe albumins, coagulation factors, cytokines, growth factors, peptide/SubstanceProtein hormones, enzymes, toxins, toxoids, recombinant vaccines, and immunomodulators."; 9974 case SUBSTANCEREFERENCEINFORMATION: return "Todo."; 9975 case SUBSTANCESOURCEMATERIAL: return "Source material shall capture information on the taxonomic and anatomical origins as well as the fraction of a material that can result in or can be modified to form a substance. This set of data elements shall be used to define polymer substances isolated from biological matrices. Taxonomic and anatomical origins shall be described using a controlled vocabulary as required. This information is captured for naturally derived polymers ( . starch) and structurally diverse substances. For Organisms belonging to the Kingdom Plantae the Substance level defines the fresh material of a single species or infraspecies, the Herbal Drug and the Herbal preparation. For Herbal preparations, the fraction information will be captured at the Substance information level and additional information for herbal extracts will be captured at the Specified Substance Group 1 information level. See for further explanation the Substance Class: Structurally Diverse and the herbal annex."; 9976 case SUPPLYDELIVERY: return "Record of delivery of what is supplied."; 9977 case SUPPLYREQUEST: return "A record of a request for a medication, substance or device used in the healthcare setting."; 9978 case TASK: return "A task to be performed."; 9979 case TERMINOLOGYCAPABILITIES: return "A TerminologyCapabilities resource documents a set of capabilities (behaviors) of a FHIR Terminology Server that may be used as a statement of actual server functionality or a statement of required or desired server implementation."; 9980 case TESTREPORT: return "A summary of information based on the results of executing a TestScript."; 9981 case TESTSCRIPT: return "A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification."; 9982 case TOPIC: return "Describes a stream of resource state changes identified by trigger criteria and annotated with labels useful to filter projections from this topic."; 9983 case VALUESET: return "A ValueSet resource instance specifies a set of codes drawn from one or more code systems, intended for use in a particular context. Value sets link between [[[CodeSystem]]] definitions and their use in [coded elements](terminologies.html)."; 9984 case VERIFICATIONRESULT: return "Describes validation requirements, source(s), status and dates for one or more elements."; 9985 case VISIONPRESCRIPTION: return "An authorization for the provision of glasses and/or contact lenses to a patient."; 9986 default: return "?"; 9987 } 9988 } 9989 public String getDisplay() { 9990 switch (this) { 9991 case ACCOUNT: return "Account"; 9992 case ACTIVITYDEFINITION: return "ActivityDefinition"; 9993 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 9994 case ADVERSEEVENT: return "AdverseEvent"; 9995 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 9996 case APPOINTMENT: return "Appointment"; 9997 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 9998 case AUDITEVENT: return "AuditEvent"; 9999 case BASIC: return "Basic"; 10000 case BINARY: return "Binary"; 10001 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 10002 case BODYSTRUCTURE: return "BodyStructure"; 10003 case BUNDLE: return "Bundle"; 10004 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 10005 case CAPABILITYSTATEMENT2: return "CapabilityStatement2"; 10006 case CAREPLAN: return "CarePlan"; 10007 case CARETEAM: return "CareTeam"; 10008 case CATALOGENTRY: return "CatalogEntry"; 10009 case CHARGEITEM: return "ChargeItem"; 10010 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 10011 case CLAIM: return "Claim"; 10012 case CLAIMRESPONSE: return "ClaimResponse"; 10013 case CLINICALIMPRESSION: return "ClinicalImpression"; 10014 case CLINICALUSEISSUE: return "ClinicalUseIssue"; 10015 case CODESYSTEM: return "CodeSystem"; 10016 case COMMUNICATION: return "Communication"; 10017 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 10018 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 10019 case COMPOSITION: return "Composition"; 10020 case CONCEPTMAP: return "ConceptMap"; 10021 case CONDITION: return "Condition"; 10022 case CONDITIONDEFINITION: return "ConditionDefinition"; 10023 case CONSENT: return "Consent"; 10024 case CONTRACT: return "Contract"; 10025 case COVERAGE: return "Coverage"; 10026 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 10027 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 10028 case DETECTEDISSUE: return "DetectedIssue"; 10029 case DEVICE: return "Device"; 10030 case DEVICEDEFINITION: return "DeviceDefinition"; 10031 case DEVICEMETRIC: return "DeviceMetric"; 10032 case DEVICEREQUEST: return "DeviceRequest"; 10033 case DEVICEUSESTATEMENT: return "DeviceUseStatement"; 10034 case DIAGNOSTICREPORT: return "DiagnosticReport"; 10035 case DOCUMENTMANIFEST: return "DocumentManifest"; 10036 case DOCUMENTREFERENCE: return "DocumentReference"; 10037 case DOMAINRESOURCE: return "DomainResource"; 10038 case ENCOUNTER: return "Encounter"; 10039 case ENDPOINT: return "Endpoint"; 10040 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 10041 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 10042 case EPISODEOFCARE: return "EpisodeOfCare"; 10043 case EVENTDEFINITION: return "EventDefinition"; 10044 case EVIDENCE: return "Evidence"; 10045 case EVIDENCEVARIABLE: return "EvidenceVariable"; 10046 case EXAMPLESCENARIO: return "ExampleScenario"; 10047 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 10048 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 10049 case FLAG: return "Flag"; 10050 case GOAL: return "Goal"; 10051 case GRAPHDEFINITION: return "GraphDefinition"; 10052 case GROUP: return "Group"; 10053 case GUIDANCERESPONSE: return "GuidanceResponse"; 10054 case HEALTHCARESERVICE: return "HealthcareService"; 10055 case IMAGINGSTUDY: return "ImagingStudy"; 10056 case IMMUNIZATION: return "Immunization"; 10057 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 10058 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 10059 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 10060 case INGREDIENT: return "Ingredient"; 10061 case INSURANCEPLAN: return "InsurancePlan"; 10062 case INVOICE: return "Invoice"; 10063 case LIBRARY: return "Library"; 10064 case LINKAGE: return "Linkage"; 10065 case LIST: return "List"; 10066 case LOCATION: return "Location"; 10067 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 10068 case MEASURE: return "Measure"; 10069 case MEASUREREPORT: return "MeasureReport"; 10070 case MEDICATION: return "Medication"; 10071 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 10072 case MEDICATIONDISPENSE: return "MedicationDispense"; 10073 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 10074 case MEDICATIONREQUEST: return "MedicationRequest"; 10075 case MEDICATIONUSAGE: return "MedicationUsage"; 10076 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 10077 case MESSAGEDEFINITION: return "MessageDefinition"; 10078 case MESSAGEHEADER: return "MessageHeader"; 10079 case MOLECULARSEQUENCE: return "MolecularSequence"; 10080 case NAMINGSYSTEM: return "NamingSystem"; 10081 case NUTRITIONINTAKE: return "NutritionIntake"; 10082 case NUTRITIONORDER: return "NutritionOrder"; 10083 case OBSERVATION: return "Observation"; 10084 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 10085 case OPERATIONDEFINITION: return "OperationDefinition"; 10086 case OPERATIONOUTCOME: return "OperationOutcome"; 10087 case ORGANIZATION: return "Organization"; 10088 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 10089 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 10090 case PARAMETERS: return "Parameters"; 10091 case PATIENT: return "Patient"; 10092 case PAYMENTNOTICE: return "PaymentNotice"; 10093 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 10094 case PERSON: return "Person"; 10095 case PLANDEFINITION: return "PlanDefinition"; 10096 case PRACTITIONER: return "Practitioner"; 10097 case PRACTITIONERROLE: return "PractitionerRole"; 10098 case PROCEDURE: return "Procedure"; 10099 case PROVENANCE: return "Provenance"; 10100 case QUESTIONNAIRE: return "Questionnaire"; 10101 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 10102 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 10103 case RELATEDPERSON: return "RelatedPerson"; 10104 case REQUESTGROUP: return "RequestGroup"; 10105 case RESEARCHSTUDY: return "ResearchStudy"; 10106 case RESEARCHSUBJECT: return "ResearchSubject"; 10107 case RESOURCE: return "Resource"; 10108 case RISKASSESSMENT: return "RiskAssessment"; 10109 case SCHEDULE: return "Schedule"; 10110 case SEARCHPARAMETER: return "SearchParameter"; 10111 case SERVICEREQUEST: return "ServiceRequest"; 10112 case SLOT: return "Slot"; 10113 case SPECIMEN: return "Specimen"; 10114 case SPECIMENDEFINITION: return "SpecimenDefinition"; 10115 case STRUCTUREDEFINITION: return "StructureDefinition"; 10116 case STRUCTUREMAP: return "StructureMap"; 10117 case SUBSCRIPTION: return "Subscription"; 10118 case SUBSTANCE: return "Substance"; 10119 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 10120 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 10121 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 10122 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 10123 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 10124 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 10125 case SUPPLYDELIVERY: return "SupplyDelivery"; 10126 case SUPPLYREQUEST: return "SupplyRequest"; 10127 case TASK: return "Task"; 10128 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 10129 case TESTREPORT: return "TestReport"; 10130 case TESTSCRIPT: return "TestScript"; 10131 case TOPIC: return "Topic"; 10132 case VALUESET: return "ValueSet"; 10133 case VERIFICATIONRESULT: return "VerificationResult"; 10134 case VISIONPRESCRIPTION: return "VisionPrescription"; 10135 default: return "?"; 10136 } 10137 } 10138 } 10139 10140 public static class ResourceTypeEnumEnumFactory implements EnumFactory<ResourceTypeEnum> { 10141 public ResourceTypeEnum fromCode(String codeString) throws IllegalArgumentException { 10142 if (codeString == null || "".equals(codeString)) 10143 if (codeString == null || "".equals(codeString)) 10144 return null; 10145 if ("Account".equals(codeString)) 10146 return ResourceTypeEnum.ACCOUNT; 10147 if ("ActivityDefinition".equals(codeString)) 10148 return ResourceTypeEnum.ACTIVITYDEFINITION; 10149 if ("AdministrableProductDefinition".equals(codeString)) 10150 return ResourceTypeEnum.ADMINISTRABLEPRODUCTDEFINITION; 10151 if ("AdverseEvent".equals(codeString)) 10152 return ResourceTypeEnum.ADVERSEEVENT; 10153 if ("AllergyIntolerance".equals(codeString)) 10154 return ResourceTypeEnum.ALLERGYINTOLERANCE; 10155 if ("Appointment".equals(codeString)) 10156 return ResourceTypeEnum.APPOINTMENT; 10157 if ("AppointmentResponse".equals(codeString)) 10158 return ResourceTypeEnum.APPOINTMENTRESPONSE; 10159 if ("AuditEvent".equals(codeString)) 10160 return ResourceTypeEnum.AUDITEVENT; 10161 if ("Basic".equals(codeString)) 10162 return ResourceTypeEnum.BASIC; 10163 if ("Binary".equals(codeString)) 10164 return ResourceTypeEnum.BINARY; 10165 if ("BiologicallyDerivedProduct".equals(codeString)) 10166 return ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCT; 10167 if ("BodyStructure".equals(codeString)) 10168 return ResourceTypeEnum.BODYSTRUCTURE; 10169 if ("Bundle".equals(codeString)) 10170 return ResourceTypeEnum.BUNDLE; 10171 if ("CapabilityStatement".equals(codeString)) 10172 return ResourceTypeEnum.CAPABILITYSTATEMENT; 10173 if ("CapabilityStatement2".equals(codeString)) 10174 return ResourceTypeEnum.CAPABILITYSTATEMENT2; 10175 if ("CarePlan".equals(codeString)) 10176 return ResourceTypeEnum.CAREPLAN; 10177 if ("CareTeam".equals(codeString)) 10178 return ResourceTypeEnum.CARETEAM; 10179 if ("CatalogEntry".equals(codeString)) 10180 return ResourceTypeEnum.CATALOGENTRY; 10181 if ("ChargeItem".equals(codeString)) 10182 return ResourceTypeEnum.CHARGEITEM; 10183 if ("ChargeItemDefinition".equals(codeString)) 10184 return ResourceTypeEnum.CHARGEITEMDEFINITION; 10185 if ("Claim".equals(codeString)) 10186 return ResourceTypeEnum.CLAIM; 10187 if ("ClaimResponse".equals(codeString)) 10188 return ResourceTypeEnum.CLAIMRESPONSE; 10189 if ("ClinicalImpression".equals(codeString)) 10190 return ResourceTypeEnum.CLINICALIMPRESSION; 10191 if ("ClinicalUseIssue".equals(codeString)) 10192 return ResourceTypeEnum.CLINICALUSEISSUE; 10193 if ("CodeSystem".equals(codeString)) 10194 return ResourceTypeEnum.CODESYSTEM; 10195 if ("Communication".equals(codeString)) 10196 return ResourceTypeEnum.COMMUNICATION; 10197 if ("CommunicationRequest".equals(codeString)) 10198 return ResourceTypeEnum.COMMUNICATIONREQUEST; 10199 if ("CompartmentDefinition".equals(codeString)) 10200 return ResourceTypeEnum.COMPARTMENTDEFINITION; 10201 if ("Composition".equals(codeString)) 10202 return ResourceTypeEnum.COMPOSITION; 10203 if ("ConceptMap".equals(codeString)) 10204 return ResourceTypeEnum.CONCEPTMAP; 10205 if ("Condition".equals(codeString)) 10206 return ResourceTypeEnum.CONDITION; 10207 if ("ConditionDefinition".equals(codeString)) 10208 return ResourceTypeEnum.CONDITIONDEFINITION; 10209 if ("Consent".equals(codeString)) 10210 return ResourceTypeEnum.CONSENT; 10211 if ("Contract".equals(codeString)) 10212 return ResourceTypeEnum.CONTRACT; 10213 if ("Coverage".equals(codeString)) 10214 return ResourceTypeEnum.COVERAGE; 10215 if ("CoverageEligibilityRequest".equals(codeString)) 10216 return ResourceTypeEnum.COVERAGEELIGIBILITYREQUEST; 10217 if ("CoverageEligibilityResponse".equals(codeString)) 10218 return ResourceTypeEnum.COVERAGEELIGIBILITYRESPONSE; 10219 if ("DetectedIssue".equals(codeString)) 10220 return ResourceTypeEnum.DETECTEDISSUE; 10221 if ("Device".equals(codeString)) 10222 return ResourceTypeEnum.DEVICE; 10223 if ("DeviceDefinition".equals(codeString)) 10224 return ResourceTypeEnum.DEVICEDEFINITION; 10225 if ("DeviceMetric".equals(codeString)) 10226 return ResourceTypeEnum.DEVICEMETRIC; 10227 if ("DeviceRequest".equals(codeString)) 10228 return ResourceTypeEnum.DEVICEREQUEST; 10229 if ("DeviceUseStatement".equals(codeString)) 10230 return ResourceTypeEnum.DEVICEUSESTATEMENT; 10231 if ("DiagnosticReport".equals(codeString)) 10232 return ResourceTypeEnum.DIAGNOSTICREPORT; 10233 if ("DocumentManifest".equals(codeString)) 10234 return ResourceTypeEnum.DOCUMENTMANIFEST; 10235 if ("DocumentReference".equals(codeString)) 10236 return ResourceTypeEnum.DOCUMENTREFERENCE; 10237 if ("DomainResource".equals(codeString)) 10238 return ResourceTypeEnum.DOMAINRESOURCE; 10239 if ("Encounter".equals(codeString)) 10240 return ResourceTypeEnum.ENCOUNTER; 10241 if ("Endpoint".equals(codeString)) 10242 return ResourceTypeEnum.ENDPOINT; 10243 if ("EnrollmentRequest".equals(codeString)) 10244 return ResourceTypeEnum.ENROLLMENTREQUEST; 10245 if ("EnrollmentResponse".equals(codeString)) 10246 return ResourceTypeEnum.ENROLLMENTRESPONSE; 10247 if ("EpisodeOfCare".equals(codeString)) 10248 return ResourceTypeEnum.EPISODEOFCARE; 10249 if ("EventDefinition".equals(codeString)) 10250 return ResourceTypeEnum.EVENTDEFINITION; 10251 if ("Evidence".equals(codeString)) 10252 return ResourceTypeEnum.EVIDENCE; 10253 if ("EvidenceVariable".equals(codeString)) 10254 return ResourceTypeEnum.EVIDENCEVARIABLE; 10255 if ("ExampleScenario".equals(codeString)) 10256 return ResourceTypeEnum.EXAMPLESCENARIO; 10257 if ("ExplanationOfBenefit".equals(codeString)) 10258 return ResourceTypeEnum.EXPLANATIONOFBENEFIT; 10259 if ("FamilyMemberHistory".equals(codeString)) 10260 return ResourceTypeEnum.FAMILYMEMBERHISTORY; 10261 if ("Flag".equals(codeString)) 10262 return ResourceTypeEnum.FLAG; 10263 if ("Goal".equals(codeString)) 10264 return ResourceTypeEnum.GOAL; 10265 if ("GraphDefinition".equals(codeString)) 10266 return ResourceTypeEnum.GRAPHDEFINITION; 10267 if ("Group".equals(codeString)) 10268 return ResourceTypeEnum.GROUP; 10269 if ("GuidanceResponse".equals(codeString)) 10270 return ResourceTypeEnum.GUIDANCERESPONSE; 10271 if ("HealthcareService".equals(codeString)) 10272 return ResourceTypeEnum.HEALTHCARESERVICE; 10273 if ("ImagingStudy".equals(codeString)) 10274 return ResourceTypeEnum.IMAGINGSTUDY; 10275 if ("Immunization".equals(codeString)) 10276 return ResourceTypeEnum.IMMUNIZATION; 10277 if ("ImmunizationEvaluation".equals(codeString)) 10278 return ResourceTypeEnum.IMMUNIZATIONEVALUATION; 10279 if ("ImmunizationRecommendation".equals(codeString)) 10280 return ResourceTypeEnum.IMMUNIZATIONRECOMMENDATION; 10281 if ("ImplementationGuide".equals(codeString)) 10282 return ResourceTypeEnum.IMPLEMENTATIONGUIDE; 10283 if ("Ingredient".equals(codeString)) 10284 return ResourceTypeEnum.INGREDIENT; 10285 if ("InsurancePlan".equals(codeString)) 10286 return ResourceTypeEnum.INSURANCEPLAN; 10287 if ("Invoice".equals(codeString)) 10288 return ResourceTypeEnum.INVOICE; 10289 if ("Library".equals(codeString)) 10290 return ResourceTypeEnum.LIBRARY; 10291 if ("Linkage".equals(codeString)) 10292 return ResourceTypeEnum.LINKAGE; 10293 if ("List".equals(codeString)) 10294 return ResourceTypeEnum.LIST; 10295 if ("Location".equals(codeString)) 10296 return ResourceTypeEnum.LOCATION; 10297 if ("ManufacturedItemDefinition".equals(codeString)) 10298 return ResourceTypeEnum.MANUFACTUREDITEMDEFINITION; 10299 if ("Measure".equals(codeString)) 10300 return ResourceTypeEnum.MEASURE; 10301 if ("MeasureReport".equals(codeString)) 10302 return ResourceTypeEnum.MEASUREREPORT; 10303 if ("Medication".equals(codeString)) 10304 return ResourceTypeEnum.MEDICATION; 10305 if ("MedicationAdministration".equals(codeString)) 10306 return ResourceTypeEnum.MEDICATIONADMINISTRATION; 10307 if ("MedicationDispense".equals(codeString)) 10308 return ResourceTypeEnum.MEDICATIONDISPENSE; 10309 if ("MedicationKnowledge".equals(codeString)) 10310 return ResourceTypeEnum.MEDICATIONKNOWLEDGE; 10311 if ("MedicationRequest".equals(codeString)) 10312 return ResourceTypeEnum.MEDICATIONREQUEST; 10313 if ("MedicationUsage".equals(codeString)) 10314 return ResourceTypeEnum.MEDICATIONUSAGE; 10315 if ("MedicinalProductDefinition".equals(codeString)) 10316 return ResourceTypeEnum.MEDICINALPRODUCTDEFINITION; 10317 if ("MessageDefinition".equals(codeString)) 10318 return ResourceTypeEnum.MESSAGEDEFINITION; 10319 if ("MessageHeader".equals(codeString)) 10320 return ResourceTypeEnum.MESSAGEHEADER; 10321 if ("MolecularSequence".equals(codeString)) 10322 return ResourceTypeEnum.MOLECULARSEQUENCE; 10323 if ("NamingSystem".equals(codeString)) 10324 return ResourceTypeEnum.NAMINGSYSTEM; 10325 if ("NutritionIntake".equals(codeString)) 10326 return ResourceTypeEnum.NUTRITIONINTAKE; 10327 if ("NutritionOrder".equals(codeString)) 10328 return ResourceTypeEnum.NUTRITIONORDER; 10329 if ("Observation".equals(codeString)) 10330 return ResourceTypeEnum.OBSERVATION; 10331 if ("ObservationDefinition".equals(codeString)) 10332 return ResourceTypeEnum.OBSERVATIONDEFINITION; 10333 if ("OperationDefinition".equals(codeString)) 10334 return ResourceTypeEnum.OPERATIONDEFINITION; 10335 if ("OperationOutcome".equals(codeString)) 10336 return ResourceTypeEnum.OPERATIONOUTCOME; 10337 if ("Organization".equals(codeString)) 10338 return ResourceTypeEnum.ORGANIZATION; 10339 if ("OrganizationAffiliation".equals(codeString)) 10340 return ResourceTypeEnum.ORGANIZATIONAFFILIATION; 10341 if ("PackagedProductDefinition".equals(codeString)) 10342 return ResourceTypeEnum.PACKAGEDPRODUCTDEFINITION; 10343 if ("Parameters".equals(codeString)) 10344 return ResourceTypeEnum.PARAMETERS; 10345 if ("Patient".equals(codeString)) 10346 return ResourceTypeEnum.PATIENT; 10347 if ("PaymentNotice".equals(codeString)) 10348 return ResourceTypeEnum.PAYMENTNOTICE; 10349 if ("PaymentReconciliation".equals(codeString)) 10350 return ResourceTypeEnum.PAYMENTRECONCILIATION; 10351 if ("Person".equals(codeString)) 10352 return ResourceTypeEnum.PERSON; 10353 if ("PlanDefinition".equals(codeString)) 10354 return ResourceTypeEnum.PLANDEFINITION; 10355 if ("Practitioner".equals(codeString)) 10356 return ResourceTypeEnum.PRACTITIONER; 10357 if ("PractitionerRole".equals(codeString)) 10358 return ResourceTypeEnum.PRACTITIONERROLE; 10359 if ("Procedure".equals(codeString)) 10360 return ResourceTypeEnum.PROCEDURE; 10361 if ("Provenance".equals(codeString)) 10362 return ResourceTypeEnum.PROVENANCE; 10363 if ("Questionnaire".equals(codeString)) 10364 return ResourceTypeEnum.QUESTIONNAIRE; 10365 if ("QuestionnaireResponse".equals(codeString)) 10366 return ResourceTypeEnum.QUESTIONNAIRERESPONSE; 10367 if ("RegulatedAuthorization".equals(codeString)) 10368 return ResourceTypeEnum.REGULATEDAUTHORIZATION; 10369 if ("RelatedPerson".equals(codeString)) 10370 return ResourceTypeEnum.RELATEDPERSON; 10371 if ("RequestGroup".equals(codeString)) 10372 return ResourceTypeEnum.REQUESTGROUP; 10373 if ("ResearchStudy".equals(codeString)) 10374 return ResourceTypeEnum.RESEARCHSTUDY; 10375 if ("ResearchSubject".equals(codeString)) 10376 return ResourceTypeEnum.RESEARCHSUBJECT; 10377 if ("Resource".equals(codeString)) 10378 return ResourceTypeEnum.RESOURCE; 10379 if ("RiskAssessment".equals(codeString)) 10380 return ResourceTypeEnum.RISKASSESSMENT; 10381 if ("Schedule".equals(codeString)) 10382 return ResourceTypeEnum.SCHEDULE; 10383 if ("SearchParameter".equals(codeString)) 10384 return ResourceTypeEnum.SEARCHPARAMETER; 10385 if ("ServiceRequest".equals(codeString)) 10386 return ResourceTypeEnum.SERVICEREQUEST; 10387 if ("Slot".equals(codeString)) 10388 return ResourceTypeEnum.SLOT; 10389 if ("Specimen".equals(codeString)) 10390 return ResourceTypeEnum.SPECIMEN; 10391 if ("SpecimenDefinition".equals(codeString)) 10392 return ResourceTypeEnum.SPECIMENDEFINITION; 10393 if ("StructureDefinition".equals(codeString)) 10394 return ResourceTypeEnum.STRUCTUREDEFINITION; 10395 if ("StructureMap".equals(codeString)) 10396 return ResourceTypeEnum.STRUCTUREMAP; 10397 if ("Subscription".equals(codeString)) 10398 return ResourceTypeEnum.SUBSCRIPTION; 10399 if ("Substance".equals(codeString)) 10400 return ResourceTypeEnum.SUBSTANCE; 10401 if ("SubstanceDefinition".equals(codeString)) 10402 return ResourceTypeEnum.SUBSTANCEDEFINITION; 10403 if ("SubstanceNucleicAcid".equals(codeString)) 10404 return ResourceTypeEnum.SUBSTANCENUCLEICACID; 10405 if ("SubstancePolymer".equals(codeString)) 10406 return ResourceTypeEnum.SUBSTANCEPOLYMER; 10407 if ("SubstanceProtein".equals(codeString)) 10408 return ResourceTypeEnum.SUBSTANCEPROTEIN; 10409 if ("SubstanceReferenceInformation".equals(codeString)) 10410 return ResourceTypeEnum.SUBSTANCEREFERENCEINFORMATION; 10411 if ("SubstanceSourceMaterial".equals(codeString)) 10412 return ResourceTypeEnum.SUBSTANCESOURCEMATERIAL; 10413 if ("SupplyDelivery".equals(codeString)) 10414 return ResourceTypeEnum.SUPPLYDELIVERY; 10415 if ("SupplyRequest".equals(codeString)) 10416 return ResourceTypeEnum.SUPPLYREQUEST; 10417 if ("Task".equals(codeString)) 10418 return ResourceTypeEnum.TASK; 10419 if ("TerminologyCapabilities".equals(codeString)) 10420 return ResourceTypeEnum.TERMINOLOGYCAPABILITIES; 10421 if ("TestReport".equals(codeString)) 10422 return ResourceTypeEnum.TESTREPORT; 10423 if ("TestScript".equals(codeString)) 10424 return ResourceTypeEnum.TESTSCRIPT; 10425 if ("Topic".equals(codeString)) 10426 return ResourceTypeEnum.TOPIC; 10427 if ("ValueSet".equals(codeString)) 10428 return ResourceTypeEnum.VALUESET; 10429 if ("VerificationResult".equals(codeString)) 10430 return ResourceTypeEnum.VERIFICATIONRESULT; 10431 if ("VisionPrescription".equals(codeString)) 10432 return ResourceTypeEnum.VISIONPRESCRIPTION; 10433 throw new IllegalArgumentException("Unknown ResourceTypeEnum code '"+codeString+"'"); 10434 } 10435 public Enumeration<ResourceTypeEnum> fromType(Base code) throws FHIRException { 10436 if (code == null) 10437 return null; 10438 if (code.isEmpty()) 10439 return new Enumeration<ResourceTypeEnum>(this); 10440 String codeString = ((PrimitiveType) code).asStringValue(); 10441 if (codeString == null || "".equals(codeString)) 10442 return null; 10443 if ("Account".equals(codeString)) 10444 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ACCOUNT); 10445 if ("ActivityDefinition".equals(codeString)) 10446 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ACTIVITYDEFINITION); 10447 if ("AdministrableProductDefinition".equals(codeString)) 10448 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ADMINISTRABLEPRODUCTDEFINITION); 10449 if ("AdverseEvent".equals(codeString)) 10450 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ADVERSEEVENT); 10451 if ("AllergyIntolerance".equals(codeString)) 10452 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ALLERGYINTOLERANCE); 10453 if ("Appointment".equals(codeString)) 10454 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.APPOINTMENT); 10455 if ("AppointmentResponse".equals(codeString)) 10456 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.APPOINTMENTRESPONSE); 10457 if ("AuditEvent".equals(codeString)) 10458 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.AUDITEVENT); 10459 if ("Basic".equals(codeString)) 10460 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BASIC); 10461 if ("Binary".equals(codeString)) 10462 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BINARY); 10463 if ("BiologicallyDerivedProduct".equals(codeString)) 10464 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCT); 10465 if ("BodyStructure".equals(codeString)) 10466 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BODYSTRUCTURE); 10467 if ("Bundle".equals(codeString)) 10468 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.BUNDLE); 10469 if ("CapabilityStatement".equals(codeString)) 10470 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CAPABILITYSTATEMENT); 10471 if ("CapabilityStatement2".equals(codeString)) 10472 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CAPABILITYSTATEMENT2); 10473 if ("CarePlan".equals(codeString)) 10474 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CAREPLAN); 10475 if ("CareTeam".equals(codeString)) 10476 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CARETEAM); 10477 if ("CatalogEntry".equals(codeString)) 10478 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CATALOGENTRY); 10479 if ("ChargeItem".equals(codeString)) 10480 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CHARGEITEM); 10481 if ("ChargeItemDefinition".equals(codeString)) 10482 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CHARGEITEMDEFINITION); 10483 if ("Claim".equals(codeString)) 10484 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLAIM); 10485 if ("ClaimResponse".equals(codeString)) 10486 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLAIMRESPONSE); 10487 if ("ClinicalImpression".equals(codeString)) 10488 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLINICALIMPRESSION); 10489 if ("ClinicalUseIssue".equals(codeString)) 10490 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CLINICALUSEISSUE); 10491 if ("CodeSystem".equals(codeString)) 10492 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CODESYSTEM); 10493 if ("Communication".equals(codeString)) 10494 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMMUNICATION); 10495 if ("CommunicationRequest".equals(codeString)) 10496 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMMUNICATIONREQUEST); 10497 if ("CompartmentDefinition".equals(codeString)) 10498 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMPARTMENTDEFINITION); 10499 if ("Composition".equals(codeString)) 10500 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COMPOSITION); 10501 if ("ConceptMap".equals(codeString)) 10502 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONCEPTMAP); 10503 if ("Condition".equals(codeString)) 10504 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONDITION); 10505 if ("ConditionDefinition".equals(codeString)) 10506 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONDITIONDEFINITION); 10507 if ("Consent".equals(codeString)) 10508 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONSENT); 10509 if ("Contract".equals(codeString)) 10510 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.CONTRACT); 10511 if ("Coverage".equals(codeString)) 10512 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COVERAGE); 10513 if ("CoverageEligibilityRequest".equals(codeString)) 10514 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COVERAGEELIGIBILITYREQUEST); 10515 if ("CoverageEligibilityResponse".equals(codeString)) 10516 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.COVERAGEELIGIBILITYRESPONSE); 10517 if ("DetectedIssue".equals(codeString)) 10518 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DETECTEDISSUE); 10519 if ("Device".equals(codeString)) 10520 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICE); 10521 if ("DeviceDefinition".equals(codeString)) 10522 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEDEFINITION); 10523 if ("DeviceMetric".equals(codeString)) 10524 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEMETRIC); 10525 if ("DeviceRequest".equals(codeString)) 10526 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEREQUEST); 10527 if ("DeviceUseStatement".equals(codeString)) 10528 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DEVICEUSESTATEMENT); 10529 if ("DiagnosticReport".equals(codeString)) 10530 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DIAGNOSTICREPORT); 10531 if ("DocumentManifest".equals(codeString)) 10532 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DOCUMENTMANIFEST); 10533 if ("DocumentReference".equals(codeString)) 10534 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DOCUMENTREFERENCE); 10535 if ("DomainResource".equals(codeString)) 10536 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.DOMAINRESOURCE); 10537 if ("Encounter".equals(codeString)) 10538 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENCOUNTER); 10539 if ("Endpoint".equals(codeString)) 10540 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENDPOINT); 10541 if ("EnrollmentRequest".equals(codeString)) 10542 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENROLLMENTREQUEST); 10543 if ("EnrollmentResponse".equals(codeString)) 10544 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ENROLLMENTRESPONSE); 10545 if ("EpisodeOfCare".equals(codeString)) 10546 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EPISODEOFCARE); 10547 if ("EventDefinition".equals(codeString)) 10548 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EVENTDEFINITION); 10549 if ("Evidence".equals(codeString)) 10550 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EVIDENCE); 10551 if ("EvidenceVariable".equals(codeString)) 10552 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EVIDENCEVARIABLE); 10553 if ("ExampleScenario".equals(codeString)) 10554 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EXAMPLESCENARIO); 10555 if ("ExplanationOfBenefit".equals(codeString)) 10556 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.EXPLANATIONOFBENEFIT); 10557 if ("FamilyMemberHistory".equals(codeString)) 10558 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.FAMILYMEMBERHISTORY); 10559 if ("Flag".equals(codeString)) 10560 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.FLAG); 10561 if ("Goal".equals(codeString)) 10562 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GOAL); 10563 if ("GraphDefinition".equals(codeString)) 10564 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GRAPHDEFINITION); 10565 if ("Group".equals(codeString)) 10566 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GROUP); 10567 if ("GuidanceResponse".equals(codeString)) 10568 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.GUIDANCERESPONSE); 10569 if ("HealthcareService".equals(codeString)) 10570 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.HEALTHCARESERVICE); 10571 if ("ImagingStudy".equals(codeString)) 10572 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMAGINGSTUDY); 10573 if ("Immunization".equals(codeString)) 10574 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMMUNIZATION); 10575 if ("ImmunizationEvaluation".equals(codeString)) 10576 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMMUNIZATIONEVALUATION); 10577 if ("ImmunizationRecommendation".equals(codeString)) 10578 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMMUNIZATIONRECOMMENDATION); 10579 if ("ImplementationGuide".equals(codeString)) 10580 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.IMPLEMENTATIONGUIDE); 10581 if ("Ingredient".equals(codeString)) 10582 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INGREDIENT); 10583 if ("InsurancePlan".equals(codeString)) 10584 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INSURANCEPLAN); 10585 if ("Invoice".equals(codeString)) 10586 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.INVOICE); 10587 if ("Library".equals(codeString)) 10588 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LIBRARY); 10589 if ("Linkage".equals(codeString)) 10590 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LINKAGE); 10591 if ("List".equals(codeString)) 10592 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LIST); 10593 if ("Location".equals(codeString)) 10594 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.LOCATION); 10595 if ("ManufacturedItemDefinition".equals(codeString)) 10596 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MANUFACTUREDITEMDEFINITION); 10597 if ("Measure".equals(codeString)) 10598 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEASURE); 10599 if ("MeasureReport".equals(codeString)) 10600 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEASUREREPORT); 10601 if ("Medication".equals(codeString)) 10602 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATION); 10603 if ("MedicationAdministration".equals(codeString)) 10604 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONADMINISTRATION); 10605 if ("MedicationDispense".equals(codeString)) 10606 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONDISPENSE); 10607 if ("MedicationKnowledge".equals(codeString)) 10608 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONKNOWLEDGE); 10609 if ("MedicationRequest".equals(codeString)) 10610 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONREQUEST); 10611 if ("MedicationUsage".equals(codeString)) 10612 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICATIONUSAGE); 10613 if ("MedicinalProductDefinition".equals(codeString)) 10614 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MEDICINALPRODUCTDEFINITION); 10615 if ("MessageDefinition".equals(codeString)) 10616 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MESSAGEDEFINITION); 10617 if ("MessageHeader".equals(codeString)) 10618 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MESSAGEHEADER); 10619 if ("MolecularSequence".equals(codeString)) 10620 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.MOLECULARSEQUENCE); 10621 if ("NamingSystem".equals(codeString)) 10622 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NAMINGSYSTEM); 10623 if ("NutritionIntake".equals(codeString)) 10624 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NUTRITIONINTAKE); 10625 if ("NutritionOrder".equals(codeString)) 10626 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.NUTRITIONORDER); 10627 if ("Observation".equals(codeString)) 10628 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OBSERVATION); 10629 if ("ObservationDefinition".equals(codeString)) 10630 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OBSERVATIONDEFINITION); 10631 if ("OperationDefinition".equals(codeString)) 10632 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OPERATIONDEFINITION); 10633 if ("OperationOutcome".equals(codeString)) 10634 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.OPERATIONOUTCOME); 10635 if ("Organization".equals(codeString)) 10636 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ORGANIZATION); 10637 if ("OrganizationAffiliation".equals(codeString)) 10638 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.ORGANIZATIONAFFILIATION); 10639 if ("PackagedProductDefinition".equals(codeString)) 10640 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PACKAGEDPRODUCTDEFINITION); 10641 if ("Parameters".equals(codeString)) 10642 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PARAMETERS); 10643 if ("Patient".equals(codeString)) 10644 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PATIENT); 10645 if ("PaymentNotice".equals(codeString)) 10646 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PAYMENTNOTICE); 10647 if ("PaymentReconciliation".equals(codeString)) 10648 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PAYMENTRECONCILIATION); 10649 if ("Person".equals(codeString)) 10650 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PERSON); 10651 if ("PlanDefinition".equals(codeString)) 10652 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PLANDEFINITION); 10653 if ("Practitioner".equals(codeString)) 10654 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PRACTITIONER); 10655 if ("PractitionerRole".equals(codeString)) 10656 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PRACTITIONERROLE); 10657 if ("Procedure".equals(codeString)) 10658 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PROCEDURE); 10659 if ("Provenance".equals(codeString)) 10660 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.PROVENANCE); 10661 if ("Questionnaire".equals(codeString)) 10662 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.QUESTIONNAIRE); 10663 if ("QuestionnaireResponse".equals(codeString)) 10664 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.QUESTIONNAIRERESPONSE); 10665 if ("RegulatedAuthorization".equals(codeString)) 10666 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.REGULATEDAUTHORIZATION); 10667 if ("RelatedPerson".equals(codeString)) 10668 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RELATEDPERSON); 10669 if ("RequestGroup".equals(codeString)) 10670 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.REQUESTGROUP); 10671 if ("ResearchStudy".equals(codeString)) 10672 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RESEARCHSTUDY); 10673 if ("ResearchSubject".equals(codeString)) 10674 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RESEARCHSUBJECT); 10675 if ("Resource".equals(codeString)) 10676 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RESOURCE); 10677 if ("RiskAssessment".equals(codeString)) 10678 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.RISKASSESSMENT); 10679 if ("Schedule".equals(codeString)) 10680 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SCHEDULE); 10681 if ("SearchParameter".equals(codeString)) 10682 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SEARCHPARAMETER); 10683 if ("ServiceRequest".equals(codeString)) 10684 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SERVICEREQUEST); 10685 if ("Slot".equals(codeString)) 10686 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SLOT); 10687 if ("Specimen".equals(codeString)) 10688 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SPECIMEN); 10689 if ("SpecimenDefinition".equals(codeString)) 10690 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SPECIMENDEFINITION); 10691 if ("StructureDefinition".equals(codeString)) 10692 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.STRUCTUREDEFINITION); 10693 if ("StructureMap".equals(codeString)) 10694 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.STRUCTUREMAP); 10695 if ("Subscription".equals(codeString)) 10696 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSCRIPTION); 10697 if ("Substance".equals(codeString)) 10698 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCE); 10699 if ("SubstanceDefinition".equals(codeString)) 10700 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEDEFINITION); 10701 if ("SubstanceNucleicAcid".equals(codeString)) 10702 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCENUCLEICACID); 10703 if ("SubstancePolymer".equals(codeString)) 10704 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEPOLYMER); 10705 if ("SubstanceProtein".equals(codeString)) 10706 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEPROTEIN); 10707 if ("SubstanceReferenceInformation".equals(codeString)) 10708 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCEREFERENCEINFORMATION); 10709 if ("SubstanceSourceMaterial".equals(codeString)) 10710 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUBSTANCESOURCEMATERIAL); 10711 if ("SupplyDelivery".equals(codeString)) 10712 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUPPLYDELIVERY); 10713 if ("SupplyRequest".equals(codeString)) 10714 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.SUPPLYREQUEST); 10715 if ("Task".equals(codeString)) 10716 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TASK); 10717 if ("TerminologyCapabilities".equals(codeString)) 10718 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TERMINOLOGYCAPABILITIES); 10719 if ("TestReport".equals(codeString)) 10720 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TESTREPORT); 10721 if ("TestScript".equals(codeString)) 10722 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TESTSCRIPT); 10723 if ("Topic".equals(codeString)) 10724 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.TOPIC); 10725 if ("ValueSet".equals(codeString)) 10726 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.VALUESET); 10727 if ("VerificationResult".equals(codeString)) 10728 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.VERIFICATIONRESULT); 10729 if ("VisionPrescription".equals(codeString)) 10730 return new Enumeration<ResourceTypeEnum>(this, ResourceTypeEnum.VISIONPRESCRIPTION); 10731 throw new FHIRException("Unknown ResourceTypeEnum code '"+codeString+"'"); 10732 } 10733 public String toCode(ResourceTypeEnum code) { 10734 if (code == ResourceTypeEnum.ACCOUNT) 10735 return "Account"; 10736 if (code == ResourceTypeEnum.ACTIVITYDEFINITION) 10737 return "ActivityDefinition"; 10738 if (code == ResourceTypeEnum.ADMINISTRABLEPRODUCTDEFINITION) 10739 return "AdministrableProductDefinition"; 10740 if (code == ResourceTypeEnum.ADVERSEEVENT) 10741 return "AdverseEvent"; 10742 if (code == ResourceTypeEnum.ALLERGYINTOLERANCE) 10743 return "AllergyIntolerance"; 10744 if (code == ResourceTypeEnum.APPOINTMENT) 10745 return "Appointment"; 10746 if (code == ResourceTypeEnum.APPOINTMENTRESPONSE) 10747 return "AppointmentResponse"; 10748 if (code == ResourceTypeEnum.AUDITEVENT) 10749 return "AuditEvent"; 10750 if (code == ResourceTypeEnum.BASIC) 10751 return "Basic"; 10752 if (code == ResourceTypeEnum.BINARY) 10753 return "Binary"; 10754 if (code == ResourceTypeEnum.BIOLOGICALLYDERIVEDPRODUCT) 10755 return "BiologicallyDerivedProduct"; 10756 if (code == ResourceTypeEnum.BODYSTRUCTURE) 10757 return "BodyStructure"; 10758 if (code == ResourceTypeEnum.BUNDLE) 10759 return "Bundle"; 10760 if (code == ResourceTypeEnum.CAPABILITYSTATEMENT) 10761 return "CapabilityStatement"; 10762 if (code == ResourceTypeEnum.CAPABILITYSTATEMENT2) 10763 return "CapabilityStatement2"; 10764 if (code == ResourceTypeEnum.CAREPLAN) 10765 return "CarePlan"; 10766 if (code == ResourceTypeEnum.CARETEAM) 10767 return "CareTeam"; 10768 if (code == ResourceTypeEnum.CATALOGENTRY) 10769 return "CatalogEntry"; 10770 if (code == ResourceTypeEnum.CHARGEITEM) 10771 return "ChargeItem"; 10772 if (code == ResourceTypeEnum.CHARGEITEMDEFINITION) 10773 return "ChargeItemDefinition"; 10774 if (code == ResourceTypeEnum.CLAIM) 10775 return "Claim"; 10776 if (code == ResourceTypeEnum.CLAIMRESPONSE) 10777 return "ClaimResponse"; 10778 if (code == ResourceTypeEnum.CLINICALIMPRESSION) 10779 return "ClinicalImpression"; 10780 if (code == ResourceTypeEnum.CLINICALUSEISSUE) 10781 return "ClinicalUseIssue"; 10782 if (code == ResourceTypeEnum.CODESYSTEM) 10783 return "CodeSystem"; 10784 if (code == ResourceTypeEnum.COMMUNICATION) 10785 return "Communication"; 10786 if (code == ResourceTypeEnum.COMMUNICATIONREQUEST) 10787 return "CommunicationRequest"; 10788 if (code == ResourceTypeEnum.COMPARTMENTDEFINITION) 10789 return "CompartmentDefinition"; 10790 if (code == ResourceTypeEnum.COMPOSITION) 10791 return "Composition"; 10792 if (code == ResourceTypeEnum.CONCEPTMAP) 10793 return "ConceptMap"; 10794 if (code == ResourceTypeEnum.CONDITION) 10795 return "Condition"; 10796 if (code == ResourceTypeEnum.CONDITIONDEFINITION) 10797 return "ConditionDefinition"; 10798 if (code == ResourceTypeEnum.CONSENT) 10799 return "Consent"; 10800 if (code == ResourceTypeEnum.CONTRACT) 10801 return "Contract"; 10802 if (code == ResourceTypeEnum.COVERAGE) 10803 return "Coverage"; 10804 if (code == ResourceTypeEnum.COVERAGEELIGIBILITYREQUEST) 10805 return "CoverageEligibilityRequest"; 10806 if (code == ResourceTypeEnum.COVERAGEELIGIBILITYRESPONSE) 10807 return "CoverageEligibilityResponse"; 10808 if (code == ResourceTypeEnum.DETECTEDISSUE) 10809 return "DetectedIssue"; 10810 if (code == ResourceTypeEnum.DEVICE) 10811 return "Device"; 10812 if (code == ResourceTypeEnum.DEVICEDEFINITION) 10813 return "DeviceDefinition"; 10814 if (code == ResourceTypeEnum.DEVICEMETRIC) 10815 return "DeviceMetric"; 10816 if (code == ResourceTypeEnum.DEVICEREQUEST) 10817 return "DeviceRequest"; 10818 if (code == ResourceTypeEnum.DEVICEUSESTATEMENT) 10819 return "DeviceUseStatement"; 10820 if (code == ResourceTypeEnum.DIAGNOSTICREPORT) 10821 return "DiagnosticReport"; 10822 if (code == ResourceTypeEnum.DOCUMENTMANIFEST) 10823 return "DocumentManifest"; 10824 if (code == ResourceTypeEnum.DOCUMENTREFERENCE) 10825 return "DocumentReference"; 10826 if (code == ResourceTypeEnum.DOMAINRESOURCE) 10827 return "DomainResource"; 10828 if (code == ResourceTypeEnum.ENCOUNTER) 10829 return "Encounter"; 10830 if (code == ResourceTypeEnum.ENDPOINT) 10831 return "Endpoint"; 10832 if (code == ResourceTypeEnum.ENROLLMENTREQUEST) 10833 return "EnrollmentRequest"; 10834 if (code == ResourceTypeEnum.ENROLLMENTRESPONSE) 10835 return "EnrollmentResponse"; 10836 if (code == ResourceTypeEnum.EPISODEOFCARE) 10837 return "EpisodeOfCare"; 10838 if (code == ResourceTypeEnum.EVENTDEFINITION) 10839 return "EventDefinition"; 10840 if (code == ResourceTypeEnum.EVIDENCE) 10841 return "Evidence"; 10842 if (code == ResourceTypeEnum.EVIDENCEVARIABLE) 10843 return "EvidenceVariable"; 10844 if (code == ResourceTypeEnum.EXAMPLESCENARIO) 10845 return "ExampleScenario"; 10846 if (code == ResourceTypeEnum.EXPLANATIONOFBENEFIT) 10847 return "ExplanationOfBenefit"; 10848 if (code == ResourceTypeEnum.FAMILYMEMBERHISTORY) 10849 return "FamilyMemberHistory"; 10850 if (code == ResourceTypeEnum.FLAG) 10851 return "Flag"; 10852 if (code == ResourceTypeEnum.GOAL) 10853 return "Goal"; 10854 if (code == ResourceTypeEnum.GRAPHDEFINITION) 10855 return "GraphDefinition"; 10856 if (code == ResourceTypeEnum.GROUP) 10857 return "Group"; 10858 if (code == ResourceTypeEnum.GUIDANCERESPONSE) 10859 return "GuidanceResponse"; 10860 if (code == ResourceTypeEnum.HEALTHCARESERVICE) 10861 return "HealthcareService"; 10862 if (code == ResourceTypeEnum.IMAGINGSTUDY) 10863 return "ImagingStudy"; 10864 if (code == ResourceTypeEnum.IMMUNIZATION) 10865 return "Immunization"; 10866 if (code == ResourceTypeEnum.IMMUNIZATIONEVALUATION) 10867 return "ImmunizationEvaluation"; 10868 if (code == ResourceTypeEnum.IMMUNIZATIONRECOMMENDATION) 10869 return "ImmunizationRecommendation"; 10870 if (code == ResourceTypeEnum.IMPLEMENTATIONGUIDE) 10871 return "ImplementationGuide"; 10872 if (code == ResourceTypeEnum.INGREDIENT) 10873 return "Ingredient"; 10874 if (code == ResourceTypeEnum.INSURANCEPLAN) 10875 return "InsurancePlan"; 10876 if (code == ResourceTypeEnum.INVOICE) 10877 return "Invoice"; 10878 if (code == ResourceTypeEnum.LIBRARY) 10879 return "Library"; 10880 if (code == ResourceTypeEnum.LINKAGE) 10881 return "Linkage"; 10882 if (code == ResourceTypeEnum.LIST) 10883 return "List"; 10884 if (code == ResourceTypeEnum.LOCATION) 10885 return "Location"; 10886 if (code == ResourceTypeEnum.MANUFACTUREDITEMDEFINITION) 10887 return "ManufacturedItemDefinition"; 10888 if (code == ResourceTypeEnum.MEASURE) 10889 return "Measure"; 10890 if (code == ResourceTypeEnum.MEASUREREPORT) 10891 return "MeasureReport"; 10892 if (code == ResourceTypeEnum.MEDICATION) 10893 return "Medication"; 10894 if (code == ResourceTypeEnum.MEDICATIONADMINISTRATION) 10895 return "MedicationAdministration"; 10896 if (code == ResourceTypeEnum.MEDICATIONDISPENSE) 10897 return "MedicationDispense"; 10898 if (code == ResourceTypeEnum.MEDICATIONKNOWLEDGE) 10899 return "MedicationKnowledge"; 10900 if (code == ResourceTypeEnum.MEDICATIONREQUEST) 10901 return "MedicationRequest"; 10902 if (code == ResourceTypeEnum.MEDICATIONUSAGE) 10903 return "MedicationUsage"; 10904 if (code == ResourceTypeEnum.MEDICINALPRODUCTDEFINITION) 10905 return "MedicinalProductDefinition"; 10906 if (code == ResourceTypeEnum.MESSAGEDEFINITION) 10907 return "MessageDefinition"; 10908 if (code == ResourceTypeEnum.MESSAGEHEADER) 10909 return "MessageHeader"; 10910 if (code == ResourceTypeEnum.MOLECULARSEQUENCE) 10911 return "MolecularSequence"; 10912 if (code == ResourceTypeEnum.NAMINGSYSTEM) 10913 return "NamingSystem"; 10914 if (code == ResourceTypeEnum.NUTRITIONINTAKE) 10915 return "NutritionIntake"; 10916 if (code == ResourceTypeEnum.NUTRITIONORDER) 10917 return "NutritionOrder"; 10918 if (code == ResourceTypeEnum.OBSERVATION) 10919 return "Observation"; 10920 if (code == ResourceTypeEnum.OBSERVATIONDEFINITION) 10921 return "ObservationDefinition"; 10922 if (code == ResourceTypeEnum.OPERATIONDEFINITION) 10923 return "OperationDefinition"; 10924 if (code == ResourceTypeEnum.OPERATIONOUTCOME) 10925 return "OperationOutcome"; 10926 if (code == ResourceTypeEnum.ORGANIZATION) 10927 return "Organization"; 10928 if (code == ResourceTypeEnum.ORGANIZATIONAFFILIATION) 10929 return "OrganizationAffiliation"; 10930 if (code == ResourceTypeEnum.PACKAGEDPRODUCTDEFINITION) 10931 return "PackagedProductDefinition"; 10932 if (code == ResourceTypeEnum.PARAMETERS) 10933 return "Parameters"; 10934 if (code == ResourceTypeEnum.PATIENT) 10935 return "Patient"; 10936 if (code == ResourceTypeEnum.PAYMENTNOTICE) 10937 return "PaymentNotice"; 10938 if (code == ResourceTypeEnum.PAYMENTRECONCILIATION) 10939 return "PaymentReconciliation"; 10940 if (code == ResourceTypeEnum.PERSON) 10941 return "Person"; 10942 if (code == ResourceTypeEnum.PLANDEFINITION) 10943 return "PlanDefinition"; 10944 if (code == ResourceTypeEnum.PRACTITIONER) 10945 return "Practitioner"; 10946 if (code == ResourceTypeEnum.PRACTITIONERROLE) 10947 return "PractitionerRole"; 10948 if (code == ResourceTypeEnum.PROCEDURE) 10949 return "Procedure"; 10950 if (code == ResourceTypeEnum.PROVENANCE) 10951 return "Provenance"; 10952 if (code == ResourceTypeEnum.QUESTIONNAIRE) 10953 return "Questionnaire"; 10954 if (code == ResourceTypeEnum.QUESTIONNAIRERESPONSE) 10955 return "QuestionnaireResponse"; 10956 if (code == ResourceTypeEnum.REGULATEDAUTHORIZATION) 10957 return "RegulatedAuthorization"; 10958 if (code == ResourceTypeEnum.RELATEDPERSON) 10959 return "RelatedPerson"; 10960 if (code == ResourceTypeEnum.REQUESTGROUP) 10961 return "RequestGroup"; 10962 if (code == ResourceTypeEnum.RESEARCHSTUDY) 10963 return "ResearchStudy"; 10964 if (code == ResourceTypeEnum.RESEARCHSUBJECT) 10965 return "ResearchSubject"; 10966 if (code == ResourceTypeEnum.RESOURCE) 10967 return "Resource"; 10968 if (code == ResourceTypeEnum.RISKASSESSMENT) 10969 return "RiskAssessment"; 10970 if (code == ResourceTypeEnum.SCHEDULE) 10971 return "Schedule"; 10972 if (code == ResourceTypeEnum.SEARCHPARAMETER) 10973 return "SearchParameter"; 10974 if (code == ResourceTypeEnum.SERVICEREQUEST) 10975 return "ServiceRequest"; 10976 if (code == ResourceTypeEnum.SLOT) 10977 return "Slot"; 10978 if (code == ResourceTypeEnum.SPECIMEN) 10979 return "Specimen"; 10980 if (code == ResourceTypeEnum.SPECIMENDEFINITION) 10981 return "SpecimenDefinition"; 10982 if (code == ResourceTypeEnum.STRUCTUREDEFINITION) 10983 return "StructureDefinition"; 10984 if (code == ResourceTypeEnum.STRUCTUREMAP) 10985 return "StructureMap"; 10986 if (code == ResourceTypeEnum.SUBSCRIPTION) 10987 return "Subscription"; 10988 if (code == ResourceTypeEnum.SUBSTANCE) 10989 return "Substance"; 10990 if (code == ResourceTypeEnum.SUBSTANCEDEFINITION) 10991 return "SubstanceDefinition"; 10992 if (code == ResourceTypeEnum.SUBSTANCENUCLEICACID) 10993 return "SubstanceNucleicAcid"; 10994 if (code == ResourceTypeEnum.SUBSTANCEPOLYMER) 10995 return "SubstancePolymer"; 10996 if (code == ResourceTypeEnum.SUBSTANCEPROTEIN) 10997 return "SubstanceProtein"; 10998 if (code == ResourceTypeEnum.SUBSTANCEREFERENCEINFORMATION) 10999 return "SubstanceReferenceInformation"; 11000 if (code == ResourceTypeEnum.SUBSTANCESOURCEMATERIAL) 11001 return "SubstanceSourceMaterial"; 11002 if (code == ResourceTypeEnum.SUPPLYDELIVERY) 11003 return "SupplyDelivery"; 11004 if (code == ResourceTypeEnum.SUPPLYREQUEST) 11005 return "SupplyRequest"; 11006 if (code == ResourceTypeEnum.TASK) 11007 return "Task"; 11008 if (code == ResourceTypeEnum.TERMINOLOGYCAPABILITIES) 11009 return "TerminologyCapabilities"; 11010 if (code == ResourceTypeEnum.TESTREPORT) 11011 return "TestReport"; 11012 if (code == ResourceTypeEnum.TESTSCRIPT) 11013 return "TestScript"; 11014 if (code == ResourceTypeEnum.TOPIC) 11015 return "Topic"; 11016 if (code == ResourceTypeEnum.VALUESET) 11017 return "ValueSet"; 11018 if (code == ResourceTypeEnum.VERIFICATIONRESULT) 11019 return "VerificationResult"; 11020 if (code == ResourceTypeEnum.VISIONPRESCRIPTION) 11021 return "VisionPrescription"; 11022 return "?"; 11023 } 11024 public String toSystem(ResourceTypeEnum code) { 11025 return code.getSystem(); 11026 } 11027 } 11028 11029 public enum RestfulCapabilityMode { 11030 /** 11031 * The application acts as a client for this resource. 11032 */ 11033 CLIENT, 11034 /** 11035 * The application acts as a server for this resource. 11036 */ 11037 SERVER, 11038 /** 11039 * added to help the parsers 11040 */ 11041 NULL; 11042 public static RestfulCapabilityMode fromCode(String codeString) throws FHIRException { 11043 if (codeString == null || "".equals(codeString)) 11044 return null; 11045 if ("client".equals(codeString)) 11046 return CLIENT; 11047 if ("server".equals(codeString)) 11048 return SERVER; 11049 throw new FHIRException("Unknown RestfulCapabilityMode code '"+codeString+"'"); 11050 } 11051 public String toCode() { 11052 switch (this) { 11053 case CLIENT: return "client"; 11054 case SERVER: return "server"; 11055 default: return "?"; 11056 } 11057 } 11058 public String getSystem() { 11059 switch (this) { 11060 case CLIENT: return "http://hl7.org/fhir/restful-capability-mode"; 11061 case SERVER: return "http://hl7.org/fhir/restful-capability-mode"; 11062 default: return "?"; 11063 } 11064 } 11065 public String getDefinition() { 11066 switch (this) { 11067 case CLIENT: return "The application acts as a client for this resource."; 11068 case SERVER: return "The application acts as a server for this resource."; 11069 default: return "?"; 11070 } 11071 } 11072 public String getDisplay() { 11073 switch (this) { 11074 case CLIENT: return "Client"; 11075 case SERVER: return "Server"; 11076 default: return "?"; 11077 } 11078 } 11079 } 11080 11081 public static class RestfulCapabilityModeEnumFactory implements EnumFactory<RestfulCapabilityMode> { 11082 public RestfulCapabilityMode fromCode(String codeString) throws IllegalArgumentException { 11083 if (codeString == null || "".equals(codeString)) 11084 if (codeString == null || "".equals(codeString)) 11085 return null; 11086 if ("client".equals(codeString)) 11087 return RestfulCapabilityMode.CLIENT; 11088 if ("server".equals(codeString)) 11089 return RestfulCapabilityMode.SERVER; 11090 throw new IllegalArgumentException("Unknown RestfulCapabilityMode code '"+codeString+"'"); 11091 } 11092 public Enumeration<RestfulCapabilityMode> fromType(Base code) throws FHIRException { 11093 if (code == null) 11094 return null; 11095 if (code.isEmpty()) 11096 return new Enumeration<RestfulCapabilityMode>(this); 11097 String codeString = ((PrimitiveType) code).asStringValue(); 11098 if (codeString == null || "".equals(codeString)) 11099 return null; 11100 if ("client".equals(codeString)) 11101 return new Enumeration<RestfulCapabilityMode>(this, RestfulCapabilityMode.CLIENT); 11102 if ("server".equals(codeString)) 11103 return new Enumeration<RestfulCapabilityMode>(this, RestfulCapabilityMode.SERVER); 11104 throw new FHIRException("Unknown RestfulCapabilityMode code '"+codeString+"'"); 11105 } 11106 public String toCode(RestfulCapabilityMode code) { 11107 if (code == RestfulCapabilityMode.CLIENT) 11108 return "client"; 11109 if (code == RestfulCapabilityMode.SERVER) 11110 return "server"; 11111 return "?"; 11112 } 11113 public String toSystem(RestfulCapabilityMode code) { 11114 return code.getSystem(); 11115 } 11116 } 11117 11118 public enum SearchParamType { 11119 /** 11120 * Search parameter SHALL be a number (a whole number, or a decimal). 11121 */ 11122 NUMBER, 11123 /** 11124 * Search parameter is on a date/time. The date format is the standard XML format, though other formats may be supported. 11125 */ 11126 DATE, 11127 /** 11128 * Search parameter is a simple string, like a name part. Search is case-insensitive and accent-insensitive. May match just the start of a string. String parameters may contain spaces. 11129 */ 11130 STRING, 11131 /** 11132 * Search parameter on a coded element or identifier. May be used to search through the text, display, code and code/codesystem (for codes) and label, system and key (for identifier). Its value is either a string or a pair of namespace and value, separated by a "|", depending on the modifier used. 11133 */ 11134 TOKEN, 11135 /** 11136 * A reference to another resource (Reference or canonical). 11137 */ 11138 REFERENCE, 11139 /** 11140 * A composite search parameter that combines a search on two values together. 11141 */ 11142 COMPOSITE, 11143 /** 11144 * A search parameter that searches on a quantity. 11145 */ 11146 QUANTITY, 11147 /** 11148 * A search parameter that searches on a URI (RFC 3986). 11149 */ 11150 URI, 11151 /** 11152 * Special logic applies to this parameter per the description of the search parameter. 11153 */ 11154 SPECIAL, 11155 /** 11156 * added to help the parsers 11157 */ 11158 NULL; 11159 public static SearchParamType fromCode(String codeString) throws FHIRException { 11160 if (codeString == null || "".equals(codeString)) 11161 return null; 11162 if ("number".equals(codeString)) 11163 return NUMBER; 11164 if ("date".equals(codeString)) 11165 return DATE; 11166 if ("string".equals(codeString)) 11167 return STRING; 11168 if ("token".equals(codeString)) 11169 return TOKEN; 11170 if ("reference".equals(codeString)) 11171 return REFERENCE; 11172 if ("composite".equals(codeString)) 11173 return COMPOSITE; 11174 if ("quantity".equals(codeString)) 11175 return QUANTITY; 11176 if ("uri".equals(codeString)) 11177 return URI; 11178 if ("special".equals(codeString)) 11179 return SPECIAL; 11180 throw new FHIRException("Unknown SearchParamType code '"+codeString+"'"); 11181 } 11182 public String toCode() { 11183 switch (this) { 11184 case NUMBER: return "number"; 11185 case DATE: return "date"; 11186 case STRING: return "string"; 11187 case TOKEN: return "token"; 11188 case REFERENCE: return "reference"; 11189 case COMPOSITE: return "composite"; 11190 case QUANTITY: return "quantity"; 11191 case URI: return "uri"; 11192 case SPECIAL: return "special"; 11193 default: return "?"; 11194 } 11195 } 11196 public String getSystem() { 11197 switch (this) { 11198 case NUMBER: return "http://hl7.org/fhir/search-param-type"; 11199 case DATE: return "http://hl7.org/fhir/search-param-type"; 11200 case STRING: return "http://hl7.org/fhir/search-param-type"; 11201 case TOKEN: return "http://hl7.org/fhir/search-param-type"; 11202 case REFERENCE: return "http://hl7.org/fhir/search-param-type"; 11203 case COMPOSITE: return "http://hl7.org/fhir/search-param-type"; 11204 case QUANTITY: return "http://hl7.org/fhir/search-param-type"; 11205 case URI: return "http://hl7.org/fhir/search-param-type"; 11206 case SPECIAL: return "http://hl7.org/fhir/search-param-type"; 11207 default: return "?"; 11208 } 11209 } 11210 public String getDefinition() { 11211 switch (this) { 11212 case NUMBER: return "Search parameter SHALL be a number (a whole number, or a decimal)."; 11213 case DATE: return "Search parameter is on a date/time. The date format is the standard XML format, though other formats may be supported."; 11214 case STRING: return "Search parameter is a simple string, like a name part. Search is case-insensitive and accent-insensitive. May match just the start of a string. String parameters may contain spaces."; 11215 case TOKEN: return "Search parameter on a coded element or identifier. May be used to search through the text, display, code and code/codesystem (for codes) and label, system and key (for identifier). Its value is either a string or a pair of namespace and value, separated by a \"|\", depending on the modifier used."; 11216 case REFERENCE: return "A reference to another resource (Reference or canonical)."; 11217 case COMPOSITE: return "A composite search parameter that combines a search on two values together."; 11218 case QUANTITY: return "A search parameter that searches on a quantity."; 11219 case URI: return "A search parameter that searches on a URI (RFC 3986)."; 11220 case SPECIAL: return "Special logic applies to this parameter per the description of the search parameter."; 11221 default: return "?"; 11222 } 11223 } 11224 public String getDisplay() { 11225 switch (this) { 11226 case NUMBER: return "Number"; 11227 case DATE: return "Date/DateTime"; 11228 case STRING: return "String"; 11229 case TOKEN: return "Token"; 11230 case REFERENCE: return "Reference"; 11231 case COMPOSITE: return "Composite"; 11232 case QUANTITY: return "Quantity"; 11233 case URI: return "URI"; 11234 case SPECIAL: return "Special"; 11235 default: return "?"; 11236 } 11237 } 11238 } 11239 11240 public static class SearchParamTypeEnumFactory implements EnumFactory<SearchParamType> { 11241 public SearchParamType fromCode(String codeString) throws IllegalArgumentException { 11242 if (codeString == null || "".equals(codeString)) 11243 if (codeString == null || "".equals(codeString)) 11244 return null; 11245 if ("number".equals(codeString)) 11246 return SearchParamType.NUMBER; 11247 if ("date".equals(codeString)) 11248 return SearchParamType.DATE; 11249 if ("string".equals(codeString)) 11250 return SearchParamType.STRING; 11251 if ("token".equals(codeString)) 11252 return SearchParamType.TOKEN; 11253 if ("reference".equals(codeString)) 11254 return SearchParamType.REFERENCE; 11255 if ("composite".equals(codeString)) 11256 return SearchParamType.COMPOSITE; 11257 if ("quantity".equals(codeString)) 11258 return SearchParamType.QUANTITY; 11259 if ("uri".equals(codeString)) 11260 return SearchParamType.URI; 11261 if ("special".equals(codeString)) 11262 return SearchParamType.SPECIAL; 11263 throw new IllegalArgumentException("Unknown SearchParamType code '"+codeString+"'"); 11264 } 11265 public Enumeration<SearchParamType> fromType(Base code) throws FHIRException { 11266 if (code == null) 11267 return null; 11268 if (code.isEmpty()) 11269 return new Enumeration<SearchParamType>(this); 11270 String codeString = ((PrimitiveType) code).asStringValue(); 11271 if (codeString == null || "".equals(codeString)) 11272 return null; 11273 if ("number".equals(codeString)) 11274 return new Enumeration<SearchParamType>(this, SearchParamType.NUMBER); 11275 if ("date".equals(codeString)) 11276 return new Enumeration<SearchParamType>(this, SearchParamType.DATE); 11277 if ("string".equals(codeString)) 11278 return new Enumeration<SearchParamType>(this, SearchParamType.STRING); 11279 if ("token".equals(codeString)) 11280 return new Enumeration<SearchParamType>(this, SearchParamType.TOKEN); 11281 if ("reference".equals(codeString)) 11282 return new Enumeration<SearchParamType>(this, SearchParamType.REFERENCE); 11283 if ("composite".equals(codeString)) 11284 return new Enumeration<SearchParamType>(this, SearchParamType.COMPOSITE); 11285 if ("quantity".equals(codeString)) 11286 return new Enumeration<SearchParamType>(this, SearchParamType.QUANTITY); 11287 if ("uri".equals(codeString)) 11288 return new Enumeration<SearchParamType>(this, SearchParamType.URI); 11289 if ("special".equals(codeString)) 11290 return new Enumeration<SearchParamType>(this, SearchParamType.SPECIAL); 11291 throw new FHIRException("Unknown SearchParamType code '"+codeString+"'"); 11292 } 11293 public String toCode(SearchParamType code) { 11294 if (code == SearchParamType.NUMBER) 11295 return "number"; 11296 if (code == SearchParamType.DATE) 11297 return "date"; 11298 if (code == SearchParamType.STRING) 11299 return "string"; 11300 if (code == SearchParamType.TOKEN) 11301 return "token"; 11302 if (code == SearchParamType.REFERENCE) 11303 return "reference"; 11304 if (code == SearchParamType.COMPOSITE) 11305 return "composite"; 11306 if (code == SearchParamType.QUANTITY) 11307 return "quantity"; 11308 if (code == SearchParamType.URI) 11309 return "uri"; 11310 if (code == SearchParamType.SPECIAL) 11311 return "special"; 11312 return "?"; 11313 } 11314 public String toSystem(SearchParamType code) { 11315 return code.getSystem(); 11316 } 11317 } 11318 11319 public enum Use { 11320 /** 11321 * The treatment is complete and this represents a Claim for the services. 11322 */ 11323 CLAIM, 11324 /** 11325 * The treatment is proposed and this represents a Pre-authorization for the services. 11326 */ 11327 PREAUTHORIZATION, 11328 /** 11329 * The treatment is proposed and this represents a Pre-determination for the services. 11330 */ 11331 PREDETERMINATION, 11332 /** 11333 * added to help the parsers 11334 */ 11335 NULL; 11336 public static Use fromCode(String codeString) throws FHIRException { 11337 if (codeString == null || "".equals(codeString)) 11338 return null; 11339 if ("claim".equals(codeString)) 11340 return CLAIM; 11341 if ("preauthorization".equals(codeString)) 11342 return PREAUTHORIZATION; 11343 if ("predetermination".equals(codeString)) 11344 return PREDETERMINATION; 11345 throw new FHIRException("Unknown Use code '"+codeString+"'"); 11346 } 11347 public String toCode() { 11348 switch (this) { 11349 case CLAIM: return "claim"; 11350 case PREAUTHORIZATION: return "preauthorization"; 11351 case PREDETERMINATION: return "predetermination"; 11352 default: return "?"; 11353 } 11354 } 11355 public String getSystem() { 11356 switch (this) { 11357 case CLAIM: return "http://hl7.org/fhir/claim-use"; 11358 case PREAUTHORIZATION: return "http://hl7.org/fhir/claim-use"; 11359 case PREDETERMINATION: return "http://hl7.org/fhir/claim-use"; 11360 default: return "?"; 11361 } 11362 } 11363 public String getDefinition() { 11364 switch (this) { 11365 case CLAIM: return "The treatment is complete and this represents a Claim for the services."; 11366 case PREAUTHORIZATION: return "The treatment is proposed and this represents a Pre-authorization for the services."; 11367 case PREDETERMINATION: return "The treatment is proposed and this represents a Pre-determination for the services."; 11368 default: return "?"; 11369 } 11370 } 11371 public String getDisplay() { 11372 switch (this) { 11373 case CLAIM: return "Claim"; 11374 case PREAUTHORIZATION: return "Preauthorization"; 11375 case PREDETERMINATION: return "Predetermination"; 11376 default: return "?"; 11377 } 11378 } 11379 } 11380 11381 public static class UseEnumFactory implements EnumFactory<Use> { 11382 public Use fromCode(String codeString) throws IllegalArgumentException { 11383 if (codeString == null || "".equals(codeString)) 11384 if (codeString == null || "".equals(codeString)) 11385 return null; 11386 if ("claim".equals(codeString)) 11387 return Use.CLAIM; 11388 if ("preauthorization".equals(codeString)) 11389 return Use.PREAUTHORIZATION; 11390 if ("predetermination".equals(codeString)) 11391 return Use.PREDETERMINATION; 11392 throw new IllegalArgumentException("Unknown Use code '"+codeString+"'"); 11393 } 11394 public Enumeration<Use> fromType(Base code) throws FHIRException { 11395 if (code == null) 11396 return null; 11397 if (code.isEmpty()) 11398 return new Enumeration<Use>(this); 11399 String codeString = ((PrimitiveType) code).asStringValue(); 11400 if (codeString == null || "".equals(codeString)) 11401 return null; 11402 if ("claim".equals(codeString)) 11403 return new Enumeration<Use>(this, Use.CLAIM); 11404 if ("preauthorization".equals(codeString)) 11405 return new Enumeration<Use>(this, Use.PREAUTHORIZATION); 11406 if ("predetermination".equals(codeString)) 11407 return new Enumeration<Use>(this, Use.PREDETERMINATION); 11408 throw new FHIRException("Unknown Use code '"+codeString+"'"); 11409 } 11410 public String toCode(Use code) { 11411 if (code == Use.CLAIM) 11412 return "claim"; 11413 if (code == Use.PREAUTHORIZATION) 11414 return "preauthorization"; 11415 if (code == Use.PREDETERMINATION) 11416 return "predetermination"; 11417 return "?"; 11418 } 11419 public String toSystem(Use code) { 11420 return code.getSystem(); 11421 } 11422 } 11423 11424 11425} 11426