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