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