
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 Tue, Dec 13, 2022 17:53+1100 for FHIR vcurrent 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, PlanDefinition, RequestOrchestration, ServiceRequest, SupplyRequest, Task, Transport] 081// RequestStatus: Codes identifying the lifecycle stage of a request.[CarePlan, CommunicationRequest, DeviceRequest, NutritionOrder, RequestOrchestration, ServiceRequest] 082// ResourceTypeEnum: All fhir data types[CapabilityStatement, CompartmentDefinition, 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(PrimitiveType<?> code) throws FHIRException { 157 if (code == null) 158 return null; 159 if (code.isEmpty()) 160 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.NULL, code); 161 String codeString = ((PrimitiveType) code).asStringValue(); 162 if (codeString == null || "".equals(codeString)) 163 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.NULL, code); 164 if ("single".equals(codeString)) 165 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.SINGLE, code); 166 if ("multiple".equals(codeString)) 167 return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.MULTIPLE, code); 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(PrimitiveType<?> code) throws FHIRException { 262 if (code == null) 263 return null; 264 if (code.isEmpty()) 265 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.NULL, code); 266 String codeString = ((PrimitiveType) code).asStringValue(); 267 if (codeString == null || "".equals(codeString)) 268 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.NULL, code); 269 if ("applicability".equals(codeString)) 270 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.APPLICABILITY, code); 271 if ("start".equals(codeString)) 272 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.START, code); 273 if ("stop".equals(codeString)) 274 return new Enumeration<ActionConditionKind>(this, ActionConditionKind.STOP, code); 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(PrimitiveType<?> code) throws FHIRException { 371 if (code == null) 372 return null; 373 if (code.isEmpty()) 374 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.NULL, code); 375 String codeString = ((PrimitiveType) code).asStringValue(); 376 if (codeString == null || "".equals(codeString)) 377 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.NULL, code); 378 if ("visual-group".equals(codeString)) 379 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.VISUALGROUP, code); 380 if ("logical-group".equals(codeString)) 381 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.LOGICALGROUP, code); 382 if ("sentence-group".equals(codeString)) 383 return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.SENTENCEGROUP, code); 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(PrimitiveType<?> code) throws FHIRException { 564 if (code == null) 565 return null; 566 if (code.isEmpty()) 567 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.NULL, code); 568 String codeString = ((PrimitiveType) code).asStringValue(); 569 if (codeString == null || "".equals(codeString)) 570 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.NULL, code); 571 if ("careteam".equals(codeString)) 572 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.CARETEAM, code); 573 if ("device".equals(codeString)) 574 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.DEVICE, code); 575 if ("group".equals(codeString)) 576 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.GROUP, code); 577 if ("healthcareservice".equals(codeString)) 578 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.HEALTHCARESERVICE, code); 579 if ("location".equals(codeString)) 580 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.LOCATION, code); 581 if ("organization".equals(codeString)) 582 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.ORGANIZATION, code); 583 if ("patient".equals(codeString)) 584 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PATIENT, code); 585 if ("practitioner".equals(codeString)) 586 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PRACTITIONER, code); 587 if ("practitionerrole".equals(codeString)) 588 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.PRACTITIONERROLE, code); 589 if ("relatedperson".equals(codeString)) 590 return new Enumeration<ActionParticipantType>(this, ActionParticipantType.RELATEDPERSON, code); 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(PrimitiveType<?> code) throws FHIRException { 689 if (code == null) 690 return null; 691 if (code.isEmpty()) 692 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NULL, code); 693 String codeString = ((PrimitiveType) code).asStringValue(); 694 if (codeString == null || "".equals(codeString)) 695 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NULL, code); 696 if ("yes".equals(codeString)) 697 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.YES, code); 698 if ("no".equals(codeString)) 699 return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NO, code); 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(PrimitiveType<?> code) throws FHIRException { 866 if (code == null) 867 return null; 868 if (code.isEmpty()) 869 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.NULL, code); 870 String codeString = ((PrimitiveType) code).asStringValue(); 871 if (codeString == null || "".equals(codeString)) 872 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.NULL, code); 873 if ("before-start".equals(codeString)) 874 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORESTART, code); 875 if ("before".equals(codeString)) 876 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORE, code); 877 if ("before-end".equals(codeString)) 878 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFOREEND, code); 879 if ("concurrent-with-start".equals(codeString)) 880 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHSTART, code); 881 if ("concurrent".equals(codeString)) 882 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENT, code); 883 if ("concurrent-with-end".equals(codeString)) 884 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHEND, code); 885 if ("after-start".equals(codeString)) 886 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTERSTART, code); 887 if ("after".equals(codeString)) 888 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTER, code); 889 if ("after-end".equals(codeString)) 890 return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTEREND, code); 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(PrimitiveType<?> code) throws FHIRException { 999 if (code == null) 1000 return null; 1001 if (code.isEmpty()) 1002 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.NULL, code); 1003 String codeString = ((PrimitiveType) code).asStringValue(); 1004 if (codeString == null || "".equals(codeString)) 1005 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.NULL, code); 1006 if ("must".equals(codeString)) 1007 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUST, code); 1008 if ("could".equals(codeString)) 1009 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.COULD, code); 1010 if ("must-unless-documented".equals(codeString)) 1011 return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUSTUNLESSDOCUMENTED, code); 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(PrimitiveType<?> code) throws FHIRException { 1144 if (code == null) 1145 return null; 1146 if (code.isEmpty()) 1147 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.NULL, code); 1148 String codeString = ((PrimitiveType) code).asStringValue(); 1149 if (codeString == null || "".equals(codeString)) 1150 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.NULL, code); 1151 if ("any".equals(codeString)) 1152 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ANY, code); 1153 if ("all".equals(codeString)) 1154 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALL, code); 1155 if ("all-or-none".equals(codeString)) 1156 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALLORNONE, code); 1157 if ("exactly-one".equals(codeString)) 1158 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.EXACTLYONE, code); 1159 if ("at-most-one".equals(codeString)) 1160 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ATMOSTONE, code); 1161 if ("one-or-more".equals(codeString)) 1162 return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ONEORMORE, code); 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(PrimitiveType<?> code) throws FHIRException { 1277 if (code == null) 1278 return null; 1279 if (code.isEmpty()) 1280 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.NULL, code); 1281 String codeString = ((PrimitiveType) code).asStringValue(); 1282 if (codeString == null || "".equals(codeString)) 1283 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.NULL, code); 1284 if ("male".equals(codeString)) 1285 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.MALE, code); 1286 if ("female".equals(codeString)) 1287 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.FEMALE, code); 1288 if ("other".equals(codeString)) 1289 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.OTHER, code); 1290 if ("unknown".equals(codeString)) 1291 return new Enumeration<AdministrativeGender>(this, AdministrativeGender.UNKNOWN, code); 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 concepts, 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 ("MedicationStatement".equals(codeString)) 2139 return MEDICATIONUSAGE; 2140 if ("MedicinalProductDefinition".equals(codeString)) 2141 return MEDICINALPRODUCTDEFINITION; 2142 if ("MessageDefinition".equals(codeString)) 2143 return MESSAGEDEFINITION; 2144 if ("MessageHeader".equals(codeString)) 2145 return MESSAGEHEADER; 2146 if ("MetadataResource".equals(codeString)) 2147 return METADATARESOURCE; 2148 if ("MolecularSequence".equals(codeString)) 2149 return MOLECULARSEQUENCE; 2150 if ("NamingSystem".equals(codeString)) 2151 return NAMINGSYSTEM; 2152 if ("NutritionIntake".equals(codeString)) 2153 return NUTRITIONINTAKE; 2154 if ("NutritionOrder".equals(codeString)) 2155 return NUTRITIONORDER; 2156 if ("NutritionProduct".equals(codeString)) 2157 return NUTRITIONPRODUCT; 2158 if ("Observation".equals(codeString)) 2159 return OBSERVATION; 2160 if ("ObservationDefinition".equals(codeString)) 2161 return OBSERVATIONDEFINITION; 2162 if ("OperationDefinition".equals(codeString)) 2163 return OPERATIONDEFINITION; 2164 if ("OperationOutcome".equals(codeString)) 2165 return OPERATIONOUTCOME; 2166 if ("Organization".equals(codeString)) 2167 return ORGANIZATION; 2168 if ("OrganizationAffiliation".equals(codeString)) 2169 return ORGANIZATIONAFFILIATION; 2170 if ("PackagedProductDefinition".equals(codeString)) 2171 return PACKAGEDPRODUCTDEFINITION; 2172 if ("Parameters".equals(codeString)) 2173 return PARAMETERS; 2174 if ("Patient".equals(codeString)) 2175 return PATIENT; 2176 if ("PaymentNotice".equals(codeString)) 2177 return PAYMENTNOTICE; 2178 if ("PaymentReconciliation".equals(codeString)) 2179 return PAYMENTRECONCILIATION; 2180 if ("Permission".equals(codeString)) 2181 return PERMISSION; 2182 if ("Person".equals(codeString)) 2183 return PERSON; 2184 if ("PlanDefinition".equals(codeString)) 2185 return PLANDEFINITION; 2186 if ("Practitioner".equals(codeString)) 2187 return PRACTITIONER; 2188 if ("PractitionerRole".equals(codeString)) 2189 return PRACTITIONERROLE; 2190 if ("Procedure".equals(codeString)) 2191 return PROCEDURE; 2192 if ("Provenance".equals(codeString)) 2193 return PROVENANCE; 2194 if ("Questionnaire".equals(codeString)) 2195 return QUESTIONNAIRE; 2196 if ("QuestionnaireResponse".equals(codeString)) 2197 return QUESTIONNAIRERESPONSE; 2198 if ("RegulatedAuthorization".equals(codeString)) 2199 return REGULATEDAUTHORIZATION; 2200 if ("RelatedPerson".equals(codeString)) 2201 return RELATEDPERSON; 2202 if ("RequestOrchestration".equals(codeString)) 2203 return REQUESTORCHESTRATION; 2204 if ("Requirements".equals(codeString)) 2205 return REQUIREMENTS; 2206 if ("ResearchStudy".equals(codeString)) 2207 return RESEARCHSTUDY; 2208 if ("ResearchSubject".equals(codeString)) 2209 return RESEARCHSUBJECT; 2210 if ("Resource".equals(codeString)) 2211 return RESOURCE; 2212 if ("RiskAssessment".equals(codeString)) 2213 return RISKASSESSMENT; 2214 if ("Schedule".equals(codeString)) 2215 return SCHEDULE; 2216 if ("SearchParameter".equals(codeString)) 2217 return SEARCHPARAMETER; 2218 if ("ServiceRequest".equals(codeString)) 2219 return SERVICEREQUEST; 2220 if ("Slot".equals(codeString)) 2221 return SLOT; 2222 if ("Specimen".equals(codeString)) 2223 return SPECIMEN; 2224 if ("SpecimenDefinition".equals(codeString)) 2225 return SPECIMENDEFINITION; 2226 if ("StructureDefinition".equals(codeString)) 2227 return STRUCTUREDEFINITION; 2228 if ("StructureMap".equals(codeString)) 2229 return STRUCTUREMAP; 2230 if ("Subscription".equals(codeString)) 2231 return SUBSCRIPTION; 2232 if ("SubscriptionStatus".equals(codeString)) 2233 return SUBSCRIPTIONSTATUS; 2234 if ("SubscriptionTopic".equals(codeString)) 2235 return SUBSCRIPTIONTOPIC; 2236 if ("Substance".equals(codeString)) 2237 return SUBSTANCE; 2238 if ("SubstanceDefinition".equals(codeString)) 2239 return SUBSTANCEDEFINITION; 2240 if ("SubstanceNucleicAcid".equals(codeString)) 2241 return SUBSTANCENUCLEICACID; 2242 if ("SubstancePolymer".equals(codeString)) 2243 return SUBSTANCEPOLYMER; 2244 if ("SubstanceProtein".equals(codeString)) 2245 return SUBSTANCEPROTEIN; 2246 if ("SubstanceReferenceInformation".equals(codeString)) 2247 return SUBSTANCEREFERENCEINFORMATION; 2248 if ("SubstanceSourceMaterial".equals(codeString)) 2249 return SUBSTANCESOURCEMATERIAL; 2250 if ("SupplyDelivery".equals(codeString)) 2251 return SUPPLYDELIVERY; 2252 if ("SupplyRequest".equals(codeString)) 2253 return SUPPLYREQUEST; 2254 if ("Task".equals(codeString)) 2255 return TASK; 2256 if ("TerminologyCapabilities".equals(codeString)) 2257 return TERMINOLOGYCAPABILITIES; 2258 if ("TestReport".equals(codeString)) 2259 return TESTREPORT; 2260 if ("TestScript".equals(codeString)) 2261 return TESTSCRIPT; 2262 if ("Transport".equals(codeString)) 2263 return TRANSPORT; 2264 if ("ValueSet".equals(codeString)) 2265 return VALUESET; 2266 if ("VerificationResult".equals(codeString)) 2267 return VERIFICATIONRESULT; 2268 if ("VisionPrescription".equals(codeString)) 2269 return VISIONPRESCRIPTION; 2270 throw new FHIRException("Unknown AllResourceTypes code '"+codeString+"'"); 2271 } 2272 public String toCode() { 2273 switch (this) { 2274 case ACCOUNT: return "Account"; 2275 case ACTIVITYDEFINITION: return "ActivityDefinition"; 2276 case ACTORDEFINITION: return "ActorDefinition"; 2277 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 2278 case ADVERSEEVENT: return "AdverseEvent"; 2279 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 2280 case APPOINTMENT: return "Appointment"; 2281 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 2282 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 2283 case AUDITEVENT: return "AuditEvent"; 2284 case BASIC: return "Basic"; 2285 case BINARY: return "Binary"; 2286 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 2287 case BODYSTRUCTURE: return "BodyStructure"; 2288 case BUNDLE: return "Bundle"; 2289 case CANONICALRESOURCE: return "CanonicalResource"; 2290 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 2291 case CAREPLAN: return "CarePlan"; 2292 case CARETEAM: return "CareTeam"; 2293 case CHARGEITEM: return "ChargeItem"; 2294 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 2295 case CITATION: return "Citation"; 2296 case CLAIM: return "Claim"; 2297 case CLAIMRESPONSE: return "ClaimResponse"; 2298 case CLINICALIMPRESSION: return "ClinicalImpression"; 2299 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 2300 case CODESYSTEM: return "CodeSystem"; 2301 case COMMUNICATION: return "Communication"; 2302 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 2303 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 2304 case COMPOSITION: return "Composition"; 2305 case CONCEPTMAP: return "ConceptMap"; 2306 case CONDITION: return "Condition"; 2307 case CONDITIONDEFINITION: return "ConditionDefinition"; 2308 case CONSENT: return "Consent"; 2309 case CONTRACT: return "Contract"; 2310 case COVERAGE: return "Coverage"; 2311 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 2312 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 2313 case DETECTEDISSUE: return "DetectedIssue"; 2314 case DEVICE: return "Device"; 2315 case DEVICEDEFINITION: return "DeviceDefinition"; 2316 case DEVICEDISPENSE: return "DeviceDispense"; 2317 case DEVICEMETRIC: return "DeviceMetric"; 2318 case DEVICEREQUEST: return "DeviceRequest"; 2319 case DEVICEUSAGE: return "DeviceUsage"; 2320 case DIAGNOSTICREPORT: return "DiagnosticReport"; 2321 case DOCUMENTMANIFEST: return "DocumentManifest"; 2322 case DOCUMENTREFERENCE: return "DocumentReference"; 2323 case DOMAINRESOURCE: return "DomainResource"; 2324 case ENCOUNTER: return "Encounter"; 2325 case ENDPOINT: return "Endpoint"; 2326 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 2327 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 2328 case EPISODEOFCARE: return "EpisodeOfCare"; 2329 case EVENTDEFINITION: return "EventDefinition"; 2330 case EVIDENCE: return "Evidence"; 2331 case EVIDENCEREPORT: return "EvidenceReport"; 2332 case EVIDENCEVARIABLE: return "EvidenceVariable"; 2333 case EXAMPLESCENARIO: return "ExampleScenario"; 2334 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 2335 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 2336 case FLAG: return "Flag"; 2337 case FORMULARYITEM: return "FormularyItem"; 2338 case GENOMICSTUDY: return "GenomicStudy"; 2339 case GOAL: return "Goal"; 2340 case GRAPHDEFINITION: return "GraphDefinition"; 2341 case GROUP: return "Group"; 2342 case GUIDANCERESPONSE: return "GuidanceResponse"; 2343 case HEALTHCARESERVICE: return "HealthcareService"; 2344 case IMAGINGSELECTION: return "ImagingSelection"; 2345 case IMAGINGSTUDY: return "ImagingStudy"; 2346 case IMMUNIZATION: return "Immunization"; 2347 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 2348 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 2349 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 2350 case INGREDIENT: return "Ingredient"; 2351 case INSURANCEPLAN: return "InsurancePlan"; 2352 case INVENTORYREPORT: return "InventoryReport"; 2353 case INVOICE: return "Invoice"; 2354 case LIBRARY: return "Library"; 2355 case LINKAGE: return "Linkage"; 2356 case LIST: return "List"; 2357 case LOCATION: return "Location"; 2358 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 2359 case MEASURE: return "Measure"; 2360 case MEASUREREPORT: return "MeasureReport"; 2361 case MEDICATION: return "Medication"; 2362 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 2363 case MEDICATIONDISPENSE: return "MedicationDispense"; 2364 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 2365 case MEDICATIONREQUEST: return "MedicationRequest"; 2366 case MEDICATIONUSAGE: return "MedicationUsage"; 2367 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 2368 case MESSAGEDEFINITION: return "MessageDefinition"; 2369 case MESSAGEHEADER: return "MessageHeader"; 2370 case METADATARESOURCE: return "MetadataResource"; 2371 case MOLECULARSEQUENCE: return "MolecularSequence"; 2372 case NAMINGSYSTEM: return "NamingSystem"; 2373 case NUTRITIONINTAKE: return "NutritionIntake"; 2374 case NUTRITIONORDER: return "NutritionOrder"; 2375 case NUTRITIONPRODUCT: return "NutritionProduct"; 2376 case OBSERVATION: return "Observation"; 2377 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 2378 case OPERATIONDEFINITION: return "OperationDefinition"; 2379 case OPERATIONOUTCOME: return "OperationOutcome"; 2380 case ORGANIZATION: return "Organization"; 2381 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 2382 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 2383 case PARAMETERS: return "Parameters"; 2384 case PATIENT: return "Patient"; 2385 case PAYMENTNOTICE: return "PaymentNotice"; 2386 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 2387 case PERMISSION: return "Permission"; 2388 case PERSON: return "Person"; 2389 case PLANDEFINITION: return "PlanDefinition"; 2390 case PRACTITIONER: return "Practitioner"; 2391 case PRACTITIONERROLE: return "PractitionerRole"; 2392 case PROCEDURE: return "Procedure"; 2393 case PROVENANCE: return "Provenance"; 2394 case QUESTIONNAIRE: return "Questionnaire"; 2395 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 2396 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 2397 case RELATEDPERSON: return "RelatedPerson"; 2398 case REQUESTORCHESTRATION: return "RequestOrchestration"; 2399 case REQUIREMENTS: return "Requirements"; 2400 case RESEARCHSTUDY: return "ResearchStudy"; 2401 case RESEARCHSUBJECT: return "ResearchSubject"; 2402 case RESOURCE: return "Resource"; 2403 case RISKASSESSMENT: return "RiskAssessment"; 2404 case SCHEDULE: return "Schedule"; 2405 case SEARCHPARAMETER: return "SearchParameter"; 2406 case SERVICEREQUEST: return "ServiceRequest"; 2407 case SLOT: return "Slot"; 2408 case SPECIMEN: return "Specimen"; 2409 case SPECIMENDEFINITION: return "SpecimenDefinition"; 2410 case STRUCTUREDEFINITION: return "StructureDefinition"; 2411 case STRUCTUREMAP: return "StructureMap"; 2412 case SUBSCRIPTION: return "Subscription"; 2413 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 2414 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 2415 case SUBSTANCE: return "Substance"; 2416 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 2417 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 2418 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 2419 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 2420 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 2421 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 2422 case SUPPLYDELIVERY: return "SupplyDelivery"; 2423 case SUPPLYREQUEST: return "SupplyRequest"; 2424 case TASK: return "Task"; 2425 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 2426 case TESTREPORT: return "TestReport"; 2427 case TESTSCRIPT: return "TestScript"; 2428 case TRANSPORT: return "Transport"; 2429 case VALUESET: return "ValueSet"; 2430 case VERIFICATIONRESULT: return "VerificationResult"; 2431 case VISIONPRESCRIPTION: return "VisionPrescription"; 2432 case NULL: return null; 2433 default: return "?"; 2434 } 2435 } 2436 public String getSystem() { 2437 switch (this) { 2438 case ACCOUNT: return "http://hl7.org/fhir/fhir-types"; 2439 case ACTIVITYDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2440 case ACTORDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2441 case ADMINISTRABLEPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2442 case ADVERSEEVENT: return "http://hl7.org/fhir/fhir-types"; 2443 case ALLERGYINTOLERANCE: return "http://hl7.org/fhir/fhir-types"; 2444 case APPOINTMENT: return "http://hl7.org/fhir/fhir-types"; 2445 case APPOINTMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 2446 case ARTIFACTASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 2447 case AUDITEVENT: return "http://hl7.org/fhir/fhir-types"; 2448 case BASIC: return "http://hl7.org/fhir/fhir-types"; 2449 case BINARY: return "http://hl7.org/fhir/fhir-types"; 2450 case BIOLOGICALLYDERIVEDPRODUCT: return "http://hl7.org/fhir/fhir-types"; 2451 case BODYSTRUCTURE: return "http://hl7.org/fhir/fhir-types"; 2452 case BUNDLE: return "http://hl7.org/fhir/fhir-types"; 2453 case CANONICALRESOURCE: return "http://hl7.org/fhir/fhir-types"; 2454 case CAPABILITYSTATEMENT: return "http://hl7.org/fhir/fhir-types"; 2455 case CAREPLAN: return "http://hl7.org/fhir/fhir-types"; 2456 case CARETEAM: return "http://hl7.org/fhir/fhir-types"; 2457 case CHARGEITEM: return "http://hl7.org/fhir/fhir-types"; 2458 case CHARGEITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2459 case CITATION: return "http://hl7.org/fhir/fhir-types"; 2460 case CLAIM: return "http://hl7.org/fhir/fhir-types"; 2461 case CLAIMRESPONSE: return "http://hl7.org/fhir/fhir-types"; 2462 case CLINICALIMPRESSION: return "http://hl7.org/fhir/fhir-types"; 2463 case CLINICALUSEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2464 case CODESYSTEM: return "http://hl7.org/fhir/fhir-types"; 2465 case COMMUNICATION: return "http://hl7.org/fhir/fhir-types"; 2466 case COMMUNICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 2467 case COMPARTMENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2468 case COMPOSITION: return "http://hl7.org/fhir/fhir-types"; 2469 case CONCEPTMAP: return "http://hl7.org/fhir/fhir-types"; 2470 case CONDITION: return "http://hl7.org/fhir/fhir-types"; 2471 case CONDITIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2472 case CONSENT: return "http://hl7.org/fhir/fhir-types"; 2473 case CONTRACT: return "http://hl7.org/fhir/fhir-types"; 2474 case COVERAGE: return "http://hl7.org/fhir/fhir-types"; 2475 case COVERAGEELIGIBILITYREQUEST: return "http://hl7.org/fhir/fhir-types"; 2476 case COVERAGEELIGIBILITYRESPONSE: return "http://hl7.org/fhir/fhir-types"; 2477 case DETECTEDISSUE: return "http://hl7.org/fhir/fhir-types"; 2478 case DEVICE: return "http://hl7.org/fhir/fhir-types"; 2479 case DEVICEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2480 case DEVICEDISPENSE: return "http://hl7.org/fhir/fhir-types"; 2481 case DEVICEMETRIC: return "http://hl7.org/fhir/fhir-types"; 2482 case DEVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 2483 case DEVICEUSAGE: return "http://hl7.org/fhir/fhir-types"; 2484 case DIAGNOSTICREPORT: return "http://hl7.org/fhir/fhir-types"; 2485 case DOCUMENTMANIFEST: return "http://hl7.org/fhir/fhir-types"; 2486 case DOCUMENTREFERENCE: return "http://hl7.org/fhir/fhir-types"; 2487 case DOMAINRESOURCE: return "http://hl7.org/fhir/fhir-types"; 2488 case ENCOUNTER: return "http://hl7.org/fhir/fhir-types"; 2489 case ENDPOINT: return "http://hl7.org/fhir/fhir-types"; 2490 case ENROLLMENTREQUEST: return "http://hl7.org/fhir/fhir-types"; 2491 case ENROLLMENTRESPONSE: return "http://hl7.org/fhir/fhir-types"; 2492 case EPISODEOFCARE: return "http://hl7.org/fhir/fhir-types"; 2493 case EVENTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2494 case EVIDENCE: return "http://hl7.org/fhir/fhir-types"; 2495 case EVIDENCEREPORT: return "http://hl7.org/fhir/fhir-types"; 2496 case EVIDENCEVARIABLE: return "http://hl7.org/fhir/fhir-types"; 2497 case EXAMPLESCENARIO: return "http://hl7.org/fhir/fhir-types"; 2498 case EXPLANATIONOFBENEFIT: return "http://hl7.org/fhir/fhir-types"; 2499 case FAMILYMEMBERHISTORY: return "http://hl7.org/fhir/fhir-types"; 2500 case FLAG: return "http://hl7.org/fhir/fhir-types"; 2501 case FORMULARYITEM: return "http://hl7.org/fhir/fhir-types"; 2502 case GENOMICSTUDY: return "http://hl7.org/fhir/fhir-types"; 2503 case GOAL: return "http://hl7.org/fhir/fhir-types"; 2504 case GRAPHDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2505 case GROUP: return "http://hl7.org/fhir/fhir-types"; 2506 case GUIDANCERESPONSE: return "http://hl7.org/fhir/fhir-types"; 2507 case HEALTHCARESERVICE: return "http://hl7.org/fhir/fhir-types"; 2508 case IMAGINGSELECTION: return "http://hl7.org/fhir/fhir-types"; 2509 case IMAGINGSTUDY: return "http://hl7.org/fhir/fhir-types"; 2510 case IMMUNIZATION: return "http://hl7.org/fhir/fhir-types"; 2511 case IMMUNIZATIONEVALUATION: return "http://hl7.org/fhir/fhir-types"; 2512 case IMMUNIZATIONRECOMMENDATION: return "http://hl7.org/fhir/fhir-types"; 2513 case IMPLEMENTATIONGUIDE: return "http://hl7.org/fhir/fhir-types"; 2514 case INGREDIENT: return "http://hl7.org/fhir/fhir-types"; 2515 case INSURANCEPLAN: return "http://hl7.org/fhir/fhir-types"; 2516 case INVENTORYREPORT: return "http://hl7.org/fhir/fhir-types"; 2517 case INVOICE: return "http://hl7.org/fhir/fhir-types"; 2518 case LIBRARY: return "http://hl7.org/fhir/fhir-types"; 2519 case LINKAGE: return "http://hl7.org/fhir/fhir-types"; 2520 case LIST: return "http://hl7.org/fhir/fhir-types"; 2521 case LOCATION: return "http://hl7.org/fhir/fhir-types"; 2522 case MANUFACTUREDITEMDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2523 case MEASURE: return "http://hl7.org/fhir/fhir-types"; 2524 case MEASUREREPORT: return "http://hl7.org/fhir/fhir-types"; 2525 case MEDICATION: return "http://hl7.org/fhir/fhir-types"; 2526 case MEDICATIONADMINISTRATION: return "http://hl7.org/fhir/fhir-types"; 2527 case MEDICATIONDISPENSE: return "http://hl7.org/fhir/fhir-types"; 2528 case MEDICATIONKNOWLEDGE: return "http://hl7.org/fhir/fhir-types"; 2529 case MEDICATIONREQUEST: return "http://hl7.org/fhir/fhir-types"; 2530 case MEDICATIONUSAGE: return "http://hl7.org/fhir/fhir-types"; 2531 case MEDICINALPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2532 case MESSAGEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2533 case MESSAGEHEADER: return "http://hl7.org/fhir/fhir-types"; 2534 case METADATARESOURCE: return "http://hl7.org/fhir/fhir-types"; 2535 case MOLECULARSEQUENCE: return "http://hl7.org/fhir/fhir-types"; 2536 case NAMINGSYSTEM: return "http://hl7.org/fhir/fhir-types"; 2537 case NUTRITIONINTAKE: return "http://hl7.org/fhir/fhir-types"; 2538 case NUTRITIONORDER: return "http://hl7.org/fhir/fhir-types"; 2539 case NUTRITIONPRODUCT: return "http://hl7.org/fhir/fhir-types"; 2540 case OBSERVATION: return "http://hl7.org/fhir/fhir-types"; 2541 case OBSERVATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2542 case OPERATIONDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2543 case OPERATIONOUTCOME: return "http://hl7.org/fhir/fhir-types"; 2544 case ORGANIZATION: return "http://hl7.org/fhir/fhir-types"; 2545 case ORGANIZATIONAFFILIATION: return "http://hl7.org/fhir/fhir-types"; 2546 case PACKAGEDPRODUCTDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2547 case PARAMETERS: return "http://hl7.org/fhir/fhir-types"; 2548 case PATIENT: return "http://hl7.org/fhir/fhir-types"; 2549 case PAYMENTNOTICE: return "http://hl7.org/fhir/fhir-types"; 2550 case PAYMENTRECONCILIATION: return "http://hl7.org/fhir/fhir-types"; 2551 case PERMISSION: return "http://hl7.org/fhir/fhir-types"; 2552 case PERSON: return "http://hl7.org/fhir/fhir-types"; 2553 case PLANDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2554 case PRACTITIONER: return "http://hl7.org/fhir/fhir-types"; 2555 case PRACTITIONERROLE: return "http://hl7.org/fhir/fhir-types"; 2556 case PROCEDURE: return "http://hl7.org/fhir/fhir-types"; 2557 case PROVENANCE: return "http://hl7.org/fhir/fhir-types"; 2558 case QUESTIONNAIRE: return "http://hl7.org/fhir/fhir-types"; 2559 case QUESTIONNAIRERESPONSE: return "http://hl7.org/fhir/fhir-types"; 2560 case REGULATEDAUTHORIZATION: return "http://hl7.org/fhir/fhir-types"; 2561 case RELATEDPERSON: return "http://hl7.org/fhir/fhir-types"; 2562 case REQUESTORCHESTRATION: return "http://hl7.org/fhir/fhir-types"; 2563 case REQUIREMENTS: return "http://hl7.org/fhir/fhir-types"; 2564 case RESEARCHSTUDY: return "http://hl7.org/fhir/fhir-types"; 2565 case RESEARCHSUBJECT: return "http://hl7.org/fhir/fhir-types"; 2566 case RESOURCE: return "http://hl7.org/fhir/fhir-types"; 2567 case RISKASSESSMENT: return "http://hl7.org/fhir/fhir-types"; 2568 case SCHEDULE: return "http://hl7.org/fhir/fhir-types"; 2569 case SEARCHPARAMETER: return "http://hl7.org/fhir/fhir-types"; 2570 case SERVICEREQUEST: return "http://hl7.org/fhir/fhir-types"; 2571 case SLOT: return "http://hl7.org/fhir/fhir-types"; 2572 case SPECIMEN: return "http://hl7.org/fhir/fhir-types"; 2573 case SPECIMENDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2574 case STRUCTUREDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2575 case STRUCTUREMAP: return "http://hl7.org/fhir/fhir-types"; 2576 case SUBSCRIPTION: return "http://hl7.org/fhir/fhir-types"; 2577 case SUBSCRIPTIONSTATUS: return "http://hl7.org/fhir/fhir-types"; 2578 case SUBSCRIPTIONTOPIC: return "http://hl7.org/fhir/fhir-types"; 2579 case SUBSTANCE: return "http://hl7.org/fhir/fhir-types"; 2580 case SUBSTANCEDEFINITION: return "http://hl7.org/fhir/fhir-types"; 2581 case SUBSTANCENUCLEICACID: return "http://hl7.org/fhir/fhir-types"; 2582 case SUBSTANCEPOLYMER: return "http://hl7.org/fhir/fhir-types"; 2583 case SUBSTANCEPROTEIN: return "http://hl7.org/fhir/fhir-types"; 2584 case SUBSTANCEREFERENCEINFORMATION: return "http://hl7.org/fhir/fhir-types"; 2585 case SUBSTANCESOURCEMATERIAL: return "http://hl7.org/fhir/fhir-types"; 2586 case SUPPLYDELIVERY: return "http://hl7.org/fhir/fhir-types"; 2587 case SUPPLYREQUEST: return "http://hl7.org/fhir/fhir-types"; 2588 case TASK: return "http://hl7.org/fhir/fhir-types"; 2589 case TERMINOLOGYCAPABILITIES: return "http://hl7.org/fhir/fhir-types"; 2590 case TESTREPORT: return "http://hl7.org/fhir/fhir-types"; 2591 case TESTSCRIPT: return "http://hl7.org/fhir/fhir-types"; 2592 case TRANSPORT: return "http://hl7.org/fhir/fhir-types"; 2593 case VALUESET: return "http://hl7.org/fhir/fhir-types"; 2594 case VERIFICATIONRESULT: return "http://hl7.org/fhir/fhir-types"; 2595 case VISIONPRESCRIPTION: return "http://hl7.org/fhir/fhir-types"; 2596 case NULL: return null; 2597 default: return "?"; 2598 } 2599 } 2600 public String getDefinition() { 2601 switch (this) { 2602 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."; 2603 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."; 2604 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."; 2605 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)."; 2606 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 concepts, we recommend consulting the domain specific implementation guides when implementing the AdverseEvent Resource. The implementation guides include specific extensions, value sets and constraints."; 2607 case ALLERGYINTOLERANCE: return "Risk of harmful or undesirable, physiological response which is unique to an individual and associated with exposure to a substance."; 2608 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)."; 2609 case APPOINTMENTRESPONSE: return "A reply to an appointment request for a patient and/or practitioner(s), such as a confirmation or rejection."; 2610 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."; 2611 case AUDITEVENT: return "A record of an event relevant for purposes such as operations, privacy, security, maintenance, and performance analysis."; 2612 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."; 2613 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."; 2614 case BIOLOGICALLYDERIVEDPRODUCT: return "A biological material originating from a biological entity intended to be transplanted or infused into another (possibly the same) biological entity."; 2615 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."; 2616 case BUNDLE: return "A container for a collection of resources."; 2617 case CANONICALRESOURCE: return "Common Interface declaration for conformance and knowledge artifact resources."; 2618 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."; 2619 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."; 2620 case CARETEAM: return "The Care Team includes all the people and organizations who plan to participate in the coordination and delivery of care."; 2621 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."; 2622 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."; 2623 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."; 2624 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."; 2625 case CLAIMRESPONSE: return "This resource provides the adjudication details from the processing of a Claim resource."; 2626 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."; 2627 case CLINICALUSEDEFINITION: return "A single issue - either an indication, contraindication, interaction or an undesirable effect for a medicinal product, medication, device or procedure."; 2628 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."; 2629 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."; 2630 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."; 2631 case COMPARTMENTDEFINITION: return "A compartment definition that defines how resources are accessed on a server."; 2632 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.)."; 2633 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."; 2634 case CONDITION: return "A clinical condition, problem, diagnosis, or other event, situation, issue, or clinical concept that has risen to a level of concern."; 2635 case CONDITIONDEFINITION: return "A definition of a condition and information relevant to managing it."; 2636 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."; 2637 case CONTRACT: return "Legally enforceable, formally recorded unilateral or bilateral directive i.e., a policy or agreement."; 2638 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."; 2639 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."; 2640 case COVERAGEELIGIBILITYRESPONSE: return "This resource provides eligibility and plan details from the processing of an CoverageEligibilityRequest resource."; 2641 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."; 2642 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."; 2643 case DEVICEDEFINITION: return "This is a specialized resource that defines the characteristics and capabilities of a device."; 2644 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."; 2645 case DEVICEMETRIC: return "Describes a measurement, calculation or setting capability of a medical device."; 2646 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."; 2647 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."; 2648 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."; 2649 case DOCUMENTMANIFEST: return "A collection of documents compiled for a purpose together with metadata that applies to the collection."; 2650 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."; 2651 case DOMAINRESOURCE: return "A resource that includes narrative, extensions, and contained resources."; 2652 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)."; 2653 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."; 2654 case ENROLLMENTREQUEST: return "This resource provides the insurance enrollment details to the insurer regarding a specified coverage."; 2655 case ENROLLMENTRESPONSE: return "This resource provides enrollment and plan details from the processing of an EnrollmentRequest resource."; 2656 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."; 2657 case EVENTDEFINITION: return "The EventDefinition resource provides a reusable description of when a particular event can occur."; 2658 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."; 2659 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."; 2660 case EVIDENCEVARIABLE: return "The EvidenceVariable resource describes an element that knowledge (Evidence) is about."; 2661 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."; 2662 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."; 2663 case FAMILYMEMBERHISTORY: return "Significant health conditions for a person related to the patient relevant in the context of care for the patient."; 2664 case FLAG: return "Prospective warnings of potential issues when providing care to the patient."; 2665 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."; 2666 case GENOMICSTUDY: return "A Genomic Study is a set of analysis performed to analyze and generate genomic data."; 2667 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."; 2668 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."; 2669 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."; 2670 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."; 2671 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."; 2672 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."; 2673 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."; 2674 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."; 2675 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."; 2676 case IMMUNIZATIONRECOMMENDATION: return "A patient's point-in-time set of recommendations (i.e. forecasting) according to a published schedule with optional supporting justification."; 2677 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."; 2678 case INGREDIENT: return "An ingredient of a manufactured item or pharmaceutical product."; 2679 case INSURANCEPLAN: return "Details of a Health Insurance product/plan provided by an organization."; 2680 case INVENTORYREPORT: return "A report of inventory or stock items."; 2681 case INVOICE: return "Invoice containing collected ChargeItems from an Account with calculated individual and total price for Billing purpose."; 2682 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."; 2683 case LINKAGE: return "Identifies two or more records (resource instances) that refer to the same real-world \"occurrence\"."; 2684 case LIST: return "A List is a curated collection of resources, for things such as problem lists, allergy lists, facility list, organization list, etc."; 2685 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."; 2686 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."; 2687 case MEASURE: return "The Measure resource provides the definition of a quality measure."; 2688 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."; 2689 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."; 2690 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."; 2691 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."; 2692 case MEDICATIONKNOWLEDGE: return "Information about a medication that is used to support knowledge."; 2693 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."; 2694 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."; 2695 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.)."; 2696 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."; 2697 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."; 2698 case METADATARESOURCE: return "Common Interface declaration for conformance and knowledge artifact resources."; 2699 case MOLECULARSEQUENCE: return "Representation of a molecular sequence."; 2700 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."; 2701 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."; 2702 case NUTRITIONORDER: return "A request to supply a diet, formula feeding (enteral) or oral nutritional supplement to a patient/resident."; 2703 case NUTRITIONPRODUCT: return "A food or supplement that is consumed by patients."; 2704 case OBSERVATION: return "Measurements and simple assertions made about a patient, device or other subject."; 2705 case OBSERVATIONDEFINITION: return "Set of definitional characteristics for a kind of observation or measurement produced or consumed by an orderable health care service."; 2706 case OPERATIONDEFINITION: return "A formal computable definition of an operation (on the RESTful interface) or a named query (using the search interaction)."; 2707 case OPERATIONOUTCOME: return "A collection of error, warning, or information messages that result from a system action."; 2708 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."; 2709 case ORGANIZATIONAFFILIATION: return "Defines an affiliation/assotiation/relationship between 2 distinct organizations, that is not a part-of relationship/sub-division relationship."; 2710 case PACKAGEDPRODUCTDEFINITION: return "A medically related item or items, in a container or package."; 2711 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."; 2712 case PATIENT: return "Demographics and other administrative information about an individual or animal receiving care or other health-related services."; 2713 case PAYMENTNOTICE: return "This resource provides the status of the payment for goods and services rendered, and the request and response resource references."; 2714 case PAYMENTRECONCILIATION: return "This resource provides the details including amount of a payment and allocates the payment items being paid."; 2715 case PERMISSION: return "Permission resource holds access rules for a given data and context."; 2716 case PERSON: return "Demographics and administrative information about a person independent of a specific health-related context."; 2717 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."; 2718 case PRACTITIONER: return "A person who is directly or indirectly involved in the provisioning of healthcare or related services."; 2719 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."; 2720 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."; 2721 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."; 2722 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."; 2723 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."; 2724 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."; 2725 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."; 2726 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\"."; 2727 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."; 2728 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."; 2729 case RESEARCHSUBJECT: return "A physical entity which is the primary unit of operational and/or administrative interest in a study."; 2730 case RESOURCE: return "This is the base resource type for everything."; 2731 case RISKASSESSMENT: return "An assessment of the likely outcome(s) for a patient or other subject as well as the likelihood of each outcome."; 2732 case SCHEDULE: return "A container for slots of time that may be available for booking appointments."; 2733 case SEARCHPARAMETER: return "A search parameter that defines a named search item that can be used to search/filter on a resource."; 2734 case SERVICEREQUEST: return "A record of a request for service such as diagnostic investigations, treatments, or operations to be performed."; 2735 case SLOT: return "A slot of time on a schedule that may be available for booking appointments."; 2736 case SPECIMEN: return "A sample to be used for analysis."; 2737 case SPECIMENDEFINITION: return "A kind of specimen with associated set of requirements."; 2738 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."; 2739 case STRUCTUREMAP: return "A Map of relationships between 2 structures that can be used to transform data."; 2740 case SUBSCRIPTION: return "The subscription resource describes a particular client's request to be notified about a SubscriptionTopic."; 2741 case SUBSCRIPTIONSTATUS: return "The SubscriptionStatus resource describes the state of a Subscription during notifications. It is not persisted."; 2742 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."; 2743 case SUBSTANCE: return "A homogeneous material with a definite composition."; 2744 case SUBSTANCEDEFINITION: return "The detailed description of a substance, typically at a level beyond what is used for prescribing."; 2745 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."; 2746 case SUBSTANCEPOLYMER: return "Properties of a substance specific to it being a polymer."; 2747 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."; 2748 case SUBSTANCEREFERENCEINFORMATION: return "Todo."; 2749 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."; 2750 case SUPPLYDELIVERY: return "Record of delivery of what is supplied."; 2751 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."; 2752 case TASK: return "A task to be performed."; 2753 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."; 2754 case TESTREPORT: return "A summary of information based on the results of executing a TestScript."; 2755 case TESTSCRIPT: return "A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification."; 2756 case TRANSPORT: return "Record of transport."; 2757 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)."; 2758 case VERIFICATIONRESULT: return "Describes validation requirements, source(s), status and dates for one or more elements."; 2759 case VISIONPRESCRIPTION: return "An authorization for the provision of glasses and/or contact lenses to a patient."; 2760 case NULL: return null; 2761 default: return "?"; 2762 } 2763 } 2764 public String getDisplay() { 2765 switch (this) { 2766 case ACCOUNT: return "Account"; 2767 case ACTIVITYDEFINITION: return "ActivityDefinition"; 2768 case ACTORDEFINITION: return "ActorDefinition"; 2769 case ADMINISTRABLEPRODUCTDEFINITION: return "AdministrableProductDefinition"; 2770 case ADVERSEEVENT: return "AdverseEvent"; 2771 case ALLERGYINTOLERANCE: return "AllergyIntolerance"; 2772 case APPOINTMENT: return "Appointment"; 2773 case APPOINTMENTRESPONSE: return "AppointmentResponse"; 2774 case ARTIFACTASSESSMENT: return "ArtifactAssessment"; 2775 case AUDITEVENT: return "AuditEvent"; 2776 case BASIC: return "Basic"; 2777 case BINARY: return "Binary"; 2778 case BIOLOGICALLYDERIVEDPRODUCT: return "BiologicallyDerivedProduct"; 2779 case BODYSTRUCTURE: return "BodyStructure"; 2780 case BUNDLE: return "Bundle"; 2781 case CANONICALRESOURCE: return "CanonicalResource"; 2782 case CAPABILITYSTATEMENT: return "CapabilityStatement"; 2783 case CAREPLAN: return "CarePlan"; 2784 case CARETEAM: return "CareTeam"; 2785 case CHARGEITEM: return "ChargeItem"; 2786 case CHARGEITEMDEFINITION: return "ChargeItemDefinition"; 2787 case CITATION: return "Citation"; 2788 case CLAIM: return "Claim"; 2789 case CLAIMRESPONSE: return "ClaimResponse"; 2790 case CLINICALIMPRESSION: return "ClinicalImpression"; 2791 case CLINICALUSEDEFINITION: return "ClinicalUseDefinition"; 2792 case CODESYSTEM: return "CodeSystem"; 2793 case COMMUNICATION: return "Communication"; 2794 case COMMUNICATIONREQUEST: return "CommunicationRequest"; 2795 case COMPARTMENTDEFINITION: return "CompartmentDefinition"; 2796 case COMPOSITION: return "Composition"; 2797 case CONCEPTMAP: return "ConceptMap"; 2798 case CONDITION: return "Condition"; 2799 case CONDITIONDEFINITION: return "ConditionDefinition"; 2800 case CONSENT: return "Consent"; 2801 case CONTRACT: return "Contract"; 2802 case COVERAGE: return "Coverage"; 2803 case COVERAGEELIGIBILITYREQUEST: return "CoverageEligibilityRequest"; 2804 case COVERAGEELIGIBILITYRESPONSE: return "CoverageEligibilityResponse"; 2805 case DETECTEDISSUE: return "DetectedIssue"; 2806 case DEVICE: return "Device"; 2807 case DEVICEDEFINITION: return "DeviceDefinition"; 2808 case DEVICEDISPENSE: return "DeviceDispense"; 2809 case DEVICEMETRIC: return "DeviceMetric"; 2810 case DEVICEREQUEST: return "DeviceRequest"; 2811 case DEVICEUSAGE: return "DeviceUsage"; 2812 case DIAGNOSTICREPORT: return "DiagnosticReport"; 2813 case DOCUMENTMANIFEST: return "DocumentManifest"; 2814 case DOCUMENTREFERENCE: return "DocumentReference"; 2815 case DOMAINRESOURCE: return "DomainResource"; 2816 case ENCOUNTER: return "Encounter"; 2817 case ENDPOINT: return "Endpoint"; 2818 case ENROLLMENTREQUEST: return "EnrollmentRequest"; 2819 case ENROLLMENTRESPONSE: return "EnrollmentResponse"; 2820 case EPISODEOFCARE: return "EpisodeOfCare"; 2821 case EVENTDEFINITION: return "EventDefinition"; 2822 case EVIDENCE: return "Evidence"; 2823 case EVIDENCEREPORT: return "EvidenceReport"; 2824 case EVIDENCEVARIABLE: return "EvidenceVariable"; 2825 case EXAMPLESCENARIO: return "ExampleScenario"; 2826 case EXPLANATIONOFBENEFIT: return "ExplanationOfBenefit"; 2827 case FAMILYMEMBERHISTORY: return "FamilyMemberHistory"; 2828 case FLAG: return "Flag"; 2829 case FORMULARYITEM: return "FormularyItem"; 2830 case GENOMICSTUDY: return "GenomicStudy"; 2831 case GOAL: return "Goal"; 2832 case GRAPHDEFINITION: return "GraphDefinition"; 2833 case GROUP: return "Group"; 2834 case GUIDANCERESPONSE: return "GuidanceResponse"; 2835 case HEALTHCARESERVICE: return "HealthcareService"; 2836 case IMAGINGSELECTION: return "ImagingSelection"; 2837 case IMAGINGSTUDY: return "ImagingStudy"; 2838 case IMMUNIZATION: return "Immunization"; 2839 case IMMUNIZATIONEVALUATION: return "ImmunizationEvaluation"; 2840 case IMMUNIZATIONRECOMMENDATION: return "ImmunizationRecommendation"; 2841 case IMPLEMENTATIONGUIDE: return "ImplementationGuide"; 2842 case INGREDIENT: return "Ingredient"; 2843 case INSURANCEPLAN: return "InsurancePlan"; 2844 case INVENTORYREPORT: return "InventoryReport"; 2845 case INVOICE: return "Invoice"; 2846 case LIBRARY: return "Library"; 2847 case LINKAGE: return "Linkage"; 2848 case LIST: return "List"; 2849 case LOCATION: return "Location"; 2850 case MANUFACTUREDITEMDEFINITION: return "ManufacturedItemDefinition"; 2851 case MEASURE: return "Measure"; 2852 case MEASUREREPORT: return "MeasureReport"; 2853 case MEDICATION: return "Medication"; 2854 case MEDICATIONADMINISTRATION: return "MedicationAdministration"; 2855 case MEDICATIONDISPENSE: return "MedicationDispense"; 2856 case MEDICATIONKNOWLEDGE: return "MedicationKnowledge"; 2857 case MEDICATIONREQUEST: return "MedicationRequest"; 2858 case MEDICATIONUSAGE: return "MedicationUsage"; 2859 case MEDICINALPRODUCTDEFINITION: return "MedicinalProductDefinition"; 2860 case MESSAGEDEFINITION: return "MessageDefinition"; 2861 case MESSAGEHEADER: return "MessageHeader"; 2862 case METADATARESOURCE: return "MetadataResource"; 2863 case MOLECULARSEQUENCE: return "MolecularSequence"; 2864 case NAMINGSYSTEM: return "NamingSystem"; 2865 case NUTRITIONINTAKE: return "NutritionIntake"; 2866 case NUTRITIONORDER: return "NutritionOrder"; 2867 case NUTRITIONPRODUCT: return "NutritionProduct"; 2868 case OBSERVATION: return "Observation"; 2869 case OBSERVATIONDEFINITION: return "ObservationDefinition"; 2870 case OPERATIONDEFINITION: return "OperationDefinition"; 2871 case OPERATIONOUTCOME: return "OperationOutcome"; 2872 case ORGANIZATION: return "Organization"; 2873 case ORGANIZATIONAFFILIATION: return "OrganizationAffiliation"; 2874 case PACKAGEDPRODUCTDEFINITION: return "PackagedProductDefinition"; 2875 case PARAMETERS: return "Parameters"; 2876 case PATIENT: return "Patient"; 2877 case PAYMENTNOTICE: return "PaymentNotice"; 2878 case PAYMENTRECONCILIATION: return "PaymentReconciliation"; 2879 case PERMISSION: return "Permission"; 2880 case PERSON: return "Person"; 2881 case PLANDEFINITION: return "PlanDefinition"; 2882 case PRACTITIONER: return "Practitioner"; 2883 case PRACTITIONERROLE: return "PractitionerRole"; 2884 case PROCEDURE: return "Procedure"; 2885 case PROVENANCE: return "Provenance"; 2886 case QUESTIONNAIRE: return "Questionnaire"; 2887 case QUESTIONNAIRERESPONSE: return "QuestionnaireResponse"; 2888 case REGULATEDAUTHORIZATION: return "RegulatedAuthorization"; 2889 case RELATEDPERSON: return "RelatedPerson"; 2890 case REQUESTORCHESTRATION: return "RequestOrchestration"; 2891 case REQUIREMENTS: return "Requirements"; 2892 case RESEARCHSTUDY: return "ResearchStudy"; 2893 case RESEARCHSUBJECT: return "ResearchSubject"; 2894 case RESOURCE: return "Resource"; 2895 case RISKASSESSMENT: return "RiskAssessment"; 2896 case SCHEDULE: return "Schedule"; 2897 case SEARCHPARAMETER: return "SearchParameter"; 2898 case SERVICEREQUEST: return "ServiceRequest"; 2899 case SLOT: return "Slot"; 2900 case SPECIMEN: return "Specimen"; 2901 case SPECIMENDEFINITION: return "SpecimenDefinition"; 2902 case STRUCTUREDEFINITION: return "StructureDefinition"; 2903 case STRUCTUREMAP: return "StructureMap"; 2904 case SUBSCRIPTION: return "Subscription"; 2905 case SUBSCRIPTIONSTATUS: return "SubscriptionStatus"; 2906 case SUBSCRIPTIONTOPIC: return "SubscriptionTopic"; 2907 case SUBSTANCE: return "Substance"; 2908 case SUBSTANCEDEFINITION: return "SubstanceDefinition"; 2909 case SUBSTANCENUCLEICACID: return "SubstanceNucleicAcid"; 2910 case SUBSTANCEPOLYMER: return "SubstancePolymer"; 2911 case SUBSTANCEPROTEIN: return "SubstanceProtein"; 2912 case SUBSTANCEREFERENCEINFORMATION: return "SubstanceReferenceInformation"; 2913 case SUBSTANCESOURCEMATERIAL: return "SubstanceSourceMaterial"; 2914 case SUPPLYDELIVERY: return "SupplyDelivery"; 2915 case SUPPLYREQUEST: return "SupplyRequest"; 2916 case TASK: return "Task"; 2917 case TERMINOLOGYCAPABILITIES: return "TerminologyCapabilities"; 2918 case TESTREPORT: return "TestReport"; 2919 case TESTSCRIPT: return "TestScript"; 2920 case TRANSPORT: return "Transport"; 2921 case VALUESET: return "ValueSet"; 2922 case VERIFICATIONRESULT: return "VerificationResult"; 2923 case VISIONPRESCRIPTION: return "VisionPrescription"; 2924 case NULL: return null; 2925 default: return "?"; 2926 } 2927 } 2928 } 2929 2930 public static class AllResourceTypesEnumFactory implements EnumFactory<AllResourceTypes> { 2931 public AllResourceTypes fromCode(String codeString) throws IllegalArgumentException { 2932 if (codeString == null || "".equals(codeString)) 2933 if (codeString == null || "".equals(codeString)) 2934 return null; 2935 if ("Account".equals(codeString)) 2936 return AllResourceTypes.ACCOUNT; 2937 if ("ActivityDefinition".equals(codeString)) 2938 return AllResourceTypes.ACTIVITYDEFINITION; 2939 if ("ActorDefinition".equals(codeString)) 2940 return AllResourceTypes.ACTORDEFINITION; 2941 if ("AdministrableProductDefinition".equals(codeString)) 2942 return AllResourceTypes.ADMINISTRABLEPRODUCTDEFINITION; 2943 if ("AdverseEvent".equals(codeString)) 2944 return AllResourceTypes.ADVERSEEVENT; 2945 if ("AllergyIntolerance".equals(codeString)) 2946 return AllResourceTypes.ALLERGYINTOLERANCE; 2947 if ("Appointment".equals(codeString)) 2948 return AllResourceTypes.APPOINTMENT; 2949 if ("AppointmentResponse".equals(codeString)) 2950 return AllResourceTypes.APPOINTMENTRESPONSE; 2951 if ("ArtifactAssessment".equals(codeString)) 2952 return AllResourceTypes.ARTIFACTASSESSMENT; 2953 if ("AuditEvent".equals(codeString)) 2954 return AllResourceTypes.AUDITEVENT; 2955 if ("Basic".equals(codeString)) 2956 return AllResourceTypes.BASIC; 2957 if ("Binary".equals(codeString)) 2958 return AllResourceTypes.BINARY; 2959 if ("BiologicallyDerivedProduct".equals(codeString)) 2960 return AllResourceTypes.BIOLOGICALLYDERIVEDPRODUCT; 2961 if ("BodyStructure".equals(codeString)) 2962 return AllResourceTypes.BODYSTRUCTURE; 2963 if ("Bundle".equals(codeString)) 2964 return AllResourceTypes.BUNDLE; 2965 if ("CanonicalResource".equals(codeString)) 2966 return AllResourceTypes.CANONICALRESOURCE; 2967 if ("CapabilityStatement".equals(codeString)) 2968 return AllResourceTypes.CAPABILITYSTATEMENT; 2969 if ("CarePlan".equals(codeString)) 2970 return AllResourceTypes.CAREPLAN; 2971 if ("CareTeam".equals(codeString)) 2972 return AllResourceTypes.CARETEAM; 2973 if ("ChargeItem".equals(codeString)) 2974 return AllResourceTypes.CHARGEITEM; 2975 if ("ChargeItemDefinition".equals(codeString)) 2976 return AllResourceTypes.CHARGEITEMDEFINITION; 2977 if ("Citation".equals(codeString)) 2978 return AllResourceTypes.CITATION; 2979 if ("Claim".equals(codeString)) 2980 return AllResourceTypes.CLAIM; 2981 if ("ClaimResponse".equals(codeString)) 2982 return AllResourceTypes.CLAIMRESPONSE; 2983 if ("ClinicalImpression".equals(codeString)) 2984 return AllResourceTypes.CLINICALIMPRESSION; 2985 if ("ClinicalUseDefinition".equals(codeString)) 2986 return AllResourceTypes.CLINICALUSEDEFINITION; 2987 if ("CodeSystem".equals(codeString)) 2988 return AllResourceTypes.CODESYSTEM; 2989 if ("Communication".equals(codeString)) 2990 return AllResourceTypes.COMMUNICATION; 2991 if ("CommunicationRequest".equals(codeString)) 2992 return AllResourceTypes.COMMUNICATIONREQUEST; 2993 if ("CompartmentDefinition".equals(codeString)) 2994 return AllResourceTypes.COMPARTMENTDEFINITION; 2995 if ("Composition".equals(codeString)) 2996 return AllResourceTypes.COMPOSITION; 2997 if ("ConceptMap".equals(codeString)) 2998 return AllResourceTypes.CONCEPTMAP; 2999 if ("Condition".equals(codeString)) 3000 return AllResourceTypes.CONDITION; 3001 if ("ConditionDefinition".equals(codeString)) 3002 return AllResourceTypes.CONDITIONDEFINITION; 3003 if ("Consent".equals(codeString)) 3004 return AllResourceTypes.CONSENT; 3005 if ("Contract".equals(codeString)) 3006 return AllResourceTypes.CONTRACT; 3007 if ("Coverage".equals(codeString)) 3008 return AllResourceTypes.COVERAGE; 3009 if ("CoverageEligibilityRequest".equals(codeString)) 3010 return AllResourceTypes.COVERAGEELIGIBILITYREQUEST; 3011 if ("CoverageEligibilityResponse".equals(codeString)) 3012 return AllResourceTypes.COVERAGEELIGIBILITYRESPONSE; 3013 if ("DetectedIssue".equals(codeString)) 3014 return AllResourceTypes.DETECTEDISSUE; 3015 if ("Device".equals(codeString)) 3016 return AllResourceTypes.DEVICE; 3017 if ("DeviceDefinition".equals(codeString)) 3018 return AllResourceTypes.DEVICEDEFINITION; 3019 if ("DeviceDispense".equals(codeString)) 3020 return AllResourceTypes.DEVICEDISPENSE; 3021 if ("DeviceMetric".equals(codeString)) 3022 return AllResourceTypes.DEVICEMETRIC; 3023 if ("DeviceRequest".equals(codeString)) 3024 return AllResourceTypes.DEVICEREQUEST; 3025 if ("DeviceUsage".equals(codeString)) 3026 return AllResourceTypes.DEVICEUSAGE; 3027 if ("DiagnosticReport".equals(codeString)) 3028 return AllResourceTypes.DIAGNOSTICREPORT; 3029 if ("DocumentManifest".equals(codeString)) 3030 return AllResourceTypes.DOCUMENTMANIFEST; 3031 if ("DocumentReference".equals(codeString)) 3032 return AllResourceTypes.DOCUMENTREFERENCE; 3033 if ("DomainResource".equals(codeString)) 3034 return AllResourceTypes.DOMAINRESOURCE; 3035 if ("Encounter".equals(codeString)) 3036 return AllResourceTypes.ENCOUNTER; 3037 if ("Endpoint".equals(codeString)) 3038 return AllResourceTypes.ENDPOINT; 3039 if ("EnrollmentRequest".equals(codeString)) 3040 return AllResourceTypes.ENROLLMENTREQUEST; 3041 if ("EnrollmentResponse".equals(codeString)) 3042 return AllResourceTypes.ENROLLMENTRESPONSE; 3043 if ("EpisodeOfCare".equals(codeString)) 3044 return AllResourceTypes.EPISODEOFCARE; 3045 if ("EventDefinition".equals(codeString)) 3046 return AllResourceTypes.EVENTDEFINITION; 3047 if ("Evidence".equals(codeString)) 3048 return AllResourceTypes.EVIDENCE; 3049 if ("EvidenceReport".equals(codeString)) 3050 return AllResourceTypes.EVIDENCEREPORT; 3051 if ("EvidenceVariable".equals(codeString)) 3052 return AllResourceTypes.EVIDENCEVARIABLE; 3053 if ("ExampleScenario".equals(codeString)) 3054 return AllResourceTypes.EXAMPLESCENARIO; 3055 if ("ExplanationOfBenefit".equals(codeString)) 3056 return AllResourceTypes.EXPLANATIONOFBENEFIT; 3057 if ("FamilyMemberHistory".equals(codeString)) 3058 return AllResourceTypes.FAMILYMEMBERHISTORY; 3059 if ("Flag".equals(codeString)) 3060 return AllResourceTypes.FLAG; 3061 if ("FormularyItem".equals(codeString)) 3062 return AllResourceTypes.FORMULARYITEM; 3063 if ("GenomicStudy".equals(codeString)) 3064 return AllResourceTypes.GENOMICSTUDY; 3065 if ("Goal".equals(codeString)) 3066 return AllResourceTypes.GOAL; 3067 if ("GraphDefinition".equals(codeString)) 3068 return AllResourceTypes.GRAPHDEFINITION; 3069 if ("Group".equals(codeString)) 3070 return AllResourceTypes.GROUP; 3071 if ("GuidanceResponse".equals(codeString)) 3072 return AllResourceTypes.GUIDANCERESPONSE; 3073 if ("HealthcareService".equals(codeString)) 3074 return AllResourceTypes.HEALTHCARESERVICE; 3075 if ("ImagingSelection".equals(codeString)) 3076 return AllResourceTypes.IMAGINGSELECTION; 3077 if ("ImagingStudy".equals(codeString)) 3078 return AllResourceTypes.IMAGINGSTUDY; 3079 if ("Immunization".equals(codeString)) 3080 return AllResourceTypes.IMMUNIZATION; 3081 if ("ImmunizationEvaluation".equals(codeString)) 3082 return AllResourceTypes.IMMUNIZATIONEVALUATION; 3083 if ("ImmunizationRecommendation".equals(codeString)) 3084 return AllResourceTypes.IMMUNIZATIONRECOMMENDATION; 3085 if ("ImplementationGuide".equals(codeString)) 3086 return AllResourceTypes.IMPLEMENTATIONGUIDE; 3087 if ("Ingredient".equals(codeString)) 3088 return AllResourceTypes.INGREDIENT; 3089 if ("InsurancePlan".equals(codeString)) 3090 return AllResourceTypes.INSURANCEPLAN; 3091 if ("InventoryReport".equals(codeString)) 3092 return AllResourceTypes.INVENTORYREPORT; 3093 if ("Invoice".equals(codeString)) 3094 return AllResourceTypes.INVOICE; 3095 if ("Library".equals(codeString)) 3096 return AllResourceTypes.LIBRARY; 3097 if ("Linkage".equals(codeString)) 3098 return AllResourceTypes.LINKAGE; 3099 if ("List".equals(codeString)) 3100 return AllResourceTypes.LIST; 3101 if ("Location".equals(codeString)) 3102 return AllResourceTypes.LOCATION; 3103 if ("ManufacturedItemDefinition".equals(codeString)) 3104 return AllResourceTypes.MANUFACTUREDITEMDEFINITION; 3105 if ("Measure".equals(codeString)) 3106 return AllResourceTypes.MEASURE; 3107 if ("MeasureReport".equals(codeString)) 3108 return AllResourceTypes.MEASUREREPORT; 3109 if ("Medication".equals(codeString)) 3110 return AllResourceTypes.MEDICATION; 3111 if ("MedicationAdministration".equals(codeString)) 3112 return AllResourceTypes.MEDICATIONADMINISTRATION; 3113 if ("MedicationDispense".equals(codeString)) 3114 return AllResourceTypes.MEDICATIONDISPENSE; 3115 if ("MedicationKnowledge".equals(codeString)) 3116 return AllResourceTypes.MEDICATIONKNOWLEDGE; 3117 if ("MedicationRequest".equals(codeString)) 3118 return AllResourceTypes.MEDICATIONREQUEST; 3119 if ("MedicationUsage".equals(codeString)) 3120 return AllResourceTypes.MEDICATIONUSAGE; 3121 if ("MedicationStatement".equals(codeString)) 3122 return AllResourceTypes.MEDICATIONUSAGE; 3123 if ("MedicinalProductDefinition".equals(codeString)) 3124 return AllResourceTypes.MEDICINALPRODUCTDEFINITION; 3125 if ("MessageDefinition".equals(codeString)) 3126 return AllResourceTypes.MESSAGEDEFINITION; 3127 if ("MessageHeader".equals(codeString)) 3128 return AllResourceTypes.MESSAGEHEADER; 3129 if ("MetadataResource".equals(codeString)) 3130 return AllResourceTypes.METADATARESOURCE; 3131 if ("MolecularSequence".equals(codeString)) 3132 return AllResourceTypes.MOLECULARSEQUENCE; 3133 if ("NamingSystem".equals(codeString)) 3134 return AllResourceTypes.NAMINGSYSTEM; 3135 if ("NutritionIntake".equals(codeString)) 3136 return AllResourceTypes.NUTRITIONINTAKE; 3137 if ("NutritionOrder".equals(codeString)) 3138 return AllResourceTypes.NUTRITIONORDER; 3139 if ("NutritionProduct".equals(codeString)) 3140 return AllResourceTypes.NUTRITIONPRODUCT; 3141 if ("Observation".equals(codeString)) 3142 return AllResourceTypes.OBSERVATION; 3143 if ("ObservationDefinition".equals(codeString)) 3144 return AllResourceTypes.OBSERVATIONDEFINITION; 3145 if ("OperationDefinition".equals(codeString)) 3146 return AllResourceTypes.OPERATIONDEFINITION; 3147 if ("OperationOutcome".equals(codeString)) 3148 return AllResourceTypes.OPERATIONOUTCOME; 3149 if ("Organization".equals(codeString)) 3150 return AllResourceTypes.ORGANIZATION; 3151 if ("OrganizationAffiliation".equals(codeString)) 3152 return AllResourceTypes.ORGANIZATIONAFFILIATION; 3153 if ("PackagedProductDefinition".equals(codeString)) 3154 return AllResourceTypes.PACKAGEDPRODUCTDEFINITION; 3155 if ("Parameters".equals(codeString)) 3156 return AllResourceTypes.PARAMETERS; 3157 if ("Patient".equals(codeString)) 3158 return AllResourceTypes.PATIENT; 3159 if ("PaymentNotice".equals(codeString)) 3160 return AllResourceTypes.PAYMENTNOTICE; 3161 if ("PaymentReconciliation".equals(codeString)) 3162 return AllResourceTypes.PAYMENTRECONCILIATION; 3163 if ("Permission".equals(codeString)) 3164 return AllResourceTypes.PERMISSION; 3165 if ("Person".equals(codeString)) 3166 return AllResourceTypes.PERSON; 3167 if ("PlanDefinition".equals(codeString)) 3168 return AllResourceTypes.PLANDEFINITION; 3169 if ("Practitioner".equals(codeString)) 3170 return AllResourceTypes.PRACTITIONER; 3171 if ("PractitionerRole".equals(codeString)) 3172 return AllResourceTypes.PRACTITIONERROLE; 3173 if ("Procedure".equals(codeString)) 3174 return AllResourceTypes.PROCEDURE; 3175 if ("Provenance".equals(codeString)) 3176 return AllResourceTypes.PROVENANCE; 3177 if ("Questionnaire".equals(codeString)) 3178 return AllResourceTypes.QUESTIONNAIRE; 3179 if ("QuestionnaireResponse".equals(codeString)) 3180 return AllResourceTypes.QUESTIONNAIRERESPONSE; 3181 if ("RegulatedAuthorization".equals(codeString)) 3182 return AllResourceTypes.REGULATEDAUTHORIZATION; 3183 if ("RelatedPerson".equals(codeString)) 3184 return AllResourceTypes.RELATEDPERSON; 3185 if ("RequestOrchestration".equals(codeString)) 3186 return AllResourceTypes.REQUESTORCHESTRATION; 3187 if ("Requirements".equals(codeString)) 3188 return AllResourceTypes.REQUIREMENTS; 3189 if ("ResearchStudy".equals(codeString)) 3190 return AllResourceTypes.RESEARCHSTUDY; 3191 if ("ResearchSubject".equals(codeString)) 3192 return AllResourceTypes.RESEARCHSUBJECT; 3193 if ("Resource".equals(codeString)) 3194 return AllResourceTypes.RESOURCE; 3195 if ("RiskAssessment".equals(codeString)) 3196 return AllResourceTypes.RISKASSESSMENT; 3197 if ("Schedule".equals(codeString)) 3198 return AllResourceTypes.SCHEDULE; 3199 if ("SearchParameter".equals(codeString)) 3200 return AllResourceTypes.SEARCHPARAMETER; 3201 if ("ServiceRequest".equals(codeString)) 3202 return AllResourceTypes.SERVICEREQUEST; 3203 if ("Slot".equals(codeString)) 3204 return AllResourceTypes.SLOT; 3205 if ("Specimen".equals(codeString)) 3206 return AllResourceTypes.SPECIMEN; 3207 if ("SpecimenDefinition".equals(codeString)) 3208 return AllResourceTypes.SPECIMENDEFINITION; 3209 if ("StructureDefinition".equals(codeString)) 3210 return AllResourceTypes.STRUCTUREDEFINITION; 3211 if ("StructureMap".equals(codeString)) 3212 return AllResourceTypes.STRUCTUREMAP; 3213 if ("Subscription".equals(codeString)) 3214 return AllResourceTypes.SUBSCRIPTION; 3215 if ("SubscriptionStatus".equals(codeString)) 3216 return AllResourceTypes.SUBSCRIPTIONSTATUS; 3217 if ("SubscriptionTopic".equals(codeString)) 3218 return AllResourceTypes.SUBSCRIPTIONTOPIC; 3219 if ("Substance".equals(codeString)) 3220 return AllResourceTypes.SUBSTANCE; 3221 if ("SubstanceDefinition".equals(codeString)) 3222 return AllResourceTypes.SUBSTANCEDEFINITION; 3223 if ("SubstanceNucleicAcid".equals(codeString)) 3224 return AllResourceTypes.SUBSTANCENUCLEICACID; 3225 if ("SubstancePolymer".equals(codeString)) 3226 return AllResourceTypes.SUBSTANCEPOLYMER; 3227 if ("SubstanceProtein".equals(codeString)) 3228 return AllResourceTypes.SUBSTANCEPROTEIN; 3229 if ("SubstanceReferenceInformation".equals(codeString)) 3230 return AllResourceTypes.SUBSTANCEREFERENCEINFORMATION; 3231 if ("SubstanceSourceMaterial".equals(codeString)) 3232 return AllResourceTypes.SUBSTANCESOURCEMATERIAL; 3233 if ("SupplyDelivery".equals(codeString)) 3234 return AllResourceTypes.SUPPLYDELIVERY; 3235 if ("SupplyRequest".equals(codeString)) 3236 return AllResourceTypes.SUPPLYREQUEST; 3237 if ("Task".equals(codeString)) 3238 return AllResourceTypes.TASK; 3239 if ("TerminologyCapabilities".equals(codeString)) 3240 return AllResourceTypes.TERMINOLOGYCAPABILITIES; 3241 if ("TestReport".equals(codeString)) 3242 return AllResourceTypes.TESTREPORT; 3243 if ("TestScript".equals(codeString)) 3244 return AllResourceTypes.TESTSCRIPT; 3245 if ("Transport".equals(codeString)) 3246 return AllResourceTypes.TRANSPORT; 3247 if ("ValueSet".equals(codeString)) 3248 return AllResourceTypes.VALUESET; 3249 if ("VerificationResult".equals(codeString)) 3250 return AllResourceTypes.VERIFICATIONRESULT; 3251 if ("VisionPrescription".equals(codeString)) 3252 return AllResourceTypes.VISIONPRESCRIPTION; 3253 throw new IllegalArgumentException("Unknown AllResourceTypes code '"+codeString+"'"); 3254 } 3255 public Enumeration<AllResourceTypes> fromType(PrimitiveType<?> code) throws FHIRException { 3256 if (code == null) 3257 return null; 3258 if (code.isEmpty()) 3259 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.NULL, code); 3260 String codeString = ((PrimitiveType) code).asStringValue(); 3261 if (codeString == null || "".equals(codeString)) 3262 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.NULL, code); 3263 if ("Account".equals(codeString)) 3264 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.ACCOUNT, code); 3265 if ("ActivityDefinition".equals(codeString)) 3266 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.ACTIVITYDEFINITION, code); 3267 if ("ActorDefinition".equals(codeString)) 3268 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.ACTORDEFINITION, code); 3269 if ("AdministrableProductDefinition".equals(codeString)) 3270 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.ADMINISTRABLEPRODUCTDEFINITION, code); 3271 if ("AdverseEvent".equals(codeString)) 3272 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.ADVERSEEVENT, code); 3273 if ("AllergyIntolerance".equals(codeString)) 3274 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.ALLERGYINTOLERANCE, code); 3275 if ("Appointment".equals(codeString)) 3276 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.APPOINTMENT, code); 3277 if ("AppointmentResponse".equals(codeString)) 3278 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.APPOINTMENTRESPONSE, code); 3279 if ("ArtifactAssessment".equals(codeString)) 3280 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.ARTIFACTASSESSMENT, code); 3281 if ("AuditEvent".equals(codeString)) 3282 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.AUDITEVENT, code); 3283 if ("Basic".equals(codeString)) 3284 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.BASIC, code); 3285 if ("Binary".equals(codeString)) 3286 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.BINARY, code); 3287 if ("BiologicallyDerivedProduct".equals(codeString)) 3288 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.BIOLOGICALLYDERIVEDPRODUCT, code); 3289 if ("BodyStructure".equals(codeString)) 3290 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.BODYSTRUCTURE, code); 3291 if ("Bundle".equals(codeString)) 3292 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.BUNDLE, code); 3293 if ("CanonicalResource".equals(codeString)) 3294 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.CANONICALRESOURCE, code); 3295 if ("CapabilityStatement".equals(codeString)) 3296 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.CAPABILITYSTATEMENT, code); 3297 if ("CarePlan".equals(codeString)) 3298 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.CAREPLAN, code); 3299 if ("CareTeam".equals(codeString)) 3300 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.CARETEAM, code); 3301 if ("ChargeItem".equals(codeString)) 3302 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.CHARGEITEM, code); 3303 if ("ChargeItemDefinition".equals(codeString)) 3304 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.CHARGEITEMDEFINITION, code); 3305 if ("Citation".equals(codeString)) 3306 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.CITATION, code); 3307 if ("Claim".equals(codeString)) 3308 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.CLAIM, code); 3309 if ("ClaimResponse".equals(codeString)) 3310 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.CLAIMRESPONSE, code); 3311 if ("ClinicalImpression".equals(codeString)) 3312 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.CLINICALIMPRESSION, code); 3313 if ("ClinicalUseDefinition".equals(codeString)) 3314 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.CLINICALUSEDEFINITION, code); 3315 if ("CodeSystem".equals(codeString)) 3316 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.CODESYSTEM, code); 3317 if ("Communication".equals(codeString)) 3318 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.COMMUNICATION, code); 3319 if ("CommunicationRequest".equals(codeString)) 3320 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.COMMUNICATIONREQUEST, code); 3321 if ("CompartmentDefinition".equals(codeString)) 3322 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.COMPARTMENTDEFINITION, code); 3323 if ("Composition".equals(codeString)) 3324 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.COMPOSITION, code); 3325 if ("ConceptMap".equals(codeString)) 3326 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.CONCEPTMAP, code); 3327 if ("Condition".equals(codeString)) 3328 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.CONDITION, code); 3329 if ("ConditionDefinition".equals(codeString)) 3330 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.CONDITIONDEFINITION, code); 3331 if ("Consent".equals(codeString)) 3332 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.CONSENT, code); 3333 if ("Contract".equals(codeString)) 3334 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.CONTRACT, code); 3335 if ("Coverage".equals(codeString)) 3336 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.COVERAGE, code); 3337 if ("CoverageEligibilityRequest".equals(codeString)) 3338 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.COVERAGEELIGIBILITYREQUEST, code); 3339 if ("CoverageEligibilityResponse".equals(codeString)) 3340 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.COVERAGEELIGIBILITYRESPONSE, code); 3341 if ("DetectedIssue".equals(codeString)) 3342 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.DETECTEDISSUE, code); 3343 if ("Device".equals(codeString)) 3344 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.DEVICE, code); 3345 if ("DeviceDefinition".equals(codeString)) 3346 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.DEVICEDEFINITION, code); 3347 if ("DeviceDispense".equals(codeString)) 3348 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.DEVICEDISPENSE, code); 3349 if ("DeviceMetric".equals(codeString)) 3350 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.DEVICEMETRIC, code); 3351 if ("DeviceRequest".equals(codeString)) 3352 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.DEVICEREQUEST, code); 3353 if ("DeviceUsage".equals(codeString)) 3354 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.DEVICEUSAGE, code); 3355 if ("DiagnosticReport".equals(codeString)) 3356 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.DIAGNOSTICREPORT, code); 3357 if ("DocumentManifest".equals(codeString)) 3358 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.DOCUMENTMANIFEST, code); 3359 if ("DocumentReference".equals(codeString)) 3360 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.DOCUMENTREFERENCE, code); 3361 if ("DomainResource".equals(codeString)) 3362 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.DOMAINRESOURCE, code); 3363 if ("Encounter".equals(codeString)) 3364 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.ENCOUNTER, code); 3365 if ("Endpoint".equals(codeString)) 3366 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.ENDPOINT, code); 3367 if ("EnrollmentRequest".equals(codeString)) 3368 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.ENROLLMENTREQUEST, code); 3369 if ("EnrollmentResponse".equals(codeString)) 3370 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.ENROLLMENTRESPONSE, code); 3371 if ("EpisodeOfCare".equals(codeString)) 3372 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.EPISODEOFCARE, code); 3373 if ("EventDefinition".equals(codeString)) 3374 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.EVENTDEFINITION, code); 3375 if ("Evidence".equals(codeString)) 3376 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.EVIDENCE, code); 3377 if ("EvidenceReport".equals(codeString)) 3378 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.EVIDENCEREPORT, code); 3379 if ("EvidenceVariable".equals(codeString)) 3380 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.EVIDENCEVARIABLE, code); 3381 if ("ExampleScenario".equals(codeString)) 3382 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.EXAMPLESCENARIO, code); 3383 if ("ExplanationOfBenefit".equals(codeString)) 3384 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.EXPLANATIONOFBENEFIT, code); 3385 if ("FamilyMemberHistory".equals(codeString)) 3386 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.FAMILYMEMBERHISTORY, code); 3387 if ("Flag".equals(codeString)) 3388 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.FLAG, code); 3389 if ("FormularyItem".equals(codeString)) 3390 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.FORMULARYITEM, code); 3391 if ("GenomicStudy".equals(codeString)) 3392 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.GENOMICSTUDY, code); 3393 if ("Goal".equals(codeString)) 3394 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.GOAL, code); 3395 if ("GraphDefinition".equals(codeString)) 3396 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.GRAPHDEFINITION, code); 3397 if ("Group".equals(codeString)) 3398 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.GROUP, code); 3399 if ("GuidanceResponse".equals(codeString)) 3400 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.GUIDANCERESPONSE, code); 3401 if ("HealthcareService".equals(codeString)) 3402 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.HEALTHCARESERVICE, code); 3403 if ("ImagingSelection".equals(codeString)) 3404 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.IMAGINGSELECTION, code); 3405 if ("ImagingStudy".equals(codeString)) 3406 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.IMAGINGSTUDY, code); 3407 if ("Immunization".equals(codeString)) 3408 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.IMMUNIZATION, code); 3409 if ("ImmunizationEvaluation".equals(codeString)) 3410 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.IMMUNIZATIONEVALUATION, code); 3411 if ("ImmunizationRecommendation".equals(codeString)) 3412 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.IMMUNIZATIONRECOMMENDATION, code); 3413 if ("ImplementationGuide".equals(codeString)) 3414 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.IMPLEMENTATIONGUIDE, code); 3415 if ("Ingredient".equals(codeString)) 3416 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.INGREDIENT, code); 3417 if ("InsurancePlan".equals(codeString)) 3418 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.INSURANCEPLAN, code); 3419 if ("InventoryReport".equals(codeString)) 3420 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.INVENTORYREPORT, code); 3421 if ("Invoice".equals(codeString)) 3422 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.INVOICE, code); 3423 if ("Library".equals(codeString)) 3424 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.LIBRARY, code); 3425 if ("Linkage".equals(codeString)) 3426 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.LINKAGE, code); 3427 if ("List".equals(codeString)) 3428 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.LIST, code); 3429 if ("Location".equals(codeString)) 3430 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.LOCATION, code); 3431 if ("ManufacturedItemDefinition".equals(codeString)) 3432 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.MANUFACTUREDITEMDEFINITION, code); 3433 if ("Measure".equals(codeString)) 3434 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.MEASURE, code); 3435 if ("MeasureReport".equals(codeString)) 3436 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.MEASUREREPORT, code); 3437 if ("Medication".equals(codeString)) 3438 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.MEDICATION, code); 3439 if ("MedicationAdministration".equals(codeString)) 3440 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.MEDICATIONADMINISTRATION, code); 3441 if ("MedicationDispense".equals(codeString)) 3442 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.MEDICATIONDISPENSE, code); 3443 if ("MedicationKnowledge".equals(codeString)) 3444 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.MEDICATIONKNOWLEDGE, code); 3445 if ("MedicationRequest".equals(codeString)) 3446 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.MEDICATIONREQUEST, code); 3447 if ("MedicationUsage".equals(codeString)) 3448 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.MEDICATIONUSAGE, code); 3449 if ("MedicationStatement".equals(codeString)) 3450 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.MEDICATIONUSAGE, code); 3451 if ("MedicinalProductDefinition".equals(codeString)) 3452 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.MEDICINALPRODUCTDEFINITION, code); 3453 if ("MessageDefinition".equals(codeString)) 3454 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.MESSAGEDEFINITION, code); 3455 if ("MessageHeader".equals(codeString)) 3456 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.MESSAGEHEADER, code); 3457 if ("MetadataResource".equals(codeString)) 3458 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.METADATARESOURCE, code); 3459 if ("MolecularSequence".equals(codeString)) 3460 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.MOLECULARSEQUENCE, code); 3461 if ("NamingSystem".equals(codeString)) 3462 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.NAMINGSYSTEM, code); 3463 if ("NutritionIntake".equals(codeString)) 3464 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.NUTRITIONINTAKE, code); 3465 if ("NutritionOrder".equals(codeString)) 3466 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.NUTRITIONORDER, code); 3467 if ("NutritionProduct".equals(codeString)) 3468 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.NUTRITIONPRODUCT, code); 3469 if ("Observation".equals(codeString)) 3470 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.OBSERVATION, code); 3471 if ("ObservationDefinition".equals(codeString)) 3472 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.OBSERVATIONDEFINITION, code); 3473 if ("OperationDefinition".equals(codeString)) 3474 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.OPERATIONDEFINITION, code); 3475 if ("OperationOutcome".equals(codeString)) 3476 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.OPERATIONOUTCOME, code); 3477 if ("Organization".equals(codeString)) 3478 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.ORGANIZATION, code); 3479 if ("OrganizationAffiliation".equals(codeString)) 3480 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.ORGANIZATIONAFFILIATION, code); 3481 if ("PackagedProductDefinition".equals(codeString)) 3482 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.PACKAGEDPRODUCTDEFINITION, code); 3483 if ("Parameters".equals(codeString)) 3484 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.PARAMETERS, code); 3485 if ("Patient".equals(codeString)) 3486 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.PATIENT, code); 3487 if ("PaymentNotice".equals(codeString)) 3488 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.PAYMENTNOTICE, code); 3489 if ("PaymentReconciliation".equals(codeString)) 3490 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.PAYMENTRECONCILIATION, code); 3491 if ("Permission".equals(codeString)) 3492 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.PERMISSION, code); 3493 if ("Person".equals(codeString)) 3494 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.PERSON, code); 3495 if ("PlanDefinition".equals(codeString)) 3496 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.PLANDEFINITION, code); 3497 if ("Practitioner".equals(codeString)) 3498 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.PRACTITIONER, code); 3499 if ("PractitionerRole".equals(codeString)) 3500 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.PRACTITIONERROLE, code); 3501 if ("Procedure".equals(codeString)) 3502 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.PROCEDURE, code); 3503 if ("Provenance".equals(codeString)) 3504 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.PROVENANCE, code); 3505 if ("Questionnaire".equals(codeString)) 3506 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.QUESTIONNAIRE, code); 3507 if ("QuestionnaireResponse".equals(codeString)) 3508 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.QUESTIONNAIRERESPONSE, code); 3509 if ("RegulatedAuthorization".equals(codeString)) 3510 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.REGULATEDAUTHORIZATION, code); 3511 if ("RelatedPerson".equals(codeString)) 3512 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.RELATEDPERSON, code); 3513 if ("RequestOrchestration".equals(codeString)) 3514 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.REQUESTORCHESTRATION, code); 3515 if ("Requirements".equals(codeString)) 3516 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.REQUIREMENTS, code); 3517 if ("ResearchStudy".equals(codeString)) 3518 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.RESEARCHSTUDY, code); 3519 if ("ResearchSubject".equals(codeString)) 3520 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.RESEARCHSUBJECT, code); 3521 if ("Resource".equals(codeString)) 3522 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.RESOURCE, code); 3523 if ("RiskAssessment".equals(codeString)) 3524 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.RISKASSESSMENT, code); 3525 if ("Schedule".equals(codeString)) 3526 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.SCHEDULE, code); 3527 if ("SearchParameter".equals(codeString)) 3528 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.SEARCHPARAMETER, code); 3529 if ("ServiceRequest".equals(codeString)) 3530 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.SERVICEREQUEST, code); 3531 if ("Slot".equals(codeString)) 3532 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.SLOT, code); 3533 if ("Specimen".equals(codeString)) 3534 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.SPECIMEN, code); 3535 if ("SpecimenDefinition".equals(codeString)) 3536 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.SPECIMENDEFINITION, code); 3537 if ("StructureDefinition".equals(codeString)) 3538 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.STRUCTUREDEFINITION, code); 3539 if ("StructureMap".equals(codeString)) 3540 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.STRUCTUREMAP, code); 3541 if ("Subscription".equals(codeString)) 3542 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.SUBSCRIPTION, code); 3543 if ("SubscriptionStatus".equals(codeString)) 3544 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.SUBSCRIPTIONSTATUS, code); 3545 if ("SubscriptionTopic".equals(codeString)) 3546 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.SUBSCRIPTIONTOPIC, code); 3547 if ("Substance".equals(codeString)) 3548 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.SUBSTANCE, code); 3549 if ("SubstanceDefinition".equals(codeString)) 3550 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.SUBSTANCEDEFINITION, code); 3551 if ("SubstanceNucleicAcid".equals(codeString)) 3552 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.SUBSTANCENUCLEICACID, code); 3553 if ("SubstancePolymer".equals(codeString)) 3554 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.SUBSTANCEPOLYMER, code); 3555 if ("SubstanceProtein".equals(codeString)) 3556 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.SUBSTANCEPROTEIN, code); 3557 if ("SubstanceReferenceInformation".equals(codeString)) 3558 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.SUBSTANCEREFERENCEINFORMATION, code); 3559 if ("SubstanceSourceMaterial".equals(codeString)) 3560 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.SUBSTANCESOURCEMATERIAL, code); 3561 if ("SupplyDelivery".equals(codeString)) 3562 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.SUPPLYDELIVERY, code); 3563 if ("SupplyRequest".equals(codeString)) 3564 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.SUPPLYREQUEST, code); 3565 if ("Task".equals(codeString)) 3566 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.TASK, code); 3567 if ("TerminologyCapabilities".equals(codeString)) 3568 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.TERMINOLOGYCAPABILITIES, code); 3569 if ("TestReport".equals(codeString)) 3570 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.TESTREPORT, code); 3571 if ("TestScript".equals(codeString)) 3572 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.TESTSCRIPT, code); 3573 if ("Transport".equals(codeString)) 3574 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.TRANSPORT, code); 3575 if ("ValueSet".equals(codeString)) 3576 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.VALUESET, code); 3577 if ("VerificationResult".equals(codeString)) 3578 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.VERIFICATIONRESULT, code); 3579 if ("VisionPrescription".equals(codeString)) 3580 return new Enumeration<AllResourceTypes>(this, AllResourceTypes.VISIONPRESCRIPTION, code); 3581 throw new FHIRException("Unknown AllResourceTypes code '"+codeString+"'"); 3582 } 3583 public String toCode(AllResourceTypes code) { 3584 if (code == AllResourceTypes.ACCOUNT) 3585 return "Account"; 3586 if (code == AllResourceTypes.ACTIVITYDEFINITION) 3587 return "ActivityDefinition"; 3588 if (code == AllResourceTypes.ACTORDEFINITION) 3589 return "ActorDefinition"; 3590 if (code == AllResourceTypes.ADMINISTRABLEPRODUCTDEFINITION) 3591 return "AdministrableProductDefinition"; 3592 if (code == AllResourceTypes.ADVERSEEVENT) 3593 return "AdverseEvent"; 3594 if (code == AllResourceTypes.ALLERGYINTOLERANCE) 3595 return "AllergyIntolerance"; 3596 if (code == AllResourceTypes.APPOINTMENT) 3597 return "Appointment"; 3598 if (code == AllResourceTypes.APPOINTMENTRESPONSE) 3599 return "AppointmentResponse"; 3600 if (code == AllResourceTypes.ARTIFACTASSESSMENT) 3601 return "ArtifactAssessment"; 3602 if (code == AllResourceTypes.AUDITEVENT) 3603 return "AuditEvent"; 3604 if (code == AllResourceTypes.BASIC) 3605 return "Basic"; 3606 if (code == AllResourceTypes.BINARY) 3607 return "Binary"; 3608 if (code == AllResourceTypes.BIOLOGICALLYDERIVEDPRODUCT) 3609 return "BiologicallyDerivedProduct"; 3610 if (code == AllResourceTypes.BODYSTRUCTURE) 3611 return "BodyStructure"; 3612 if (code == AllResourceTypes.BUNDLE) 3613 return "Bundle"; 3614 if (code == AllResourceTypes.CANONICALRESOURCE) 3615 return "CanonicalResource"; 3616 if (code == AllResourceTypes.CAPABILITYSTATEMENT) 3617 return "CapabilityStatement"; 3618 if (code == AllResourceTypes.CAREPLAN) 3619 return "CarePlan"; 3620 if (code == AllResourceTypes.CARETEAM) 3621 return "CareTeam"; 3622 if (code == AllResourceTypes.CHARGEITEM) 3623 return "ChargeItem"; 3624 if (code == AllResourceTypes.CHARGEITEMDEFINITION) 3625 return "ChargeItemDefinition"; 3626 if (code == AllResourceTypes.CITATION) 3627 return "Citation"; 3628 if (code == AllResourceTypes.CLAIM) 3629 return "Claim"; 3630 if (code == AllResourceTypes.CLAIMRESPONSE) 3631 return "ClaimResponse"; 3632 if (code == AllResourceTypes.CLINICALIMPRESSION) 3633 return "ClinicalImpression"; 3634 if (code == AllResourceTypes.CLINICALUSEDEFINITION) 3635 return "ClinicalUseDefinition"; 3636 if (code == AllResourceTypes.CODESYSTEM) 3637 return "CodeSystem"; 3638 if (code == AllResourceTypes.COMMUNICATION) 3639 return "Communication"; 3640 if (code == AllResourceTypes.COMMUNICATIONREQUEST) 3641 return "CommunicationRequest"; 3642 if (code == AllResourceTypes.COMPARTMENTDEFINITION) 3643 return "CompartmentDefinition"; 3644 if (code == AllResourceTypes.COMPOSITION) 3645 return "Composition"; 3646 if (code == AllResourceTypes.CONCEPTMAP) 3647 return "ConceptMap"; 3648 if (code == AllResourceTypes.CONDITION) 3649 return "Condition"; 3650 if (code == AllResourceTypes.CONDITIONDEFINITION) 3651 return "ConditionDefinition"; 3652 if (code == AllResourceTypes.CONSENT) 3653 return "Consent"; 3654 if (code == AllResourceTypes.CONTRACT) 3655 return "Contract"; 3656 if (code == AllResourceTypes.COVERAGE) 3657 return "Coverage"; 3658 if (code == AllResourceTypes.COVERAGEELIGIBILITYREQUEST) 3659 return "CoverageEligibilityRequest"; 3660 if (code == AllResourceTypes.COVERAGEELIGIBILITYRESPONSE) 3661 return "CoverageEligibilityResponse"; 3662 if (code == AllResourceTypes.DETECTEDISSUE) 3663 return "DetectedIssue"; 3664 if (code == AllResourceTypes.DEVICE) 3665 return "Device"; 3666 if (code == AllResourceTypes.DEVICEDEFINITION) 3667 return "DeviceDefinition"; 3668 if (code == AllResourceTypes.DEVICEDISPENSE) 3669 return "DeviceDispense"; 3670 if (code == AllResourceTypes.DEVICEMETRIC) 3671 return "DeviceMetric"; 3672 if (code == AllResourceTypes.DEVICEREQUEST) 3673 return "DeviceRequest"; 3674 if (code == AllResourceTypes.DEVICEUSAGE) 3675 return "DeviceUsage"; 3676 if (code == AllResourceTypes.DIAGNOSTICREPORT) 3677 return "DiagnosticReport"; 3678 if (code == AllResourceTypes.DOCUMENTMANIFEST) 3679 return "DocumentManifest"; 3680 if (code == AllResourceTypes.DOCUMENTREFERENCE) 3681 return "DocumentReference"; 3682 if (code == AllResourceTypes.DOMAINRESOURCE) 3683 return "DomainResource"; 3684 if (code == AllResourceTypes.ENCOUNTER) 3685 return "Encounter"; 3686 if (code == AllResourceTypes.ENDPOINT) 3687 return "Endpoint"; 3688 if (code == AllResourceTypes.ENROLLMENTREQUEST) 3689 return "EnrollmentRequest"; 3690 if (code == AllResourceTypes.ENROLLMENTRESPONSE) 3691 return "EnrollmentResponse"; 3692 if (code == AllResourceTypes.EPISODEOFCARE) 3693 return "EpisodeOfCare"; 3694 if (code == AllResourceTypes.EVENTDEFINITION) 3695 return "EventDefinition"; 3696 if (code == AllResourceTypes.EVIDENCE) 3697 return "Evidence"; 3698 if (code == AllResourceTypes.EVIDENCEREPORT) 3699 return "EvidenceReport"; 3700 if (code == AllResourceTypes.EVIDENCEVARIABLE) 3701 return "EvidenceVariable"; 3702 if (code == AllResourceTypes.EXAMPLESCENARIO) 3703 return "ExampleScenario"; 3704 if (code == AllResourceTypes.EXPLANATIONOFBENEFIT) 3705 return "ExplanationOfBenefit"; 3706 if (code == AllResourceTypes.FAMILYMEMBERHISTORY) 3707 return "FamilyMemberHistory"; 3708 if (code == AllResourceTypes.FLAG) 3709 return "Flag"; 3710 if (code == AllResourceTypes.FORMULARYITEM) 3711 return "FormularyItem"; 3712 if (code == AllResourceTypes.GENOMICSTUDY) 3713 return "GenomicStudy"; 3714 if (code == AllResourceTypes.GOAL) 3715 return "Goal"; 3716 if (code == AllResourceTypes.GRAPHDEFINITION) 3717 return "GraphDefinition"; 3718 if (code == AllResourceTypes.GROUP) 3719 return "Group"; 3720 if (code == AllResourceTypes.GUIDANCERESPONSE) 3721 return "GuidanceResponse"; 3722 if (code == AllResourceTypes.HEALTHCARESERVICE) 3723 return "HealthcareService"; 3724 if (code == AllResourceTypes.IMAGINGSELECTION) 3725 return "ImagingSelection"; 3726 if (code == AllResourceTypes.IMAGINGSTUDY) 3727 return "ImagingStudy"; 3728 if (code == AllResourceTypes.IMMUNIZATION) 3729 return "Immunization"; 3730 if (code == AllResourceTypes.IMMUNIZATIONEVALUATION) 3731 return "ImmunizationEvaluation"; 3732 if (code == AllResourceTypes.IMMUNIZATIONRECOMMENDATION) 3733 return "ImmunizationRecommendation"; 3734 if (code == AllResourceTypes.IMPLEMENTATIONGUIDE) 3735 return "ImplementationGuide"; 3736 if (code == AllResourceTypes.INGREDIENT) 3737 return "Ingredient"; 3738 if (code == AllResourceTypes.INSURANCEPLAN) 3739 return "InsurancePlan"; 3740 if (code == AllResourceTypes.INVENTORYREPORT) 3741 return "InventoryReport"; 3742 if (code == AllResourceTypes.INVOICE) 3743 return "Invoice"; 3744 if (code == AllResourceTypes.LIBRARY) 3745 return "Library"; 3746 if (code == AllResourceTypes.LINKAGE) 3747 return "Linkage"; 3748 if (code == AllResourceTypes.LIST) 3749 return "List"; 3750 if (code == AllResourceTypes.LOCATION) 3751 return "Location"; 3752 if (code == AllResourceTypes.MANUFACTUREDITEMDEFINITION) 3753 return "ManufacturedItemDefinition"; 3754 if (code == AllResourceTypes.MEASURE) 3755 return "Measure"; 3756 if (code == AllResourceTypes.MEASUREREPORT) 3757 return "MeasureReport"; 3758 if (code == AllResourceTypes.MEDICATION) 3759 return "Medication"; 3760 if (code == AllResourceTypes.MEDICATIONADMINISTRATION) 3761 return "MedicationAdministration"; 3762 if (code == AllResourceTypes.MEDICATIONDISPENSE) 3763 return "MedicationDispense"; 3764 if (code == AllResourceTypes.MEDICATIONKNOWLEDGE) 3765 return "MedicationKnowledge"; 3766 if (code == AllResourceTypes.MEDICATIONREQUEST) 3767 return "MedicationRequest"; 3768 if (code == AllResourceTypes.MEDICATIONUSAGE) 3769 return "MedicationUsage"; 3770 if (code == AllResourceTypes.MEDICINALPRODUCTDEFINITION) 3771 return "MedicinalProductDefinition"; 3772 if (code == AllResourceTypes.MESSAGEDEFINITION) 3773 return "MessageDefinition"; 3774 if (code == AllResourceTypes.MESSAGEHEADER) 3775 return "MessageHeader"; 3776 if (code == AllResourceTypes.METADATARESOURCE) 3777 return "MetadataResource"; 3778 if (code == AllResourceTypes.MOLECULARSEQUENCE) 3779 return "MolecularSequence"; 3780 if (code == AllResourceTypes.NAMINGSYSTEM) 3781 return "NamingSystem"; 3782 if (code == AllResourceTypes.NUTRITIONINTAKE) 3783 return "NutritionIntake"; 3784 if (code == AllResourceTypes.NUTRITIONORDER) 3785 return "NutritionOrder"; 3786 if (code == AllResourceTypes.NUTRITIONPRODUCT) 3787 return "NutritionProduct"; 3788 if (code == AllResourceTypes.OBSERVATION) 3789 return "Observation"; 3790 if (code == AllResourceTypes.OBSERVATIONDEFINITION) 3791 return "ObservationDefinition"; 3792 if (code == AllResourceTypes.OPERATIONDEFINITION) 3793 return "OperationDefinition"; 3794 if (code == AllResourceTypes.OPERATIONOUTCOME) 3795 return "OperationOutcome"; 3796 if (code == AllResourceTypes.ORGANIZATION) 3797 return "Organization"; 3798 if (code == AllResourceTypes.ORGANIZATIONAFFILIATION) 3799 return "OrganizationAffiliation"; 3800 if (code == AllResourceTypes.PACKAGEDPRODUCTDEFINITION) 3801 return "PackagedProductDefinition"; 3802 if (code == AllResourceTypes.PARAMETERS) 3803 return "Parameters"; 3804 if (code == AllResourceTypes.PATIENT) 3805 return "Patient"; 3806 if (code == AllResourceTypes.PAYMENTNOTICE) 3807 return "PaymentNotice"; 3808 if (code == AllResourceTypes.PAYMENTRECONCILIATION) 3809 return "PaymentReconciliation"; 3810 if (code == AllResourceTypes.PERMISSION) 3811 return "Permission"; 3812 if (code == AllResourceTypes.PERSON) 3813 return "Person"; 3814 if (code == AllResourceTypes.PLANDEFINITION) 3815 return "PlanDefinition"; 3816 if (code == AllResourceTypes.PRACTITIONER) 3817 return "Practitioner"; 3818 if (code == AllResourceTypes.PRACTITIONERROLE) 3819 return "PractitionerRole"; 3820 if (code == AllResourceTypes.PROCEDURE) 3821 return "Procedure"; 3822 if (code == AllResourceTypes.PROVENANCE) 3823 return "Provenance"; 3824 if (code == AllResourceTypes.QUESTIONNAIRE) 3825 return "Questionnaire"; 3826 if (code == AllResourceTypes.QUESTIONNAIRERESPONSE) 3827 return "QuestionnaireResponse"; 3828 if (code == AllResourceTypes.REGULATEDAUTHORIZATION) 3829 return "RegulatedAuthorization"; 3830 if (code == AllResourceTypes.RELATEDPERSON) 3831 return "RelatedPerson"; 3832 if (code == AllResourceTypes.REQUESTORCHESTRATION) 3833 return "RequestOrchestration"; 3834 if (code == AllResourceTypes.REQUIREMENTS) 3835 return "Requirements"; 3836 if (code == AllResourceTypes.RESEARCHSTUDY) 3837 return "ResearchStudy"; 3838 if (code == AllResourceTypes.RESEARCHSUBJECT) 3839 return "ResearchSubject"; 3840 if (code == AllResourceTypes.RESOURCE) 3841 return "Resource"; 3842 if (code == AllResourceTypes.RISKASSESSMENT) 3843 return "RiskAssessment"; 3844 if (code == AllResourceTypes.SCHEDULE) 3845 return "Schedule"; 3846 if (code == AllResourceTypes.SEARCHPARAMETER) 3847 return "SearchParameter"; 3848 if (code == AllResourceTypes.SERVICEREQUEST) 3849 return "ServiceRequest"; 3850 if (code == AllResourceTypes.SLOT) 3851 return "Slot"; 3852 if (code == AllResourceTypes.SPECIMEN) 3853 return "Specimen"; 3854 if (code == AllResourceTypes.SPECIMENDEFINITION) 3855 return "SpecimenDefinition"; 3856 if (code == AllResourceTypes.STRUCTUREDEFINITION) 3857 return "StructureDefinition"; 3858 if (code == AllResourceTypes.STRUCTUREMAP) 3859 return "StructureMap"; 3860 if (code == AllResourceTypes.SUBSCRIPTION) 3861 return "Subscription"; 3862 if (code == AllResourceTypes.SUBSCRIPTIONSTATUS) 3863 return "SubscriptionStatus"; 3864 if (code == AllResourceTypes.SUBSCRIPTIONTOPIC) 3865 return "SubscriptionTopic"; 3866 if (code == AllResourceTypes.SUBSTANCE) 3867 return "Substance"; 3868 if (code == AllResourceTypes.SUBSTANCEDEFINITION) 3869 return "SubstanceDefinition"; 3870 if (code == AllResourceTypes.SUBSTANCENUCLEICACID) 3871 return "SubstanceNucleicAcid"; 3872 if (code == AllResourceTypes.SUBSTANCEPOLYMER) 3873 return "SubstancePolymer"; 3874 if (code == AllResourceTypes.SUBSTANCEPROTEIN) 3875 return "SubstanceProtein"; 3876 if (code == AllResourceTypes.SUBSTANCEREFERENCEINFORMATION) 3877 return "SubstanceReferenceInformation"; 3878 if (code == AllResourceTypes.SUBSTANCESOURCEMATERIAL) 3879 return "SubstanceSourceMaterial"; 3880 if (code == AllResourceTypes.SUPPLYDELIVERY) 3881 return "SupplyDelivery"; 3882 if (code == AllResourceTypes.SUPPLYREQUEST) 3883 return "SupplyRequest"; 3884 if (code == AllResourceTypes.TASK) 3885 return "Task"; 3886 if (code == AllResourceTypes.TERMINOLOGYCAPABILITIES) 3887 return "TerminologyCapabilities"; 3888 if (code == AllResourceTypes.TESTREPORT) 3889 return "TestReport"; 3890 if (code == AllResourceTypes.TESTSCRIPT) 3891 return "TestScript"; 3892 if (code == AllResourceTypes.TRANSPORT) 3893 return "Transport"; 3894 if (code == AllResourceTypes.VALUESET) 3895 return "ValueSet"; 3896 if (code == AllResourceTypes.VERIFICATIONRESULT) 3897 return "VerificationResult"; 3898 if (code == AllResourceTypes.VISIONPRESCRIPTION) 3899 return "VisionPrescription"; 3900 return "?"; 3901 } 3902 public String toSystem(AllResourceTypes code) { 3903 return code.getSystem(); 3904 } 3905 } 3906 3907 public enum BindingStrength { 3908 /** 3909 * To be conformant, the concept in this element SHALL be from the specified value set. 3910 */ 3911 REQUIRED, 3912 /** 3913 * 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. 3914 */ 3915 EXTENSIBLE, 3916 /** 3917 * Instances are encouraged to draw from the specified codes for interoperability purposes but are not required to do so to be considered conformant. 3918 */ 3919 PREFERRED, 3920 /** 3921 * 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. 3922 */ 3923 EXAMPLE, 3924 /** 3925 * added to help the parsers 3926 */ 3927 NULL; 3928 public static BindingStrength fromCode(String codeString) throws FHIRException { 3929 if (codeString == null || "".equals(codeString)) 3930 return null; 3931 if ("required".equals(codeString)) 3932 return REQUIRED; 3933 if ("extensible".equals(codeString)) 3934 return EXTENSIBLE; 3935 if ("preferred".equals(codeString)) 3936 return PREFERRED; 3937 if ("example".equals(codeString)) 3938 return EXAMPLE; 3939 throw new FHIRException("Unknown BindingStrength code '"+codeString+"'"); 3940 } 3941 public String toCode() { 3942 switch (this) { 3943 case REQUIRED: return "required"; 3944 case EXTENSIBLE: return "extensible"; 3945 case PREFERRED: return "preferred"; 3946 case EXAMPLE: return "example"; 3947 case NULL: return null; 3948 default: return "?"; 3949 } 3950 } 3951 public String getSystem() { 3952 switch (this) { 3953 case REQUIRED: return "http://hl7.org/fhir/binding-strength"; 3954 case EXTENSIBLE: return "http://hl7.org/fhir/binding-strength"; 3955 case PREFERRED: return "http://hl7.org/fhir/binding-strength"; 3956 case EXAMPLE: return "http://hl7.org/fhir/binding-strength"; 3957 case NULL: return null; 3958 default: return "?"; 3959 } 3960 } 3961 public String getDefinition() { 3962 switch (this) { 3963 case REQUIRED: return "To be conformant, the concept in this element SHALL be from the specified value set."; 3964 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."; 3965 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."; 3966 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."; 3967 case NULL: return null; 3968 default: return "?"; 3969 } 3970 } 3971 public String getDisplay() { 3972 switch (this) { 3973 case REQUIRED: return "Required"; 3974 case EXTENSIBLE: return "Extensible"; 3975 case PREFERRED: return "Preferred"; 3976 case EXAMPLE: return "Example"; 3977 case NULL: return null; 3978 default: return "?"; 3979 } 3980 } 3981 } 3982 3983 public static class BindingStrengthEnumFactory implements EnumFactory<BindingStrength> { 3984 public BindingStrength fromCode(String codeString) throws IllegalArgumentException { 3985 if (codeString == null || "".equals(codeString)) 3986 if (codeString == null || "".equals(codeString)) 3987 return null; 3988 if ("required".equals(codeString)) 3989 return BindingStrength.REQUIRED; 3990 if ("extensible".equals(codeString)) 3991 return BindingStrength.EXTENSIBLE; 3992 if ("preferred".equals(codeString)) 3993 return BindingStrength.PREFERRED; 3994 if ("example".equals(codeString)) 3995 return BindingStrength.EXAMPLE; 3996 throw new IllegalArgumentException("Unknown BindingStrength code '"+codeString+"'"); 3997 } 3998 public Enumeration<BindingStrength> fromType(PrimitiveType<?> code) throws FHIRException { 3999 if (code == null) 4000 return null; 4001 if (code.isEmpty()) 4002 return new Enumeration<BindingStrength>(this, BindingStrength.NULL, code); 4003 String codeString = ((PrimitiveType) code).asStringValue(); 4004 if (codeString == null || "".equals(codeString)) 4005 return new Enumeration<BindingStrength>(this, BindingStrength.NULL, code); 4006 if ("required".equals(codeString)) 4007 return new Enumeration<BindingStrength>(this, BindingStrength.REQUIRED, code); 4008 if ("extensible".equals(codeString)) 4009 return new Enumeration<BindingStrength>(this, BindingStrength.EXTENSIBLE, code); 4010 if ("preferred".equals(codeString)) 4011 return new Enumeration<BindingStrength>(this, BindingStrength.PREFERRED, code); 4012 if ("example".equals(codeString)) 4013 return new Enumeration<BindingStrength>(this, BindingStrength.EXAMPLE, code); 4014 throw new FHIRException("Unknown BindingStrength code '"+codeString+"'"); 4015 } 4016 public String toCode(BindingStrength code) { 4017 if (code == BindingStrength.REQUIRED) 4018 return "required"; 4019 if (code == BindingStrength.EXTENSIBLE) 4020 return "extensible"; 4021 if (code == BindingStrength.PREFERRED) 4022 return "preferred"; 4023 if (code == BindingStrength.EXAMPLE) 4024 return "example"; 4025 return "?"; 4026 } 4027 public String toSystem(BindingStrength code) { 4028 return code.getSystem(); 4029 } 4030 } 4031 4032 public enum CapabilityStatementKind { 4033 /** 4034 * 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. 4035 */ 4036 INSTANCE, 4037 /** 4038 * The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation. 4039 */ 4040 CAPABILITY, 4041 /** 4042 * 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'. 4043 */ 4044 REQUIREMENTS, 4045 /** 4046 * added to help the parsers 4047 */ 4048 NULL; 4049 public static CapabilityStatementKind fromCode(String codeString) throws FHIRException { 4050 if (codeString == null || "".equals(codeString)) 4051 return null; 4052 if ("instance".equals(codeString)) 4053 return INSTANCE; 4054 if ("capability".equals(codeString)) 4055 return CAPABILITY; 4056 if ("requirements".equals(codeString)) 4057 return REQUIREMENTS; 4058 throw new FHIRException("Unknown CapabilityStatementKind code '"+codeString+"'"); 4059 } 4060 public String toCode() { 4061 switch (this) { 4062 case INSTANCE: return "instance"; 4063 case CAPABILITY: return "capability"; 4064 case REQUIREMENTS: return "requirements"; 4065 case NULL: return null; 4066 default: return "?"; 4067 } 4068 } 4069 public String getSystem() { 4070 switch (this) { 4071 case INSTANCE: return "http://hl7.org/fhir/capability-statement-kind"; 4072 case CAPABILITY: return "http://hl7.org/fhir/capability-statement-kind"; 4073 case REQUIREMENTS: return "http://hl7.org/fhir/capability-statement-kind"; 4074 case NULL: return null; 4075 default: return "?"; 4076 } 4077 } 4078 public String getDefinition() { 4079 switch (this) { 4080 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."; 4081 case CAPABILITY: return "The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation."; 4082 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'."; 4083 case NULL: return null; 4084 default: return "?"; 4085 } 4086 } 4087 public String getDisplay() { 4088 switch (this) { 4089 case INSTANCE: return "Instance"; 4090 case CAPABILITY: return "Capability"; 4091 case REQUIREMENTS: return "Requirements"; 4092 case NULL: return null; 4093 default: return "?"; 4094 } 4095 } 4096 } 4097 4098 public static class CapabilityStatementKindEnumFactory implements EnumFactory<CapabilityStatementKind> { 4099 public CapabilityStatementKind fromCode(String codeString) throws IllegalArgumentException { 4100 if (codeString == null || "".equals(codeString)) 4101 if (codeString == null || "".equals(codeString)) 4102 return null; 4103 if ("instance".equals(codeString)) 4104 return CapabilityStatementKind.INSTANCE; 4105 if ("capability".equals(codeString)) 4106 return CapabilityStatementKind.CAPABILITY; 4107 if ("requirements".equals(codeString)) 4108 return CapabilityStatementKind.REQUIREMENTS; 4109 throw new IllegalArgumentException("Unknown CapabilityStatementKind code '"+codeString+"'"); 4110 } 4111 public Enumeration<CapabilityStatementKind> fromType(PrimitiveType<?> code) throws FHIRException { 4112 if (code == null) 4113 return null; 4114 if (code.isEmpty()) 4115 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.NULL, code); 4116 String codeString = ((PrimitiveType) code).asStringValue(); 4117 if (codeString == null || "".equals(codeString)) 4118 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.NULL, code); 4119 if ("instance".equals(codeString)) 4120 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.INSTANCE, code); 4121 if ("capability".equals(codeString)) 4122 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.CAPABILITY, code); 4123 if ("requirements".equals(codeString)) 4124 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.REQUIREMENTS, code); 4125 throw new FHIRException("Unknown CapabilityStatementKind code '"+codeString+"'"); 4126 } 4127 public String toCode(CapabilityStatementKind code) { 4128 if (code == CapabilityStatementKind.INSTANCE) 4129 return "instance"; 4130 if (code == CapabilityStatementKind.CAPABILITY) 4131 return "capability"; 4132 if (code == CapabilityStatementKind.REQUIREMENTS) 4133 return "requirements"; 4134 return "?"; 4135 } 4136 public String toSystem(CapabilityStatementKind code) { 4137 return code.getSystem(); 4138 } 4139 } 4140 4141 public enum ClaimProcessingCodes { 4142 /** 4143 * The Claim/Pre-authorization/Pre-determination has been received but processing has not begun. 4144 */ 4145 QUEUED, 4146 /** 4147 * The processing has completed without errors 4148 */ 4149 COMPLETE, 4150 /** 4151 * One or more errors have been detected in the Claim 4152 */ 4153 ERROR, 4154 /** 4155 * No errors have been detected in the Claim and some of the adjudication has been performed. 4156 */ 4157 PARTIAL, 4158 /** 4159 * added to help the parsers 4160 */ 4161 NULL; 4162 public static ClaimProcessingCodes fromCode(String codeString) throws FHIRException { 4163 if (codeString == null || "".equals(codeString)) 4164 return null; 4165 if ("queued".equals(codeString)) 4166 return QUEUED; 4167 if ("complete".equals(codeString)) 4168 return COMPLETE; 4169 if ("error".equals(codeString)) 4170 return ERROR; 4171 if ("partial".equals(codeString)) 4172 return PARTIAL; 4173 throw new FHIRException("Unknown ClaimProcessingCodes code '"+codeString+"'"); 4174 } 4175 public String toCode() { 4176 switch (this) { 4177 case QUEUED: return "queued"; 4178 case COMPLETE: return "complete"; 4179 case ERROR: return "error"; 4180 case PARTIAL: return "partial"; 4181 case NULL: return null; 4182 default: return "?"; 4183 } 4184 } 4185 public String getSystem() { 4186 switch (this) { 4187 case QUEUED: return "http://hl7.org/fhir/claim-outcome"; 4188 case COMPLETE: return "http://hl7.org/fhir/claim-outcome"; 4189 case ERROR: return "http://hl7.org/fhir/claim-outcome"; 4190 case PARTIAL: return "http://hl7.org/fhir/claim-outcome"; 4191 case NULL: return null; 4192 default: return "?"; 4193 } 4194 } 4195 public String getDefinition() { 4196 switch (this) { 4197 case QUEUED: return "The Claim/Pre-authorization/Pre-determination has been received but processing has not begun."; 4198 case COMPLETE: return "The processing has completed without errors"; 4199 case ERROR: return "One or more errors have been detected in the Claim"; 4200 case PARTIAL: return "No errors have been detected in the Claim and some of the adjudication has been performed."; 4201 case NULL: return null; 4202 default: return "?"; 4203 } 4204 } 4205 public String getDisplay() { 4206 switch (this) { 4207 case QUEUED: return "Queued"; 4208 case COMPLETE: return "Processing Complete"; 4209 case ERROR: return "Error"; 4210 case PARTIAL: return "Partial Processing"; 4211 case NULL: return null; 4212 default: return "?"; 4213 } 4214 } 4215 } 4216 4217 public static class ClaimProcessingCodesEnumFactory implements EnumFactory<ClaimProcessingCodes> { 4218 public ClaimProcessingCodes fromCode(String codeString) throws IllegalArgumentException { 4219 if (codeString == null || "".equals(codeString)) 4220 if (codeString == null || "".equals(codeString)) 4221 return null; 4222 if ("queued".equals(codeString)) 4223 return ClaimProcessingCodes.QUEUED; 4224 if ("complete".equals(codeString)) 4225 return ClaimProcessingCodes.COMPLETE; 4226 if ("error".equals(codeString)) 4227 return ClaimProcessingCodes.ERROR; 4228 if ("partial".equals(codeString)) 4229 return ClaimProcessingCodes.PARTIAL; 4230 throw new IllegalArgumentException("Unknown ClaimProcessingCodes code '"+codeString+"'"); 4231 } 4232 public Enumeration<ClaimProcessingCodes> fromType(PrimitiveType<?> code) throws FHIRException { 4233 if (code == null) 4234 return null; 4235 if (code.isEmpty()) 4236 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.NULL, code); 4237 String codeString = ((PrimitiveType) code).asStringValue(); 4238 if (codeString == null || "".equals(codeString)) 4239 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.NULL, code); 4240 if ("queued".equals(codeString)) 4241 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.QUEUED, code); 4242 if ("complete".equals(codeString)) 4243 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.COMPLETE, code); 4244 if ("error".equals(codeString)) 4245 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.ERROR, code); 4246 if ("partial".equals(codeString)) 4247 return new Enumeration<ClaimProcessingCodes>(this, ClaimProcessingCodes.PARTIAL, code); 4248 throw new FHIRException("Unknown ClaimProcessingCodes code '"+codeString+"'"); 4249 } 4250 public String toCode(ClaimProcessingCodes code) { 4251 if (code == ClaimProcessingCodes.QUEUED) 4252 return "queued"; 4253 if (code == ClaimProcessingCodes.COMPLETE) 4254 return "complete"; 4255 if (code == ClaimProcessingCodes.ERROR) 4256 return "error"; 4257 if (code == ClaimProcessingCodes.PARTIAL) 4258 return "partial"; 4259 return "?"; 4260 } 4261 public String toSystem(ClaimProcessingCodes code) { 4262 return code.getSystem(); 4263 } 4264 } 4265 4266 public enum CompartmentType { 4267 /** 4268 * The compartment definition is for the patient compartment. 4269 */ 4270 PATIENT, 4271 /** 4272 * The compartment definition is for the encounter compartment. 4273 */ 4274 ENCOUNTER, 4275 /** 4276 * The compartment definition is for the related-person compartment. 4277 */ 4278 RELATEDPERSON, 4279 /** 4280 * The compartment definition is for the practitioner compartment. 4281 */ 4282 PRACTITIONER, 4283 /** 4284 * The compartment definition is for the device compartment. 4285 */ 4286 DEVICE, 4287 /** 4288 * added to help the parsers 4289 */ 4290 NULL; 4291 public static CompartmentType fromCode(String codeString) throws FHIRException { 4292 if (codeString == null || "".equals(codeString)) 4293 return null; 4294 if ("Patient".equals(codeString)) 4295 return PATIENT; 4296 if ("Encounter".equals(codeString)) 4297 return ENCOUNTER; 4298 if ("RelatedPerson".equals(codeString)) 4299 return RELATEDPERSON; 4300 if ("Practitioner".equals(codeString)) 4301 return PRACTITIONER; 4302 if ("Device".equals(codeString)) 4303 return DEVICE; 4304 throw new FHIRException("Unknown CompartmentType code '"+codeString+"'"); 4305 } 4306 public String toCode() { 4307 switch (this) { 4308 case PATIENT: return "Patient"; 4309 case ENCOUNTER: return "Encounter"; 4310 case RELATEDPERSON: return "RelatedPerson"; 4311 case PRACTITIONER: return "Practitioner"; 4312 case DEVICE: return "Device"; 4313 case NULL: return null; 4314 default: return "?"; 4315 } 4316 } 4317 public String getSystem() { 4318 switch (this) { 4319 case PATIENT: return "http://hl7.org/fhir/compartment-type"; 4320 case ENCOUNTER: return "http://hl7.org/fhir/compartment-type"; 4321 case RELATEDPERSON: return "http://hl7.org/fhir/compartment-type"; 4322 case PRACTITIONER: return "http://hl7.org/fhir/compartment-type"; 4323 case DEVICE: return "http://hl7.org/fhir/compartment-type"; 4324 case NULL: return null; 4325 default: return "?"; 4326 } 4327 } 4328 public String getDefinition() { 4329 switch (this) { 4330 case PATIENT: return "The compartment definition is for the patient compartment."; 4331 case ENCOUNTER: return "The compartment definition is for the encounter compartment."; 4332 case RELATEDPERSON: return "The compartment definition is for the related-person compartment."; 4333 case PRACTITIONER: return "The compartment definition is for the practitioner compartment."; 4334 case DEVICE: return "The compartment definition is for the device compartment."; 4335 case NULL: return null; 4336 default: return "?"; 4337 } 4338 } 4339 public String getDisplay() { 4340 switch (this) { 4341 case PATIENT: return "Patient"; 4342 case ENCOUNTER: return "Encounter"; 4343 case RELATEDPERSON: return "RelatedPerson"; 4344 case PRACTITIONER: return "Practitioner"; 4345 case DEVICE: return "Device"; 4346 case NULL: return null; 4347 default: return "?"; 4348 } 4349 } 4350 } 4351 4352 public static class CompartmentTypeEnumFactory implements EnumFactory<CompartmentType> { 4353 public CompartmentType fromCode(String codeString) throws IllegalArgumentException { 4354 if (codeString == null || "".equals(codeString)) 4355 if (codeString == null || "".equals(codeString)) 4356 return null; 4357 if ("Patient".equals(codeString)) 4358 return CompartmentType.PATIENT; 4359 if ("Encounter".equals(codeString)) 4360 return CompartmentType.ENCOUNTER; 4361 if ("RelatedPerson".equals(codeString)) 4362 return CompartmentType.RELATEDPERSON; 4363 if ("Practitioner".equals(codeString)) 4364 return CompartmentType.PRACTITIONER; 4365 if ("Device".equals(codeString)) 4366 return CompartmentType.DEVICE; 4367 throw new IllegalArgumentException("Unknown CompartmentType code '"+codeString+"'"); 4368 } 4369 public Enumeration<CompartmentType> fromType(PrimitiveType<?> code) throws FHIRException { 4370 if (code == null) 4371 return null; 4372 if (code.isEmpty()) 4373 return new Enumeration<CompartmentType>(this, CompartmentType.NULL, code); 4374 String codeString = ((PrimitiveType) code).asStringValue(); 4375 if (codeString == null || "".equals(codeString)) 4376 return new Enumeration<CompartmentType>(this, CompartmentType.NULL, code); 4377 if ("Patient".equals(codeString)) 4378 return new Enumeration<CompartmentType>(this, CompartmentType.PATIENT, code); 4379 if ("Encounter".equals(codeString)) 4380 return new Enumeration<CompartmentType>(this, CompartmentType.ENCOUNTER, code); 4381 if ("RelatedPerson".equals(codeString)) 4382 return new Enumeration<CompartmentType>(this, CompartmentType.RELATEDPERSON, code); 4383 if ("Practitioner".equals(codeString)) 4384 return new Enumeration<CompartmentType>(this, CompartmentType.PRACTITIONER, code); 4385 if ("Device".equals(codeString)) 4386 return new Enumeration<CompartmentType>(this, CompartmentType.DEVICE, code); 4387 throw new FHIRException("Unknown CompartmentType code '"+codeString+"'"); 4388 } 4389 public String toCode(CompartmentType code) { 4390 if (code == CompartmentType.PATIENT) 4391 return "Patient"; 4392 if (code == CompartmentType.ENCOUNTER) 4393 return "Encounter"; 4394 if (code == CompartmentType.RELATEDPERSON) 4395 return "RelatedPerson"; 4396 if (code == CompartmentType.PRACTITIONER) 4397 return "Practitioner"; 4398 if (code == CompartmentType.DEVICE) 4399 return "Device"; 4400 return "?"; 4401 } 4402 public String toSystem(CompartmentType code) { 4403 return code.getSystem(); 4404 } 4405 } 4406 4407 public enum CompositionStatus { 4408 /** 4409 * The existence of the report is registered, but there is nothing yet available. 4410 */ 4411 REGISTERED, 4412 /** 4413 * This is a partial (e.g. initial, interim or preliminary) report: data in the report may be incomplete or unverified. 4414 */ 4415 PARTIAL, 4416 /** 4417 * Verified early results are available, but not all results are final. 4418 */ 4419 PRELIMINARY, 4420 /** 4421 * 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. 4422 */ 4423 FINAL, 4424 /** 4425 * 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. 4426 */ 4427 AMENDED, 4428 /** 4429 * Subsequent to being final, the composition content has been modified to correct an error in the report or referenced results. 4430 */ 4431 CORRECTED, 4432 /** 4433 * Subsequent to being final, the composition content has been modified by adding new content. The existing content is unchanged. 4434 */ 4435 APPENDED, 4436 /** 4437 * The composition is unavailable because the measurement was not started or not completed (also sometimes called "aborted"). 4438 */ 4439 CANCELLED, 4440 /** 4441 * 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. 4442 */ 4443 ENTEREDINERROR, 4444 /** 4445 * This composition has been withdrawn or superseded and should no longer be used. 4446 */ 4447 DEPRECATED, 4448 /** 4449 * 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. 4450 */ 4451 UNKNOWN, 4452 /** 4453 * added to help the parsers 4454 */ 4455 NULL; 4456 public static CompositionStatus fromCode(String codeString) throws FHIRException { 4457 if (codeString == null || "".equals(codeString)) 4458 return null; 4459 if ("registered".equals(codeString)) 4460 return REGISTERED; 4461 if ("partial".equals(codeString)) 4462 return PARTIAL; 4463 if ("preliminary".equals(codeString)) 4464 return PRELIMINARY; 4465 if ("final".equals(codeString)) 4466 return FINAL; 4467 if ("amended".equals(codeString)) 4468 return AMENDED; 4469 if ("corrected".equals(codeString)) 4470 return CORRECTED; 4471 if ("appended".equals(codeString)) 4472 return APPENDED; 4473 if ("cancelled".equals(codeString)) 4474 return CANCELLED; 4475 if ("entered-in-error".equals(codeString)) 4476 return ENTEREDINERROR; 4477 if ("deprecated".equals(codeString)) 4478 return DEPRECATED; 4479 if ("unknown".equals(codeString)) 4480 return UNKNOWN; 4481 throw new FHIRException("Unknown CompositionStatus code '"+codeString+"'"); 4482 } 4483 public String toCode() { 4484 switch (this) { 4485 case REGISTERED: return "registered"; 4486 case PARTIAL: return "partial"; 4487 case PRELIMINARY: return "preliminary"; 4488 case FINAL: return "final"; 4489 case AMENDED: return "amended"; 4490 case CORRECTED: return "corrected"; 4491 case APPENDED: return "appended"; 4492 case CANCELLED: return "cancelled"; 4493 case ENTEREDINERROR: return "entered-in-error"; 4494 case DEPRECATED: return "deprecated"; 4495 case UNKNOWN: return "unknown"; 4496 case NULL: return null; 4497 default: return "?"; 4498 } 4499 } 4500 public String getSystem() { 4501 switch (this) { 4502 case REGISTERED: return "http://hl7.org/fhir/composition-status"; 4503 case PARTIAL: return "http://hl7.org/fhir/composition-status"; 4504 case PRELIMINARY: return "http://hl7.org/fhir/composition-status"; 4505 case FINAL: return "http://hl7.org/fhir/composition-status"; 4506 case AMENDED: return "http://hl7.org/fhir/composition-status"; 4507 case CORRECTED: return "http://hl7.org/fhir/composition-status"; 4508 case APPENDED: return "http://hl7.org/fhir/composition-status"; 4509 case CANCELLED: return "http://hl7.org/fhir/composition-status"; 4510 case ENTEREDINERROR: return "http://hl7.org/fhir/composition-status"; 4511 case DEPRECATED: return "http://hl7.org/fhir/composition-status"; 4512 case UNKNOWN: return "http://hl7.org/fhir/composition-status"; 4513 case NULL: return null; 4514 default: return "?"; 4515 } 4516 } 4517 public String getDefinition() { 4518 switch (this) { 4519 case REGISTERED: return "The existence of the report is registered, but there is nothing yet available."; 4520 case PARTIAL: return "This is a partial (e.g. initial, interim or preliminary) report: data in the report may be incomplete or unverified."; 4521 case PRELIMINARY: return "Verified early results are available, but not all results are final."; 4522 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."; 4523 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."; 4524 case CORRECTED: return "Subsequent to being final, the composition content has been modified to correct an error in the report or referenced results."; 4525 case APPENDED: return "Subsequent to being final, the composition content has been modified by adding new content. The existing content is unchanged."; 4526 case CANCELLED: return "The composition is unavailable because the measurement was not started or not completed (also sometimes called \"aborted\")."; 4527 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."; 4528 case DEPRECATED: return "This composition has been withdrawn or superseded and should no longer be used."; 4529 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."; 4530 case NULL: return null; 4531 default: return "?"; 4532 } 4533 } 4534 public String getDisplay() { 4535 switch (this) { 4536 case REGISTERED: return "Registered"; 4537 case PARTIAL: return "Partial"; 4538 case PRELIMINARY: return "Preliminary"; 4539 case FINAL: return "Final"; 4540 case AMENDED: return "Amended"; 4541 case CORRECTED: return "Corrected"; 4542 case APPENDED: return "Appended"; 4543 case CANCELLED: return "Cancelled"; 4544 case ENTEREDINERROR: return "Entered in Error"; 4545 case DEPRECATED: return "Deprecated"; 4546 case UNKNOWN: return "Unknown"; 4547 case NULL: return null; 4548 default: return "?"; 4549 } 4550 } 4551 } 4552 4553 public static class CompositionStatusEnumFactory implements EnumFactory<CompositionStatus> { 4554 public CompositionStatus fromCode(String codeString) throws IllegalArgumentException { 4555 if (codeString == null || "".equals(codeString)) 4556 if (codeString == null || "".equals(codeString)) 4557 return null; 4558 if ("registered".equals(codeString)) 4559 return CompositionStatus.REGISTERED; 4560 if ("partial".equals(codeString)) 4561 return CompositionStatus.PARTIAL; 4562 if ("preliminary".equals(codeString)) 4563 return CompositionStatus.PRELIMINARY; 4564 if ("final".equals(codeString)) 4565 return CompositionStatus.FINAL; 4566 if ("amended".equals(codeString)) 4567 return CompositionStatus.AMENDED; 4568 if ("corrected".equals(codeString)) 4569 return CompositionStatus.CORRECTED; 4570 if ("appended".equals(codeString)) 4571 return CompositionStatus.APPENDED; 4572 if ("cancelled".equals(codeString)) 4573 return CompositionStatus.CANCELLED; 4574 if ("entered-in-error".equals(codeString)) 4575 return CompositionStatus.ENTEREDINERROR; 4576 if ("deprecated".equals(codeString)) 4577 return CompositionStatus.DEPRECATED; 4578 if ("unknown".equals(codeString)) 4579 return CompositionStatus.UNKNOWN; 4580 throw new IllegalArgumentException("Unknown CompositionStatus code '"+codeString+"'"); 4581 } 4582 public Enumeration<CompositionStatus> fromType(PrimitiveType<?> code) throws FHIRException { 4583 if (code == null) 4584 return null; 4585 if (code.isEmpty()) 4586 return new Enumeration<CompositionStatus>(this, CompositionStatus.NULL, code); 4587 String codeString = ((PrimitiveType) code).asStringValue(); 4588 if (codeString == null || "".equals(codeString)) 4589 return new Enumeration<CompositionStatus>(this, CompositionStatus.NULL, code); 4590 if ("registered".equals(codeString)) 4591 return new Enumeration<CompositionStatus>(this, CompositionStatus.REGISTERED, code); 4592 if ("partial".equals(codeString)) 4593 return new Enumeration<CompositionStatus>(this, CompositionStatus.PARTIAL, code); 4594 if ("preliminary".equals(codeString)) 4595 return new Enumeration<CompositionStatus>(this, CompositionStatus.PRELIMINARY, code); 4596 if ("final".equals(codeString)) 4597 return new Enumeration<CompositionStatus>(this, CompositionStatus.FINAL, code); 4598 if ("amended".equals(codeString)) 4599 return new Enumeration<CompositionStatus>(this, CompositionStatus.AMENDED, code); 4600 if ("corrected".equals(codeString)) 4601 return new Enumeration<CompositionStatus>(this, CompositionStatus.CORRECTED, code); 4602 if ("appended".equals(codeString)) 4603 return new Enumeration<CompositionStatus>(this, CompositionStatus.APPENDED, code); 4604 if ("cancelled".equals(codeString)) 4605 return new Enumeration<CompositionStatus>(this, CompositionStatus.CANCELLED, code); 4606 if ("entered-in-error".equals(codeString)) 4607 return new Enumeration<CompositionStatus>(this, CompositionStatus.ENTEREDINERROR, code); 4608 if ("deprecated".equals(codeString)) 4609 return new Enumeration<CompositionStatus>(this, CompositionStatus.DEPRECATED, code); 4610 if ("unknown".equals(codeString)) 4611 return new Enumeration<CompositionStatus>(this, CompositionStatus.UNKNOWN, code); 4612 throw new FHIRException("Unknown CompositionStatus code '"+codeString+"'"); 4613 } 4614 public String toCode(CompositionStatus code) { 4615 if (code == CompositionStatus.REGISTERED) 4616 return "registered"; 4617 if (code == CompositionStatus.PARTIAL) 4618 return "partial"; 4619 if (code == CompositionStatus.PRELIMINARY) 4620 return "preliminary"; 4621 if (code == CompositionStatus.FINAL) 4622 return "final"; 4623 if (code == CompositionStatus.AMENDED) 4624 return "amended"; 4625 if (code == CompositionStatus.CORRECTED) 4626 return "corrected"; 4627 if (code == CompositionStatus.APPENDED) 4628 return "appended"; 4629 if (code == CompositionStatus.CANCELLED) 4630 return "cancelled"; 4631 if (code == CompositionStatus.ENTEREDINERROR) 4632 return "entered-in-error"; 4633 if (code == CompositionStatus.DEPRECATED) 4634 return "deprecated"; 4635 if (code == CompositionStatus.UNKNOWN) 4636 return "unknown"; 4637 return "?"; 4638 } 4639 public String toSystem(CompositionStatus code) { 4640 return code.getSystem(); 4641 } 4642 } 4643 4644 public enum ConceptMapRelationship { 4645 /** 4646 * The concepts are related to each other, but the exact relationship is not known. 4647 */ 4648 RELATEDTO, 4649 /** 4650 * The definitions of the concepts mean the same thing. 4651 */ 4652 EQUIVALENT, 4653 /** 4654 * The source concept is narrower in meaning than the target concept. 4655 */ 4656 SOURCEISNARROWERTHANTARGET, 4657 /** 4658 * The source concept is broader in meaning than the target concept. 4659 */ 4660 SOURCEISBROADERTHANTARGET, 4661 /** 4662 * This is an explicit assertion that the target concept is not related to the source concept. 4663 */ 4664 NOTRELATEDTO, 4665 /** 4666 * added to help the parsers 4667 */ 4668 NULL; 4669 public static ConceptMapRelationship fromCode(String codeString) throws FHIRException { 4670 if (codeString == null || "".equals(codeString)) 4671 return null; 4672 if ("related-to".equals(codeString)) 4673 return RELATEDTO; 4674 if ("equivalent".equals(codeString)) 4675 return EQUIVALENT; 4676 if ("source-is-narrower-than-target".equals(codeString)) 4677 return SOURCEISNARROWERTHANTARGET; 4678 if ("source-is-broader-than-target".equals(codeString)) 4679 return SOURCEISBROADERTHANTARGET; 4680 if ("not-related-to".equals(codeString)) 4681 return NOTRELATEDTO; 4682 throw new FHIRException("Unknown ConceptMapRelationship code '"+codeString+"'"); 4683 } 4684 public String toCode() { 4685 switch (this) { 4686 case RELATEDTO: return "related-to"; 4687 case EQUIVALENT: return "equivalent"; 4688 case SOURCEISNARROWERTHANTARGET: return "source-is-narrower-than-target"; 4689 case SOURCEISBROADERTHANTARGET: return "source-is-broader-than-target"; 4690 case NOTRELATEDTO: return "not-related-to"; 4691 case NULL: return null; 4692 default: return "?"; 4693 } 4694 } 4695 public String getSystem() { 4696 switch (this) { 4697 case RELATEDTO: return "http://hl7.org/fhir/concept-map-relationship"; 4698 case EQUIVALENT: return "http://hl7.org/fhir/concept-map-relationship"; 4699 case SOURCEISNARROWERTHANTARGET: return "http://hl7.org/fhir/concept-map-relationship"; 4700 case SOURCEISBROADERTHANTARGET: return "http://hl7.org/fhir/concept-map-relationship"; 4701 case NOTRELATEDTO: return "http://hl7.org/fhir/concept-map-relationship"; 4702 case NULL: return null; 4703 default: return "?"; 4704 } 4705 } 4706 public String getDefinition() { 4707 switch (this) { 4708 case RELATEDTO: return "The concepts are related to each other, but the exact relationship is not known."; 4709 case EQUIVALENT: return "The definitions of the concepts mean the same thing."; 4710 case SOURCEISNARROWERTHANTARGET: return "The source concept is narrower in meaning than the target concept."; 4711 case SOURCEISBROADERTHANTARGET: return "The source concept is broader in meaning than the target concept."; 4712 case NOTRELATEDTO: return "This is an explicit assertion that the target concept is not related to the source concept."; 4713 case NULL: return null; 4714 default: return "?"; 4715 } 4716 } 4717 public String getDisplay() { 4718 switch (this) { 4719 case RELATEDTO: return "Related To"; 4720 case EQUIVALENT: return "Equivalent"; 4721 case SOURCEISNARROWERTHANTARGET: return "Source Is Narrower Than Target"; 4722 case SOURCEISBROADERTHANTARGET: return "Source Is Broader Than Target"; 4723 case NOTRELATEDTO: return "Not Related To"; 4724 case NULL: return null; 4725 default: return "?"; 4726 } 4727 } 4728 } 4729 4730 public static class ConceptMapRelationshipEnumFactory implements EnumFactory<ConceptMapRelationship> { 4731 public ConceptMapRelationship fromCode(String codeString) throws IllegalArgumentException { 4732 if (codeString == null || "".equals(codeString)) 4733 if (codeString == null || "".equals(codeString)) 4734 return null; 4735 if ("related-to".equals(codeString)) 4736 return ConceptMapRelationship.RELATEDTO; 4737 if ("equivalent".equals(codeString)) 4738 return ConceptMapRelationship.EQUIVALENT; 4739 if ("source-is-narrower-than-target".equals(codeString)) 4740 return ConceptMapRelationship.SOURCEISNARROWERTHANTARGET; 4741 if ("source-is-broader-than-target".equals(codeString)) 4742 return ConceptMapRelationship.SOURCEISBROADERTHANTARGET; 4743 if ("not-related-to".equals(codeString)) 4744 return ConceptMapRelationship.NOTRELATEDTO; 4745 throw new IllegalArgumentException("Unknown ConceptMapRelationship code '"+codeString+"'"); 4746 } 4747 public Enumeration<ConceptMapRelationship> fromType(PrimitiveType<?> code) throws FHIRException { 4748 if (code == null) 4749 return null; 4750 if (code.isEmpty()) 4751 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NULL, code); 4752 String codeString = ((PrimitiveType) code).asStringValue(); 4753 if (codeString == null || "".equals(codeString)) 4754 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NULL, code); 4755 if ("related-to".equals(codeString)) 4756 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.RELATEDTO, code); 4757 if ("equivalent".equals(codeString)) 4758 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.EQUIVALENT, code); 4759 if ("source-is-narrower-than-target".equals(codeString)) 4760 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.SOURCEISNARROWERTHANTARGET, code); 4761 if ("source-is-broader-than-target".equals(codeString)) 4762 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.SOURCEISBROADERTHANTARGET, code); 4763 if ("not-related-to".equals(codeString)) 4764 return new Enumeration<ConceptMapRelationship>(this, ConceptMapRelationship.NOTRELATEDTO, code); 4765 throw new FHIRException("Unknown ConceptMapRelationship code '"+codeString+"'"); 4766 } 4767 public String toCode(ConceptMapRelationship code) { 4768 if (code == ConceptMapRelationship.RELATEDTO) 4769 return "related-to"; 4770 if (code == ConceptMapRelationship.EQUIVALENT) 4771 return "equivalent"; 4772 if (code == ConceptMapRelationship.SOURCEISNARROWERTHANTARGET) 4773 return "source-is-narrower-than-target"; 4774 if (code == ConceptMapRelationship.SOURCEISBROADERTHANTARGET) 4775 return "source-is-broader-than-target"; 4776 if (code == ConceptMapRelationship.NOTRELATEDTO) 4777 return "not-related-to"; 4778 return "?"; 4779 } 4780 public String toSystem(ConceptMapRelationship code) { 4781 return code.getSystem(); 4782 } 4783 } 4784 4785 public enum ConsentDataMeaning { 4786 /** 4787 * The consent applies directly to the instance of the resource. 4788 */ 4789 INSTANCE, 4790 /** 4791 * The consent applies directly to the instance of the resource and instances it refers to. 4792 */ 4793 RELATED, 4794 /** 4795 * The consent applies directly to the instance of the resource and instances that refer to it. 4796 */ 4797 DEPENDENTS, 4798 /** 4799 * The consent applies to instances of resources that are authored by. 4800 */ 4801 AUTHOREDBY, 4802 /** 4803 * added to help the parsers 4804 */ 4805 NULL; 4806 public static ConsentDataMeaning fromCode(String codeString) throws FHIRException { 4807 if (codeString == null || "".equals(codeString)) 4808 return null; 4809 if ("instance".equals(codeString)) 4810 return INSTANCE; 4811 if ("related".equals(codeString)) 4812 return RELATED; 4813 if ("dependents".equals(codeString)) 4814 return DEPENDENTS; 4815 if ("authoredby".equals(codeString)) 4816 return AUTHOREDBY; 4817 throw new FHIRException("Unknown ConsentDataMeaning code '"+codeString+"'"); 4818 } 4819 public String toCode() { 4820 switch (this) { 4821 case INSTANCE: return "instance"; 4822 case RELATED: return "related"; 4823 case DEPENDENTS: return "dependents"; 4824 case AUTHOREDBY: return "authoredby"; 4825 case NULL: return null; 4826 default: return "?"; 4827 } 4828 } 4829 public String getSystem() { 4830 switch (this) { 4831 case INSTANCE: return "http://hl7.org/fhir/consent-data-meaning"; 4832 case RELATED: return "http://hl7.org/fhir/consent-data-meaning"; 4833 case DEPENDENTS: return "http://hl7.org/fhir/consent-data-meaning"; 4834 case AUTHOREDBY: return "http://hl7.org/fhir/consent-data-meaning"; 4835 case NULL: return null; 4836 default: return "?"; 4837 } 4838 } 4839 public String getDefinition() { 4840 switch (this) { 4841 case INSTANCE: return "The consent applies directly to the instance of the resource."; 4842 case RELATED: return "The consent applies directly to the instance of the resource and instances it refers to."; 4843 case DEPENDENTS: return "The consent applies directly to the instance of the resource and instances that refer to it."; 4844 case AUTHOREDBY: return "The consent applies to instances of resources that are authored by."; 4845 case NULL: return null; 4846 default: return "?"; 4847 } 4848 } 4849 public String getDisplay() { 4850 switch (this) { 4851 case INSTANCE: return "Instance"; 4852 case RELATED: return "Related"; 4853 case DEPENDENTS: return "Dependents"; 4854 case AUTHOREDBY: return "AuthoredBy"; 4855 case NULL: return null; 4856 default: return "?"; 4857 } 4858 } 4859 } 4860 4861 public static class ConsentDataMeaningEnumFactory implements EnumFactory<ConsentDataMeaning> { 4862 public ConsentDataMeaning fromCode(String codeString) throws IllegalArgumentException { 4863 if (codeString == null || "".equals(codeString)) 4864 if (codeString == null || "".equals(codeString)) 4865 return null; 4866 if ("instance".equals(codeString)) 4867 return ConsentDataMeaning.INSTANCE; 4868 if ("related".equals(codeString)) 4869 return ConsentDataMeaning.RELATED; 4870 if ("dependents".equals(codeString)) 4871 return ConsentDataMeaning.DEPENDENTS; 4872 if ("authoredby".equals(codeString)) 4873 return ConsentDataMeaning.AUTHOREDBY; 4874 throw new IllegalArgumentException("Unknown ConsentDataMeaning code '"+codeString+"'"); 4875 } 4876 public Enumeration<ConsentDataMeaning> fromType(PrimitiveType<?> code) throws FHIRException { 4877 if (code == null) 4878 return null; 4879 if (code.isEmpty()) 4880 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.NULL, code); 4881 String codeString = ((PrimitiveType) code).asStringValue(); 4882 if (codeString == null || "".equals(codeString)) 4883 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.NULL, code); 4884 if ("instance".equals(codeString)) 4885 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.INSTANCE, code); 4886 if ("related".equals(codeString)) 4887 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.RELATED, code); 4888 if ("dependents".equals(codeString)) 4889 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.DEPENDENTS, code); 4890 if ("authoredby".equals(codeString)) 4891 return new Enumeration<ConsentDataMeaning>(this, ConsentDataMeaning.AUTHOREDBY, code); 4892 throw new FHIRException("Unknown ConsentDataMeaning code '"+codeString+"'"); 4893 } 4894 public String toCode(ConsentDataMeaning code) { 4895 if (code == ConsentDataMeaning.INSTANCE) 4896 return "instance"; 4897 if (code == ConsentDataMeaning.RELATED) 4898 return "related"; 4899 if (code == ConsentDataMeaning.DEPENDENTS) 4900 return "dependents"; 4901 if (code == ConsentDataMeaning.AUTHOREDBY) 4902 return "authoredby"; 4903 return "?"; 4904 } 4905 public String toSystem(ConsentDataMeaning code) { 4906 return code.getSystem(); 4907 } 4908 } 4909 4910 public enum ConsentProvisionType { 4911 /** 4912 * Consent is denied for actions meeting these rules. 4913 */ 4914 DENY, 4915 /** 4916 * Consent is provided for actions meeting these rules. 4917 */ 4918 PERMIT, 4919 /** 4920 * added to help the parsers 4921 */ 4922 NULL; 4923 public static ConsentProvisionType fromCode(String codeString) throws FHIRException { 4924 if (codeString == null || "".equals(codeString)) 4925 return null; 4926 if ("deny".equals(codeString)) 4927 return DENY; 4928 if ("permit".equals(codeString)) 4929 return PERMIT; 4930 throw new FHIRException("Unknown ConsentProvisionType code '"+codeString+"'"); 4931 } 4932 public String toCode() { 4933 switch (this) { 4934 case DENY: return "deny"; 4935 case PERMIT: return "permit"; 4936 case NULL: return null; 4937 default: return "?"; 4938 } 4939 } 4940 public String getSystem() { 4941 switch (this) { 4942 case DENY: return "http://hl7.org/fhir/consent-provision-type"; 4943 case PERMIT: return "http://hl7.org/fhir/consent-provision-type"; 4944 case NULL: return null; 4945 default: return "?"; 4946 } 4947 } 4948 public String getDefinition() { 4949 switch (this) { 4950 case DENY: return "Consent is denied for actions meeting these rules."; 4951 case PERMIT: return "Consent is provided for actions meeting these rules."; 4952 case NULL: return null; 4953 default: return "?"; 4954 } 4955 } 4956 public String getDisplay() { 4957 switch (this) { 4958 case DENY: return "Deny"; 4959 case PERMIT: return "Permit"; 4960 case NULL: return null; 4961 default: return "?"; 4962 } 4963 } 4964 } 4965 4966 public static class ConsentProvisionTypeEnumFactory implements EnumFactory<ConsentProvisionType> { 4967 public ConsentProvisionType fromCode(String codeString) throws IllegalArgumentException { 4968 if (codeString == null || "".equals(codeString)) 4969 if (codeString == null || "".equals(codeString)) 4970 return null; 4971 if ("deny".equals(codeString)) 4972 return ConsentProvisionType.DENY; 4973 if ("permit".equals(codeString)) 4974 return ConsentProvisionType.PERMIT; 4975 throw new IllegalArgumentException("Unknown ConsentProvisionType code '"+codeString+"'"); 4976 } 4977 public Enumeration<ConsentProvisionType> fromType(PrimitiveType<?> code) throws FHIRException { 4978 if (code == null) 4979 return null; 4980 if (code.isEmpty()) 4981 return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.NULL, code); 4982 String codeString = ((PrimitiveType) code).asStringValue(); 4983 if (codeString == null || "".equals(codeString)) 4984 return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.NULL, code); 4985 if ("deny".equals(codeString)) 4986 return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.DENY, code); 4987 if ("permit".equals(codeString)) 4988 return new Enumeration<ConsentProvisionType>(this, ConsentProvisionType.PERMIT, code); 4989 throw new FHIRException("Unknown ConsentProvisionType code '"+codeString+"'"); 4990 } 4991 public String toCode(ConsentProvisionType code) { 4992 if (code == ConsentProvisionType.DENY) 4993 return "deny"; 4994 if (code == ConsentProvisionType.PERMIT) 4995 return "permit"; 4996 return "?"; 4997 } 4998 public String toSystem(ConsentProvisionType code) { 4999 return code.getSystem(); 5000 } 5001 } 5002 5003 public enum Currencies { 5004 /** 5005 * null 5006 */ 5007 AED, 5008 /** 5009 * null 5010 */ 5011 AFN, 5012 /** 5013 * null 5014 */ 5015 ALL, 5016 /** 5017 * null 5018 */ 5019 AMD, 5020 /** 5021 * null 5022 */ 5023 ANG, 5024 /** 5025 * null 5026 */ 5027 AOA, 5028 /** 5029 * null 5030 */ 5031 ARS, 5032 /** 5033 * null 5034 */ 5035 AUD, 5036 /** 5037 * null 5038 */ 5039 AWG, 5040 /** 5041 * null 5042 */ 5043 AZN, 5044 /** 5045 * null 5046 */ 5047 BAM, 5048 /** 5049 * null 5050 */ 5051 BBD, 5052 /** 5053 * null 5054 */ 5055 BDT, 5056 /** 5057 * null 5058 */ 5059 BGN, 5060 /** 5061 * null 5062 */ 5063 BHD, 5064 /** 5065 * null 5066 */ 5067 BIF, 5068 /** 5069 * null 5070 */ 5071 BMD, 5072 /** 5073 * null 5074 */ 5075 BND, 5076 /** 5077 * null 5078 */ 5079 BOB, 5080 /** 5081 * null 5082 */ 5083 BOV, 5084 /** 5085 * null 5086 */ 5087 BRL, 5088 /** 5089 * null 5090 */ 5091 BSD, 5092 /** 5093 * null 5094 */ 5095 BTN, 5096 /** 5097 * null 5098 */ 5099 BWP, 5100 /** 5101 * null 5102 */ 5103 BYN, 5104 /** 5105 * null 5106 */ 5107 BZD, 5108 /** 5109 * null 5110 */ 5111 CAD, 5112 /** 5113 * null 5114 */ 5115 CDF, 5116 /** 5117 * null 5118 */ 5119 CHE, 5120 /** 5121 * null 5122 */ 5123 CHF, 5124 /** 5125 * null 5126 */ 5127 CHW, 5128 /** 5129 * null 5130 */ 5131 CLF, 5132 /** 5133 * null 5134 */ 5135 CLP, 5136 /** 5137 * null 5138 */ 5139 CNY, 5140 /** 5141 * null 5142 */ 5143 COP, 5144 /** 5145 * null 5146 */ 5147 COU, 5148 /** 5149 * null 5150 */ 5151 CRC, 5152 /** 5153 * null 5154 */ 5155 CUC, 5156 /** 5157 * null 5158 */ 5159 CUP, 5160 /** 5161 * null 5162 */ 5163 CVE, 5164 /** 5165 * null 5166 */ 5167 CZK, 5168 /** 5169 * null 5170 */ 5171 DJF, 5172 /** 5173 * null 5174 */ 5175 DKK, 5176 /** 5177 * null 5178 */ 5179 DOP, 5180 /** 5181 * null 5182 */ 5183 DZD, 5184 /** 5185 * null 5186 */ 5187 EGP, 5188 /** 5189 * null 5190 */ 5191 ERN, 5192 /** 5193 * null 5194 */ 5195 ETB, 5196 /** 5197 * null 5198 */ 5199 EUR, 5200 /** 5201 * null 5202 */ 5203 FJD, 5204 /** 5205 * null 5206 */ 5207 FKP, 5208 /** 5209 * null 5210 */ 5211 GBP, 5212 /** 5213 * null 5214 */ 5215 GEL, 5216 /** 5217 * null 5218 */ 5219 GGP, 5220 /** 5221 * null 5222 */ 5223 GHS, 5224 /** 5225 * null 5226 */ 5227 GIP, 5228 /** 5229 * null 5230 */ 5231 GMD, 5232 /** 5233 * null 5234 */ 5235 GNF, 5236 /** 5237 * null 5238 */ 5239 GTQ, 5240 /** 5241 * null 5242 */ 5243 GYD, 5244 /** 5245 * null 5246 */ 5247 HKD, 5248 /** 5249 * null 5250 */ 5251 HNL, 5252 /** 5253 * null 5254 */ 5255 HRK, 5256 /** 5257 * null 5258 */ 5259 HTG, 5260 /** 5261 * null 5262 */ 5263 HUF, 5264 /** 5265 * null 5266 */ 5267 IDR, 5268 /** 5269 * null 5270 */ 5271 ILS, 5272 /** 5273 * null 5274 */ 5275 IMP, 5276 /** 5277 * null 5278 */ 5279 INR, 5280 /** 5281 * null 5282 */ 5283 IQD, 5284 /** 5285 * null 5286 */ 5287 IRR, 5288 /** 5289 * null 5290 */ 5291 ISK, 5292 /** 5293 * null 5294 */ 5295 JEP, 5296 /** 5297 * null 5298 */ 5299 JMD, 5300 /** 5301 * null 5302 */ 5303 JOD, 5304 /** 5305 * null 5306 */ 5307 JPY, 5308 /** 5309 * null 5310 */ 5311 KES, 5312 /** 5313 * null 5314 */ 5315 KGS, 5316 /** 5317 * null 5318 */ 5319 KHR, 5320 /** 5321 * null 5322 */ 5323 KMF, 5324 /** 5325 * null 5326 */ 5327 KPW, 5328 /** 5329 * null 5330 */ 5331 KRW, 5332 /** 5333 * null 5334 */ 5335 KWD, 5336 /** 5337 * null 5338 */ 5339 KYD, 5340 /** 5341 * null 5342 */ 5343 KZT, 5344 /** 5345 * null 5346 */ 5347 LAK, 5348 /** 5349 * null 5350 */ 5351 LBP, 5352 /** 5353 * null 5354 */ 5355 LKR, 5356 /** 5357 * null 5358 */ 5359 LRD, 5360 /** 5361 * null 5362 */ 5363 LSL, 5364 /** 5365 * null 5366 */ 5367 LYD, 5368 /** 5369 * null 5370 */ 5371 MAD, 5372 /** 5373 * null 5374 */ 5375 MDL, 5376 /** 5377 * null 5378 */ 5379 MGA, 5380 /** 5381 * null 5382 */ 5383 MKD, 5384 /** 5385 * null 5386 */ 5387 MMK, 5388 /** 5389 * null 5390 */ 5391 MNT, 5392 /** 5393 * null 5394 */ 5395 MOP, 5396 /** 5397 * null 5398 */ 5399 MRU, 5400 /** 5401 * null 5402 */ 5403 MUR, 5404 /** 5405 * null 5406 */ 5407 MVR, 5408 /** 5409 * null 5410 */ 5411 MWK, 5412 /** 5413 * null 5414 */ 5415 MXN, 5416 /** 5417 * null 5418 */ 5419 MXV, 5420 /** 5421 * null 5422 */ 5423 MYR, 5424 /** 5425 * null 5426 */ 5427 MZN, 5428 /** 5429 * null 5430 */ 5431 NAD, 5432 /** 5433 * null 5434 */ 5435 NGN, 5436 /** 5437 * null 5438 */ 5439 NIO, 5440 /** 5441 * null 5442 */ 5443 NOK, 5444 /** 5445 * null 5446 */ 5447 NPR, 5448 /** 5449 * null 5450 */ 5451 NZD, 5452 /** 5453 * null 5454 */ 5455 OMR, 5456 /** 5457 * null 5458 */ 5459 PAB, 5460 /** 5461 * null 5462 */ 5463 PEN, 5464 /** 5465 * null 5466 */ 5467 PGK, 5468 /** 5469 * null 5470 */ 5471 PHP, 5472 /** 5473 * null 5474 */ 5475 PKR, 5476 /** 5477 * null 5478 */ 5479 PLN, 5480 /** 5481 * null 5482 */ 5483 PYG, 5484 /** 5485 * null 5486 */ 5487 QAR, 5488 /** 5489 * null 5490 */ 5491 RON, 5492 /** 5493 * null 5494 */ 5495 RSD, 5496 /** 5497 * null 5498 */ 5499 RUB, 5500 /** 5501 * null 5502 */ 5503 RWF, 5504 /** 5505 * null 5506 */ 5507 SAR, 5508 /** 5509 * null 5510 */ 5511 SBD, 5512 /** 5513 * null 5514 */ 5515 SCR, 5516 /** 5517 * null 5518 */ 5519 SDG, 5520 /** 5521 * null 5522 */ 5523 SEK, 5524 /** 5525 * null 5526 */ 5527 SGD, 5528 /** 5529 * null 5530 */ 5531 SHP, 5532 /** 5533 * null 5534 */ 5535 SLL, 5536 /** 5537 * null 5538 */ 5539 SOS, 5540 /** 5541 * null 5542 */ 5543 SRD, 5544 /** 5545 * null 5546 */ 5547 SSP, 5548 /** 5549 * null 5550 */ 5551 STN, 5552 /** 5553 * null 5554 */ 5555 SVC, 5556 /** 5557 * null 5558 */ 5559 SYP, 5560 /** 5561 * null 5562 */ 5563 SZL, 5564 /** 5565 * null 5566 */ 5567 THB, 5568 /** 5569 * null 5570 */ 5571 TJS, 5572 /** 5573 * null 5574 */ 5575 TMT, 5576 /** 5577 * null 5578 */ 5579 TND, 5580 /** 5581 * null 5582 */ 5583 TOP, 5584 /** 5585 * null 5586 */ 5587 TRY, 5588 /** 5589 * null 5590 */ 5591 TTD, 5592 /** 5593 * null 5594 */ 5595 TVD, 5596 /** 5597 * null 5598 */ 5599 TWD, 5600 /** 5601 * null 5602 */ 5603 TZS, 5604 /** 5605 * null 5606 */ 5607 UAH, 5608 /** 5609 * null 5610 */ 5611 UGX, 5612 /** 5613 * null 5614 */ 5615 USD, 5616 /** 5617 * null 5618 */ 5619 USN, 5620 /** 5621 * null 5622 */ 5623 UYI, 5624 /** 5625 * null 5626 */ 5627 UYU, 5628 /** 5629 * null 5630 */ 5631 UZS, 5632 /** 5633 * null 5634 */ 5635 VEF, 5636 /** 5637 * null 5638 */ 5639 VND, 5640 /** 5641 * null 5642 */ 5643 VUV, 5644 /** 5645 * null 5646 */ 5647 WST, 5648 /** 5649 * null 5650 */ 5651 XAF, 5652 /** 5653 * null 5654 */ 5655 XAG, 5656 /** 5657 * null 5658 */ 5659 XAU, 5660 /** 5661 * null 5662 */ 5663 XBA, 5664 /** 5665 * null 5666 */ 5667 XBB, 5668 /** 5669 * null 5670 */ 5671 XBC, 5672 /** 5673 * null 5674 */ 5675 XBD, 5676 /** 5677 * null 5678 */ 5679 XCD, 5680 /** 5681 * null 5682 */ 5683 XDR, 5684 /** 5685 * null 5686 */ 5687 XOF, 5688 /** 5689 * null 5690 */ 5691 XPD, 5692 /** 5693 * null 5694 */ 5695 XPF, 5696 /** 5697 * null 5698 */ 5699 XPT, 5700 /** 5701 * null 5702 */ 5703 XSU, 5704 /** 5705 * null 5706 */ 5707 XTS, 5708 /** 5709 * null 5710 */ 5711 XUA, 5712 /** 5713 * null 5714 */ 5715 XXX, 5716 /** 5717 * null 5718 */ 5719 YER, 5720 /** 5721 * null 5722 */ 5723 ZAR, 5724 /** 5725 * null 5726 */ 5727 ZMW, 5728 /** 5729 * null 5730 */ 5731 ZWL, 5732 /** 5733 * added to help the parsers 5734 */ 5735 NULL; 5736 public static Currencies fromCode(String codeString) throws FHIRException { 5737 if (codeString == null || "".equals(codeString)) 5738 return null; 5739 if ("AED".equals(codeString)) 5740 return AED; 5741 if ("AFN".equals(codeString)) 5742 return AFN; 5743 if ("ALL".equals(codeString)) 5744 return ALL; 5745 if ("AMD".equals(codeString)) 5746 return AMD; 5747 if ("ANG".equals(codeString)) 5748 return ANG; 5749 if ("AOA".equals(codeString)) 5750 return AOA; 5751 if ("ARS".equals(codeString)) 5752 return ARS; 5753 if ("AUD".equals(codeString)) 5754 return AUD; 5755 if ("AWG".equals(codeString)) 5756 return AWG; 5757 if ("AZN".equals(codeString)) 5758 return AZN; 5759 if ("BAM".equals(codeString)) 5760 return BAM; 5761 if ("BBD".equals(codeString)) 5762 return BBD; 5763 if ("BDT".equals(codeString)) 5764 return BDT; 5765 if ("BGN".equals(codeString)) 5766 return BGN; 5767 if ("BHD".equals(codeString)) 5768 return BHD; 5769 if ("BIF".equals(codeString)) 5770 return BIF; 5771 if ("BMD".equals(codeString)) 5772 return BMD; 5773 if ("BND".equals(codeString)) 5774 return BND; 5775 if ("BOB".equals(codeString)) 5776 return BOB; 5777 if ("BOV".equals(codeString)) 5778 return BOV; 5779 if ("BRL".equals(codeString)) 5780 return BRL; 5781 if ("BSD".equals(codeString)) 5782 return BSD; 5783 if ("BTN".equals(codeString)) 5784 return BTN; 5785 if ("BWP".equals(codeString)) 5786 return BWP; 5787 if ("BYN".equals(codeString)) 5788 return BYN; 5789 if ("BZD".equals(codeString)) 5790 return BZD; 5791 if ("CAD".equals(codeString)) 5792 return CAD; 5793 if ("CDF".equals(codeString)) 5794 return CDF; 5795 if ("CHE".equals(codeString)) 5796 return CHE; 5797 if ("CHF".equals(codeString)) 5798 return CHF; 5799 if ("CHW".equals(codeString)) 5800 return CHW; 5801 if ("CLF".equals(codeString)) 5802 return CLF; 5803 if ("CLP".equals(codeString)) 5804 return CLP; 5805 if ("CNY".equals(codeString)) 5806 return CNY; 5807 if ("COP".equals(codeString)) 5808 return COP; 5809 if ("COU".equals(codeString)) 5810 return COU; 5811 if ("CRC".equals(codeString)) 5812 return CRC; 5813 if ("CUC".equals(codeString)) 5814 return CUC; 5815 if ("CUP".equals(codeString)) 5816 return CUP; 5817 if ("CVE".equals(codeString)) 5818 return CVE; 5819 if ("CZK".equals(codeString)) 5820 return CZK; 5821 if ("DJF".equals(codeString)) 5822 return DJF; 5823 if ("DKK".equals(codeString)) 5824 return DKK; 5825 if ("DOP".equals(codeString)) 5826 return DOP; 5827 if ("DZD".equals(codeString)) 5828 return DZD; 5829 if ("EGP".equals(codeString)) 5830 return EGP; 5831 if ("ERN".equals(codeString)) 5832 return ERN; 5833 if ("ETB".equals(codeString)) 5834 return ETB; 5835 if ("EUR".equals(codeString)) 5836 return EUR; 5837 if ("FJD".equals(codeString)) 5838 return FJD; 5839 if ("FKP".equals(codeString)) 5840 return FKP; 5841 if ("GBP".equals(codeString)) 5842 return GBP; 5843 if ("GEL".equals(codeString)) 5844 return GEL; 5845 if ("GGP".equals(codeString)) 5846 return GGP; 5847 if ("GHS".equals(codeString)) 5848 return GHS; 5849 if ("GIP".equals(codeString)) 5850 return GIP; 5851 if ("GMD".equals(codeString)) 5852 return GMD; 5853 if ("GNF".equals(codeString)) 5854 return GNF; 5855 if ("GTQ".equals(codeString)) 5856 return GTQ; 5857 if ("GYD".equals(codeString)) 5858 return GYD; 5859 if ("HKD".equals(codeString)) 5860 return HKD; 5861 if ("HNL".equals(codeString)) 5862 return HNL; 5863 if ("HRK".equals(codeString)) 5864 return HRK; 5865 if ("HTG".equals(codeString)) 5866 return HTG; 5867 if ("HUF".equals(codeString)) 5868 return HUF; 5869 if ("IDR".equals(codeString)) 5870 return IDR; 5871 if ("ILS".equals(codeString)) 5872 return ILS; 5873 if ("IMP".equals(codeString)) 5874 return IMP; 5875 if ("INR".equals(codeString)) 5876 return INR; 5877 if ("IQD".equals(codeString)) 5878 return IQD; 5879 if ("IRR".equals(codeString)) 5880 return IRR; 5881 if ("ISK".equals(codeString)) 5882 return ISK; 5883 if ("JEP".equals(codeString)) 5884 return JEP; 5885 if ("JMD".equals(codeString)) 5886 return JMD; 5887 if ("JOD".equals(codeString)) 5888 return JOD; 5889 if ("JPY".equals(codeString)) 5890 return JPY; 5891 if ("KES".equals(codeString)) 5892 return KES; 5893 if ("KGS".equals(codeString)) 5894 return KGS; 5895 if ("KHR".equals(codeString)) 5896 return KHR; 5897 if ("KMF".equals(codeString)) 5898 return KMF; 5899 if ("KPW".equals(codeString)) 5900 return KPW; 5901 if ("KRW".equals(codeString)) 5902 return KRW; 5903 if ("KWD".equals(codeString)) 5904 return KWD; 5905 if ("KYD".equals(codeString)) 5906 return KYD; 5907 if ("KZT".equals(codeString)) 5908 return KZT; 5909 if ("LAK".equals(codeString)) 5910 return LAK; 5911 if ("LBP".equals(codeString)) 5912 return LBP; 5913 if ("LKR".equals(codeString)) 5914 return LKR; 5915 if ("LRD".equals(codeString)) 5916 return LRD; 5917 if ("LSL".equals(codeString)) 5918 return LSL; 5919 if ("LYD".equals(codeString)) 5920 return LYD; 5921 if ("MAD".equals(codeString)) 5922 return MAD; 5923 if ("MDL".equals(codeString)) 5924 return MDL; 5925 if ("MGA".equals(codeString)) 5926 return MGA; 5927 if ("MKD".equals(codeString)) 5928 return MKD; 5929 if ("MMK".equals(codeString)) 5930 return MMK; 5931 if ("MNT".equals(codeString)) 5932 return MNT; 5933 if ("MOP".equals(codeString)) 5934 return MOP; 5935 if ("MRU".equals(codeString)) 5936 return MRU; 5937 if ("MUR".equals(codeString)) 5938 return MUR; 5939 if ("MVR".equals(codeString)) 5940 return MVR; 5941 if ("MWK".equals(codeString)) 5942 return MWK; 5943 if ("MXN".equals(codeString)) 5944 return MXN; 5945 if ("MXV".equals(codeString)) 5946 return MXV; 5947 if ("MYR".equals(codeString)) 5948 return MYR; 5949 if ("MZN".equals(codeString)) 5950 return MZN; 5951 if ("NAD".equals(codeString)) 5952 return NAD; 5953 if ("NGN".equals(codeString)) 5954 return NGN; 5955 if ("NIO".equals(codeString)) 5956 return NIO; 5957 if ("NOK".equals(codeString)) 5958 return NOK; 5959 if ("NPR".equals(codeString)) 5960 return NPR; 5961 if ("NZD".equals(codeString)) 5962 return NZD; 5963 if ("OMR".equals(codeString)) 5964 return OMR; 5965 if ("PAB".equals(codeString)) 5966 return PAB; 5967 if ("PEN".equals(codeString)) 5968 return PEN; 5969 if ("PGK".equals(codeString)) 5970 return PGK; 5971 if ("PHP".equals(codeString)) 5972 return PHP; 5973 if ("PKR".equals(codeString)) 5974 return PKR; 5975 if ("PLN".equals(codeString)) 5976 return PLN; 5977 if ("PYG".equals(codeString)) 5978 return PYG; 5979 if ("QAR".equals(codeString)) 5980 return QAR; 5981 if ("RON".equals(codeString)) 5982 return RON; 5983 if ("RSD".equals(codeString)) 5984 return RSD; 5985 if ("RUB".equals(codeString)) 5986 return RUB; 5987 if ("RWF".equals(codeString)) 5988 return RWF; 5989 if ("SAR".equals(codeString)) 5990 return SAR; 5991 if ("SBD".equals(codeString)) 5992 return SBD; 5993 if ("SCR".equals(codeString)) 5994 return SCR; 5995 if ("SDG".equals(codeString)) 5996 return SDG; 5997 if ("SEK".equals(codeString)) 5998 return SEK; 5999 if ("SGD".equals(codeString)) 6000 return SGD; 6001 if ("SHP".equals(codeString)) 6002 return SHP; 6003 if ("SLL".equals(codeString)) 6004 return SLL; 6005 if ("SOS".equals(codeString)) 6006 return SOS; 6007 if ("SRD".equals(codeString)) 6008 return SRD; 6009 if ("SSP".equals(codeString)) 6010 return SSP; 6011 if ("STN".equals(codeString)) 6012 return STN; 6013 if ("SVC".equals(codeString)) 6014 return SVC; 6015 if ("SYP".equals(codeString)) 6016 return SYP; 6017 if ("SZL".equals(codeString)) 6018 return SZL; 6019 if ("THB".equals(codeString)) 6020 return THB; 6021 if ("TJS".equals(codeString)) 6022 return TJS; 6023 if ("TMT".equals(codeString)) 6024 return TMT; 6025 if ("TND".equals(codeString)) 6026 return TND; 6027 if ("TOP".equals(codeString)) 6028 return TOP; 6029 if ("TRY".equals(codeString)) 6030 return TRY; 6031 if ("TTD".equals(codeString)) 6032 return TTD; 6033 if ("TVD".equals(codeString)) 6034 return TVD; 6035 if ("TWD".equals(codeString)) 6036 return TWD; 6037 if ("TZS".equals(codeString)) 6038 return TZS; 6039 if ("UAH".equals(codeString)) 6040 return UAH; 6041 if ("UGX".equals(codeString)) 6042 return UGX; 6043 if ("USD".equals(codeString)) 6044 return USD; 6045 if ("USN".equals(codeString)) 6046 return USN; 6047 if ("UYI".equals(codeString)) 6048 return UYI; 6049 if ("UYU".equals(codeString)) 6050 return UYU; 6051 if ("UZS".equals(codeString)) 6052 return UZS; 6053 if ("VEF".equals(codeString)) 6054 return VEF; 6055 if ("VND".equals(codeString)) 6056 return VND; 6057 if ("VUV".equals(codeString)) 6058 return VUV; 6059 if ("WST".equals(codeString)) 6060 return WST; 6061 if ("XAF".equals(codeString)) 6062 return XAF; 6063 if ("XAG".equals(codeString)) 6064 return XAG; 6065 if ("XAU".equals(codeString)) 6066 return XAU; 6067 if ("XBA".equals(codeString)) 6068 return XBA; 6069 if ("XBB".equals(codeString)) 6070 return XBB; 6071 if ("XBC".equals(codeString)) 6072 return XBC; 6073 if ("XBD".equals(codeString)) 6074 return XBD; 6075 if ("XCD".equals(codeString)) 6076 return XCD; 6077 if ("XDR".equals(codeString)) 6078 return XDR; 6079 if ("XOF".equals(codeString)) 6080 return XOF; 6081 if ("XPD".equals(codeString)) 6082 return XPD; 6083 if ("XPF".equals(codeString)) 6084 return XPF; 6085 if ("XPT".equals(codeString)) 6086 return XPT; 6087 if ("XSU".equals(codeString)) 6088 return XSU; 6089 if ("XTS".equals(codeString)) 6090 return XTS; 6091 if ("XUA".equals(codeString)) 6092 return XUA; 6093 if ("XXX".equals(codeString)) 6094 return XXX; 6095 if ("YER".equals(codeString)) 6096 return YER; 6097 if ("ZAR".equals(codeString)) 6098 return ZAR; 6099 if ("ZMW".equals(codeString)) 6100 return ZMW; 6101 if ("ZWL".equals(codeString)) 6102 return ZWL; 6103 throw new FHIRException("Unknown Currencies code '"+codeString+"'"); 6104 } 6105 public String toCode() { 6106 switch (this) { 6107 case AED: return "AED"; 6108 case AFN: return "AFN"; 6109 case ALL: return "ALL"; 6110 case AMD: return "AMD"; 6111 case ANG: return "ANG"; 6112 case AOA: return "AOA"; 6113 case ARS: return "ARS"; 6114 case AUD: return "AUD"; 6115 case AWG: return "AWG"; 6116 case AZN: return "AZN"; 6117 case BAM: return "BAM"; 6118 case BBD: return "BBD"; 6119 case BDT: return "BDT"; 6120 case BGN: return "BGN"; 6121 case BHD: return "BHD"; 6122 case BIF: return "BIF"; 6123 case BMD: return "BMD"; 6124 case BND: return "BND"; 6125 case BOB: return "BOB"; 6126 case BOV: return "BOV"; 6127 case BRL: return "BRL"; 6128 case BSD: return "BSD"; 6129 case BTN: return "BTN"; 6130 case BWP: return "BWP"; 6131 case BYN: return "BYN"; 6132 case BZD: return "BZD"; 6133 case CAD: return "CAD"; 6134 case CDF: return "CDF"; 6135 case CHE: return "CHE"; 6136 case CHF: return "CHF"; 6137 case CHW: return "CHW"; 6138 case CLF: return "CLF"; 6139 case CLP: return "CLP"; 6140 case CNY: return "CNY"; 6141 case COP: return "COP"; 6142 case COU: return "COU"; 6143 case CRC: return "CRC"; 6144 case CUC: return "CUC"; 6145 case CUP: return "CUP"; 6146 case CVE: return "CVE"; 6147 case CZK: return "CZK"; 6148 case DJF: return "DJF"; 6149 case DKK: return "DKK"; 6150 case DOP: return "DOP"; 6151 case DZD: return "DZD"; 6152 case EGP: return "EGP"; 6153 case ERN: return "ERN"; 6154 case ETB: return "ETB"; 6155 case EUR: return "EUR"; 6156 case FJD: return "FJD"; 6157 case FKP: return "FKP"; 6158 case GBP: return "GBP"; 6159 case GEL: return "GEL"; 6160 case GGP: return "GGP"; 6161 case GHS: return "GHS"; 6162 case GIP: return "GIP"; 6163 case GMD: return "GMD"; 6164 case GNF: return "GNF"; 6165 case GTQ: return "GTQ"; 6166 case GYD: return "GYD"; 6167 case HKD: return "HKD"; 6168 case HNL: return "HNL"; 6169 case HRK: return "HRK"; 6170 case HTG: return "HTG"; 6171 case HUF: return "HUF"; 6172 case IDR: return "IDR"; 6173 case ILS: return "ILS"; 6174 case IMP: return "IMP"; 6175 case INR: return "INR"; 6176 case IQD: return "IQD"; 6177 case IRR: return "IRR"; 6178 case ISK: return "ISK"; 6179 case JEP: return "JEP"; 6180 case JMD: return "JMD"; 6181 case JOD: return "JOD"; 6182 case JPY: return "JPY"; 6183 case KES: return "KES"; 6184 case KGS: return "KGS"; 6185 case KHR: return "KHR"; 6186 case KMF: return "KMF"; 6187 case KPW: return "KPW"; 6188 case KRW: return "KRW"; 6189 case KWD: return "KWD"; 6190 case KYD: return "KYD"; 6191 case KZT: return "KZT"; 6192 case LAK: return "LAK"; 6193 case LBP: return "LBP"; 6194 case LKR: return "LKR"; 6195 case LRD: return "LRD"; 6196 case LSL: return "LSL"; 6197 case LYD: return "LYD"; 6198 case MAD: return "MAD"; 6199 case MDL: return "MDL"; 6200 case MGA: return "MGA"; 6201 case MKD: return "MKD"; 6202 case MMK: return "MMK"; 6203 case MNT: return "MNT"; 6204 case MOP: return "MOP"; 6205 case MRU: return "MRU"; 6206 case MUR: return "MUR"; 6207 case MVR: return "MVR"; 6208 case MWK: return "MWK"; 6209 case MXN: return "MXN"; 6210 case MXV: return "MXV"; 6211 case MYR: return "MYR"; 6212 case MZN: return "MZN"; 6213 case NAD: return "NAD"; 6214 case NGN: return "NGN"; 6215 case NIO: return "NIO"; 6216 case NOK: return "NOK"; 6217 case NPR: return "NPR"; 6218 case NZD: return "NZD"; 6219 case OMR: return "OMR"; 6220 case PAB: return "PAB"; 6221 case PEN: return "PEN"; 6222 case PGK: return "PGK"; 6223 case PHP: return "PHP"; 6224 case PKR: return "PKR"; 6225 case PLN: return "PLN"; 6226 case PYG: return "PYG"; 6227 case QAR: return "QAR"; 6228 case RON: return "RON"; 6229 case RSD: return "RSD"; 6230 case RUB: return "RUB"; 6231 case RWF: return "RWF"; 6232 case SAR: return "SAR"; 6233 case SBD: return "SBD"; 6234 case SCR: return "SCR"; 6235 case SDG: return "SDG"; 6236 case SEK: return "SEK"; 6237 case SGD: return "SGD"; 6238 case SHP: return "SHP"; 6239 case SLL: return "SLL"; 6240 case SOS: return "SOS"; 6241 case SRD: return "SRD"; 6242 case SSP: return "SSP"; 6243 case STN: return "STN"; 6244 case SVC: return "SVC"; 6245 case SYP: return "SYP"; 6246 case SZL: return "SZL"; 6247 case THB: return "THB"; 6248 case TJS: return "TJS"; 6249 case TMT: return "TMT"; 6250 case TND: return "TND"; 6251 case TOP: return "TOP"; 6252 case TRY: return "TRY"; 6253 case TTD: return "TTD"; 6254 case TVD: return "TVD"; 6255 case TWD: return "TWD"; 6256 case TZS: return "TZS"; 6257 case UAH: return "UAH"; 6258 case UGX: return "UGX"; 6259 case USD: return "USD"; 6260 case USN: return "USN"; 6261 case UYI: return "UYI"; 6262 case UYU: return "UYU"; 6263 case UZS: return "UZS"; 6264 case VEF: return "VEF"; 6265 case VND: return "VND"; 6266 case VUV: return "VUV"; 6267 case WST: return "WST"; 6268 case XAF: return "XAF"; 6269 case XAG: return "XAG"; 6270 case XAU: return "XAU"; 6271 case XBA: return "XBA"; 6272 case XBB: return "XBB"; 6273 case XBC: return "XBC"; 6274 case XBD: return "XBD"; 6275 case XCD: return "XCD"; 6276 case XDR: return "XDR"; 6277 case XOF: return "XOF"; 6278 case XPD: return "XPD"; 6279 case XPF: return "XPF"; 6280 case XPT: return "XPT"; 6281 case XSU: return "XSU"; 6282 case XTS: return "XTS"; 6283 case XUA: return "XUA"; 6284 case XXX: return "XXX"; 6285 case YER: return "YER"; 6286 case ZAR: return "ZAR"; 6287 case ZMW: return "ZMW"; 6288 case ZWL: return "ZWL"; 6289 case NULL: return null; 6290 default: return "?"; 6291 } 6292 } 6293 public String getSystem() { 6294 switch (this) { 6295 case AED: return "urn:iso:std:iso:4217"; 6296 case AFN: return "urn:iso:std:iso:4217"; 6297 case ALL: return "urn:iso:std:iso:4217"; 6298 case AMD: return "urn:iso:std:iso:4217"; 6299 case ANG: return "urn:iso:std:iso:4217"; 6300 case AOA: return "urn:iso:std:iso:4217"; 6301 case ARS: return "urn:iso:std:iso:4217"; 6302 case AUD: return "urn:iso:std:iso:4217"; 6303 case AWG: return "urn:iso:std:iso:4217"; 6304 case AZN: return "urn:iso:std:iso:4217"; 6305 case BAM: return "urn:iso:std:iso:4217"; 6306 case BBD: return "urn:iso:std:iso:4217"; 6307 case BDT: return "urn:iso:std:iso:4217"; 6308 case BGN: return "urn:iso:std:iso:4217"; 6309 case BHD: return "urn:iso:std:iso:4217"; 6310 case BIF: return "urn:iso:std:iso:4217"; 6311 case BMD: return "urn:iso:std:iso:4217"; 6312 case BND: return "urn:iso:std:iso:4217"; 6313 case BOB: return "urn:iso:std:iso:4217"; 6314 case BOV: return "urn:iso:std:iso:4217"; 6315 case BRL: return "urn:iso:std:iso:4217"; 6316 case BSD: return "urn:iso:std:iso:4217"; 6317 case BTN: return "urn:iso:std:iso:4217"; 6318 case BWP: return "urn:iso:std:iso:4217"; 6319 case BYN: return "urn:iso:std:iso:4217"; 6320 case BZD: return "urn:iso:std:iso:4217"; 6321 case CAD: return "urn:iso:std:iso:4217"; 6322 case CDF: return "urn:iso:std:iso:4217"; 6323 case CHE: return "urn:iso:std:iso:4217"; 6324 case CHF: return "urn:iso:std:iso:4217"; 6325 case CHW: return "urn:iso:std:iso:4217"; 6326 case CLF: return "urn:iso:std:iso:4217"; 6327 case CLP: return "urn:iso:std:iso:4217"; 6328 case CNY: return "urn:iso:std:iso:4217"; 6329 case COP: return "urn:iso:std:iso:4217"; 6330 case COU: return "urn:iso:std:iso:4217"; 6331 case CRC: return "urn:iso:std:iso:4217"; 6332 case CUC: return "urn:iso:std:iso:4217"; 6333 case CUP: return "urn:iso:std:iso:4217"; 6334 case CVE: return "urn:iso:std:iso:4217"; 6335 case CZK: return "urn:iso:std:iso:4217"; 6336 case DJF: return "urn:iso:std:iso:4217"; 6337 case DKK: return "urn:iso:std:iso:4217"; 6338 case DOP: return "urn:iso:std:iso:4217"; 6339 case DZD: return "urn:iso:std:iso:4217"; 6340 case EGP: return "urn:iso:std:iso:4217"; 6341 case ERN: return "urn:iso:std:iso:4217"; 6342 case ETB: return "urn:iso:std:iso:4217"; 6343 case EUR: return "urn:iso:std:iso:4217"; 6344 case FJD: return "urn:iso:std:iso:4217"; 6345 case FKP: return "urn:iso:std:iso:4217"; 6346 case GBP: return "urn:iso:std:iso:4217"; 6347 case GEL: return "urn:iso:std:iso:4217"; 6348 case GGP: return "urn:iso:std:iso:4217"; 6349 case GHS: return "urn:iso:std:iso:4217"; 6350 case GIP: return "urn:iso:std:iso:4217"; 6351 case GMD: return "urn:iso:std:iso:4217"; 6352 case GNF: return "urn:iso:std:iso:4217"; 6353 case GTQ: return "urn:iso:std:iso:4217"; 6354 case GYD: return "urn:iso:std:iso:4217"; 6355 case HKD: return "urn:iso:std:iso:4217"; 6356 case HNL: return "urn:iso:std:iso:4217"; 6357 case HRK: return "urn:iso:std:iso:4217"; 6358 case HTG: return "urn:iso:std:iso:4217"; 6359 case HUF: return "urn:iso:std:iso:4217"; 6360 case IDR: return "urn:iso:std:iso:4217"; 6361 case ILS: return "urn:iso:std:iso:4217"; 6362 case IMP: return "urn:iso:std:iso:4217"; 6363 case INR: return "urn:iso:std:iso:4217"; 6364 case IQD: return "urn:iso:std:iso:4217"; 6365 case IRR: return "urn:iso:std:iso:4217"; 6366 case ISK: return "urn:iso:std:iso:4217"; 6367 case JEP: return "urn:iso:std:iso:4217"; 6368 case JMD: return "urn:iso:std:iso:4217"; 6369 case JOD: return "urn:iso:std:iso:4217"; 6370 case JPY: return "urn:iso:std:iso:4217"; 6371 case KES: return "urn:iso:std:iso:4217"; 6372 case KGS: return "urn:iso:std:iso:4217"; 6373 case KHR: return "urn:iso:std:iso:4217"; 6374 case KMF: return "urn:iso:std:iso:4217"; 6375 case KPW: return "urn:iso:std:iso:4217"; 6376 case KRW: return "urn:iso:std:iso:4217"; 6377 case KWD: return "urn:iso:std:iso:4217"; 6378 case KYD: return "urn:iso:std:iso:4217"; 6379 case KZT: return "urn:iso:std:iso:4217"; 6380 case LAK: return "urn:iso:std:iso:4217"; 6381 case LBP: return "urn:iso:std:iso:4217"; 6382 case LKR: return "urn:iso:std:iso:4217"; 6383 case LRD: return "urn:iso:std:iso:4217"; 6384 case LSL: return "urn:iso:std:iso:4217"; 6385 case LYD: return "urn:iso:std:iso:4217"; 6386 case MAD: return "urn:iso:std:iso:4217"; 6387 case MDL: return "urn:iso:std:iso:4217"; 6388 case MGA: return "urn:iso:std:iso:4217"; 6389 case MKD: return "urn:iso:std:iso:4217"; 6390 case MMK: return "urn:iso:std:iso:4217"; 6391 case MNT: return "urn:iso:std:iso:4217"; 6392 case MOP: return "urn:iso:std:iso:4217"; 6393 case MRU: return "urn:iso:std:iso:4217"; 6394 case MUR: return "urn:iso:std:iso:4217"; 6395 case MVR: return "urn:iso:std:iso:4217"; 6396 case MWK: return "urn:iso:std:iso:4217"; 6397 case MXN: return "urn:iso:std:iso:4217"; 6398 case MXV: return "urn:iso:std:iso:4217"; 6399 case MYR: return "urn:iso:std:iso:4217"; 6400 case MZN: return "urn:iso:std:iso:4217"; 6401 case NAD: return "urn:iso:std:iso:4217"; 6402 case NGN: return "urn:iso:std:iso:4217"; 6403 case NIO: return "urn:iso:std:iso:4217"; 6404 case NOK: return "urn:iso:std:iso:4217"; 6405 case NPR: return "urn:iso:std:iso:4217"; 6406 case NZD: return "urn:iso:std:iso:4217"; 6407 case OMR: return "urn:iso:std:iso:4217"; 6408 case PAB: return "urn:iso:std:iso:4217"; 6409 case PEN: return "urn:iso:std:iso:4217"; 6410 case PGK: return "urn:iso:std:iso:4217"; 6411 case PHP: return "urn:iso:std:iso:4217"; 6412 case PKR: return "urn:iso:std:iso:4217"; 6413 case PLN: return "urn:iso:std:iso:4217"; 6414 case PYG: return "urn:iso:std:iso:4217"; 6415 case QAR: return "urn:iso:std:iso:4217"; 6416 case RON: return "urn:iso:std:iso:4217"; 6417 case RSD: return "urn:iso:std:iso:4217"; 6418 case RUB: return "urn:iso:std:iso:4217"; 6419 case RWF: return "urn:iso:std:iso:4217"; 6420 case SAR: return "urn:iso:std:iso:4217"; 6421 case SBD: return "urn:iso:std:iso:4217"; 6422 case SCR: return "urn:iso:std:iso:4217"; 6423 case SDG: return "urn:iso:std:iso:4217"; 6424 case SEK: return "urn:iso:std:iso:4217"; 6425 case SGD: return "urn:iso:std:iso:4217"; 6426 case SHP: return "urn:iso:std:iso:4217"; 6427 case SLL: return "urn:iso:std:iso:4217"; 6428 case SOS: return "urn:iso:std:iso:4217"; 6429 case SRD: return "urn:iso:std:iso:4217"; 6430 case SSP: return "urn:iso:std:iso:4217"; 6431 case STN: return "urn:iso:std:iso:4217"; 6432 case SVC: return "urn:iso:std:iso:4217"; 6433 case SYP: return "urn:iso:std:iso:4217"; 6434 case SZL: return "urn:iso:std:iso:4217"; 6435 case THB: return "urn:iso:std:iso:4217"; 6436 case TJS: return "urn:iso:std:iso:4217"; 6437 case TMT: return "urn:iso:std:iso:4217"; 6438 case TND: return "urn:iso:std:iso:4217"; 6439 case TOP: return "urn:iso:std:iso:4217"; 6440 case TRY: return "urn:iso:std:iso:4217"; 6441 case TTD: return "urn:iso:std:iso:4217"; 6442 case TVD: return "urn:iso:std:iso:4217"; 6443 case TWD: return "urn:iso:std:iso:4217"; 6444 case TZS: return "urn:iso:std:iso:4217"; 6445 case UAH: return "urn:iso:std:iso:4217"; 6446 case UGX: return "urn:iso:std:iso:4217"; 6447 case USD: return "urn:iso:std:iso:4217"; 6448 case USN: return "urn:iso:std:iso:4217"; 6449 case UYI: return "urn:iso:std:iso:4217"; 6450 case UYU: return "urn:iso:std:iso:4217"; 6451 case UZS: return "urn:iso:std:iso:4217"; 6452 case VEF: return "urn:iso:std:iso:4217"; 6453 case VND: return "urn:iso:std:iso:4217"; 6454 case VUV: return "urn:iso:std:iso:4217"; 6455 case WST: return "urn:iso:std:iso:4217"; 6456 case XAF: return "urn:iso:std:iso:4217"; 6457 case XAG: return "urn:iso:std:iso:4217"; 6458 case XAU: return "urn:iso:std:iso:4217"; 6459 case XBA: return "urn:iso:std:iso:4217"; 6460 case XBB: return "urn:iso:std:iso:4217"; 6461 case XBC: return "urn:iso:std:iso:4217"; 6462 case XBD: return "urn:iso:std:iso:4217"; 6463 case XCD: return "urn:iso:std:iso:4217"; 6464 case XDR: return "urn:iso:std:iso:4217"; 6465 case XOF: return "urn:iso:std:iso:4217"; 6466 case XPD: return "urn:iso:std:iso:4217"; 6467 case XPF: return "urn:iso:std:iso:4217"; 6468 case XPT: return "urn:iso:std:iso:4217"; 6469 case XSU: return "urn:iso:std:iso:4217"; 6470 case XTS: return "urn:iso:std:iso:4217"; 6471 case XUA: return "urn:iso:std:iso:4217"; 6472 case XXX: return "urn:iso:std:iso:4217"; 6473 case YER: return "urn:iso:std:iso:4217"; 6474 case ZAR: return "urn:iso:std:iso:4217"; 6475 case ZMW: return "urn:iso:std:iso:4217"; 6476 case ZWL: return "urn:iso:std:iso:4217"; 6477 case NULL: return null; 6478 default: return "?"; 6479 } 6480 } 6481 public String getDefinition() { 6482 switch (this) { 6483 case AED: return ""; 6484 case AFN: return ""; 6485 case ALL: return ""; 6486 case AMD: return ""; 6487 case ANG: return ""; 6488 case AOA: return ""; 6489 case ARS: return ""; 6490 case AUD: return ""; 6491 case AWG: return ""; 6492 case AZN: return ""; 6493 case BAM: return ""; 6494 case BBD: return ""; 6495 case BDT: return ""; 6496 case BGN: return ""; 6497 case BHD: return ""; 6498 case BIF: return ""; 6499 case BMD: return ""; 6500 case BND: return ""; 6501 case BOB: return ""; 6502 case BOV: return ""; 6503 case BRL: return ""; 6504 case BSD: return ""; 6505 case BTN: return ""; 6506 case BWP: return ""; 6507 case BYN: return ""; 6508 case BZD: return ""; 6509 case CAD: return ""; 6510 case CDF: return ""; 6511 case CHE: return ""; 6512 case CHF: return ""; 6513 case CHW: return ""; 6514 case CLF: return ""; 6515 case CLP: return ""; 6516 case CNY: return ""; 6517 case COP: return ""; 6518 case COU: return ""; 6519 case CRC: return ""; 6520 case CUC: return ""; 6521 case CUP: return ""; 6522 case CVE: return ""; 6523 case CZK: return ""; 6524 case DJF: return ""; 6525 case DKK: return ""; 6526 case DOP: return ""; 6527 case DZD: return ""; 6528 case EGP: return ""; 6529 case ERN: return ""; 6530 case ETB: return ""; 6531 case EUR: return ""; 6532 case FJD: return ""; 6533 case FKP: return ""; 6534 case GBP: return ""; 6535 case GEL: return ""; 6536 case GGP: return ""; 6537 case GHS: return ""; 6538 case GIP: return ""; 6539 case GMD: return ""; 6540 case GNF: return ""; 6541 case GTQ: return ""; 6542 case GYD: return ""; 6543 case HKD: return ""; 6544 case HNL: return ""; 6545 case HRK: return ""; 6546 case HTG: return ""; 6547 case HUF: return ""; 6548 case IDR: return ""; 6549 case ILS: return ""; 6550 case IMP: return ""; 6551 case INR: return ""; 6552 case IQD: return ""; 6553 case IRR: return ""; 6554 case ISK: return ""; 6555 case JEP: return ""; 6556 case JMD: return ""; 6557 case JOD: return ""; 6558 case JPY: return ""; 6559 case KES: return ""; 6560 case KGS: return ""; 6561 case KHR: return ""; 6562 case KMF: return ""; 6563 case KPW: return ""; 6564 case KRW: return ""; 6565 case KWD: return ""; 6566 case KYD: return ""; 6567 case KZT: return ""; 6568 case LAK: return ""; 6569 case LBP: return ""; 6570 case LKR: return ""; 6571 case LRD: return ""; 6572 case LSL: return ""; 6573 case LYD: return ""; 6574 case MAD: return ""; 6575 case MDL: return ""; 6576 case MGA: return ""; 6577 case MKD: return ""; 6578 case MMK: return ""; 6579 case MNT: return ""; 6580 case MOP: return ""; 6581 case MRU: return ""; 6582 case MUR: return ""; 6583 case MVR: return ""; 6584 case MWK: return ""; 6585 case MXN: return ""; 6586 case MXV: return ""; 6587 case MYR: return ""; 6588 case MZN: return ""; 6589 case NAD: return ""; 6590 case NGN: return ""; 6591 case NIO: return ""; 6592 case NOK: return ""; 6593 case NPR: return ""; 6594 case NZD: return ""; 6595 case OMR: return ""; 6596 case PAB: return ""; 6597 case PEN: return ""; 6598 case PGK: return ""; 6599 case PHP: return ""; 6600 case PKR: return ""; 6601 case PLN: return ""; 6602 case PYG: return ""; 6603 case QAR: return ""; 6604 case RON: return ""; 6605 case RSD: return ""; 6606 case RUB: return ""; 6607 case RWF: return ""; 6608 case SAR: return ""; 6609 case SBD: return ""; 6610 case SCR: return ""; 6611 case SDG: return ""; 6612 case SEK: return ""; 6613 case SGD: return ""; 6614 case SHP: return ""; 6615 case SLL: return ""; 6616 case SOS: return ""; 6617 case SRD: return ""; 6618 case SSP: return ""; 6619 case STN: return ""; 6620 case SVC: return ""; 6621 case SYP: return ""; 6622 case SZL: return ""; 6623 case THB: return ""; 6624 case TJS: return ""; 6625 case TMT: return ""; 6626 case TND: return ""; 6627 case TOP: return ""; 6628 case TRY: return ""; 6629 case TTD: return ""; 6630 case TVD: return ""; 6631 case TWD: return ""; 6632 case TZS: return ""; 6633 case UAH: return ""; 6634 case UGX: return ""; 6635 case USD: return ""; 6636 case USN: return ""; 6637 case UYI: return ""; 6638 case UYU: return ""; 6639 case UZS: return ""; 6640 case VEF: return ""; 6641 case VND: return ""; 6642 case VUV: return ""; 6643 case WST: return ""; 6644 case XAF: return ""; 6645 case XAG: return ""; 6646 case XAU: return ""; 6647 case XBA: return ""; 6648 case XBB: return ""; 6649 case XBC: return ""; 6650 case XBD: return ""; 6651 case XCD: return ""; 6652 case XDR: return ""; 6653 case XOF: return ""; 6654 case XPD: return ""; 6655 case XPF: return ""; 6656 case XPT: return ""; 6657 case XSU: return ""; 6658 case XTS: return ""; 6659 case XUA: return ""; 6660 case XXX: return ""; 6661 case YER: return ""; 6662 case ZAR: return ""; 6663 case ZMW: return ""; 6664 case ZWL: return ""; 6665 case NULL: return null; 6666 default: return "?"; 6667 } 6668 } 6669 public String getDisplay() { 6670 switch (this) { 6671 case AED: return "United Arab Emirates dirham"; 6672 case AFN: return "Afghan afghani"; 6673 case ALL: return "Albanian lek"; 6674 case AMD: return "Armenian dram"; 6675 case ANG: return "Netherlands Antillean guilder"; 6676 case AOA: return "Angolan kwanza"; 6677 case ARS: return "Argentine peso"; 6678 case AUD: return "Australian dollar"; 6679 case AWG: return "Aruban florin"; 6680 case AZN: return "Azerbaijani manat"; 6681 case BAM: return "Bosnia and Herzegovina convertible mark"; 6682 case BBD: return "Barbados dollar"; 6683 case BDT: return "Bangladeshi taka"; 6684 case BGN: return "Bulgarian lev"; 6685 case BHD: return "Bahraini dinar"; 6686 case BIF: return "Burundian franc"; 6687 case BMD: return "Bermudian dollar"; 6688 case BND: return "Brunei dollar"; 6689 case BOB: return "Boliviano"; 6690 case BOV: return "Bolivian Mvdol (funds code)"; 6691 case BRL: return "Brazilian real"; 6692 case BSD: return "Bahamian dollar"; 6693 case BTN: return "Bhutanese ngultrum"; 6694 case BWP: return "Botswana pula"; 6695 case BYN: return "Belarusian ruble"; 6696 case BZD: return "Belize dollar"; 6697 case CAD: return "Canadian dollar"; 6698 case CDF: return "Congolese franc"; 6699 case CHE: return "WIR Euro (complementary currency)"; 6700 case CHF: return "Swiss franc"; 6701 case CHW: return "WIR Franc (complementary currency)"; 6702 case CLF: return "Unidad de Fomento (funds code)"; 6703 case CLP: return "Chilean peso"; 6704 case CNY: return "Renminbi (Chinese) yuan[8]"; 6705 case COP: return "Colombian peso"; 6706 case COU: return "Unidad de Valor Real (UVR) (funds code)[9]"; 6707 case CRC: return "Costa Rican colon"; 6708 case CUC: return "Cuban convertible peso"; 6709 case CUP: return "Cuban peso"; 6710 case CVE: return "Cape Verde escudo"; 6711 case CZK: return "Czech koruna"; 6712 case DJF: return "Djiboutian franc"; 6713 case DKK: return "Danish krone"; 6714 case DOP: return "Dominican peso"; 6715 case DZD: return "Algerian dinar"; 6716 case EGP: return "Egyptian pound"; 6717 case ERN: return "Eritrean nakfa"; 6718 case ETB: return "Ethiopian birr"; 6719 case EUR: return "Euro"; 6720 case FJD: return "Fiji dollar"; 6721 case FKP: return "Falkland Islands pound"; 6722 case GBP: return "Pound sterling"; 6723 case GEL: return "Georgian lari"; 6724 case GGP: return "Guernsey Pound"; 6725 case GHS: return "Ghanaian cedi"; 6726 case GIP: return "Gibraltar pound"; 6727 case GMD: return "Gambian dalasi"; 6728 case GNF: return "Guinean franc"; 6729 case GTQ: return "Guatemalan quetzal"; 6730 case GYD: return "Guyanese dollar"; 6731 case HKD: return "Hong Kong dollar"; 6732 case HNL: return "Honduran lempira"; 6733 case HRK: return "Croatian kuna"; 6734 case HTG: return "Haitian gourde"; 6735 case HUF: return "Hungarian forint"; 6736 case IDR: return "Indonesian rupiah"; 6737 case ILS: return "Israeli new shekel"; 6738 case IMP: return "Isle of Man Pound"; 6739 case INR: return "Indian rupee"; 6740 case IQD: return "Iraqi dinar"; 6741 case IRR: return "Iranian rial"; 6742 case ISK: return "Icelandic króna"; 6743 case JEP: return "Jersey Pound"; 6744 case JMD: return "Jamaican dollar"; 6745 case JOD: return "Jordanian dinar"; 6746 case JPY: return "Japanese yen"; 6747 case KES: return "Kenyan shilling"; 6748 case KGS: return "Kyrgyzstani som"; 6749 case KHR: return "Cambodian riel"; 6750 case KMF: return "Comoro franc"; 6751 case KPW: return "North Korean won"; 6752 case KRW: return "South Korean won"; 6753 case KWD: return "Kuwaiti dinar"; 6754 case KYD: return "Cayman Islands dollar"; 6755 case KZT: return "Kazakhstani tenge"; 6756 case LAK: return "Lao kip"; 6757 case LBP: return "Lebanese pound"; 6758 case LKR: return "Sri Lankan rupee"; 6759 case LRD: return "Liberian dollar"; 6760 case LSL: return "Lesotho loti"; 6761 case LYD: return "Libyan dinar"; 6762 case MAD: return "Moroccan dirham"; 6763 case MDL: return "Moldovan leu"; 6764 case MGA: return "Malagasy ariary"; 6765 case MKD: return "Macedonian denar"; 6766 case MMK: return "Myanmar kyat"; 6767 case MNT: return "Mongolian tögrög"; 6768 case MOP: return "Macanese pataca"; 6769 case MRU: return "Mauritanian ouguiya"; 6770 case MUR: return "Mauritian rupee"; 6771 case MVR: return "Maldivian rufiyaa"; 6772 case MWK: return "Malawian kwacha"; 6773 case MXN: return "Mexican peso"; 6774 case MXV: return "Mexican Unidad de Inversion (UDI) (funds code)"; 6775 case MYR: return "Malaysian ringgit"; 6776 case MZN: return "Mozambican metical"; 6777 case NAD: return "Namibian dollar"; 6778 case NGN: return "Nigerian naira"; 6779 case NIO: return "Nicaraguan córdoba"; 6780 case NOK: return "Norwegian krone"; 6781 case NPR: return "Nepalese rupee"; 6782 case NZD: return "New Zealand dollar"; 6783 case OMR: return "Omani rial"; 6784 case PAB: return "Panamanian balboa"; 6785 case PEN: return "Peruvian Sol"; 6786 case PGK: return "Papua New Guinean kina"; 6787 case PHP: return "Philippine piso[13]"; 6788 case PKR: return "Pakistani rupee"; 6789 case PLN: return "Polish z?oty"; 6790 case PYG: return "Paraguayan guaraní"; 6791 case QAR: return "Qatari riyal"; 6792 case RON: return "Romanian leu"; 6793 case RSD: return "Serbian dinar"; 6794 case RUB: return "Russian ruble"; 6795 case RWF: return "Rwandan franc"; 6796 case SAR: return "Saudi riyal"; 6797 case SBD: return "Solomon Islands dollar"; 6798 case SCR: return "Seychelles rupee"; 6799 case SDG: return "Sudanese pound"; 6800 case SEK: return "Swedish krona/kronor"; 6801 case SGD: return "Singapore dollar"; 6802 case SHP: return "Saint Helena pound"; 6803 case SLL: return "Sierra Leonean leone"; 6804 case SOS: return "Somali shilling"; 6805 case SRD: return "Surinamese dollar"; 6806 case SSP: return "South Sudanese pound"; 6807 case STN: return "São Tomé and Príncipe dobra"; 6808 case SVC: return "Salvadoran colón"; 6809 case SYP: return "Syrian pound"; 6810 case SZL: return "Swazi lilangeni"; 6811 case THB: return "Thai baht"; 6812 case TJS: return "Tajikistani somoni"; 6813 case TMT: return "Turkmenistan manat"; 6814 case TND: return "Tunisian dinar"; 6815 case TOP: return "Tongan pa?anga"; 6816 case TRY: return "Turkish lira"; 6817 case TTD: return "Trinidad and Tobago dollar"; 6818 case TVD: return "Tuvalu Dollar"; 6819 case TWD: return "New Taiwan dollar"; 6820 case TZS: return "Tanzanian shilling"; 6821 case UAH: return "Ukrainian hryvnia"; 6822 case UGX: return "Ugandan shilling"; 6823 case USD: return "United States dollar"; 6824 case USN: return "United States dollar (next day) (funds code)"; 6825 case UYI: return "Uruguay Peso en Unidades Indexadas (URUIURUI) (funds code)"; 6826 case UYU: return "Uruguayan peso"; 6827 case UZS: return "Uzbekistan som"; 6828 case VEF: return "Venezuelan bolívar"; 6829 case VND: return "Vietnamese ??ng"; 6830 case VUV: return "Vanuatu vatu"; 6831 case WST: return "Samoan tala"; 6832 case XAF: return "CFA franc BEAC"; 6833 case XAG: return "Silver (one troy ounce)"; 6834 case XAU: return "Gold (one troy ounce)"; 6835 case XBA: return "European Composite Unit (EURCO) (bond market unit)"; 6836 case XBB: return "European Monetary Unit (E.M.U.-6) (bond market unit)"; 6837 case XBC: return "European Unit of Account 9 (E.U.A.-9) (bond market unit)"; 6838 case XBD: return "European Unit of Account 17 (E.U.A.-17) (bond market unit)"; 6839 case XCD: return "East Caribbean dollar"; 6840 case XDR: return "Special drawing rights"; 6841 case XOF: return "CFA franc BCEAO"; 6842 case XPD: return "Palladium (one troy ounce)"; 6843 case XPF: return "CFP franc (franc Pacifique)"; 6844 case XPT: return "Platinum (one troy ounce)"; 6845 case XSU: return "SUCRE"; 6846 case XTS: return "Code reserved for testing purposes"; 6847 case XUA: return "ADB Unit of Account"; 6848 case XXX: return "No currency"; 6849 case YER: return "Yemeni rial"; 6850 case ZAR: return "South African rand"; 6851 case ZMW: return "Zambian kwacha"; 6852 case ZWL: return "Zimbabwean dollar A/10"; 6853 case NULL: return null; 6854 default: return "?"; 6855 } 6856 } 6857 } 6858 6859 public static class CurrenciesEnumFactory implements EnumFactory<Currencies> { 6860 public Currencies fromCode(String codeString) throws IllegalArgumentException { 6861 if (codeString == null || "".equals(codeString)) 6862 if (codeString == null || "".equals(codeString)) 6863 return null; 6864 if ("AED".equals(codeString)) 6865 return Currencies.AED; 6866 if ("AFN".equals(codeString)) 6867 return Currencies.AFN; 6868 if ("ALL".equals(codeString)) 6869 return Currencies.ALL; 6870 if ("AMD".equals(codeString)) 6871 return Currencies.AMD; 6872 if ("ANG".equals(codeString)) 6873 return Currencies.ANG; 6874 if ("AOA".equals(codeString)) 6875 return Currencies.AOA; 6876 if ("ARS".equals(codeString)) 6877 return Currencies.ARS; 6878 if ("AUD".equals(codeString)) 6879 return Currencies.AUD; 6880 if ("AWG".equals(codeString)) 6881 return Currencies.AWG; 6882 if ("AZN".equals(codeString)) 6883 return Currencies.AZN; 6884 if ("BAM".equals(codeString)) 6885 return Currencies.BAM; 6886 if ("BBD".equals(codeString)) 6887 return Currencies.BBD; 6888 if ("BDT".equals(codeString)) 6889 return Currencies.BDT; 6890 if ("BGN".equals(codeString)) 6891 return Currencies.BGN; 6892 if ("BHD".equals(codeString)) 6893 return Currencies.BHD; 6894 if ("BIF".equals(codeString)) 6895 return Currencies.BIF; 6896 if ("BMD".equals(codeString)) 6897 return Currencies.BMD; 6898 if ("BND".equals(codeString)) 6899 return Currencies.BND; 6900 if ("BOB".equals(codeString)) 6901 return Currencies.BOB; 6902 if ("BOV".equals(codeString)) 6903 return Currencies.BOV; 6904 if ("BRL".equals(codeString)) 6905 return Currencies.BRL; 6906 if ("BSD".equals(codeString)) 6907 return Currencies.BSD; 6908 if ("BTN".equals(codeString)) 6909 return Currencies.BTN; 6910 if ("BWP".equals(codeString)) 6911 return Currencies.BWP; 6912 if ("BYN".equals(codeString)) 6913 return Currencies.BYN; 6914 if ("BZD".equals(codeString)) 6915 return Currencies.BZD; 6916 if ("CAD".equals(codeString)) 6917 return Currencies.CAD; 6918 if ("CDF".equals(codeString)) 6919 return Currencies.CDF; 6920 if ("CHE".equals(codeString)) 6921 return Currencies.CHE; 6922 if ("CHF".equals(codeString)) 6923 return Currencies.CHF; 6924 if ("CHW".equals(codeString)) 6925 return Currencies.CHW; 6926 if ("CLF".equals(codeString)) 6927 return Currencies.CLF; 6928 if ("CLP".equals(codeString)) 6929 return Currencies.CLP; 6930 if ("CNY".equals(codeString)) 6931 return Currencies.CNY; 6932 if ("COP".equals(codeString)) 6933 return Currencies.COP; 6934 if ("COU".equals(codeString)) 6935 return Currencies.COU; 6936 if ("CRC".equals(codeString)) 6937 return Currencies.CRC; 6938 if ("CUC".equals(codeString)) 6939 return Currencies.CUC; 6940 if ("CUP".equals(codeString)) 6941 return Currencies.CUP; 6942 if ("CVE".equals(codeString)) 6943 return Currencies.CVE; 6944 if ("CZK".equals(codeString)) 6945 return Currencies.CZK; 6946 if ("DJF".equals(codeString)) 6947 return Currencies.DJF; 6948 if ("DKK".equals(codeString)) 6949 return Currencies.DKK; 6950 if ("DOP".equals(codeString)) 6951 return Currencies.DOP; 6952 if ("DZD".equals(codeString)) 6953 return Currencies.DZD; 6954 if ("EGP".equals(codeString)) 6955 return Currencies.EGP; 6956 if ("ERN".equals(codeString)) 6957 return Currencies.ERN; 6958 if ("ETB".equals(codeString)) 6959 return Currencies.ETB; 6960 if ("EUR".equals(codeString)) 6961 return Currencies.EUR; 6962 if ("FJD".equals(codeString)) 6963 return Currencies.FJD; 6964 if ("FKP".equals(codeString)) 6965 return Currencies.FKP; 6966 if ("GBP".equals(codeString)) 6967 return Currencies.GBP; 6968 if ("GEL".equals(codeString)) 6969 return Currencies.GEL; 6970 if ("GGP".equals(codeString)) 6971 return Currencies.GGP; 6972 if ("GHS".equals(codeString)) 6973 return Currencies.GHS; 6974 if ("GIP".equals(codeString)) 6975 return Currencies.GIP; 6976 if ("GMD".equals(codeString)) 6977 return Currencies.GMD; 6978 if ("GNF".equals(codeString)) 6979 return Currencies.GNF; 6980 if ("GTQ".equals(codeString)) 6981 return Currencies.GTQ; 6982 if ("GYD".equals(codeString)) 6983 return Currencies.GYD; 6984 if ("HKD".equals(codeString)) 6985 return Currencies.HKD; 6986 if ("HNL".equals(codeString)) 6987 return Currencies.HNL; 6988 if ("HRK".equals(codeString)) 6989 return Currencies.HRK; 6990 if ("HTG".equals(codeString)) 6991 return Currencies.HTG; 6992 if ("HUF".equals(codeString)) 6993 return Currencies.HUF; 6994 if ("IDR".equals(codeString)) 6995 return Currencies.IDR; 6996 if ("ILS".equals(codeString)) 6997 return Currencies.ILS; 6998 if ("IMP".equals(codeString)) 6999 return Currencies.IMP; 7000 if ("INR".equals(codeString)) 7001 return Currencies.INR; 7002 if ("IQD".equals(codeString)) 7003 return Currencies.IQD; 7004 if ("IRR".equals(codeString)) 7005 return Currencies.IRR; 7006 if ("ISK".equals(codeString)) 7007 return Currencies.ISK; 7008 if ("JEP".equals(codeString)) 7009 return Currencies.JEP; 7010 if ("JMD".equals(codeString)) 7011 return Currencies.JMD; 7012 if ("JOD".equals(codeString)) 7013 return Currencies.JOD; 7014 if ("JPY".equals(codeString)) 7015 return Currencies.JPY; 7016 if ("KES".equals(codeString)) 7017 return Currencies.KES; 7018 if ("KGS".equals(codeString)) 7019 return Currencies.KGS; 7020 if ("KHR".equals(codeString)) 7021 return Currencies.KHR; 7022 if ("KMF".equals(codeString)) 7023 return Currencies.KMF; 7024 if ("KPW".equals(codeString)) 7025 return Currencies.KPW; 7026 if ("KRW".equals(codeString)) 7027 return Currencies.KRW; 7028 if ("KWD".equals(codeString)) 7029 return Currencies.KWD; 7030 if ("KYD".equals(codeString)) 7031 return Currencies.KYD; 7032 if ("KZT".equals(codeString)) 7033 return Currencies.KZT; 7034 if ("LAK".equals(codeString)) 7035 return Currencies.LAK; 7036 if ("LBP".equals(codeString)) 7037 return Currencies.LBP; 7038 if ("LKR".equals(codeString)) 7039 return Currencies.LKR; 7040 if ("LRD".equals(codeString)) 7041 return Currencies.LRD; 7042 if ("LSL".equals(codeString)) 7043 return Currencies.LSL; 7044 if ("LYD".equals(codeString)) 7045 return Currencies.LYD; 7046 if ("MAD".equals(codeString)) 7047 return Currencies.MAD; 7048 if ("MDL".equals(codeString)) 7049 return Currencies.MDL; 7050 if ("MGA".equals(codeString)) 7051 return Currencies.MGA; 7052 if ("MKD".equals(codeString)) 7053 return Currencies.MKD; 7054 if ("MMK".equals(codeString)) 7055 return Currencies.MMK; 7056 if ("MNT".equals(codeString)) 7057 return Currencies.MNT; 7058 if ("MOP".equals(codeString)) 7059 return Currencies.MOP; 7060 if ("MRU".equals(codeString)) 7061 return Currencies.MRU; 7062 if ("MUR".equals(codeString)) 7063 return Currencies.MUR; 7064 if ("MVR".equals(codeString)) 7065 return Currencies.MVR; 7066 if ("MWK".equals(codeString)) 7067 return Currencies.MWK; 7068 if ("MXN".equals(codeString)) 7069 return Currencies.MXN; 7070 if ("MXV".equals(codeString)) 7071 return Currencies.MXV; 7072 if ("MYR".equals(codeString)) 7073 return Currencies.MYR; 7074 if ("MZN".equals(codeString)) 7075 return Currencies.MZN; 7076 if ("NAD".equals(codeString)) 7077 return Currencies.NAD; 7078 if ("NGN".equals(codeString)) 7079 return Currencies.NGN; 7080 if ("NIO".equals(codeString)) 7081 return Currencies.NIO; 7082 if ("NOK".equals(codeString)) 7083 return Currencies.NOK; 7084 if ("NPR".equals(codeString)) 7085 return Currencies.NPR; 7086 if ("NZD".equals(codeString)) 7087 return Currencies.NZD; 7088 if ("OMR".equals(codeString)) 7089 return Currencies.OMR; 7090 if ("PAB".equals(codeString)) 7091 return Currencies.PAB; 7092 if ("PEN".equals(codeString)) 7093 return Currencies.PEN; 7094 if ("PGK".equals(codeString)) 7095 return Currencies.PGK; 7096 if ("PHP".equals(codeString)) 7097 return Currencies.PHP; 7098 if ("PKR".equals(codeString)) 7099 return Currencies.PKR; 7100 if ("PLN".equals(codeString)) 7101 return Currencies.PLN; 7102 if ("PYG".equals(codeString)) 7103 return Currencies.PYG; 7104 if ("QAR".equals(codeString)) 7105 return Currencies.QAR; 7106 if ("RON".equals(codeString)) 7107 return Currencies.RON; 7108 if ("RSD".equals(codeString)) 7109 return Currencies.RSD; 7110 if ("RUB".equals(codeString)) 7111 return Currencies.RUB; 7112 if ("RWF".equals(codeString)) 7113 return Currencies.RWF; 7114 if ("SAR".equals(codeString)) 7115 return Currencies.SAR; 7116 if ("SBD".equals(codeString)) 7117 return Currencies.SBD; 7118 if ("SCR".equals(codeString)) 7119 return Currencies.SCR; 7120 if ("SDG".equals(codeString)) 7121 return Currencies.SDG; 7122 if ("SEK".equals(codeString)) 7123 return Currencies.SEK; 7124 if ("SGD".equals(codeString)) 7125 return Currencies.SGD; 7126 if ("SHP".equals(codeString)) 7127 return Currencies.SHP; 7128 if ("SLL".equals(codeString)) 7129 return Currencies.SLL; 7130 if ("SOS".equals(codeString)) 7131 return Currencies.SOS; 7132 if ("SRD".equals(codeString)) 7133 return Currencies.SRD; 7134 if ("SSP".equals(codeString)) 7135 return Currencies.SSP; 7136 if ("STN".equals(codeString)) 7137 return Currencies.STN; 7138 if ("SVC".equals(codeString)) 7139 return Currencies.SVC; 7140 if ("SYP".equals(codeString)) 7141 return Currencies.SYP; 7142 if ("SZL".equals(codeString)) 7143 return Currencies.SZL; 7144 if ("THB".equals(codeString)) 7145 return Currencies.THB; 7146 if ("TJS".equals(codeString)) 7147 return Currencies.TJS; 7148 if ("TMT".equals(codeString)) 7149 return Currencies.TMT; 7150 if ("TND".equals(codeString)) 7151 return Currencies.TND; 7152 if ("TOP".equals(codeString)) 7153 return Currencies.TOP; 7154 if ("TRY".equals(codeString)) 7155 return Currencies.TRY; 7156 if ("TTD".equals(codeString)) 7157 return Currencies.TTD; 7158 if ("TVD".equals(codeString)) 7159 return Currencies.TVD; 7160 if ("TWD".equals(codeString)) 7161 return Currencies.TWD; 7162 if ("TZS".equals(codeString)) 7163 return Currencies.TZS; 7164 if ("UAH".equals(codeString)) 7165 return Currencies.UAH; 7166 if ("UGX".equals(codeString)) 7167 return Currencies.UGX; 7168 if ("USD".equals(codeString)) 7169 return Currencies.USD; 7170 if ("USN".equals(codeString)) 7171 return Currencies.USN; 7172 if ("UYI".equals(codeString)) 7173 return Currencies.UYI; 7174 if ("UYU".equals(codeString)) 7175 return Currencies.UYU; 7176 if ("UZS".equals(codeString)) 7177 return Currencies.UZS; 7178 if ("VEF".equals(codeString)) 7179 return Currencies.VEF; 7180 if ("VND".equals(codeString)) 7181 return Currencies.VND; 7182 if ("VUV".equals(codeString)) 7183 return Currencies.VUV; 7184 if ("WST".equals(codeString)) 7185 return Currencies.WST; 7186 if ("XAF".equals(codeString)) 7187 return Currencies.XAF; 7188 if ("XAG".equals(codeString)) 7189 return Currencies.XAG; 7190 if ("XAU".equals(codeString)) 7191 return Currencies.XAU; 7192 if ("XBA".equals(codeString)) 7193 return Currencies.XBA; 7194 if ("XBB".equals(codeString)) 7195 return Currencies.XBB; 7196 if ("XBC".equals(codeString)) 7197 return Currencies.XBC; 7198 if ("XBD".equals(codeString)) 7199 return Currencies.XBD; 7200 if ("XCD".equals(codeString)) 7201 return Currencies.XCD; 7202 if ("XDR".equals(codeString)) 7203 return Currencies.XDR; 7204 if ("XOF".equals(codeString)) 7205 return Currencies.XOF; 7206 if ("XPD".equals(codeString)) 7207 return Currencies.XPD; 7208 if ("XPF".equals(codeString)) 7209 return Currencies.XPF; 7210 if ("XPT".equals(codeString)) 7211 return Currencies.XPT; 7212 if ("XSU".equals(codeString)) 7213 return Currencies.XSU; 7214 if ("XTS".equals(codeString)) 7215 return Currencies.XTS; 7216 if ("XUA".equals(codeString)) 7217 return Currencies.XUA; 7218 if ("XXX".equals(codeString)) 7219 return Currencies.XXX; 7220 if ("YER".equals(codeString)) 7221 return Currencies.YER; 7222 if ("ZAR".equals(codeString)) 7223 return Currencies.ZAR; 7224 if ("ZMW".equals(codeString)) 7225 return Currencies.ZMW; 7226 if ("ZWL".equals(codeString)) 7227 return Currencies.ZWL; 7228 throw new IllegalArgumentException("Unknown Currencies code '"+codeString+"'"); 7229 } 7230 public Enumeration<Currencies> fromType(PrimitiveType<?> code) throws FHIRException { 7231 if (code == null) 7232 return null; 7233 if (code.isEmpty()) 7234 return new Enumeration<Currencies>(this, Currencies.NULL, code); 7235 String codeString = ((PrimitiveType) code).asStringValue(); 7236 if (codeString == null || "".equals(codeString)) 7237 return new Enumeration<Currencies>(this, Currencies.NULL, code); 7238 if ("AED".equals(codeString)) 7239 return new Enumeration<Currencies>(this, Currencies.AED, code); 7240 if ("AFN".equals(codeString)) 7241 return new Enumeration<Currencies>(this, Currencies.AFN, code); 7242 if ("ALL".equals(codeString)) 7243 return new Enumeration<Currencies>(this, Currencies.ALL, code); 7244 if ("AMD".equals(codeString)) 7245 return new Enumeration<Currencies>(this, Currencies.AMD, code); 7246 if ("ANG".equals(codeString)) 7247 return new Enumeration<Currencies>(this, Currencies.ANG, code); 7248 if ("AOA".equals(codeString)) 7249 return new Enumeration<Currencies>(this, Currencies.AOA, code); 7250 if ("ARS".equals(codeString)) 7251 return new Enumeration<Currencies>(this, Currencies.ARS, code); 7252 if ("AUD".equals(codeString)) 7253 return new Enumeration<Currencies>(this, Currencies.AUD, code); 7254 if ("AWG".equals(codeString)) 7255 return new Enumeration<Currencies>(this, Currencies.AWG, code); 7256 if ("AZN".equals(codeString)) 7257 return new Enumeration<Currencies>(this, Currencies.AZN, code); 7258 if ("BAM".equals(codeString)) 7259 return new Enumeration<Currencies>(this, Currencies.BAM, code); 7260 if ("BBD".equals(codeString)) 7261 return new Enumeration<Currencies>(this, Currencies.BBD, code); 7262 if ("BDT".equals(codeString)) 7263 return new Enumeration<Currencies>(this, Currencies.BDT, code); 7264 if ("BGN".equals(codeString)) 7265 return new Enumeration<Currencies>(this, Currencies.BGN, code); 7266 if ("BHD".equals(codeString)) 7267 return new Enumeration<Currencies>(this, Currencies.BHD, code); 7268 if ("BIF".equals(codeString)) 7269 return new Enumeration<Currencies>(this, Currencies.BIF, code); 7270 if ("BMD".equals(codeString)) 7271 return new Enumeration<Currencies>(this, Currencies.BMD, code); 7272 if ("BND".equals(codeString)) 7273 return new Enumeration<Currencies>(this, Currencies.BND, code); 7274 if ("BOB".equals(codeString)) 7275 return new Enumeration<Currencies>(this, Currencies.BOB, code); 7276 if ("BOV".equals(codeString)) 7277 return new Enumeration<Currencies>(this, Currencies.BOV, code); 7278 if ("BRL".equals(codeString)) 7279 return new Enumeration<Currencies>(this, Currencies.BRL, code); 7280 if ("BSD".equals(codeString)) 7281 return new Enumeration<Currencies>(this, Currencies.BSD, code); 7282 if ("BTN".equals(codeString)) 7283 return new Enumeration<Currencies>(this, Currencies.BTN, code); 7284 if ("BWP".equals(codeString)) 7285 return new Enumeration<Currencies>(this, Currencies.BWP, code); 7286 if ("BYN".equals(codeString)) 7287 return new Enumeration<Currencies>(this, Currencies.BYN, code); 7288 if ("BZD".equals(codeString)) 7289 return new Enumeration<Currencies>(this, Currencies.BZD, code); 7290 if ("CAD".equals(codeString)) 7291 return new Enumeration<Currencies>(this, Currencies.CAD, code); 7292 if ("CDF".equals(codeString)) 7293 return new Enumeration<Currencies>(this, Currencies.CDF, code); 7294 if ("CHE".equals(codeString)) 7295 return new Enumeration<Currencies>(this, Currencies.CHE, code); 7296 if ("CHF".equals(codeString)) 7297 return new Enumeration<Currencies>(this, Currencies.CHF, code); 7298 if ("CHW".equals(codeString)) 7299 return new Enumeration<Currencies>(this, Currencies.CHW, code); 7300 if ("CLF".equals(codeString)) 7301 return new Enumeration<Currencies>(this, Currencies.CLF, code); 7302 if ("CLP".equals(codeString)) 7303 return new Enumeration<Currencies>(this, Currencies.CLP, code); 7304 if ("CNY".equals(codeString)) 7305 return new Enumeration<Currencies>(this, Currencies.CNY, code); 7306 if ("COP".equals(codeString)) 7307 return new Enumeration<Currencies>(this, Currencies.COP, code); 7308 if ("COU".equals(codeString)) 7309 return new Enumeration<Currencies>(this, Currencies.COU, code); 7310 if ("CRC".equals(codeString)) 7311 return new Enumeration<Currencies>(this, Currencies.CRC, code); 7312 if ("CUC".equals(codeString)) 7313 return new Enumeration<Currencies>(this, Currencies.CUC, code); 7314 if ("CUP".equals(codeString)) 7315 return new Enumeration<Currencies>(this, Currencies.CUP, code); 7316 if ("CVE".equals(codeString)) 7317 return new Enumeration<Currencies>(this, Currencies.CVE, code); 7318 if ("CZK".equals(codeString)) 7319 return new Enumeration<Currencies>(this, Currencies.CZK, code); 7320 if ("DJF".equals(codeString)) 7321 return new Enumeration<Currencies>(this, Currencies.DJF, code); 7322 if ("DKK".equals(codeString)) 7323 return new Enumeration<Currencies>(this, Currencies.DKK, code); 7324 if ("DOP".equals(codeString)) 7325 return new Enumeration<Currencies>(this, Currencies.DOP, code); 7326 if ("DZD".equals(codeString)) 7327 return new Enumeration<Currencies>(this, Currencies.DZD, code); 7328 if ("EGP".equals(codeString)) 7329 return new Enumeration<Currencies>(this, Currencies.EGP, code); 7330 if ("ERN".equals(codeString)) 7331 return new Enumeration<Currencies>(this, Currencies.ERN, code); 7332 if ("ETB".equals(codeString)) 7333 return new Enumeration<Currencies>(this, Currencies.ETB, code); 7334 if ("EUR".equals(codeString)) 7335 return new Enumeration<Currencies>(this, Currencies.EUR, code); 7336 if ("FJD".equals(codeString)) 7337 return new Enumeration<Currencies>(this, Currencies.FJD, code); 7338 if ("FKP".equals(codeString)) 7339 return new Enumeration<Currencies>(this, Currencies.FKP, code); 7340 if ("GBP".equals(codeString)) 7341 return new Enumeration<Currencies>(this, Currencies.GBP, code); 7342 if ("GEL".equals(codeString)) 7343 return new Enumeration<Currencies>(this, Currencies.GEL, code); 7344 if ("GGP".equals(codeString)) 7345 return new Enumeration<Currencies>(this, Currencies.GGP, code); 7346 if ("GHS".equals(codeString)) 7347 return new Enumeration<Currencies>(this, Currencies.GHS, code); 7348 if ("GIP".equals(codeString)) 7349 return new Enumeration<Currencies>(this, Currencies.GIP, code); 7350 if ("GMD".equals(codeString)) 7351 return new Enumeration<Currencies>(this, Currencies.GMD, code); 7352 if ("GNF".equals(codeString)) 7353 return new Enumeration<Currencies>(this, Currencies.GNF, code); 7354 if ("GTQ".equals(codeString)) 7355 return new Enumeration<Currencies>(this, Currencies.GTQ, code); 7356 if ("GYD".equals(codeString)) 7357 return new Enumeration<Currencies>(this, Currencies.GYD, code); 7358 if ("HKD".equals(codeString)) 7359 return new Enumeration<Currencies>(this, Currencies.HKD, code); 7360 if ("HNL".equals(codeString)) 7361 return new Enumeration<Currencies>(this, Currencies.HNL, code); 7362 if ("HRK".equals(codeString)) 7363 return new Enumeration<Currencies>(this, Currencies.HRK, code); 7364 if ("HTG".equals(codeString)) 7365 return new Enumeration<Currencies>(this, Currencies.HTG, code); 7366 if ("HUF".equals(codeString)) 7367 return new Enumeration<Currencies>(this, Currencies.HUF, code); 7368 if ("IDR".equals(codeString)) 7369 return new Enumeration<Currencies>(this, Currencies.IDR, code); 7370 if ("ILS".equals(codeString)) 7371 return new Enumeration<Currencies>(this, Currencies.ILS, code); 7372 if ("IMP".equals(codeString)) 7373 return new Enumeration<Currencies>(this, Currencies.IMP, code); 7374 if ("INR".equals(codeString)) 7375 return new Enumeration<Currencies>(this, Currencies.INR, code); 7376 if ("IQD".equals(codeString)) 7377 return new Enumeration<Currencies>(this, Currencies.IQD, code); 7378 if ("IRR".equals(codeString)) 7379 return new Enumeration<Currencies>(this, Currencies.IRR, code); 7380 if ("ISK".equals(codeString)) 7381 return new Enumeration<Currencies>(this, Currencies.ISK, code); 7382 if ("JEP".equals(codeString)) 7383 return new Enumeration<Currencies>(this, Currencies.JEP, code); 7384 if ("JMD".equals(codeString)) 7385 return new Enumeration<Currencies>(this, Currencies.JMD, code); 7386 if ("JOD".equals(codeString)) 7387 return new Enumeration<Currencies>(this, Currencies.JOD, code); 7388 if ("JPY".equals(codeString)) 7389 return new Enumeration<Currencies>(this, Currencies.JPY, code); 7390 if ("KES".equals(codeString)) 7391 return new Enumeration<Currencies>(this, Currencies.KES, code); 7392 if ("KGS".equals(codeString)) 7393 return new Enumeration<Currencies>(this, Currencies.KGS, code); 7394 if ("KHR".equals(codeString)) 7395 return new Enumeration<Currencies>(this, Currencies.KHR, code); 7396 if ("KMF".equals(codeString)) 7397 return new Enumeration<Currencies>(this, Currencies.KMF, code); 7398 if ("KPW".equals(codeString)) 7399 return new Enumeration<Currencies>(this, Currencies.KPW, code); 7400 if ("KRW".equals(codeString)) 7401 return new Enumeration<Currencies>(this, Currencies.KRW, code); 7402 if ("KWD".equals(codeString)) 7403 return new Enumeration<Currencies>(this, Currencies.KWD, code); 7404 if ("KYD".equals(codeString)) 7405 return new Enumeration<Currencies>(this, Currencies.KYD, code); 7406 if ("KZT".equals(codeString)) 7407 return new Enumeration<Currencies>(this, Currencies.KZT, code); 7408 if ("LAK".equals(codeString)) 7409 return new Enumeration<Currencies>(this, Currencies.LAK, code); 7410 if ("LBP".equals(codeString)) 7411 return new Enumeration<Currencies>(this, Currencies.LBP, code); 7412 if ("LKR".equals(codeString)) 7413 return new Enumeration<Currencies>(this, Currencies.LKR, code); 7414 if ("LRD".equals(codeString)) 7415 return new Enumeration<Currencies>(this, Currencies.LRD, code); 7416 if ("LSL".equals(codeString)) 7417 return new Enumeration<Currencies>(this, Currencies.LSL, code); 7418 if ("LYD".equals(codeString)) 7419 return new Enumeration<Currencies>(this, Currencies.LYD, code); 7420 if ("MAD".equals(codeString)) 7421 return new Enumeration<Currencies>(this, Currencies.MAD, code); 7422 if ("MDL".equals(codeString)) 7423 return new Enumeration<Currencies>(this, Currencies.MDL, code); 7424 if ("MGA".equals(codeString)) 7425 return new Enumeration<Currencies>(this, Currencies.MGA, code); 7426 if ("MKD".equals(codeString)) 7427 return new Enumeration<Currencies>(this, Currencies.MKD, code); 7428 if ("MMK".equals(codeString)) 7429 return new Enumeration<Currencies>(this, Currencies.MMK, code); 7430 if ("MNT".equals(codeString)) 7431 return new Enumeration<Currencies>(this, Currencies.MNT, code); 7432 if ("MOP".equals(codeString)) 7433 return new Enumeration<Currencies>(this, Currencies.MOP, code); 7434 if ("MRU".equals(codeString)) 7435 return new Enumeration<Currencies>(this, Currencies.MRU, code); 7436 if ("MUR".equals(codeString)) 7437 return new Enumeration<Currencies>(this, Currencies.MUR, code); 7438 if ("MVR".equals(codeString)) 7439 return new Enumeration<Currencies>(this, Currencies.MVR, code); 7440 if ("MWK".equals(codeString)) 7441 return new Enumeration<Currencies>(this, Currencies.MWK, code); 7442 if ("MXN".equals(codeString)) 7443 return new Enumeration<Currencies>(this, Currencies.MXN, code); 7444 if ("MXV".equals(codeString)) 7445 return new Enumeration<Currencies>(this, Currencies.MXV, code); 7446 if ("MYR".equals(codeString)) 7447 return new Enumeration<Currencies>(this, Currencies.MYR, code); 7448 if ("MZN".equals(codeString)) 7449 return new Enumeration<Currencies>(this, Currencies.MZN, code); 7450 if ("NAD".equals(codeString)) 7451 return new Enumeration<Currencies>(this, Currencies.NAD, code); 7452 if ("NGN".equals(codeString)) 7453 return new Enumeration<Currencies>(this, Currencies.NGN, code); 7454 if ("NIO".equals(codeString)) 7455 return new Enumeration<Currencies>(this, Currencies.NIO, code); 7456 if ("NOK".equals(codeString)) 7457 return new Enumeration<Currencies>(this, Currencies.NOK, code); 7458 if ("NPR".equals(codeString)) 7459 return new Enumeration<Currencies>(this, Currencies.NPR, code); 7460 if ("NZD".equals(codeString)) 7461 return new Enumeration<Currencies>(this, Currencies.NZD, code); 7462 if ("OMR".equals(codeString)) 7463 return new Enumeration<Currencies>(this, Currencies.OMR, code); 7464 if ("PAB".equals(codeString)) 7465 return new Enumeration<Currencies>(this, Currencies.PAB, code); 7466 if ("PEN".equals(codeString)) 7467 return new Enumeration<Currencies>(this, Currencies.PEN, code); 7468 if ("PGK".equals(codeString)) 7469 return new Enumeration<Currencies>(this, Currencies.PGK, code); 7470 if ("PHP".equals(codeString)) 7471 return new Enumeration<Currencies>(this, Currencies.PHP, code); 7472 if ("PKR".equals(codeString)) 7473 return new Enumeration<Currencies>(this, Currencies.PKR, code); 7474 if ("PLN".equals(codeString)) 7475 return new Enumeration<Currencies>(this, Currencies.PLN, code); 7476 if ("PYG".equals(codeString)) 7477 return new Enumeration<Currencies>(this, Currencies.PYG, code); 7478 if ("QAR".equals(codeString)) 7479 return new Enumeration<Currencies>(this, Currencies.QAR, code); 7480 if ("RON".equals(codeString)) 7481 return new Enumeration<Currencies>(this, Currencies.RON, code); 7482 if ("RSD".equals(codeString)) 7483 return new Enumeration<Currencies>(this, Currencies.RSD, code); 7484 if ("RUB".equals(codeString)) 7485 return new Enumeration<Currencies>(this, Currencies.RUB, code); 7486 if ("RWF".equals(codeString)) 7487 return new Enumeration<Currencies>(this, Currencies.RWF, code); 7488 if ("SAR".equals(codeString)) 7489 return new Enumeration<Currencies>(this, Currencies.SAR, code); 7490 if ("SBD".equals(codeString)) 7491 return new Enumeration<Currencies>(this, Currencies.SBD, code); 7492 if ("SCR".equals(codeString)) 7493 return new Enumeration<Currencies>(this, Currencies.SCR, code); 7494 if ("SDG".equals(codeString)) 7495 return new Enumeration<Currencies>(this, Currencies.SDG, code); 7496 if ("SEK".equals(codeString)) 7497 return new Enumeration<Currencies>(this, Currencies.SEK, code); 7498 if ("SGD".equals(codeString)) 7499 return new Enumeration<Currencies>(this, Currencies.SGD, code); 7500 if ("SHP".equals(codeString)) 7501 return new Enumeration<Currencies>(this, Currencies.SHP, code); 7502 if ("SLL".equals(codeString)) 7503 return new Enumeration<Currencies>(this, Currencies.SLL, code); 7504 if ("SOS".equals(codeString)) 7505 return new Enumeration<Currencies>(this, Currencies.SOS, code); 7506 if ("SRD".equals(codeString)) 7507 return new Enumeration<Currencies>(this, Currencies.SRD, code); 7508 if ("SSP".equals(codeString)) 7509 return new Enumeration<Currencies>(this, Currencies.SSP, code); 7510 if ("STN".equals(codeString)) 7511 return new Enumeration<Currencies>(this, Currencies.STN, code); 7512 if ("SVC".equals(codeString)) 7513 return new Enumeration<Currencies>(this, Currencies.SVC, code); 7514 if ("SYP".equals(codeString)) 7515 return new Enumeration<Currencies>(this, Currencies.SYP, code); 7516 if ("SZL".equals(codeString)) 7517 return new Enumeration<Currencies>(this, Currencies.SZL, code); 7518 if ("THB".equals(codeString)) 7519 return new Enumeration<Currencies>(this, Currencies.THB, code); 7520 if ("TJS".equals(codeString)) 7521 return new Enumeration<Currencies>(this, Currencies.TJS, code); 7522 if ("TMT".equals(codeString)) 7523 return new Enumeration<Currencies>(this, Currencies.TMT, code); 7524 if ("TND".equals(codeString)) 7525 return new Enumeration<Currencies>(this, Currencies.TND, code); 7526 if ("TOP".equals(codeString)) 7527 return new Enumeration<Currencies>(this, Currencies.TOP, code); 7528 if ("TRY".equals(codeString)) 7529 return new Enumeration<Currencies>(this, Currencies.TRY, code); 7530 if ("TTD".equals(codeString)) 7531 return new Enumeration<Currencies>(this, Currencies.TTD, code); 7532 if ("TVD".equals(codeString)) 7533 return new Enumeration<Currencies>(this, Currencies.TVD, code); 7534 if ("TWD".equals(codeString)) 7535 return new Enumeration<Currencies>(this, Currencies.TWD, code); 7536 if ("TZS".equals(codeString)) 7537 return new Enumeration<Currencies>(this, Currencies.TZS, code); 7538 if ("UAH".equals(codeString)) 7539 return new Enumeration<Currencies>(this, Currencies.UAH, code); 7540 if ("UGX".equals(codeString)) 7541 return new Enumeration<Currencies>(this, Currencies.UGX, code); 7542 if ("USD".equals(codeString)) 7543 return new Enumeration<Currencies>(this, Currencies.USD, code); 7544 if ("USN".equals(codeString)) 7545 return new Enumeration<Currencies>(this, Currencies.USN, code); 7546 if ("UYI".equals(codeString)) 7547 return new Enumeration<Currencies>(this, Currencies.UYI, code); 7548 if ("UYU".equals(codeString)) 7549 return new Enumeration<Currencies>(this, Currencies.UYU, code); 7550 if ("UZS".equals(codeString)) 7551 return new Enumeration<Currencies>(this, Currencies.UZS, code); 7552 if ("VEF".equals(codeString)) 7553 return new Enumeration<Currencies>(this, Currencies.VEF, code); 7554 if ("VND".equals(codeString)) 7555 return new Enumeration<Currencies>(this, Currencies.VND, code); 7556 if ("VUV".equals(codeString)) 7557 return new Enumeration<Currencies>(this, Currencies.VUV, code); 7558 if ("WST".equals(codeString)) 7559 return new Enumeration<Currencies>(this, Currencies.WST, code); 7560 if ("XAF".equals(codeString)) 7561 return new Enumeration<Currencies>(this, Currencies.XAF, code); 7562 if ("XAG".equals(codeString)) 7563 return new Enumeration<Currencies>(this, Currencies.XAG, code); 7564 if ("XAU".equals(codeString)) 7565 return new Enumeration<Currencies>(this, Currencies.XAU, code); 7566 if ("XBA".equals(codeString)) 7567 return new Enumeration<Currencies>(this, Currencies.XBA, code); 7568 if ("XBB".equals(codeString)) 7569 return new Enumeration<Currencies>(this, Currencies.XBB, code); 7570 if ("XBC".equals(codeString)) 7571 return new Enumeration<Currencies>(this, Currencies.XBC, code); 7572 if ("XBD".equals(codeString)) 7573 return new Enumeration<Currencies>(this, Currencies.XBD, code); 7574 if ("XCD".equals(codeString)) 7575 return new Enumeration<Currencies>(this, Currencies.XCD, code); 7576 if ("XDR".equals(codeString)) 7577 return new Enumeration<Currencies>(this, Currencies.XDR, code); 7578 if ("XOF".equals(codeString)) 7579 return new Enumeration<Currencies>(this, Currencies.XOF, code); 7580 if ("XPD".equals(codeString)) 7581 return new Enumeration<Currencies>(this, Currencies.XPD, code); 7582 if ("XPF".equals(codeString)) 7583 return new Enumeration<Currencies>(this, Currencies.XPF, code); 7584 if ("XPT".equals(codeString)) 7585 return new Enumeration<Currencies>(this, Currencies.XPT, code); 7586 if ("XSU".equals(codeString)) 7587 return new Enumeration<Currencies>(this, Currencies.XSU, code); 7588 if ("XTS".equals(codeString)) 7589 return new Enumeration<Currencies>(this, Currencies.XTS, code); 7590 if ("XUA".equals(codeString)) 7591 return new Enumeration<Currencies>(this, Currencies.XUA, code); 7592 if ("XXX".equals(codeString)) 7593 return new Enumeration<Currencies>(this, Currencies.XXX, code); 7594 if ("YER".equals(codeString)) 7595 return new Enumeration<Currencies>(this, Currencies.YER, code); 7596 if ("ZAR".equals(codeString)) 7597 return new Enumeration<Currencies>(this, Currencies.ZAR, code); 7598 if ("ZMW".equals(codeString)) 7599 return new Enumeration<Currencies>(this, Currencies.ZMW, code); 7600 if ("ZWL".equals(codeString)) 7601 return new Enumeration<Currencies>(this, Currencies.ZWL, code); 7602 throw new FHIRException("Unknown Currencies code '"+codeString+"'"); 7603 } 7604 public String toCode(Currencies code) { 7605 if (code == Currencies.AED) 7606 return "AED"; 7607 if (code == Currencies.AFN) 7608 return "AFN"; 7609 if (code == Currencies.ALL) 7610 return "ALL"; 7611 if (code == Currencies.AMD) 7612 return "AMD"; 7613 if (code == Currencies.ANG) 7614 return "ANG"; 7615 if (code == Currencies.AOA) 7616 return "AOA"; 7617 if (code == Currencies.ARS) 7618 return "ARS"; 7619 if (code == Currencies.AUD) 7620 return "AUD"; 7621 if (code == Currencies.AWG) 7622 return "AWG"; 7623 if (code == Currencies.AZN) 7624 return "AZN"; 7625 if (code == Currencies.BAM) 7626 return "BAM"; 7627 if (code == Currencies.BBD) 7628 return "BBD"; 7629 if (code == Currencies.BDT) 7630 return "BDT"; 7631 if (code == Currencies.BGN) 7632 return "BGN"; 7633 if (code == Currencies.BHD) 7634 return "BHD"; 7635 if (code == Currencies.BIF) 7636 return "BIF"; 7637 if (code == Currencies.BMD) 7638 return "BMD"; 7639 if (code == Currencies.BND) 7640 return "BND"; 7641 if (code == Currencies.BOB) 7642 return "BOB"; 7643 if (code == Currencies.BOV) 7644 return "BOV"; 7645 if (code == Currencies.BRL) 7646 return "BRL"; 7647 if (code == Currencies.BSD) 7648 return "BSD"; 7649 if (code == Currencies.BTN) 7650 return "BTN"; 7651 if (code == Currencies.BWP) 7652 return "BWP"; 7653 if (code == Currencies.BYN) 7654 return "BYN"; 7655 if (code == Currencies.BZD) 7656 return "BZD"; 7657 if (code == Currencies.CAD) 7658 return "CAD"; 7659 if (code == Currencies.CDF) 7660 return "CDF"; 7661 if (code == Currencies.CHE) 7662 return "CHE"; 7663 if (code == Currencies.CHF) 7664 return "CHF"; 7665 if (code == Currencies.CHW) 7666 return "CHW"; 7667 if (code == Currencies.CLF) 7668 return "CLF"; 7669 if (code == Currencies.CLP) 7670 return "CLP"; 7671 if (code == Currencies.CNY) 7672 return "CNY"; 7673 if (code == Currencies.COP) 7674 return "COP"; 7675 if (code == Currencies.COU) 7676 return "COU"; 7677 if (code == Currencies.CRC) 7678 return "CRC"; 7679 if (code == Currencies.CUC) 7680 return "CUC"; 7681 if (code == Currencies.CUP) 7682 return "CUP"; 7683 if (code == Currencies.CVE) 7684 return "CVE"; 7685 if (code == Currencies.CZK) 7686 return "CZK"; 7687 if (code == Currencies.DJF) 7688 return "DJF"; 7689 if (code == Currencies.DKK) 7690 return "DKK"; 7691 if (code == Currencies.DOP) 7692 return "DOP"; 7693 if (code == Currencies.DZD) 7694 return "DZD"; 7695 if (code == Currencies.EGP) 7696 return "EGP"; 7697 if (code == Currencies.ERN) 7698 return "ERN"; 7699 if (code == Currencies.ETB) 7700 return "ETB"; 7701 if (code == Currencies.EUR) 7702 return "EUR"; 7703 if (code == Currencies.FJD) 7704 return "FJD"; 7705 if (code == Currencies.FKP) 7706 return "FKP"; 7707 if (code == Currencies.GBP) 7708 return "GBP"; 7709 if (code == Currencies.GEL) 7710 return "GEL"; 7711 if (code == Currencies.GGP) 7712 return "GGP"; 7713 if (code == Currencies.GHS) 7714 return "GHS"; 7715 if (code == Currencies.GIP) 7716 return "GIP"; 7717 if (code == Currencies.GMD) 7718 return "GMD"; 7719 if (code == Currencies.GNF) 7720 return "GNF"; 7721 if (code == Currencies.GTQ) 7722 return "GTQ"; 7723 if (code == Currencies.GYD) 7724 return "GYD"; 7725 if (code == Currencies.HKD) 7726 return "HKD"; 7727 if (code == Currencies.HNL) 7728 return "HNL"; 7729 if (code == Currencies.HRK) 7730 return "HRK"; 7731 if (code == Currencies.HTG) 7732 return "HTG"; 7733 if (code == Currencies.HUF) 7734 return "HUF"; 7735 if (code == Currencies.IDR) 7736 return "IDR"; 7737 if (code == Currencies.ILS) 7738 return "ILS"; 7739 if (code == Currencies.IMP) 7740 return "IMP"; 7741 if (code == Currencies.INR) 7742 return "INR"; 7743 if (code == Currencies.IQD) 7744 return "IQD"; 7745 if (code == Currencies.IRR) 7746 return "IRR"; 7747 if (code == Currencies.ISK) 7748 return "ISK"; 7749 if (code == Currencies.JEP) 7750 return "JEP"; 7751 if (code == Currencies.JMD) 7752 return "JMD"; 7753 if (code == Currencies.JOD) 7754 return "JOD"; 7755 if (code == Currencies.JPY) 7756 return "JPY"; 7757 if (code == Currencies.KES) 7758 return "KES"; 7759 if (code == Currencies.KGS) 7760 return "KGS"; 7761 if (code == Currencies.KHR) 7762 return "KHR"; 7763 if (code == Currencies.KMF) 7764 return "KMF"; 7765 if (code == Currencies.KPW) 7766 return "KPW"; 7767 if (code == Currencies.KRW) 7768 return "KRW"; 7769 if (code == Currencies.KWD) 7770 return "KWD"; 7771 if (code == Currencies.KYD) 7772 return "KYD"; 7773 if (code == Currencies.KZT) 7774 return "KZT"; 7775 if (code == Currencies.LAK) 7776 return "LAK"; 7777 if (code == Currencies.LBP) 7778 return "LBP"; 7779 if (code == Currencies.LKR) 7780 return "LKR"; 7781 if (code == Currencies.LRD) 7782 return "LRD"; 7783 if (code == Currencies.LSL) 7784 return "LSL"; 7785 if (code == Currencies.LYD) 7786 return "LYD"; 7787 if (code == Currencies.MAD) 7788 return "MAD"; 7789 if (code == Currencies.MDL) 7790 return "MDL"; 7791 if (code == Currencies.MGA) 7792 return "MGA"; 7793 if (code == Currencies.MKD) 7794 return "MKD"; 7795 if (code == Currencies.MMK) 7796 return "MMK"; 7797 if (code == Currencies.MNT) 7798 return "MNT"; 7799 if (code == Currencies.MOP) 7800 return "MOP"; 7801 if (code == Currencies.MRU) 7802 return "MRU"; 7803 if (code == Currencies.MUR) 7804 return "MUR"; 7805 if (code == Currencies.MVR) 7806 return "MVR"; 7807 if (code == Currencies.MWK) 7808 return "MWK"; 7809 if (code == Currencies.MXN) 7810 return "MXN"; 7811 if (code == Currencies.MXV) 7812 return "MXV"; 7813 if (code == Currencies.MYR) 7814 return "MYR"; 7815 if (code == Currencies.MZN) 7816 return "MZN"; 7817 if (code == Currencies.NAD) 7818 return "NAD"; 7819 if (code == Currencies.NGN) 7820 return "NGN"; 7821 if (code == Currencies.NIO) 7822 return "NIO"; 7823 if (code == Currencies.NOK) 7824 return "NOK"; 7825 if (code == Currencies.NPR) 7826 return "NPR"; 7827 if (code == Currencies.NZD) 7828 return "NZD"; 7829 if (code == Currencies.OMR) 7830 return "OMR"; 7831 if (code == Currencies.PAB) 7832 return "PAB"; 7833 if (code == Currencies.PEN) 7834 return "PEN"; 7835 if (code == Currencies.PGK) 7836 return "PGK"; 7837 if (code == Currencies.PHP) 7838 return "PHP"; 7839 if (code == Currencies.PKR) 7840 return "PKR"; 7841 if (code == Currencies.PLN) 7842 return "PLN"; 7843 if (code == Currencies.PYG) 7844 return "PYG"; 7845 if (code == Currencies.QAR) 7846 return "QAR"; 7847 if (code == Currencies.RON) 7848 return "RON"; 7849 if (code == Currencies.RSD) 7850 return "RSD"; 7851 if (code == Currencies.RUB) 7852 return "RUB"; 7853 if (code == Currencies.RWF) 7854 return "RWF"; 7855 if (code == Currencies.SAR) 7856 return "SAR"; 7857 if (code == Currencies.SBD) 7858 return "SBD"; 7859 if (code == Currencies.SCR) 7860 return "SCR"; 7861 if (code == Currencies.SDG) 7862 return "SDG"; 7863 if (code == Currencies.SEK) 7864 return "SEK"; 7865 if (code == Currencies.SGD) 7866 return "SGD"; 7867 if (code == Currencies.SHP) 7868 return "SHP"; 7869 if (code == Currencies.SLL) 7870 return "SLL"; 7871 if (code == Currencies.SOS) 7872 return "SOS"; 7873 if (code == Currencies.SRD) 7874 return "SRD"; 7875 if (code == Currencies.SSP) 7876 return "SSP"; 7877 if (code == Currencies.STN) 7878 return "STN"; 7879 if (code == Currencies.SVC) 7880 return "SVC"; 7881 if (code == Currencies.SYP) 7882 return "SYP"; 7883 if (code == Currencies.SZL) 7884 return "SZL"; 7885 if (code == Currencies.THB) 7886 return "THB"; 7887 if (code == Currencies.TJS) 7888 return "TJS"; 7889 if (code == Currencies.TMT) 7890 return "TMT"; 7891 if (code == Currencies.TND) 7892 return "TND"; 7893 if (code == Currencies.TOP) 7894 return "TOP"; 7895 if (code == Currencies.TRY) 7896 return "TRY"; 7897 if (code == Currencies.TTD) 7898 return "TTD"; 7899 if (code == Currencies.TVD) 7900 return "TVD"; 7901 if (code == Currencies.TWD) 7902 return "TWD"; 7903 if (code == Currencies.TZS) 7904 return "TZS"; 7905 if (code == Currencies.UAH) 7906 return "UAH"; 7907 if (code == Currencies.UGX) 7908 return "UGX"; 7909 if (code == Currencies.USD) 7910 return "USD"; 7911 if (code == Currencies.USN) 7912 return "USN"; 7913 if (code == Currencies.UYI) 7914 return "UYI"; 7915 if (code == Currencies.UYU) 7916 return "UYU"; 7917 if (code == Currencies.UZS) 7918 return "UZS"; 7919 if (code == Currencies.VEF) 7920 return "VEF"; 7921 if (code == Currencies.VND) 7922 return "VND"; 7923 if (code == Currencies.VUV) 7924 return "VUV"; 7925 if (code == Currencies.WST) 7926 return "WST"; 7927 if (code == Currencies.XAF) 7928 return "XAF"; 7929 if (code == Currencies.XAG) 7930 return "XAG"; 7931 if (code == Currencies.XAU) 7932 return "XAU"; 7933 if (code == Currencies.XBA) 7934 return "XBA"; 7935 if (code == Currencies.XBB) 7936 return "XBB"; 7937 if (code == Currencies.XBC) 7938 return "XBC"; 7939 if (code == Currencies.XBD) 7940 return "XBD"; 7941 if (code == Currencies.XCD) 7942 return "XCD"; 7943 if (code == Currencies.XDR) 7944 return "XDR"; 7945 if (code == Currencies.XOF) 7946 return "XOF"; 7947 if (code == Currencies.XPD) 7948 return "XPD"; 7949 if (code == Currencies.XPF) 7950 return "XPF"; 7951 if (code == Currencies.XPT) 7952 return "XPT"; 7953 if (code == Currencies.XSU) 7954 return "XSU"; 7955 if (code == Currencies.XTS) 7956 return "XTS"; 7957 if (code == Currencies.XUA) 7958 return "XUA"; 7959 if (code == Currencies.XXX) 7960 return "XXX"; 7961 if (code == Currencies.YER) 7962 return "YER"; 7963 if (code == Currencies.ZAR) 7964 return "ZAR"; 7965 if (code == Currencies.ZMW) 7966 return "ZMW"; 7967 if (code == Currencies.ZWL) 7968 return "ZWL"; 7969 return "?"; 7970 } 7971 public String toSystem(Currencies code) { 7972 return code.getSystem(); 7973 } 7974 } 7975 7976 public enum DaysOfWeek { 7977 /** 7978 * Monday. 7979 */ 7980 MON, 7981 /** 7982 * Tuesday. 7983 */ 7984 TUE, 7985 /** 7986 * Wednesday. 7987 */ 7988 WED, 7989 /** 7990 * Thursday. 7991 */ 7992 THU, 7993 /** 7994 * Friday. 7995 */ 7996 FRI, 7997 /** 7998 * Saturday. 7999 */ 8000 SAT, 8001 /** 8002 * Sunday. 8003 */ 8004 SUN, 8005 /** 8006 * added to help the parsers 8007 */ 8008 NULL; 8009 public static DaysOfWeek fromCode(String codeString) throws FHIRException { 8010 if (codeString == null || "".equals(codeString)) 8011 return null; 8012 if ("mon".equals(codeString)) 8013 return MON; 8014 if ("tue".equals(codeString)) 8015 return TUE; 8016 if ("wed".equals(codeString)) 8017 return WED; 8018 if ("thu".equals(codeString)) 8019 return THU; 8020 if ("fri".equals(codeString)) 8021 return FRI; 8022 if ("sat".equals(codeString)) 8023 return SAT; 8024 if ("sun".equals(codeString)) 8025 return SUN; 8026 throw new FHIRException("Unknown DaysOfWeek code '"+codeString+"'"); 8027 } 8028 public String toCode() { 8029 switch (this) { 8030 case MON: return "mon"; 8031 case TUE: return "tue"; 8032 case WED: return "wed"; 8033 case THU: return "thu"; 8034 case FRI: return "fri"; 8035 case SAT: return "sat"; 8036 case SUN: return "sun"; 8037 case NULL: return null; 8038 default: return "?"; 8039 } 8040 } 8041 public String getSystem() { 8042 switch (this) { 8043 case MON: return "http://hl7.org/fhir/days-of-week"; 8044 case TUE: return "http://hl7.org/fhir/days-of-week"; 8045 case WED: return "http://hl7.org/fhir/days-of-week"; 8046 case THU: return "http://hl7.org/fhir/days-of-week"; 8047 case FRI: return "http://hl7.org/fhir/days-of-week"; 8048 case SAT: return "http://hl7.org/fhir/days-of-week"; 8049 case SUN: return "http://hl7.org/fhir/days-of-week"; 8050 case NULL: return null; 8051 default: return "?"; 8052 } 8053 } 8054 public String getDefinition() { 8055 switch (this) { 8056 case MON: return "Monday."; 8057 case TUE: return "Tuesday."; 8058 case WED: return "Wednesday."; 8059 case THU: return "Thursday."; 8060 case FRI: return "Friday."; 8061 case SAT: return "Saturday."; 8062 case SUN: return "Sunday."; 8063 case NULL: return null; 8064 default: return "?"; 8065 } 8066 } 8067 public String getDisplay() { 8068 switch (this) { 8069 case MON: return "Monday"; 8070 case TUE: return "Tuesday"; 8071 case WED: return "Wednesday"; 8072 case THU: return "Thursday"; 8073 case FRI: return "Friday"; 8074 case SAT: return "Saturday"; 8075 case SUN: return "Sunday"; 8076 case NULL: return null; 8077 default: return "?"; 8078 } 8079 } 8080 } 8081 8082 public static class DaysOfWeekEnumFactory implements EnumFactory<DaysOfWeek> { 8083 public DaysOfWeek fromCode(String codeString) throws IllegalArgumentException { 8084 if (codeString == null || "".equals(codeString)) 8085 if (codeString == null || "".equals(codeString)) 8086 return null; 8087 if ("mon".equals(codeString)) 8088 return DaysOfWeek.MON; 8089 if ("tue".equals(codeString)) 8090 return DaysOfWeek.TUE; 8091 if ("wed".equals(codeString)) 8092 return DaysOfWeek.WED; 8093 if ("thu".equals(codeString)) 8094 return DaysOfWeek.THU; 8095 if ("fri".equals(codeString)) 8096 return DaysOfWeek.FRI; 8097 if ("sat".equals(codeString)) 8098 return DaysOfWeek.SAT; 8099 if ("sun".equals(codeString)) 8100 return DaysOfWeek.SUN; 8101 throw new IllegalArgumentException("Unknown DaysOfWeek code '"+codeString+"'"); 8102 } 8103 public Enumeration<DaysOfWeek> fromType(PrimitiveType<?> code) throws FHIRException { 8104 if (code == null) 8105 return null; 8106 if (code.isEmpty()) 8107 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.NULL, code); 8108 String codeString = ((PrimitiveType) code).asStringValue(); 8109 if (codeString == null || "".equals(codeString)) 8110 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.NULL, code); 8111 if ("mon".equals(codeString)) 8112 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.MON, code); 8113 if ("tue".equals(codeString)) 8114 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.TUE, code); 8115 if ("wed".equals(codeString)) 8116 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.WED, code); 8117 if ("thu".equals(codeString)) 8118 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.THU, code); 8119 if ("fri".equals(codeString)) 8120 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.FRI, code); 8121 if ("sat".equals(codeString)) 8122 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.SAT, code); 8123 if ("sun".equals(codeString)) 8124 return new Enumeration<DaysOfWeek>(this, DaysOfWeek.SUN, code); 8125 throw new FHIRException("Unknown DaysOfWeek code '"+codeString+"'"); 8126 } 8127 public String toCode(DaysOfWeek code) { 8128 if (code == DaysOfWeek.MON) 8129 return "mon"; 8130 if (code == DaysOfWeek.TUE) 8131 return "tue"; 8132 if (code == DaysOfWeek.WED) 8133 return "wed"; 8134 if (code == DaysOfWeek.THU) 8135 return "thu"; 8136 if (code == DaysOfWeek.FRI) 8137 return "fri"; 8138 if (code == DaysOfWeek.SAT) 8139 return "sat"; 8140 if (code == DaysOfWeek.SUN) 8141 return "sun"; 8142 return "?"; 8143 } 8144 public String toSystem(DaysOfWeek code) { 8145 return code.getSystem(); 8146 } 8147 } 8148 8149 public enum DeviceNameType { 8150 /** 8151 * 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. 8152 */ 8153 REGISTEREDNAME, 8154 /** 8155 * 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. 8156 */ 8157 USERFRIENDLYNAME, 8158 /** 8159 * 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. 8160 */ 8161 PATIENTREPORTEDNAME, 8162 /** 8163 * added to help the parsers 8164 */ 8165 NULL; 8166 public static DeviceNameType fromCode(String codeString) throws FHIRException { 8167 if (codeString == null || "".equals(codeString)) 8168 return null; 8169 if ("registered-name".equals(codeString)) 8170 return REGISTEREDNAME; 8171 if ("user-friendly-name".equals(codeString)) 8172 return USERFRIENDLYNAME; 8173 if ("patient-reported-name".equals(codeString)) 8174 return PATIENTREPORTEDNAME; 8175 throw new FHIRException("Unknown DeviceNameType code '"+codeString+"'"); 8176 } 8177 public String toCode() { 8178 switch (this) { 8179 case REGISTEREDNAME: return "registered-name"; 8180 case USERFRIENDLYNAME: return "user-friendly-name"; 8181 case PATIENTREPORTEDNAME: return "patient-reported-name"; 8182 case NULL: return null; 8183 default: return "?"; 8184 } 8185 } 8186 public String getSystem() { 8187 switch (this) { 8188 case REGISTEREDNAME: return "http://hl7.org/fhir/device-nametype"; 8189 case USERFRIENDLYNAME: return "http://hl7.org/fhir/device-nametype"; 8190 case PATIENTREPORTEDNAME: return "http://hl7.org/fhir/device-nametype"; 8191 case NULL: return null; 8192 default: return "?"; 8193 } 8194 } 8195 public String getDefinition() { 8196 switch (this) { 8197 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."; 8198 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."; 8199 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."; 8200 case NULL: return null; 8201 default: return "?"; 8202 } 8203 } 8204 public String getDisplay() { 8205 switch (this) { 8206 case REGISTEREDNAME: return "Registered name"; 8207 case USERFRIENDLYNAME: return "User Friendly name"; 8208 case PATIENTREPORTEDNAME: return "Patient Reported name"; 8209 case NULL: return null; 8210 default: return "?"; 8211 } 8212 } 8213 } 8214 8215 public static class DeviceNameTypeEnumFactory implements EnumFactory<DeviceNameType> { 8216 public DeviceNameType fromCode(String codeString) throws IllegalArgumentException { 8217 if (codeString == null || "".equals(codeString)) 8218 if (codeString == null || "".equals(codeString)) 8219 return null; 8220 if ("registered-name".equals(codeString)) 8221 return DeviceNameType.REGISTEREDNAME; 8222 if ("user-friendly-name".equals(codeString)) 8223 return DeviceNameType.USERFRIENDLYNAME; 8224 if ("patient-reported-name".equals(codeString)) 8225 return DeviceNameType.PATIENTREPORTEDNAME; 8226 throw new IllegalArgumentException("Unknown DeviceNameType code '"+codeString+"'"); 8227 } 8228 public Enumeration<DeviceNameType> fromType(PrimitiveType<?> code) throws FHIRException { 8229 if (code == null) 8230 return null; 8231 if (code.isEmpty()) 8232 return new Enumeration<DeviceNameType>(this, DeviceNameType.NULL, code); 8233 String codeString = ((PrimitiveType) code).asStringValue(); 8234 if (codeString == null || "".equals(codeString)) 8235 return new Enumeration<DeviceNameType>(this, DeviceNameType.NULL, code); 8236 if ("registered-name".equals(codeString)) 8237 return new Enumeration<DeviceNameType>(this, DeviceNameType.REGISTEREDNAME, code); 8238 if ("user-friendly-name".equals(codeString)) 8239 return new Enumeration<DeviceNameType>(this, DeviceNameType.USERFRIENDLYNAME, code); 8240 if ("patient-reported-name".equals(codeString)) 8241 return new Enumeration<DeviceNameType>(this, DeviceNameType.PATIENTREPORTEDNAME, code); 8242 throw new FHIRException("Unknown DeviceNameType code '"+codeString+"'"); 8243 } 8244 public String toCode(DeviceNameType code) { 8245 if (code == DeviceNameType.REGISTEREDNAME) 8246 return "registered-name"; 8247 if (code == DeviceNameType.USERFRIENDLYNAME) 8248 return "user-friendly-name"; 8249 if (code == DeviceNameType.PATIENTREPORTEDNAME) 8250 return "patient-reported-name"; 8251 return "?"; 8252 } 8253 public String toSystem(DeviceNameType code) { 8254 return code.getSystem(); 8255 } 8256 } 8257 8258 public enum DocumentReferenceStatus { 8259 /** 8260 * This is the current reference for this document. 8261 */ 8262 CURRENT, 8263 /** 8264 * This reference has been superseded by another reference. 8265 */ 8266 SUPERSEDED, 8267 /** 8268 * This reference was created in error. 8269 */ 8270 ENTEREDINERROR, 8271 /** 8272 * added to help the parsers 8273 */ 8274 NULL; 8275 public static DocumentReferenceStatus fromCode(String codeString) throws FHIRException { 8276 if (codeString == null || "".equals(codeString)) 8277 return null; 8278 if ("current".equals(codeString)) 8279 return CURRENT; 8280 if ("superseded".equals(codeString)) 8281 return SUPERSEDED; 8282 if ("entered-in-error".equals(codeString)) 8283 return ENTEREDINERROR; 8284 throw new FHIRException("Unknown DocumentReferenceStatus code '"+codeString+"'"); 8285 } 8286 public String toCode() { 8287 switch (this) { 8288 case CURRENT: return "current"; 8289 case SUPERSEDED: return "superseded"; 8290 case ENTEREDINERROR: return "entered-in-error"; 8291 case NULL: return null; 8292 default: return "?"; 8293 } 8294 } 8295 public String getSystem() { 8296 switch (this) { 8297 case CURRENT: return "http://hl7.org/fhir/document-reference-status"; 8298 case SUPERSEDED: return "http://hl7.org/fhir/document-reference-status"; 8299 case ENTEREDINERROR: return "http://hl7.org/fhir/document-reference-status"; 8300 case NULL: return null; 8301 default: return "?"; 8302 } 8303 } 8304 public String getDefinition() { 8305 switch (this) { 8306 case CURRENT: return "This is the current reference for this document."; 8307 case SUPERSEDED: return "This reference has been superseded by another reference."; 8308 case ENTEREDINERROR: return "This reference was created in error."; 8309 case NULL: return null; 8310 default: return "?"; 8311 } 8312 } 8313 public String getDisplay() { 8314 switch (this) { 8315 case CURRENT: return "Current"; 8316 case SUPERSEDED: return "Superseded"; 8317 case ENTEREDINERROR: return "Entered in Error"; 8318 case NULL: return null; 8319 default: return "?"; 8320 } 8321 } 8322 } 8323 8324 public static class DocumentReferenceStatusEnumFactory implements EnumFactory<DocumentReferenceStatus> { 8325 public DocumentReferenceStatus fromCode(String codeString) throws IllegalArgumentException { 8326 if (codeString == null || "".equals(codeString)) 8327 if (codeString == null || "".equals(codeString)) 8328 return null; 8329 if ("current".equals(codeString)) 8330 return DocumentReferenceStatus.CURRENT; 8331 if ("superseded".equals(codeString)) 8332 return DocumentReferenceStatus.SUPERSEDED; 8333 if ("entered-in-error".equals(codeString)) 8334 return DocumentReferenceStatus.ENTEREDINERROR; 8335 throw new IllegalArgumentException("Unknown DocumentReferenceStatus code '"+codeString+"'"); 8336 } 8337 public Enumeration<DocumentReferenceStatus> fromType(PrimitiveType<?> code) throws FHIRException { 8338 if (code == null) 8339 return null; 8340 if (code.isEmpty()) 8341 return new Enumeration<DocumentReferenceStatus>(this, DocumentReferenceStatus.NULL, code); 8342 String codeString = ((PrimitiveType) code).asStringValue(); 8343 if (codeString == null || "".equals(codeString)) 8344 return new Enumeration<DocumentReferenceStatus>(this, DocumentReferenceStatus.NULL, code); 8345 if ("current".equals(codeString)) 8346 return new Enumeration<DocumentReferenceStatus>(this, DocumentReferenceStatus.CURRENT, code); 8347 if ("superseded".equals(codeString)) 8348 return new Enumeration<DocumentReferenceStatus>(this, DocumentReferenceStatus.SUPERSEDED, code); 8349 if ("entered-in-error".equals(codeString)) 8350 return new Enumeration<DocumentReferenceStatus>(this, DocumentReferenceStatus.ENTEREDINERROR, code); 8351 throw new FHIRException("Unknown DocumentReferenceStatus code '"+codeString+"'"); 8352 } 8353 public String toCode(DocumentReferenceStatus code) { 8354 if (code == DocumentReferenceStatus.CURRENT) 8355 return "current"; 8356 if (code == DocumentReferenceStatus.SUPERSEDED) 8357 return "superseded"; 8358 if (code == DocumentReferenceStatus.ENTEREDINERROR) 8359 return "entered-in-error"; 8360 return "?"; 8361 } 8362 public String toSystem(DocumentReferenceStatus code) { 8363 return code.getSystem(); 8364 } 8365 } 8366 8367 public enum EventStatus { 8368 /** 8369 * 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. 8370 */ 8371 PREPARATION, 8372 /** 8373 * The event is currently occurring. 8374 */ 8375 INPROGRESS, 8376 /** 8377 * 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. 8378 */ 8379 NOTDONE, 8380 /** 8381 * The event has been temporarily stopped but is expected to resume in the future. 8382 */ 8383 ONHOLD, 8384 /** 8385 * 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. 8386 */ 8387 STOPPED, 8388 /** 8389 * The event has now concluded. 8390 */ 8391 COMPLETED, 8392 /** 8393 * 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".). 8394 */ 8395 ENTEREDINERROR, 8396 /** 8397 * 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. 8398 */ 8399 UNKNOWN, 8400 /** 8401 * added to help the parsers 8402 */ 8403 NULL; 8404 public static EventStatus fromCode(String codeString) throws FHIRException { 8405 if (codeString == null || "".equals(codeString)) 8406 return null; 8407 if ("preparation".equals(codeString)) 8408 return PREPARATION; 8409 if ("in-progress".equals(codeString)) 8410 return INPROGRESS; 8411 if ("not-done".equals(codeString)) 8412 return NOTDONE; 8413 if ("on-hold".equals(codeString)) 8414 return ONHOLD; 8415 if ("stopped".equals(codeString)) 8416 return STOPPED; 8417 if ("completed".equals(codeString)) 8418 return COMPLETED; 8419 if ("entered-in-error".equals(codeString)) 8420 return ENTEREDINERROR; 8421 if ("unknown".equals(codeString)) 8422 return UNKNOWN; 8423 throw new FHIRException("Unknown EventStatus code '"+codeString+"'"); 8424 } 8425 public String toCode() { 8426 switch (this) { 8427 case PREPARATION: return "preparation"; 8428 case INPROGRESS: return "in-progress"; 8429 case NOTDONE: return "not-done"; 8430 case ONHOLD: return "on-hold"; 8431 case STOPPED: return "stopped"; 8432 case COMPLETED: return "completed"; 8433 case ENTEREDINERROR: return "entered-in-error"; 8434 case UNKNOWN: return "unknown"; 8435 case NULL: return null; 8436 default: return "?"; 8437 } 8438 } 8439 public String getSystem() { 8440 switch (this) { 8441 case PREPARATION: return "http://hl7.org/fhir/event-status"; 8442 case INPROGRESS: return "http://hl7.org/fhir/event-status"; 8443 case NOTDONE: return "http://hl7.org/fhir/event-status"; 8444 case ONHOLD: return "http://hl7.org/fhir/event-status"; 8445 case STOPPED: return "http://hl7.org/fhir/event-status"; 8446 case COMPLETED: return "http://hl7.org/fhir/event-status"; 8447 case ENTEREDINERROR: return "http://hl7.org/fhir/event-status"; 8448 case UNKNOWN: return "http://hl7.org/fhir/event-status"; 8449 case NULL: return null; 8450 default: return "?"; 8451 } 8452 } 8453 public String getDefinition() { 8454 switch (this) { 8455 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."; 8456 case INPROGRESS: return "The event is currently occurring."; 8457 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."; 8458 case ONHOLD: return "The event has been temporarily stopped but is expected to resume in the future."; 8459 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."; 8460 case COMPLETED: return "The event has now concluded."; 8461 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\".)."; 8462 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."; 8463 case NULL: return null; 8464 default: return "?"; 8465 } 8466 } 8467 public String getDisplay() { 8468 switch (this) { 8469 case PREPARATION: return "Preparation"; 8470 case INPROGRESS: return "In Progress"; 8471 case NOTDONE: return "Not Done"; 8472 case ONHOLD: return "On Hold"; 8473 case STOPPED: return "Stopped"; 8474 case COMPLETED: return "Completed"; 8475 case ENTEREDINERROR: return "Entered in Error"; 8476 case UNKNOWN: return "Unknown"; 8477 case NULL: return null; 8478 default: return "?"; 8479 } 8480 } 8481 } 8482 8483 public static class EventStatusEnumFactory implements EnumFactory<EventStatus> { 8484 public EventStatus fromCode(String codeString) throws IllegalArgumentException { 8485 if (codeString == null || "".equals(codeString)) 8486 if (codeString == null || "".equals(codeString)) 8487 return null; 8488 if ("preparation".equals(codeString)) 8489 return EventStatus.PREPARATION; 8490 if ("in-progress".equals(codeString)) 8491 return EventStatus.INPROGRESS; 8492 if ("not-done".equals(codeString)) 8493 return EventStatus.NOTDONE; 8494 if ("on-hold".equals(codeString)) 8495 return EventStatus.ONHOLD; 8496 if ("stopped".equals(codeString)) 8497 return EventStatus.STOPPED; 8498 if ("completed".equals(codeString)) 8499 return EventStatus.COMPLETED; 8500 if ("entered-in-error".equals(codeString)) 8501 return EventStatus.ENTEREDINERROR; 8502 if ("unknown".equals(codeString)) 8503 return EventStatus.UNKNOWN; 8504 throw new IllegalArgumentException("Unknown EventStatus code '"+codeString+"'"); 8505 } 8506 public Enumeration<EventStatus> fromType(PrimitiveType<?> code) throws FHIRException { 8507 if (code == null) 8508 return null; 8509 if (code.isEmpty()) 8510 return new Enumeration<EventStatus>(this, EventStatus.NULL, code); 8511 String codeString = ((PrimitiveType) code).asStringValue(); 8512 if (codeString == null || "".equals(codeString)) 8513 return new Enumeration<EventStatus>(this, EventStatus.NULL, code); 8514 if ("preparation".equals(codeString)) 8515 return new Enumeration<EventStatus>(this, EventStatus.PREPARATION, code); 8516 if ("in-progress".equals(codeString)) 8517 return new Enumeration<EventStatus>(this, EventStatus.INPROGRESS, code); 8518 if ("not-done".equals(codeString)) 8519 return new Enumeration<EventStatus>(this, EventStatus.NOTDONE, code); 8520 if ("on-hold".equals(codeString)) 8521 return new Enumeration<EventStatus>(this, EventStatus.ONHOLD, code); 8522 if ("stopped".equals(codeString)) 8523 return new Enumeration<EventStatus>(this, EventStatus.STOPPED, code); 8524 if ("completed".equals(codeString)) 8525 return new Enumeration<EventStatus>(this, EventStatus.COMPLETED, code); 8526 if ("entered-in-error".equals(codeString)) 8527 return new Enumeration<EventStatus>(this, EventStatus.ENTEREDINERROR, code); 8528 if ("unknown".equals(codeString)) 8529 return new Enumeration<EventStatus>(this, EventStatus.UNKNOWN, code); 8530 throw new FHIRException("Unknown EventStatus code '"+codeString+"'"); 8531 } 8532 public String toCode(EventStatus code) { 8533 if (code == EventStatus.PREPARATION) 8534 return "preparation"; 8535 if (code == EventStatus.INPROGRESS) 8536 return "in-progress"; 8537 if (code == EventStatus.NOTDONE) 8538 return "not-done"; 8539 if (code == EventStatus.ONHOLD) 8540 return "on-hold"; 8541 if (code == EventStatus.STOPPED) 8542 return "stopped"; 8543 if (code == EventStatus.COMPLETED) 8544 return "completed"; 8545 if (code == EventStatus.ENTEREDINERROR) 8546 return "entered-in-error"; 8547 if (code == EventStatus.UNKNOWN) 8548 return "unknown"; 8549 return "?"; 8550 } 8551 public String toSystem(EventStatus code) { 8552 return code.getSystem(); 8553 } 8554 } 8555 8556 public enum EvidenceVariableHandling { 8557 /** 8558 * 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). 8559 */ 8560 CONTINUOUS, 8561 /** 8562 * 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). 8563 */ 8564 DICHOTOMOUS, 8565 /** 8566 * 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). 8567 */ 8568 ORDINAL, 8569 /** 8570 * 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. 8571 */ 8572 POLYCHOTOMOUS, 8573 /** 8574 * added to help the parsers 8575 */ 8576 NULL; 8577 public static EvidenceVariableHandling fromCode(String codeString) throws FHIRException { 8578 if (codeString == null || "".equals(codeString)) 8579 return null; 8580 if ("continuous".equals(codeString)) 8581 return CONTINUOUS; 8582 if ("dichotomous".equals(codeString)) 8583 return DICHOTOMOUS; 8584 if ("ordinal".equals(codeString)) 8585 return ORDINAL; 8586 if ("polychotomous".equals(codeString)) 8587 return POLYCHOTOMOUS; 8588 throw new FHIRException("Unknown EvidenceVariableHandling code '"+codeString+"'"); 8589 } 8590 public String toCode() { 8591 switch (this) { 8592 case CONTINUOUS: return "continuous"; 8593 case DICHOTOMOUS: return "dichotomous"; 8594 case ORDINAL: return "ordinal"; 8595 case POLYCHOTOMOUS: return "polychotomous"; 8596 case NULL: return null; 8597 default: return "?"; 8598 } 8599 } 8600 public String getSystem() { 8601 switch (this) { 8602 case CONTINUOUS: return "http://hl7.org/fhir/variable-handling"; 8603 case DICHOTOMOUS: return "http://hl7.org/fhir/variable-handling"; 8604 case ORDINAL: return "http://hl7.org/fhir/variable-handling"; 8605 case POLYCHOTOMOUS: return "http://hl7.org/fhir/variable-handling"; 8606 case NULL: return null; 8607 default: return "?"; 8608 } 8609 } 8610 public String getDefinition() { 8611 switch (this) { 8612 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)."; 8613 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)."; 8614 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)."; 8615 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."; 8616 case NULL: return null; 8617 default: return "?"; 8618 } 8619 } 8620 public String getDisplay() { 8621 switch (this) { 8622 case CONTINUOUS: return "continuous variable"; 8623 case DICHOTOMOUS: return "dichotomous variable"; 8624 case ORDINAL: return "ordinal variable"; 8625 case POLYCHOTOMOUS: return "polychotomous variable"; 8626 case NULL: return null; 8627 default: return "?"; 8628 } 8629 } 8630 } 8631 8632 public static class EvidenceVariableHandlingEnumFactory implements EnumFactory<EvidenceVariableHandling> { 8633 public EvidenceVariableHandling fromCode(String codeString) throws IllegalArgumentException { 8634 if (codeString == null || "".equals(codeString)) 8635 if (codeString == null || "".equals(codeString)) 8636 return null; 8637 if ("continuous".equals(codeString)) 8638 return EvidenceVariableHandling.CONTINUOUS; 8639 if ("dichotomous".equals(codeString)) 8640 return EvidenceVariableHandling.DICHOTOMOUS; 8641 if ("ordinal".equals(codeString)) 8642 return EvidenceVariableHandling.ORDINAL; 8643 if ("polychotomous".equals(codeString)) 8644 return EvidenceVariableHandling.POLYCHOTOMOUS; 8645 throw new IllegalArgumentException("Unknown EvidenceVariableHandling code '"+codeString+"'"); 8646 } 8647 public Enumeration<EvidenceVariableHandling> fromType(PrimitiveType<?> code) throws FHIRException { 8648 if (code == null) 8649 return null; 8650 if (code.isEmpty()) 8651 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.NULL, code); 8652 String codeString = ((PrimitiveType) code).asStringValue(); 8653 if (codeString == null || "".equals(codeString)) 8654 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.NULL, code); 8655 if ("continuous".equals(codeString)) 8656 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.CONTINUOUS, code); 8657 if ("dichotomous".equals(codeString)) 8658 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.DICHOTOMOUS, code); 8659 if ("ordinal".equals(codeString)) 8660 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.ORDINAL, code); 8661 if ("polychotomous".equals(codeString)) 8662 return new Enumeration<EvidenceVariableHandling>(this, EvidenceVariableHandling.POLYCHOTOMOUS, code); 8663 throw new FHIRException("Unknown EvidenceVariableHandling code '"+codeString+"'"); 8664 } 8665 public String toCode(EvidenceVariableHandling code) { 8666 if (code == EvidenceVariableHandling.CONTINUOUS) 8667 return "continuous"; 8668 if (code == EvidenceVariableHandling.DICHOTOMOUS) 8669 return "dichotomous"; 8670 if (code == EvidenceVariableHandling.ORDINAL) 8671 return "ordinal"; 8672 if (code == EvidenceVariableHandling.POLYCHOTOMOUS) 8673 return "polychotomous"; 8674 return "?"; 8675 } 8676 public String toSystem(EvidenceVariableHandling code) { 8677 return code.getSystem(); 8678 } 8679 } 8680 8681 public enum ExampleScenarioActorType { 8682 /** 8683 * A human actor 8684 */ 8685 PERSON, 8686 /** 8687 * A software application or other system 8688 */ 8689 SYSTEM, 8690 /** 8691 * added to help the parsers 8692 */ 8693 NULL; 8694 public static ExampleScenarioActorType fromCode(String codeString) throws FHIRException { 8695 if (codeString == null || "".equals(codeString)) 8696 return null; 8697 if ("person".equals(codeString)) 8698 return PERSON; 8699 if ("system".equals(codeString)) 8700 return SYSTEM; 8701 throw new FHIRException("Unknown ExampleScenarioActorType code '"+codeString+"'"); 8702 } 8703 public String toCode() { 8704 switch (this) { 8705 case PERSON: return "person"; 8706 case SYSTEM: return "system"; 8707 case NULL: return null; 8708 default: return "?"; 8709 } 8710 } 8711 public String getSystem() { 8712 switch (this) { 8713 case PERSON: return "http://hl7.org/fhir/examplescenario-actor-type"; 8714 case SYSTEM: return "http://hl7.org/fhir/examplescenario-actor-type"; 8715 case NULL: return null; 8716 default: return "?"; 8717 } 8718 } 8719 public String getDefinition() { 8720 switch (this) { 8721 case PERSON: return "A human actor"; 8722 case SYSTEM: return "A software application or other system"; 8723 case NULL: return null; 8724 default: return "?"; 8725 } 8726 } 8727 public String getDisplay() { 8728 switch (this) { 8729 case PERSON: return "Person"; 8730 case SYSTEM: return "System"; 8731 case NULL: return null; 8732 default: return "?"; 8733 } 8734 } 8735 } 8736 8737 public static class ExampleScenarioActorTypeEnumFactory implements EnumFactory<ExampleScenarioActorType> { 8738 public ExampleScenarioActorType fromCode(String codeString) throws IllegalArgumentException { 8739 if (codeString == null || "".equals(codeString)) 8740 if (codeString == null || "".equals(codeString)) 8741 return null; 8742 if ("person".equals(codeString)) 8743 return ExampleScenarioActorType.PERSON; 8744 if ("system".equals(codeString)) 8745 return ExampleScenarioActorType.SYSTEM; 8746 throw new IllegalArgumentException("Unknown ExampleScenarioActorType code '"+codeString+"'"); 8747 } 8748 public Enumeration<ExampleScenarioActorType> fromType(PrimitiveType<?> code) throws FHIRException { 8749 if (code == null) 8750 return null; 8751 if (code.isEmpty()) 8752 return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.NULL, code); 8753 String codeString = ((PrimitiveType) code).asStringValue(); 8754 if (codeString == null || "".equals(codeString)) 8755 return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.NULL, code); 8756 if ("person".equals(codeString)) 8757 return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.PERSON, code); 8758 if ("system".equals(codeString)) 8759 return new Enumeration<ExampleScenarioActorType>(this, ExampleScenarioActorType.SYSTEM, code); 8760 throw new FHIRException("Unknown ExampleScenarioActorType code '"+codeString+"'"); 8761 } 8762 public String toCode(ExampleScenarioActorType code) { 8763 if (code == ExampleScenarioActorType.PERSON) 8764 return "person"; 8765 if (code == ExampleScenarioActorType.SYSTEM) 8766 return "system"; 8767 return "?"; 8768 } 8769 public String toSystem(ExampleScenarioActorType code) { 8770 return code.getSystem(); 8771 } 8772 } 8773 8774 public enum FHIRTypes { 8775 /** 8776 * Base Type: Base definition for all types defined in FHIR type system. 8777 */ 8778 BASE, 8779 /** 8780 * Element Type: Base definition for all elements in a resource. 8781 */ 8782 ELEMENT, 8783 /** 8784 * BackboneElement Type: Base definition for all elements that are defined inside a resource - but not those in a data type. 8785 */ 8786 BACKBONEELEMENT, 8787 /** 8788 * DataType Type: The base class for all re-useable types defined as part of the FHIR Specification. 8789 */ 8790 DATATYPE, 8791 /** 8792 * 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. 8793The ISO21090-codedString may be used to provide a coded representation of the contents of strings in an Address. 8794 */ 8795 ADDRESS, 8796 /** 8797 * Annotation Type: A text note which also contains information about who made the statement and when. 8798 */ 8799 ANNOTATION, 8800 /** 8801 * Attachment Type: For referring to data content defined in other formats. 8802 */ 8803 ATTACHMENT, 8804 /** 8805 * Availability Type: Availability data for an {item}. 8806 */ 8807 AVAILABILITY, 8808 /** 8809 * BackboneType Type: Base definition for the few data types that are allowed to carry modifier extensions. 8810 */ 8811 BACKBONETYPE, 8812 /** 8813 * Dosage Type: Indicates how the medication is/was taken or should be taken by the patient. 8814 */ 8815 DOSAGE, 8816 /** 8817 * ElementDefinition Type: Captures constraints on each element within the resource, profile, or extension. 8818 */ 8819 ELEMENTDEFINITION, 8820 /** 8821 * 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. 8822 */ 8823 MARKETINGSTATUS, 8824 /** 8825 * Population Type: A populatioof people with some set of grouping criteria. 8826 */ 8827 POPULATION, 8828 /** 8829 * ProductShelfLife Type: The shelf-life and storage information for a medicinal product item or container can be described using this class. 8830 */ 8831 PRODUCTSHELFLIFE, 8832 /** 8833 * 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. 8834 */ 8835 TIMING, 8836 /** 8837 * CodeableConcept Type: A concept that may be defined by a formal reference to a terminology or ontology or may be provided by text. 8838 */ 8839 CODEABLECONCEPT, 8840 /** 8841 * CodeableReference Type: A reference to a resource (by instance), or instead, a reference to a concept defined in a terminology or ontology (by class). 8842 */ 8843 CODEABLEREFERENCE, 8844 /** 8845 * Coding Type: A reference to a code defined by a terminology system. 8846 */ 8847 CODING, 8848 /** 8849 * ContactDetail Type: Specifies contact information for a person or organization. 8850 */ 8851 CONTACTDETAIL, 8852 /** 8853 * ContactPoint Type: Details for all kinds of technology mediated contact points for a person or organization, including telephone, email, etc. 8854 */ 8855 CONTACTPOINT, 8856 /** 8857 * Contributor Type: A contributor to the content of a knowledge asset, including authors, editors, reviewers, and endorsers. 8858 */ 8859 CONTRIBUTOR, 8860 /** 8861 * 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. 8862 */ 8863 DATAREQUIREMENT, 8864 /** 8865 * 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. 8866 */ 8867 EXPRESSION, 8868 /** 8869 * 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. 8870 */ 8871 EXTENDEDCONTACTDETAIL, 8872 /** 8873 * Extension Type: Optional Extension Element - found in all resources. 8874 */ 8875 EXTENSION, 8876 /** 8877 * 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. 8878 */ 8879 HUMANNAME, 8880 /** 8881 * Identifier Type: An identifier - identifies some entity uniquely and unambiguously. Typically this is used for business identifiers. 8882 */ 8883 IDENTIFIER, 8884 /** 8885 * 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. 8886 */ 8887 META, 8888 /** 8889 * MonetaryComponent Type: Availability data for an {item}. 8890 */ 8891 MONETARYCOMPONENT, 8892 /** 8893 * Money Type: An amount of economic utility in some recognized currency. 8894 */ 8895 MONEY, 8896 /** 8897 * Narrative Type: A human-readable summary of the resource conveying the essential clinical and business information for the resource. 8898 */ 8899 NARRATIVE, 8900 /** 8901 * 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. 8902 */ 8903 PARAMETERDEFINITION, 8904 /** 8905 * Period Type: A time period defined by a start and end date and optionally time. 8906 */ 8907 PERIOD, 8908 /** 8909 * PrimitiveType Type: The base type for all re-useable types defined that have a simple property. 8910 */ 8911 PRIMITIVETYPE, 8912 /** 8913 * base64Binary Type: A stream of bytes 8914 */ 8915 BASE64BINARY, 8916 /** 8917 * boolean Type: Value of "true" or "false" 8918 */ 8919 BOOLEAN, 8920 /** 8921 * 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. 8922 */ 8923 DATE, 8924 /** 8925 * 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. 8926 */ 8927 DATETIME, 8928 /** 8929 * decimal Type: A rational number with implicit precision 8930 */ 8931 DECIMAL, 8932 /** 8933 * instant Type: An instant in time - known at least to the second 8934 */ 8935 INSTANT, 8936 /** 8937 * integer Type: A whole number 8938 */ 8939 INTEGER, 8940 /** 8941 * positiveInt type: An integer with a value that is positive (e.g. >0) 8942 */ 8943 POSITIVEINT, 8944 /** 8945 * unsignedInt type: An integer with a value that is not negative (e.g. >= 0) 8946 */ 8947 UNSIGNEDINT, 8948 /** 8949 * integer64 Type: A very large whole number 8950 */ 8951 INTEGER64, 8952 /** 8953 * string Type: A sequence of Unicode characters 8954 */ 8955 STRING, 8956 /** 8957 * 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 8958 */ 8959 CODE, 8960 /** 8961 * 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. 8962 */ 8963 ID, 8964 /** 8965 * markdown type: A string that may contain Github Flavored Markdown syntax for optional processing by a mark down presentation engine 8966 */ 8967 MARKDOWN, 8968 /** 8969 * time Type: A time during the day, with no date specified