001package org.hl7.fhir.r4.model; 002 003 004 005/* 006 Copyright (c) 2011+, HL7, Inc. 007 All rights reserved. 008 009 Redistribution and use in source and binary forms, with or without modification, 010 are permitted provided that the following conditions are met: 011 012 * Redistributions of source code must retain the above copyright notice, this 013 list of conditions and the following disclaimer. 014 * Redistributions in binary form must reproduce the above copyright notice, 015 this list of conditions and the following disclaimer in the documentation 016 and/or other materials provided with the distribution. 017 * Neither the name of HL7 nor the names of its contributors may be used to 018 endorse or promote products derived from this software without specific 019 prior written permission. 020 021 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 022 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 023 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 024 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 025 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 026 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 027 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 028 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 029 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 030 POSSIBILITY OF SUCH DAMAGE. 031 032*/ 033 034 035// Generated on Tue, May 12, 2020 07:26+1000 for FHIR v4.0.1 036 037import java.util.*; 038 039import org.hl7.fhir.utilities.Utilities; 040import ca.uhn.fhir.model.api.annotation.ResourceDef; 041import ca.uhn.fhir.model.api.annotation.SearchParamDefinition; 042import ca.uhn.fhir.model.api.annotation.Child; 043import ca.uhn.fhir.model.api.annotation.ChildOrder; 044import ca.uhn.fhir.model.api.annotation.Description; 045import ca.uhn.fhir.model.api.annotation.Block; 046import org.hl7.fhir.instance.model.api.*; 047import org.hl7.fhir.exceptions.FHIRException; 048/** 049 * 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. 050 */ 051@ResourceDef(name="GuidanceResponse", profile="http://hl7.org/fhir/StructureDefinition/GuidanceResponse") 052public class GuidanceResponse extends DomainResource { 053 054 public enum GuidanceResponseStatus { 055 /** 056 * The request was processed successfully. 057 */ 058 SUCCESS, 059 /** 060 * The request was processed successfully, but more data may result in a more complete evaluation. 061 */ 062 DATAREQUESTED, 063 /** 064 * The request was processed, but more data is required to complete the evaluation. 065 */ 066 DATAREQUIRED, 067 /** 068 * The request is currently being processed. 069 */ 070 INPROGRESS, 071 /** 072 * The request was not processed successfully. 073 */ 074 FAILURE, 075 /** 076 * The response was entered in error. 077 */ 078 ENTEREDINERROR, 079 /** 080 * added to help the parsers with the generic types 081 */ 082 NULL; 083 public static GuidanceResponseStatus fromCode(String codeString) throws FHIRException { 084 if (codeString == null || "".equals(codeString)) 085 return null; 086 if ("success".equals(codeString)) 087 return SUCCESS; 088 if ("data-requested".equals(codeString)) 089 return DATAREQUESTED; 090 if ("data-required".equals(codeString)) 091 return DATAREQUIRED; 092 if ("in-progress".equals(codeString)) 093 return INPROGRESS; 094 if ("failure".equals(codeString)) 095 return FAILURE; 096 if ("entered-in-error".equals(codeString)) 097 return ENTEREDINERROR; 098 if (Configuration.isAcceptInvalidEnums()) 099 return null; 100 else 101 throw new FHIRException("Unknown GuidanceResponseStatus code '"+codeString+"'"); 102 } 103 public String toCode() { 104 switch (this) { 105 case SUCCESS: return "success"; 106 case DATAREQUESTED: return "data-requested"; 107 case DATAREQUIRED: return "data-required"; 108 case INPROGRESS: return "in-progress"; 109 case FAILURE: return "failure"; 110 case ENTEREDINERROR: return "entered-in-error"; 111 default: return "?"; 112 } 113 } 114 public String getSystem() { 115 switch (this) { 116 case SUCCESS: return "http://hl7.org/fhir/guidance-response-status"; 117 case DATAREQUESTED: return "http://hl7.org/fhir/guidance-response-status"; 118 case DATAREQUIRED: return "http://hl7.org/fhir/guidance-response-status"; 119 case INPROGRESS: return "http://hl7.org/fhir/guidance-response-status"; 120 case FAILURE: return "http://hl7.org/fhir/guidance-response-status"; 121 case ENTEREDINERROR: return "http://hl7.org/fhir/guidance-response-status"; 122 default: return "?"; 123 } 124 } 125 public String getDefinition() { 126 switch (this) { 127 case SUCCESS: return "The request was processed successfully."; 128 case DATAREQUESTED: return "The request was processed successfully, but more data may result in a more complete evaluation."; 129 case DATAREQUIRED: return "The request was processed, but more data is required to complete the evaluation."; 130 case INPROGRESS: return "The request is currently being processed."; 131 case FAILURE: return "The request was not processed successfully."; 132 case ENTEREDINERROR: return "The response was entered in error."; 133 default: return "?"; 134 } 135 } 136 public String getDisplay() { 137 switch (this) { 138 case SUCCESS: return "Success"; 139 case DATAREQUESTED: return "Data Requested"; 140 case DATAREQUIRED: return "Data Required"; 141 case INPROGRESS: return "In Progress"; 142 case FAILURE: return "Failure"; 143 case ENTEREDINERROR: return "Entered In Error"; 144 default: return "?"; 145 } 146 } 147 } 148 149 public static class GuidanceResponseStatusEnumFactory implements EnumFactory<GuidanceResponseStatus> { 150 public GuidanceResponseStatus fromCode(String codeString) throws IllegalArgumentException { 151 if (codeString == null || "".equals(codeString)) 152 if (codeString == null || "".equals(codeString)) 153 return null; 154 if ("success".equals(codeString)) 155 return GuidanceResponseStatus.SUCCESS; 156 if ("data-requested".equals(codeString)) 157 return GuidanceResponseStatus.DATAREQUESTED; 158 if ("data-required".equals(codeString)) 159 return GuidanceResponseStatus.DATAREQUIRED; 160 if ("in-progress".equals(codeString)) 161 return GuidanceResponseStatus.INPROGRESS; 162 if ("failure".equals(codeString)) 163 return GuidanceResponseStatus.FAILURE; 164 if ("entered-in-error".equals(codeString)) 165 return GuidanceResponseStatus.ENTEREDINERROR; 166 throw new IllegalArgumentException("Unknown GuidanceResponseStatus code '"+codeString+"'"); 167 } 168 public Enumeration<GuidanceResponseStatus> fromType(Base code) throws FHIRException { 169 if (code == null) 170 return null; 171 if (code.isEmpty()) 172 return new Enumeration<GuidanceResponseStatus>(this); 173 String codeString = ((PrimitiveType) code).asStringValue(); 174 if (codeString == null || "".equals(codeString)) 175 return null; 176 if ("success".equals(codeString)) 177 return new Enumeration<GuidanceResponseStatus>(this, GuidanceResponseStatus.SUCCESS); 178 if ("data-requested".equals(codeString)) 179 return new Enumeration<GuidanceResponseStatus>(this, GuidanceResponseStatus.DATAREQUESTED); 180 if ("data-required".equals(codeString)) 181 return new Enumeration<GuidanceResponseStatus>(this, GuidanceResponseStatus.DATAREQUIRED); 182 if ("in-progress".equals(codeString)) 183 return new Enumeration<GuidanceResponseStatus>(this, GuidanceResponseStatus.INPROGRESS); 184 if ("failure".equals(codeString)) 185 return new Enumeration<GuidanceResponseStatus>(this, GuidanceResponseStatus.FAILURE); 186 if ("entered-in-error".equals(codeString)) 187 return new Enumeration<GuidanceResponseStatus>(this, GuidanceResponseStatus.ENTEREDINERROR); 188 throw new FHIRException("Unknown GuidanceResponseStatus code '"+codeString+"'"); 189 } 190 public String toCode(GuidanceResponseStatus code) { 191 if (code == GuidanceResponseStatus.SUCCESS) 192 return "success"; 193 if (code == GuidanceResponseStatus.DATAREQUESTED) 194 return "data-requested"; 195 if (code == GuidanceResponseStatus.DATAREQUIRED) 196 return "data-required"; 197 if (code == GuidanceResponseStatus.INPROGRESS) 198 return "in-progress"; 199 if (code == GuidanceResponseStatus.FAILURE) 200 return "failure"; 201 if (code == GuidanceResponseStatus.ENTEREDINERROR) 202 return "entered-in-error"; 203 return "?"; 204 } 205 public String toSystem(GuidanceResponseStatus code) { 206 return code.getSystem(); 207 } 208 } 209 210 /** 211 * The identifier of the request associated with this response. If an identifier was given as part of the request, it will be reproduced here to enable the requester to more easily identify the response in a multi-request scenario. 212 */ 213 @Child(name = "requestIdentifier", type = {Identifier.class}, order=0, min=0, max=1, modifier=false, summary=true) 214 @Description(shortDefinition="The identifier of the request associated with this response, if any", formalDefinition="The identifier of the request associated with this response. If an identifier was given as part of the request, it will be reproduced here to enable the requester to more easily identify the response in a multi-request scenario." ) 215 protected Identifier requestIdentifier; 216 217 /** 218 * Allows a service to provide unique, business identifiers for the response. 219 */ 220 @Child(name = "identifier", type = {Identifier.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 221 @Description(shortDefinition="Business identifier", formalDefinition="Allows a service to provide unique, business identifiers for the response." ) 222 protected List<Identifier> identifier; 223 224 /** 225 * An identifier, CodeableConcept or canonical reference to the guidance that was requested. 226 */ 227 @Child(name = "module", type = {UriType.class, CanonicalType.class, CodeableConcept.class}, order=2, min=1, max=1, modifier=false, summary=true) 228 @Description(shortDefinition="What guidance was requested", formalDefinition="An identifier, CodeableConcept or canonical reference to the guidance that was requested." ) 229 protected Type module; 230 231 /** 232 * The status of the response. If the evaluation is completed successfully, the status will indicate success. However, in order to complete the evaluation, the engine may require more information. In this case, the status will be data-required, and the response will contain a description of the additional required information. If the evaluation completed successfully, but the engine determines that a potentially more accurate response could be provided if more data was available, the status will be data-requested, and the response will contain a description of the additional requested information. 233 */ 234 @Child(name = "status", type = {CodeType.class}, order=3, min=1, max=1, modifier=true, summary=true) 235 @Description(shortDefinition="success | data-requested | data-required | in-progress | failure | entered-in-error", formalDefinition="The status of the response. If the evaluation is completed successfully, the status will indicate success. However, in order to complete the evaluation, the engine may require more information. In this case, the status will be data-required, and the response will contain a description of the additional required information. If the evaluation completed successfully, but the engine determines that a potentially more accurate response could be provided if more data was available, the status will be data-requested, and the response will contain a description of the additional requested information." ) 236 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/guidance-response-status") 237 protected Enumeration<GuidanceResponseStatus> status; 238 239 /** 240 * The patient for which the request was processed. 241 */ 242 @Child(name = "subject", type = {Patient.class, Group.class}, order=4, min=0, max=1, modifier=false, summary=false) 243 @Description(shortDefinition="Patient the request was performed for", formalDefinition="The patient for which the request was processed." ) 244 protected Reference subject; 245 246 /** 247 * The actual object that is the target of the reference (The patient for which the request was processed.) 248 */ 249 protected Resource subjectTarget; 250 251 /** 252 * The encounter during which this response was created or to which the creation of this record is tightly associated. 253 */ 254 @Child(name = "encounter", type = {Encounter.class}, order=5, min=0, max=1, modifier=false, summary=false) 255 @Description(shortDefinition="Encounter during which the response was returned", formalDefinition="The encounter during which this response was created or to which the creation of this record is tightly associated." ) 256 protected Reference encounter; 257 258 /** 259 * The actual object that is the target of the reference (The encounter during which this response was created or to which the creation of this record is tightly associated.) 260 */ 261 protected Encounter encounterTarget; 262 263 /** 264 * Indicates when the guidance response was processed. 265 */ 266 @Child(name = "occurrenceDateTime", type = {DateTimeType.class}, order=6, min=0, max=1, modifier=false, summary=false) 267 @Description(shortDefinition="When the guidance response was processed", formalDefinition="Indicates when the guidance response was processed." ) 268 protected DateTimeType occurrenceDateTime; 269 270 /** 271 * Provides a reference to the device that performed the guidance. 272 */ 273 @Child(name = "performer", type = {Device.class}, order=7, min=0, max=1, modifier=false, summary=false) 274 @Description(shortDefinition="Device returning the guidance", formalDefinition="Provides a reference to the device that performed the guidance." ) 275 protected Reference performer; 276 277 /** 278 * The actual object that is the target of the reference (Provides a reference to the device that performed the guidance.) 279 */ 280 protected Device performerTarget; 281 282 /** 283 * Describes the reason for the guidance response in coded or textual form. 284 */ 285 @Child(name = "reasonCode", type = {CodeableConcept.class}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 286 @Description(shortDefinition="Why guidance is needed", formalDefinition="Describes the reason for the guidance response in coded or textual form." ) 287 protected List<CodeableConcept> reasonCode; 288 289 /** 290 * Indicates the reason the request was initiated. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response. 291 */ 292 @Child(name = "reasonReference", type = {Condition.class, Observation.class, DiagnosticReport.class, DocumentReference.class}, order=9, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 293 @Description(shortDefinition="Why guidance is needed", formalDefinition="Indicates the reason the request was initiated. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response." ) 294 protected List<Reference> reasonReference; 295 /** 296 * The actual objects that are the target of the reference (Indicates the reason the request was initiated. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.) 297 */ 298 protected List<Resource> reasonReferenceTarget; 299 300 301 /** 302 * Provides a mechanism to communicate additional information about the response. 303 */ 304 @Child(name = "note", type = {Annotation.class}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 305 @Description(shortDefinition="Additional notes about the response", formalDefinition="Provides a mechanism to communicate additional information about the response." ) 306 protected List<Annotation> note; 307 308 /** 309 * Messages resulting from the evaluation of the artifact or artifacts. As part of evaluating the request, the engine may produce informational or warning messages. These messages will be provided by this element. 310 */ 311 @Child(name = "evaluationMessage", type = {OperationOutcome.class}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 312 @Description(shortDefinition="Messages resulting from the evaluation of the artifact or artifacts", formalDefinition="Messages resulting from the evaluation of the artifact or artifacts. As part of evaluating the request, the engine may produce informational or warning messages. These messages will be provided by this element." ) 313 protected List<Reference> evaluationMessage; 314 /** 315 * The actual objects that are the target of the reference (Messages resulting from the evaluation of the artifact or artifacts. As part of evaluating the request, the engine may produce informational or warning messages. These messages will be provided by this element.) 316 */ 317 protected List<OperationOutcome> evaluationMessageTarget; 318 319 320 /** 321 * The output parameters of the evaluation, if any. Many modules will result in the return of specific resources such as procedure or communication requests that are returned as part of the operation result. However, modules may define specific outputs that would be returned as the result of the evaluation, and these would be returned in this element. 322 */ 323 @Child(name = "outputParameters", type = {Parameters.class}, order=12, min=0, max=1, modifier=false, summary=false) 324 @Description(shortDefinition="The output parameters of the evaluation, if any", formalDefinition="The output parameters of the evaluation, if any. Many modules will result in the return of specific resources such as procedure or communication requests that are returned as part of the operation result. However, modules may define specific outputs that would be returned as the result of the evaluation, and these would be returned in this element." ) 325 protected Reference outputParameters; 326 327 /** 328 * The actual object that is the target of the reference (The output parameters of the evaluation, if any. Many modules will result in the return of specific resources such as procedure or communication requests that are returned as part of the operation result. However, modules may define specific outputs that would be returned as the result of the evaluation, and these would be returned in this element.) 329 */ 330 protected Parameters outputParametersTarget; 331 332 /** 333 * The actions, if any, produced by the evaluation of the artifact. 334 */ 335 @Child(name = "result", type = {CarePlan.class, RequestGroup.class}, order=13, min=0, max=1, modifier=false, summary=false) 336 @Description(shortDefinition="Proposed actions, if any", formalDefinition="The actions, if any, produced by the evaluation of the artifact." ) 337 protected Reference result; 338 339 /** 340 * The actual object that is the target of the reference (The actions, if any, produced by the evaluation of the artifact.) 341 */ 342 protected Resource resultTarget; 343 344 /** 345 * If the evaluation could not be completed due to lack of information, or additional information would potentially result in a more accurate response, this element will a description of the data required in order to proceed with the evaluation. A subsequent request to the service should include this data. 346 */ 347 @Child(name = "dataRequirement", type = {DataRequirement.class}, order=14, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 348 @Description(shortDefinition="Additional required data", formalDefinition="If the evaluation could not be completed due to lack of information, or additional information would potentially result in a more accurate response, this element will a description of the data required in order to proceed with the evaluation. A subsequent request to the service should include this data." ) 349 protected List<DataRequirement> dataRequirement; 350 351 private static final long serialVersionUID = -760182193L; 352 353 /** 354 * Constructor 355 */ 356 public GuidanceResponse() { 357 super(); 358 } 359 360 /** 361 * Constructor 362 */ 363 public GuidanceResponse(Type module, Enumeration<GuidanceResponseStatus> status) { 364 super(); 365 this.module = module; 366 this.status = status; 367 } 368 369 /** 370 * @return {@link #requestIdentifier} (The identifier of the request associated with this response. If an identifier was given as part of the request, it will be reproduced here to enable the requester to more easily identify the response in a multi-request scenario.) 371 */ 372 public Identifier getRequestIdentifier() { 373 if (this.requestIdentifier == null) 374 if (Configuration.errorOnAutoCreate()) 375 throw new Error("Attempt to auto-create GuidanceResponse.requestIdentifier"); 376 else if (Configuration.doAutoCreate()) 377 this.requestIdentifier = new Identifier(); // cc 378 return this.requestIdentifier; 379 } 380 381 public boolean hasRequestIdentifier() { 382 return this.requestIdentifier != null && !this.requestIdentifier.isEmpty(); 383 } 384 385 /** 386 * @param value {@link #requestIdentifier} (The identifier of the request associated with this response. If an identifier was given as part of the request, it will be reproduced here to enable the requester to more easily identify the response in a multi-request scenario.) 387 */ 388 public GuidanceResponse setRequestIdentifier(Identifier value) { 389 this.requestIdentifier = value; 390 return this; 391 } 392 393 /** 394 * @return {@link #identifier} (Allows a service to provide unique, business identifiers for the response.) 395 */ 396 public List<Identifier> getIdentifier() { 397 if (this.identifier == null) 398 this.identifier = new ArrayList<Identifier>(); 399 return this.identifier; 400 } 401 402 /** 403 * @return Returns a reference to <code>this</code> for easy method chaining 404 */ 405 public GuidanceResponse setIdentifier(List<Identifier> theIdentifier) { 406 this.identifier = theIdentifier; 407 return this; 408 } 409 410 public boolean hasIdentifier() { 411 if (this.identifier == null) 412 return false; 413 for (Identifier item : this.identifier) 414 if (!item.isEmpty()) 415 return true; 416 return false; 417 } 418 419 public Identifier addIdentifier() { //3 420 Identifier t = new Identifier(); 421 if (this.identifier == null) 422 this.identifier = new ArrayList<Identifier>(); 423 this.identifier.add(t); 424 return t; 425 } 426 427 public GuidanceResponse addIdentifier(Identifier t) { //3 428 if (t == null) 429 return this; 430 if (this.identifier == null) 431 this.identifier = new ArrayList<Identifier>(); 432 this.identifier.add(t); 433 return this; 434 } 435 436 /** 437 * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist 438 */ 439 public Identifier getIdentifierFirstRep() { 440 if (getIdentifier().isEmpty()) { 441 addIdentifier(); 442 } 443 return getIdentifier().get(0); 444 } 445 446 /** 447 * @return {@link #module} (An identifier, CodeableConcept or canonical reference to the guidance that was requested.) 448 */ 449 public Type getModule() { 450 return this.module; 451 } 452 453 /** 454 * @return {@link #module} (An identifier, CodeableConcept or canonical reference to the guidance that was requested.) 455 */ 456 public UriType getModuleUriType() throws FHIRException { 457 if (this.module == null) 458 this.module = new UriType(); 459 if (!(this.module instanceof UriType)) 460 throw new FHIRException("Type mismatch: the type UriType was expected, but "+this.module.getClass().getName()+" was encountered"); 461 return (UriType) this.module; 462 } 463 464 public boolean hasModuleUriType() { 465 return this != null && this.module instanceof UriType; 466 } 467 468 /** 469 * @return {@link #module} (An identifier, CodeableConcept or canonical reference to the guidance that was requested.) 470 */ 471 public CanonicalType getModuleCanonicalType() throws FHIRException { 472 if (this.module == null) 473 this.module = new CanonicalType(); 474 if (!(this.module instanceof CanonicalType)) 475 throw new FHIRException("Type mismatch: the type CanonicalType was expected, but "+this.module.getClass().getName()+" was encountered"); 476 return (CanonicalType) this.module; 477 } 478 479 public boolean hasModuleCanonicalType() { 480 return this != null && this.module instanceof CanonicalType; 481 } 482 483 /** 484 * @return {@link #module} (An identifier, CodeableConcept or canonical reference to the guidance that was requested.) 485 */ 486 public CodeableConcept getModuleCodeableConcept() throws FHIRException { 487 if (this.module == null) 488 this.module = new CodeableConcept(); 489 if (!(this.module instanceof CodeableConcept)) 490 throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but "+this.module.getClass().getName()+" was encountered"); 491 return (CodeableConcept) this.module; 492 } 493 494 public boolean hasModuleCodeableConcept() { 495 return this != null && this.module instanceof CodeableConcept; 496 } 497 498 public boolean hasModule() { 499 return this.module != null && !this.module.isEmpty(); 500 } 501 502 /** 503 * @param value {@link #module} (An identifier, CodeableConcept or canonical reference to the guidance that was requested.) 504 */ 505 public GuidanceResponse setModule(Type value) { 506 if (value != null && !(value instanceof UriType || value instanceof CanonicalType || value instanceof CodeableConcept)) 507 throw new Error("Not the right type for GuidanceResponse.module[x]: "+value.fhirType()); 508 this.module = value; 509 return this; 510 } 511 512 /** 513 * @return {@link #status} (The status of the response. If the evaluation is completed successfully, the status will indicate success. However, in order to complete the evaluation, the engine may require more information. In this case, the status will be data-required, and the response will contain a description of the additional required information. If the evaluation completed successfully, but the engine determines that a potentially more accurate response could be provided if more data was available, the status will be data-requested, and the response will contain a description of the additional requested information.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value 514 */ 515 public Enumeration<GuidanceResponseStatus> getStatusElement() { 516 if (this.status == null) 517 if (Configuration.errorOnAutoCreate()) 518 throw new Error("Attempt to auto-create GuidanceResponse.status"); 519 else if (Configuration.doAutoCreate()) 520 this.status = new Enumeration<GuidanceResponseStatus>(new GuidanceResponseStatusEnumFactory()); // bb 521 return this.status; 522 } 523 524 public boolean hasStatusElement() { 525 return this.status != null && !this.status.isEmpty(); 526 } 527 528 public boolean hasStatus() { 529 return this.status != null && !this.status.isEmpty(); 530 } 531 532 /** 533 * @param value {@link #status} (The status of the response. If the evaluation is completed successfully, the status will indicate success. However, in order to complete the evaluation, the engine may require more information. In this case, the status will be data-required, and the response will contain a description of the additional required information. If the evaluation completed successfully, but the engine determines that a potentially more accurate response could be provided if more data was available, the status will be data-requested, and the response will contain a description of the additional requested information.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value 534 */ 535 public GuidanceResponse setStatusElement(Enumeration<GuidanceResponseStatus> value) { 536 this.status = value; 537 return this; 538 } 539 540 /** 541 * @return The status of the response. If the evaluation is completed successfully, the status will indicate success. However, in order to complete the evaluation, the engine may require more information. In this case, the status will be data-required, and the response will contain a description of the additional required information. If the evaluation completed successfully, but the engine determines that a potentially more accurate response could be provided if more data was available, the status will be data-requested, and the response will contain a description of the additional requested information. 542 */ 543 public GuidanceResponseStatus getStatus() { 544 return this.status == null ? null : this.status.getValue(); 545 } 546 547 /** 548 * @param value The status of the response. If the evaluation is completed successfully, the status will indicate success. However, in order to complete the evaluation, the engine may require more information. In this case, the status will be data-required, and the response will contain a description of the additional required information. If the evaluation completed successfully, but the engine determines that a potentially more accurate response could be provided if more data was available, the status will be data-requested, and the response will contain a description of the additional requested information. 549 */ 550 public GuidanceResponse setStatus(GuidanceResponseStatus value) { 551 if (this.status == null) 552 this.status = new Enumeration<GuidanceResponseStatus>(new GuidanceResponseStatusEnumFactory()); 553 this.status.setValue(value); 554 return this; 555 } 556 557 /** 558 * @return {@link #subject} (The patient for which the request was processed.) 559 */ 560 public Reference getSubject() { 561 if (this.subject == null) 562 if (Configuration.errorOnAutoCreate()) 563 throw new Error("Attempt to auto-create GuidanceResponse.subject"); 564 else if (Configuration.doAutoCreate()) 565 this.subject = new Reference(); // cc 566 return this.subject; 567 } 568 569 public boolean hasSubject() { 570 return this.subject != null && !this.subject.isEmpty(); 571 } 572 573 /** 574 * @param value {@link #subject} (The patient for which the request was processed.) 575 */ 576 public GuidanceResponse setSubject(Reference value) { 577 this.subject = value; 578 return this; 579 } 580 581 /** 582 * @return {@link #subject} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The patient for which the request was processed.) 583 */ 584 public Resource getSubjectTarget() { 585 return this.subjectTarget; 586 } 587 588 /** 589 * @param value {@link #subject} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The patient for which the request was processed.) 590 */ 591 public GuidanceResponse setSubjectTarget(Resource value) { 592 this.subjectTarget = value; 593 return this; 594 } 595 596 /** 597 * @return {@link #encounter} (The encounter during which this response was created or to which the creation of this record is tightly associated.) 598 */ 599 public Reference getEncounter() { 600 if (this.encounter == null) 601 if (Configuration.errorOnAutoCreate()) 602 throw new Error("Attempt to auto-create GuidanceResponse.encounter"); 603 else if (Configuration.doAutoCreate()) 604 this.encounter = new Reference(); // cc 605 return this.encounter; 606 } 607 608 public boolean hasEncounter() { 609 return this.encounter != null && !this.encounter.isEmpty(); 610 } 611 612 /** 613 * @param value {@link #encounter} (The encounter during which this response was created or to which the creation of this record is tightly associated.) 614 */ 615 public GuidanceResponse setEncounter(Reference value) { 616 this.encounter = value; 617 return this; 618 } 619 620 /** 621 * @return {@link #encounter} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The encounter during which this response was created or to which the creation of this record is tightly associated.) 622 */ 623 public Encounter getEncounterTarget() { 624 if (this.encounterTarget == null) 625 if (Configuration.errorOnAutoCreate()) 626 throw new Error("Attempt to auto-create GuidanceResponse.encounter"); 627 else if (Configuration.doAutoCreate()) 628 this.encounterTarget = new Encounter(); // aa 629 return this.encounterTarget; 630 } 631 632 /** 633 * @param value {@link #encounter} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The encounter during which this response was created or to which the creation of this record is tightly associated.) 634 */ 635 public GuidanceResponse setEncounterTarget(Encounter value) { 636 this.encounterTarget = value; 637 return this; 638 } 639 640 /** 641 * @return {@link #occurrenceDateTime} (Indicates when the guidance response was processed.). This is the underlying object with id, value and extensions. The accessor "getOccurrenceDateTime" gives direct access to the value 642 */ 643 public DateTimeType getOccurrenceDateTimeElement() { 644 if (this.occurrenceDateTime == null) 645 if (Configuration.errorOnAutoCreate()) 646 throw new Error("Attempt to auto-create GuidanceResponse.occurrenceDateTime"); 647 else if (Configuration.doAutoCreate()) 648 this.occurrenceDateTime = new DateTimeType(); // bb 649 return this.occurrenceDateTime; 650 } 651 652 public boolean hasOccurrenceDateTimeElement() { 653 return this.occurrenceDateTime != null && !this.occurrenceDateTime.isEmpty(); 654 } 655 656 public boolean hasOccurrenceDateTime() { 657 return this.occurrenceDateTime != null && !this.occurrenceDateTime.isEmpty(); 658 } 659 660 /** 661 * @param value {@link #occurrenceDateTime} (Indicates when the guidance response was processed.). This is the underlying object with id, value and extensions. The accessor "getOccurrenceDateTime" gives direct access to the value 662 */ 663 public GuidanceResponse setOccurrenceDateTimeElement(DateTimeType value) { 664 this.occurrenceDateTime = value; 665 return this; 666 } 667 668 /** 669 * @return Indicates when the guidance response was processed. 670 */ 671 public Date getOccurrenceDateTime() { 672 return this.occurrenceDateTime == null ? null : this.occurrenceDateTime.getValue(); 673 } 674 675 /** 676 * @param value Indicates when the guidance response was processed. 677 */ 678 public GuidanceResponse setOccurrenceDateTime(Date value) { 679 if (value == null) 680 this.occurrenceDateTime = null; 681 else { 682 if (this.occurrenceDateTime == null) 683 this.occurrenceDateTime = new DateTimeType(); 684 this.occurrenceDateTime.setValue(value); 685 } 686 return this; 687 } 688 689 /** 690 * @return {@link #performer} (Provides a reference to the device that performed the guidance.) 691 */ 692 public Reference getPerformer() { 693 if (this.performer == null) 694 if (Configuration.errorOnAutoCreate()) 695 throw new Error("Attempt to auto-create GuidanceResponse.performer"); 696 else if (Configuration.doAutoCreate()) 697 this.performer = new Reference(); // cc 698 return this.performer; 699 } 700 701 public boolean hasPerformer() { 702 return this.performer != null && !this.performer.isEmpty(); 703 } 704 705 /** 706 * @param value {@link #performer} (Provides a reference to the device that performed the guidance.) 707 */ 708 public GuidanceResponse setPerformer(Reference value) { 709 this.performer = value; 710 return this; 711 } 712 713 /** 714 * @return {@link #performer} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (Provides a reference to the device that performed the guidance.) 715 */ 716 public Device getPerformerTarget() { 717 if (this.performerTarget == null) 718 if (Configuration.errorOnAutoCreate()) 719 throw new Error("Attempt to auto-create GuidanceResponse.performer"); 720 else if (Configuration.doAutoCreate()) 721 this.performerTarget = new Device(); // aa 722 return this.performerTarget; 723 } 724 725 /** 726 * @param value {@link #performer} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (Provides a reference to the device that performed the guidance.) 727 */ 728 public GuidanceResponse setPerformerTarget(Device value) { 729 this.performerTarget = value; 730 return this; 731 } 732 733 /** 734 * @return {@link #reasonCode} (Describes the reason for the guidance response in coded or textual form.) 735 */ 736 public List<CodeableConcept> getReasonCode() { 737 if (this.reasonCode == null) 738 this.reasonCode = new ArrayList<CodeableConcept>(); 739 return this.reasonCode; 740 } 741 742 /** 743 * @return Returns a reference to <code>this</code> for easy method chaining 744 */ 745 public GuidanceResponse setReasonCode(List<CodeableConcept> theReasonCode) { 746 this.reasonCode = theReasonCode; 747 return this; 748 } 749 750 public boolean hasReasonCode() { 751 if (this.reasonCode == null) 752 return false; 753 for (CodeableConcept item : this.reasonCode) 754 if (!item.isEmpty()) 755 return true; 756 return false; 757 } 758 759 public CodeableConcept addReasonCode() { //3 760 CodeableConcept t = new CodeableConcept(); 761 if (this.reasonCode == null) 762 this.reasonCode = new ArrayList<CodeableConcept>(); 763 this.reasonCode.add(t); 764 return t; 765 } 766 767 public GuidanceResponse addReasonCode(CodeableConcept t) { //3 768 if (t == null) 769 return this; 770 if (this.reasonCode == null) 771 this.reasonCode = new ArrayList<CodeableConcept>(); 772 this.reasonCode.add(t); 773 return this; 774 } 775 776 /** 777 * @return The first repetition of repeating field {@link #reasonCode}, creating it if it does not already exist 778 */ 779 public CodeableConcept getReasonCodeFirstRep() { 780 if (getReasonCode().isEmpty()) { 781 addReasonCode(); 782 } 783 return getReasonCode().get(0); 784 } 785 786 /** 787 * @return {@link #reasonReference} (Indicates the reason the request was initiated. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.) 788 */ 789 public List<Reference> getReasonReference() { 790 if (this.reasonReference == null) 791 this.reasonReference = new ArrayList<Reference>(); 792 return this.reasonReference; 793 } 794 795 /** 796 * @return Returns a reference to <code>this</code> for easy method chaining 797 */ 798 public GuidanceResponse setReasonReference(List<Reference> theReasonReference) { 799 this.reasonReference = theReasonReference; 800 return this; 801 } 802 803 public boolean hasReasonReference() { 804 if (this.reasonReference == null) 805 return false; 806 for (Reference item : this.reasonReference) 807 if (!item.isEmpty()) 808 return true; 809 return false; 810 } 811 812 public Reference addReasonReference() { //3 813 Reference t = new Reference(); 814 if (this.reasonReference == null) 815 this.reasonReference = new ArrayList<Reference>(); 816 this.reasonReference.add(t); 817 return t; 818 } 819 820 public GuidanceResponse addReasonReference(Reference t) { //3 821 if (t == null) 822 return this; 823 if (this.reasonReference == null) 824 this.reasonReference = new ArrayList<Reference>(); 825 this.reasonReference.add(t); 826 return this; 827 } 828 829 /** 830 * @return The first repetition of repeating field {@link #reasonReference}, creating it if it does not already exist 831 */ 832 public Reference getReasonReferenceFirstRep() { 833 if (getReasonReference().isEmpty()) { 834 addReasonReference(); 835 } 836 return getReasonReference().get(0); 837 } 838 839 /** 840 * @deprecated Use Reference#setResource(IBaseResource) instead 841 */ 842 @Deprecated 843 public List<Resource> getReasonReferenceTarget() { 844 if (this.reasonReferenceTarget == null) 845 this.reasonReferenceTarget = new ArrayList<Resource>(); 846 return this.reasonReferenceTarget; 847 } 848 849 /** 850 * @return {@link #note} (Provides a mechanism to communicate additional information about the response.) 851 */ 852 public List<Annotation> getNote() { 853 if (this.note == null) 854 this.note = new ArrayList<Annotation>(); 855 return this.note; 856 } 857 858 /** 859 * @return Returns a reference to <code>this</code> for easy method chaining 860 */ 861 public GuidanceResponse setNote(List<Annotation> theNote) { 862 this.note = theNote; 863 return this; 864 } 865 866 public boolean hasNote() { 867 if (this.note == null) 868 return false; 869 for (Annotation item : this.note) 870 if (!item.isEmpty()) 871 return true; 872 return false; 873 } 874 875 public Annotation addNote() { //3 876 Annotation t = new Annotation(); 877 if (this.note == null) 878 this.note = new ArrayList<Annotation>(); 879 this.note.add(t); 880 return t; 881 } 882 883 public GuidanceResponse addNote(Annotation t) { //3 884 if (t == null) 885 return this; 886 if (this.note == null) 887 this.note = new ArrayList<Annotation>(); 888 this.note.add(t); 889 return this; 890 } 891 892 /** 893 * @return The first repetition of repeating field {@link #note}, creating it if it does not already exist 894 */ 895 public Annotation getNoteFirstRep() { 896 if (getNote().isEmpty()) { 897 addNote(); 898 } 899 return getNote().get(0); 900 } 901 902 /** 903 * @return {@link #evaluationMessage} (Messages resulting from the evaluation of the artifact or artifacts. As part of evaluating the request, the engine may produce informational or warning messages. These messages will be provided by this element.) 904 */ 905 public List<Reference> getEvaluationMessage() { 906 if (this.evaluationMessage == null) 907 this.evaluationMessage = new ArrayList<Reference>(); 908 return this.evaluationMessage; 909 } 910 911 /** 912 * @return Returns a reference to <code>this</code> for easy method chaining 913 */ 914 public GuidanceResponse setEvaluationMessage(List<Reference> theEvaluationMessage) { 915 this.evaluationMessage = theEvaluationMessage; 916 return this; 917 } 918 919 public boolean hasEvaluationMessage() { 920 if (this.evaluationMessage == null) 921 return false; 922 for (Reference item : this.evaluationMessage) 923 if (!item.isEmpty()) 924 return true; 925 return false; 926 } 927 928 public Reference addEvaluationMessage() { //3 929 Reference t = new Reference(); 930 if (this.evaluationMessage == null) 931 this.evaluationMessage = new ArrayList<Reference>(); 932 this.evaluationMessage.add(t); 933 return t; 934 } 935 936 public GuidanceResponse addEvaluationMessage(Reference t) { //3 937 if (t == null) 938 return this; 939 if (this.evaluationMessage == null) 940 this.evaluationMessage = new ArrayList<Reference>(); 941 this.evaluationMessage.add(t); 942 return this; 943 } 944 945 /** 946 * @return The first repetition of repeating field {@link #evaluationMessage}, creating it if it does not already exist 947 */ 948 public Reference getEvaluationMessageFirstRep() { 949 if (getEvaluationMessage().isEmpty()) { 950 addEvaluationMessage(); 951 } 952 return getEvaluationMessage().get(0); 953 } 954 955 /** 956 * @deprecated Use Reference#setResource(IBaseResource) instead 957 */ 958 @Deprecated 959 public List<OperationOutcome> getEvaluationMessageTarget() { 960 if (this.evaluationMessageTarget == null) 961 this.evaluationMessageTarget = new ArrayList<OperationOutcome>(); 962 return this.evaluationMessageTarget; 963 } 964 965 /** 966 * @deprecated Use Reference#setResource(IBaseResource) instead 967 */ 968 @Deprecated 969 public OperationOutcome addEvaluationMessageTarget() { 970 OperationOutcome r = new OperationOutcome(); 971 if (this.evaluationMessageTarget == null) 972 this.evaluationMessageTarget = new ArrayList<OperationOutcome>(); 973 this.evaluationMessageTarget.add(r); 974 return r; 975 } 976 977 /** 978 * @return {@link #outputParameters} (The output parameters of the evaluation, if any. Many modules will result in the return of specific resources such as procedure or communication requests that are returned as part of the operation result. However, modules may define specific outputs that would be returned as the result of the evaluation, and these would be returned in this element.) 979 */ 980 public Reference getOutputParameters() { 981 if (this.outputParameters == null) 982 if (Configuration.errorOnAutoCreate()) 983 throw new Error("Attempt to auto-create GuidanceResponse.outputParameters"); 984 else if (Configuration.doAutoCreate()) 985 this.outputParameters = new Reference(); // cc 986 return this.outputParameters; 987 } 988 989 public boolean hasOutputParameters() { 990 return this.outputParameters != null && !this.outputParameters.isEmpty(); 991 } 992 993 /** 994 * @param value {@link #outputParameters} (The output parameters of the evaluation, if any. Many modules will result in the return of specific resources such as procedure or communication requests that are returned as part of the operation result. However, modules may define specific outputs that would be returned as the result of the evaluation, and these would be returned in this element.) 995 */ 996 public GuidanceResponse setOutputParameters(Reference value) { 997 this.outputParameters = value; 998 return this; 999 } 1000 1001 /** 1002 * @return {@link #outputParameters} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The output parameters of the evaluation, if any. Many modules will result in the return of specific resources such as procedure or communication requests that are returned as part of the operation result. However, modules may define specific outputs that would be returned as the result of the evaluation, and these would be returned in this element.) 1003 */ 1004 public Parameters getOutputParametersTarget() { 1005 if (this.outputParametersTarget == null) 1006 if (Configuration.errorOnAutoCreate()) 1007 throw new Error("Attempt to auto-create GuidanceResponse.outputParameters"); 1008 else if (Configuration.doAutoCreate()) 1009 this.outputParametersTarget = new Parameters(); // aa 1010 return this.outputParametersTarget; 1011 } 1012 1013 /** 1014 * @param value {@link #outputParameters} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The output parameters of the evaluation, if any. Many modules will result in the return of specific resources such as procedure or communication requests that are returned as part of the operation result. However, modules may define specific outputs that would be returned as the result of the evaluation, and these would be returned in this element.) 1015 */ 1016 public GuidanceResponse setOutputParametersTarget(Parameters value) { 1017 this.outputParametersTarget = value; 1018 return this; 1019 } 1020 1021 /** 1022 * @return {@link #result} (The actions, if any, produced by the evaluation of the artifact.) 1023 */ 1024 public Reference getResult() { 1025 if (this.result == null) 1026 if (Configuration.errorOnAutoCreate()) 1027 throw new Error("Attempt to auto-create GuidanceResponse.result"); 1028 else if (Configuration.doAutoCreate()) 1029 this.result = new Reference(); // cc 1030 return this.result; 1031 } 1032 1033 public boolean hasResult() { 1034 return this.result != null && !this.result.isEmpty(); 1035 } 1036 1037 /** 1038 * @param value {@link #result} (The actions, if any, produced by the evaluation of the artifact.) 1039 */ 1040 public GuidanceResponse setResult(Reference value) { 1041 this.result = value; 1042 return this; 1043 } 1044 1045 /** 1046 * @return {@link #result} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The actions, if any, produced by the evaluation of the artifact.) 1047 */ 1048 public Resource getResultTarget() { 1049 return this.resultTarget; 1050 } 1051 1052 /** 1053 * @param value {@link #result} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The actions, if any, produced by the evaluation of the artifact.) 1054 */ 1055 public GuidanceResponse setResultTarget(Resource value) { 1056 this.resultTarget = value; 1057 return this; 1058 } 1059 1060 /** 1061 * @return {@link #dataRequirement} (If the evaluation could not be completed due to lack of information, or additional information would potentially result in a more accurate response, this element will a description of the data required in order to proceed with the evaluation. A subsequent request to the service should include this data.) 1062 */ 1063 public List<DataRequirement> getDataRequirement() { 1064 if (this.dataRequirement == null) 1065 this.dataRequirement = new ArrayList<DataRequirement>(); 1066 return this.dataRequirement; 1067 } 1068 1069 /** 1070 * @return Returns a reference to <code>this</code> for easy method chaining 1071 */ 1072 public GuidanceResponse setDataRequirement(List<DataRequirement> theDataRequirement) { 1073 this.dataRequirement = theDataRequirement; 1074 return this; 1075 } 1076 1077 public boolean hasDataRequirement() { 1078 if (this.dataRequirement == null) 1079 return false; 1080 for (DataRequirement item : this.dataRequirement) 1081 if (!item.isEmpty()) 1082 return true; 1083 return false; 1084 } 1085 1086 public DataRequirement addDataRequirement() { //3 1087 DataRequirement t = new DataRequirement(); 1088 if (this.dataRequirement == null) 1089 this.dataRequirement = new ArrayList<DataRequirement>(); 1090 this.dataRequirement.add(t); 1091 return t; 1092 } 1093 1094 public GuidanceResponse addDataRequirement(DataRequirement t) { //3 1095 if (t == null) 1096 return this; 1097 if (this.dataRequirement == null) 1098 this.dataRequirement = new ArrayList<DataRequirement>(); 1099 this.dataRequirement.add(t); 1100 return this; 1101 } 1102 1103 /** 1104 * @return The first repetition of repeating field {@link #dataRequirement}, creating it if it does not already exist 1105 */ 1106 public DataRequirement getDataRequirementFirstRep() { 1107 if (getDataRequirement().isEmpty()) { 1108 addDataRequirement(); 1109 } 1110 return getDataRequirement().get(0); 1111 } 1112 1113 protected void listChildren(List<Property> children) { 1114 super.listChildren(children); 1115 children.add(new Property("requestIdentifier", "Identifier", "The identifier of the request associated with this response. If an identifier was given as part of the request, it will be reproduced here to enable the requester to more easily identify the response in a multi-request scenario.", 0, 1, requestIdentifier)); 1116 children.add(new Property("identifier", "Identifier", "Allows a service to provide unique, business identifiers for the response.", 0, java.lang.Integer.MAX_VALUE, identifier)); 1117 children.add(new Property("module[x]", "uri|canonical|CodeableConcept", "An identifier, CodeableConcept or canonical reference to the guidance that was requested.", 0, 1, module)); 1118 children.add(new Property("status", "code", "The status of the response. If the evaluation is completed successfully, the status will indicate success. However, in order to complete the evaluation, the engine may require more information. In this case, the status will be data-required, and the response will contain a description of the additional required information. If the evaluation completed successfully, but the engine determines that a potentially more accurate response could be provided if more data was available, the status will be data-requested, and the response will contain a description of the additional requested information.", 0, 1, status)); 1119 children.add(new Property("subject", "Reference(Patient|Group)", "The patient for which the request was processed.", 0, 1, subject)); 1120 children.add(new Property("encounter", "Reference(Encounter)", "The encounter during which this response was created or to which the creation of this record is tightly associated.", 0, 1, encounter)); 1121 children.add(new Property("occurrenceDateTime", "dateTime", "Indicates when the guidance response was processed.", 0, 1, occurrenceDateTime)); 1122 children.add(new Property("performer", "Reference(Device)", "Provides a reference to the device that performed the guidance.", 0, 1, performer)); 1123 children.add(new Property("reasonCode", "CodeableConcept", "Describes the reason for the guidance response in coded or textual form.", 0, java.lang.Integer.MAX_VALUE, reasonCode)); 1124 children.add(new Property("reasonReference", "Reference(Condition|Observation|DiagnosticReport|DocumentReference)", "Indicates the reason the request was initiated. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.", 0, java.lang.Integer.MAX_VALUE, reasonReference)); 1125 children.add(new Property("note", "Annotation", "Provides a mechanism to communicate additional information about the response.", 0, java.lang.Integer.MAX_VALUE, note)); 1126 children.add(new Property("evaluationMessage", "Reference(OperationOutcome)", "Messages resulting from the evaluation of the artifact or artifacts. As part of evaluating the request, the engine may produce informational or warning messages. These messages will be provided by this element.", 0, java.lang.Integer.MAX_VALUE, evaluationMessage)); 1127 children.add(new Property("outputParameters", "Reference(Parameters)", "The output parameters of the evaluation, if any. Many modules will result in the return of specific resources such as procedure or communication requests that are returned as part of the operation result. However, modules may define specific outputs that would be returned as the result of the evaluation, and these would be returned in this element.", 0, 1, outputParameters)); 1128 children.add(new Property("result", "Reference(CarePlan|RequestGroup)", "The actions, if any, produced by the evaluation of the artifact.", 0, 1, result)); 1129 children.add(new Property("dataRequirement", "DataRequirement", "If the evaluation could not be completed due to lack of information, or additional information would potentially result in a more accurate response, this element will a description of the data required in order to proceed with the evaluation. A subsequent request to the service should include this data.", 0, java.lang.Integer.MAX_VALUE, dataRequirement)); 1130 } 1131 1132 @Override 1133 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1134 switch (_hash) { 1135 case -354233192: /*requestIdentifier*/ return new Property("requestIdentifier", "Identifier", "The identifier of the request associated with this response. If an identifier was given as part of the request, it will be reproduced here to enable the requester to more easily identify the response in a multi-request scenario.", 0, 1, requestIdentifier); 1136 case -1618432855: /*identifier*/ return new Property("identifier", "Identifier", "Allows a service to provide unique, business identifiers for the response.", 0, java.lang.Integer.MAX_VALUE, identifier); 1137 case -1552083308: /*module[x]*/ return new Property("module[x]", "uri|canonical|CodeableConcept", "An identifier, CodeableConcept or canonical reference to the guidance that was requested.", 0, 1, module); 1138 case -1068784020: /*module*/ return new Property("module[x]", "uri|canonical|CodeableConcept", "An identifier, CodeableConcept or canonical reference to the guidance that was requested.", 0, 1, module); 1139 case -1552089248: /*moduleUri*/ return new Property("module[x]", "uri|canonical|CodeableConcept", "An identifier, CodeableConcept or canonical reference to the guidance that was requested.", 0, 1, module); 1140 case -1153656856: /*moduleCanonical*/ return new Property("module[x]", "uri|canonical|CodeableConcept", "An identifier, CodeableConcept or canonical reference to the guidance that was requested.", 0, 1, module); 1141 case -1157899371: /*moduleCodeableConcept*/ return new Property("module[x]", "uri|canonical|CodeableConcept", "An identifier, CodeableConcept or canonical reference to the guidance that was requested.", 0, 1, module); 1142 case -892481550: /*status*/ return new Property("status", "code", "The status of the response. If the evaluation is completed successfully, the status will indicate success. However, in order to complete the evaluation, the engine may require more information. In this case, the status will be data-required, and the response will contain a description of the additional required information. If the evaluation completed successfully, but the engine determines that a potentially more accurate response could be provided if more data was available, the status will be data-requested, and the response will contain a description of the additional requested information.", 0, 1, status); 1143 case -1867885268: /*subject*/ return new Property("subject", "Reference(Patient|Group)", "The patient for which the request was processed.", 0, 1, subject); 1144 case 1524132147: /*encounter*/ return new Property("encounter", "Reference(Encounter)", "The encounter during which this response was created or to which the creation of this record is tightly associated.", 0, 1, encounter); 1145 case -298443636: /*occurrenceDateTime*/ return new Property("occurrenceDateTime", "dateTime", "Indicates when the guidance response was processed.", 0, 1, occurrenceDateTime); 1146 case 481140686: /*performer*/ return new Property("performer", "Reference(Device)", "Provides a reference to the device that performed the guidance.", 0, 1, performer); 1147 case 722137681: /*reasonCode*/ return new Property("reasonCode", "CodeableConcept", "Describes the reason for the guidance response in coded or textual form.", 0, java.lang.Integer.MAX_VALUE, reasonCode); 1148 case -1146218137: /*reasonReference*/ return new Property("reasonReference", "Reference(Condition|Observation|DiagnosticReport|DocumentReference)", "Indicates the reason the request was initiated. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.", 0, java.lang.Integer.MAX_VALUE, reasonReference); 1149 case 3387378: /*note*/ return new Property("note", "Annotation", "Provides a mechanism to communicate additional information about the response.", 0, java.lang.Integer.MAX_VALUE, note); 1150 case 1081619755: /*evaluationMessage*/ return new Property("evaluationMessage", "Reference(OperationOutcome)", "Messages resulting from the evaluation of the artifact or artifacts. As part of evaluating the request, the engine may produce informational or warning messages. These messages will be provided by this element.", 0, java.lang.Integer.MAX_VALUE, evaluationMessage); 1151 case 525609419: /*outputParameters*/ return new Property("outputParameters", "Reference(Parameters)", "The output parameters of the evaluation, if any. Many modules will result in the return of specific resources such as procedure or communication requests that are returned as part of the operation result. However, modules may define specific outputs that would be returned as the result of the evaluation, and these would be returned in this element.", 0, 1, outputParameters); 1152 case -934426595: /*result*/ return new Property("result", "Reference(CarePlan|RequestGroup)", "The actions, if any, produced by the evaluation of the artifact.", 0, 1, result); 1153 case 629147193: /*dataRequirement*/ return new Property("dataRequirement", "DataRequirement", "If the evaluation could not be completed due to lack of information, or additional information would potentially result in a more accurate response, this element will a description of the data required in order to proceed with the evaluation. A subsequent request to the service should include this data.", 0, java.lang.Integer.MAX_VALUE, dataRequirement); 1154 default: return super.getNamedProperty(_hash, _name, _checkValid); 1155 } 1156 1157 } 1158 1159 @Override 1160 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1161 switch (hash) { 1162 case -354233192: /*requestIdentifier*/ return this.requestIdentifier == null ? new Base[0] : new Base[] {this.requestIdentifier}; // Identifier 1163 case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier 1164 case -1068784020: /*module*/ return this.module == null ? new Base[0] : new Base[] {this.module}; // Type 1165 case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<GuidanceResponseStatus> 1166 case -1867885268: /*subject*/ return this.subject == null ? new Base[0] : new Base[] {this.subject}; // Reference 1167 case 1524132147: /*encounter*/ return this.encounter == null ? new Base[0] : new Base[] {this.encounter}; // Reference 1168 case -298443636: /*occurrenceDateTime*/ return this.occurrenceDateTime == null ? new Base[0] : new Base[] {this.occurrenceDateTime}; // DateTimeType 1169 case 481140686: /*performer*/ return this.performer == null ? new Base[0] : new Base[] {this.performer}; // Reference 1170 case 722137681: /*reasonCode*/ return this.reasonCode == null ? new Base[0] : this.reasonCode.toArray(new Base[this.reasonCode.size()]); // CodeableConcept 1171 case -1146218137: /*reasonReference*/ return this.reasonReference == null ? new Base[0] : this.reasonReference.toArray(new Base[this.reasonReference.size()]); // Reference 1172 case 3387378: /*note*/ return this.note == null ? new Base[0] : this.note.toArray(new Base[this.note.size()]); // Annotation 1173 case 1081619755: /*evaluationMessage*/ return this.evaluationMessage == null ? new Base[0] : this.evaluationMessage.toArray(new Base[this.evaluationMessage.size()]); // Reference 1174 case 525609419: /*outputParameters*/ return this.outputParameters == null ? new Base[0] : new Base[] {this.outputParameters}; // Reference 1175 case -934426595: /*result*/ return this.result == null ? new Base[0] : new Base[] {this.result}; // Reference 1176 case 629147193: /*dataRequirement*/ return this.dataRequirement == null ? new Base[0] : this.dataRequirement.toArray(new Base[this.dataRequirement.size()]); // DataRequirement 1177 default: return super.getProperty(hash, name, checkValid); 1178 } 1179 1180 } 1181 1182 @Override 1183 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1184 switch (hash) { 1185 case -354233192: // requestIdentifier 1186 this.requestIdentifier = castToIdentifier(value); // Identifier 1187 return value; 1188 case -1618432855: // identifier 1189 this.getIdentifier().add(castToIdentifier(value)); // Identifier 1190 return value; 1191 case -1068784020: // module 1192 this.module = castToType(value); // Type 1193 return value; 1194 case -892481550: // status 1195 value = new GuidanceResponseStatusEnumFactory().fromType(castToCode(value)); 1196 this.status = (Enumeration) value; // Enumeration<GuidanceResponseStatus> 1197 return value; 1198 case -1867885268: // subject 1199 this.subject = castToReference(value); // Reference 1200 return value; 1201 case 1524132147: // encounter 1202 this.encounter = castToReference(value); // Reference 1203 return value; 1204 case -298443636: // occurrenceDateTime 1205 this.occurrenceDateTime = castToDateTime(value); // DateTimeType 1206 return value; 1207 case 481140686: // performer 1208 this.performer = castToReference(value); // Reference 1209 return value; 1210 case 722137681: // reasonCode 1211 this.getReasonCode().add(castToCodeableConcept(value)); // CodeableConcept 1212 return value; 1213 case -1146218137: // reasonReference 1214 this.getReasonReference().add(castToReference(value)); // Reference 1215 return value; 1216 case 3387378: // note 1217 this.getNote().add(castToAnnotation(value)); // Annotation 1218 return value; 1219 case 1081619755: // evaluationMessage 1220 this.getEvaluationMessage().add(castToReference(value)); // Reference 1221 return value; 1222 case 525609419: // outputParameters 1223 this.outputParameters = castToReference(value); // Reference 1224 return value; 1225 case -934426595: // result 1226 this.result = castToReference(value); // Reference 1227 return value; 1228 case 629147193: // dataRequirement 1229 this.getDataRequirement().add(castToDataRequirement(value)); // DataRequirement 1230 return value; 1231 default: return super.setProperty(hash, name, value); 1232 } 1233 1234 } 1235 1236 @Override 1237 public Base setProperty(String name, Base value) throws FHIRException { 1238 if (name.equals("requestIdentifier")) { 1239 this.requestIdentifier = castToIdentifier(value); // Identifier 1240 } else if (name.equals("identifier")) { 1241 this.getIdentifier().add(castToIdentifier(value)); 1242 } else if (name.equals("module[x]")) { 1243 this.module = castToType(value); // Type 1244 } else if (name.equals("status")) { 1245 value = new GuidanceResponseStatusEnumFactory().fromType(castToCode(value)); 1246 this.status = (Enumeration) value; // Enumeration<GuidanceResponseStatus> 1247 } else if (name.equals("subject")) { 1248 this.subject = castToReference(value); // Reference 1249 } else if (name.equals("encounter")) { 1250 this.encounter = castToReference(value); // Reference 1251 } else if (name.equals("occurrenceDateTime")) { 1252 this.occurrenceDateTime = castToDateTime(value); // DateTimeType 1253 } else if (name.equals("performer")) { 1254 this.performer = castToReference(value); // Reference 1255 } else if (name.equals("reasonCode")) { 1256 this.getReasonCode().add(castToCodeableConcept(value)); 1257 } else if (name.equals("reasonReference")) { 1258 this.getReasonReference().add(castToReference(value)); 1259 } else if (name.equals("note")) { 1260 this.getNote().add(castToAnnotation(value)); 1261 } else if (name.equals("evaluationMessage")) { 1262 this.getEvaluationMessage().add(castToReference(value)); 1263 } else if (name.equals("outputParameters")) { 1264 this.outputParameters = castToReference(value); // Reference 1265 } else if (name.equals("result")) { 1266 this.result = castToReference(value); // Reference 1267 } else if (name.equals("dataRequirement")) { 1268 this.getDataRequirement().add(castToDataRequirement(value)); 1269 } else 1270 return super.setProperty(name, value); 1271 return value; 1272 } 1273 1274 @Override 1275 public Base makeProperty(int hash, String name) throws FHIRException { 1276 switch (hash) { 1277 case -354233192: return getRequestIdentifier(); 1278 case -1618432855: return addIdentifier(); 1279 case -1552083308: return getModule(); 1280 case -1068784020: return getModule(); 1281 case -892481550: return getStatusElement(); 1282 case -1867885268: return getSubject(); 1283 case 1524132147: return getEncounter(); 1284 case -298443636: return getOccurrenceDateTimeElement(); 1285 case 481140686: return getPerformer(); 1286 case 722137681: return addReasonCode(); 1287 case -1146218137: return addReasonReference(); 1288 case 3387378: return addNote(); 1289 case 1081619755: return addEvaluationMessage(); 1290 case 525609419: return getOutputParameters(); 1291 case -934426595: return getResult(); 1292 case 629147193: return addDataRequirement(); 1293 default: return super.makeProperty(hash, name); 1294 } 1295 1296 } 1297 1298 @Override 1299 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1300 switch (hash) { 1301 case -354233192: /*requestIdentifier*/ return new String[] {"Identifier"}; 1302 case -1618432855: /*identifier*/ return new String[] {"Identifier"}; 1303 case -1068784020: /*module*/ return new String[] {"uri", "canonical", "CodeableConcept"}; 1304 case -892481550: /*status*/ return new String[] {"code"}; 1305 case -1867885268: /*subject*/ return new String[] {"Reference"}; 1306 case 1524132147: /*encounter*/ return new String[] {"Reference"}; 1307 case -298443636: /*occurrenceDateTime*/ return new String[] {"dateTime"}; 1308 case 481140686: /*performer*/ return new String[] {"Reference"}; 1309 case 722137681: /*reasonCode*/ return new String[] {"CodeableConcept"}; 1310 case -1146218137: /*reasonReference*/ return new String[] {"Reference"}; 1311 case 3387378: /*note*/ return new String[] {"Annotation"}; 1312 case 1081619755: /*evaluationMessage*/ return new String[] {"Reference"}; 1313 case 525609419: /*outputParameters*/ return new String[] {"Reference"}; 1314 case -934426595: /*result*/ return new String[] {"Reference"}; 1315 case 629147193: /*dataRequirement*/ return new String[] {"DataRequirement"}; 1316 default: return super.getTypesForProperty(hash, name); 1317 } 1318 1319 } 1320 1321 @Override 1322 public Base addChild(String name) throws FHIRException { 1323 if (name.equals("requestIdentifier")) { 1324 this.requestIdentifier = new Identifier(); 1325 return this.requestIdentifier; 1326 } 1327 else if (name.equals("identifier")) { 1328 return addIdentifier(); 1329 } 1330 else if (name.equals("moduleUri")) { 1331 this.module = new UriType(); 1332 return this.module; 1333 } 1334 else if (name.equals("moduleCanonical")) { 1335 this.module = new CanonicalType(); 1336 return this.module; 1337 } 1338 else if (name.equals("moduleCodeableConcept")) { 1339 this.module = new CodeableConcept(); 1340 return this.module; 1341 } 1342 else if (name.equals("status")) { 1343 throw new FHIRException("Cannot call addChild on a primitive type GuidanceResponse.status"); 1344 } 1345 else if (name.equals("subject")) { 1346 this.subject = new Reference(); 1347 return this.subject; 1348 } 1349 else if (name.equals("encounter")) { 1350 this.encounter = new Reference(); 1351 return this.encounter; 1352 } 1353 else if (name.equals("occurrenceDateTime")) { 1354 throw new FHIRException("Cannot call addChild on a primitive type GuidanceResponse.occurrenceDateTime"); 1355 } 1356 else if (name.equals("performer")) { 1357 this.performer = new Reference(); 1358 return this.performer; 1359 } 1360 else if (name.equals("reasonCode")) { 1361 return addReasonCode(); 1362 } 1363 else if (name.equals("reasonReference")) { 1364 return addReasonReference(); 1365 } 1366 else if (name.equals("note")) { 1367 return addNote(); 1368 } 1369 else if (name.equals("evaluationMessage")) { 1370 return addEvaluationMessage(); 1371 } 1372 else if (name.equals("outputParameters")) { 1373 this.outputParameters = new Reference(); 1374 return this.outputParameters; 1375 } 1376 else if (name.equals("result")) { 1377 this.result = new Reference(); 1378 return this.result; 1379 } 1380 else if (name.equals("dataRequirement")) { 1381 return addDataRequirement(); 1382 } 1383 else 1384 return super.addChild(name); 1385 } 1386 1387 public String fhirType() { 1388 return "GuidanceResponse"; 1389 1390 } 1391 1392 public GuidanceResponse copy() { 1393 GuidanceResponse dst = new GuidanceResponse(); 1394 copyValues(dst); 1395 return dst; 1396 } 1397 1398 public void copyValues(GuidanceResponse dst) { 1399 super.copyValues(dst); 1400 dst.requestIdentifier = requestIdentifier == null ? null : requestIdentifier.copy(); 1401 if (identifier != null) { 1402 dst.identifier = new ArrayList<Identifier>(); 1403 for (Identifier i : identifier) 1404 dst.identifier.add(i.copy()); 1405 }; 1406 dst.module = module == null ? null : module.copy(); 1407 dst.status = status == null ? null : status.copy(); 1408 dst.subject = subject == null ? null : subject.copy(); 1409 dst.encounter = encounter == null ? null : encounter.copy(); 1410 dst.occurrenceDateTime = occurrenceDateTime == null ? null : occurrenceDateTime.copy(); 1411 dst.performer = performer == null ? null : performer.copy(); 1412 if (reasonCode != null) { 1413 dst.reasonCode = new ArrayList<CodeableConcept>(); 1414 for (CodeableConcept i : reasonCode) 1415 dst.reasonCode.add(i.copy()); 1416 }; 1417 if (reasonReference != null) { 1418 dst.reasonReference = new ArrayList<Reference>(); 1419 for (Reference i : reasonReference) 1420 dst.reasonReference.add(i.copy()); 1421 }; 1422 if (note != null) { 1423 dst.note = new ArrayList<Annotation>(); 1424 for (Annotation i : note) 1425 dst.note.add(i.copy()); 1426 }; 1427 if (evaluationMessage != null) { 1428 dst.evaluationMessage = new ArrayList<Reference>(); 1429 for (Reference i : evaluationMessage) 1430 dst.evaluationMessage.add(i.copy()); 1431 }; 1432 dst.outputParameters = outputParameters == null ? null : outputParameters.copy(); 1433 dst.result = result == null ? null : result.copy(); 1434 if (dataRequirement != null) { 1435 dst.dataRequirement = new ArrayList<DataRequirement>(); 1436 for (DataRequirement i : dataRequirement) 1437 dst.dataRequirement.add(i.copy()); 1438 }; 1439 } 1440 1441 protected GuidanceResponse typedCopy() { 1442 return copy(); 1443 } 1444 1445 @Override 1446 public boolean equalsDeep(Base other_) { 1447 if (!super.equalsDeep(other_)) 1448 return false; 1449 if (!(other_ instanceof GuidanceResponse)) 1450 return false; 1451 GuidanceResponse o = (GuidanceResponse) other_; 1452 return compareDeep(requestIdentifier, o.requestIdentifier, true) && compareDeep(identifier, o.identifier, true) 1453 && compareDeep(module, o.module, true) && compareDeep(status, o.status, true) && compareDeep(subject, o.subject, true) 1454 && compareDeep(encounter, o.encounter, true) && compareDeep(occurrenceDateTime, o.occurrenceDateTime, true) 1455 && compareDeep(performer, o.performer, true) && compareDeep(reasonCode, o.reasonCode, true) && compareDeep(reasonReference, o.reasonReference, true) 1456 && compareDeep(note, o.note, true) && compareDeep(evaluationMessage, o.evaluationMessage, true) 1457 && compareDeep(outputParameters, o.outputParameters, true) && compareDeep(result, o.result, true) 1458 && compareDeep(dataRequirement, o.dataRequirement, true); 1459 } 1460 1461 @Override 1462 public boolean equalsShallow(Base other_) { 1463 if (!super.equalsShallow(other_)) 1464 return false; 1465 if (!(other_ instanceof GuidanceResponse)) 1466 return false; 1467 GuidanceResponse o = (GuidanceResponse) other_; 1468 return compareValues(status, o.status, true) && compareValues(occurrenceDateTime, o.occurrenceDateTime, true) 1469 ; 1470 } 1471 1472 public boolean isEmpty() { 1473 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(requestIdentifier, identifier 1474 , module, status, subject, encounter, occurrenceDateTime, performer, reasonCode 1475 , reasonReference, note, evaluationMessage, outputParameters, result, dataRequirement 1476 ); 1477 } 1478 1479 @Override 1480 public ResourceType getResourceType() { 1481 return ResourceType.GuidanceResponse; 1482 } 1483 1484 /** 1485 * Search parameter: <b>request</b> 1486 * <p> 1487 * Description: <b>The identifier of the request associated with the response</b><br> 1488 * Type: <b>token</b><br> 1489 * Path: <b>GuidanceResponse.requestIdentifier</b><br> 1490 * </p> 1491 */ 1492 @SearchParamDefinition(name="request", path="GuidanceResponse.requestIdentifier", description="The identifier of the request associated with the response", type="token" ) 1493 public static final String SP_REQUEST = "request"; 1494 /** 1495 * <b>Fluent Client</b> search parameter constant for <b>request</b> 1496 * <p> 1497 * Description: <b>The identifier of the request associated with the response</b><br> 1498 * Type: <b>token</b><br> 1499 * Path: <b>GuidanceResponse.requestIdentifier</b><br> 1500 * </p> 1501 */ 1502 public static final ca.uhn.fhir.rest.gclient.TokenClientParam REQUEST = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_REQUEST); 1503 1504 /** 1505 * Search parameter: <b>identifier</b> 1506 * <p> 1507 * Description: <b>The identifier of the guidance response</b><br> 1508 * Type: <b>token</b><br> 1509 * Path: <b>GuidanceResponse.identifier</b><br> 1510 * </p> 1511 */ 1512 @SearchParamDefinition(name="identifier", path="GuidanceResponse.identifier", description="The identifier of the guidance response", type="token" ) 1513 public static final String SP_IDENTIFIER = "identifier"; 1514 /** 1515 * <b>Fluent Client</b> search parameter constant for <b>identifier</b> 1516 * <p> 1517 * Description: <b>The identifier of the guidance response</b><br> 1518 * Type: <b>token</b><br> 1519 * Path: <b>GuidanceResponse.identifier</b><br> 1520 * </p> 1521 */ 1522 public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER); 1523 1524 /** 1525 * Search parameter: <b>patient</b> 1526 * <p> 1527 * Description: <b>The identity of a patient to search for guidance response results</b><br> 1528 * Type: <b>reference</b><br> 1529 * Path: <b>GuidanceResponse.subject</b><br> 1530 * </p> 1531 */ 1532 @SearchParamDefinition(name="patient", path="GuidanceResponse.subject.where(resolve() is Patient)", description="The identity of a patient to search for guidance response results", type="reference", target={Patient.class } ) 1533 public static final String SP_PATIENT = "patient"; 1534 /** 1535 * <b>Fluent Client</b> search parameter constant for <b>patient</b> 1536 * <p> 1537 * Description: <b>The identity of a patient to search for guidance response results</b><br> 1538 * Type: <b>reference</b><br> 1539 * Path: <b>GuidanceResponse.subject</b><br> 1540 * </p> 1541 */ 1542 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PATIENT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_PATIENT); 1543 1544/** 1545 * Constant for fluent queries to be used to add include statements. Specifies 1546 * the path value of "<b>GuidanceResponse:patient</b>". 1547 */ 1548 public static final ca.uhn.fhir.model.api.Include INCLUDE_PATIENT = new ca.uhn.fhir.model.api.Include("GuidanceResponse:patient").toLocked(); 1549 1550 /** 1551 * Search parameter: <b>subject</b> 1552 * <p> 1553 * Description: <b>The subject that the guidance response is about</b><br> 1554 * Type: <b>reference</b><br> 1555 * Path: <b>GuidanceResponse.subject</b><br> 1556 * </p> 1557 */ 1558 @SearchParamDefinition(name="subject", path="GuidanceResponse.subject", description="The subject that the guidance response is about", type="reference", target={Group.class, Patient.class } ) 1559 public static final String SP_SUBJECT = "subject"; 1560 /** 1561 * <b>Fluent Client</b> search parameter constant for <b>subject</b> 1562 * <p> 1563 * Description: <b>The subject that the guidance response is about</b><br> 1564 * Type: <b>reference</b><br> 1565 * Path: <b>GuidanceResponse.subject</b><br> 1566 * </p> 1567 */ 1568 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SUBJECT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_SUBJECT); 1569 1570/** 1571 * Constant for fluent queries to be used to add include statements. Specifies 1572 * the path value of "<b>GuidanceResponse:subject</b>". 1573 */ 1574 public static final ca.uhn.fhir.model.api.Include INCLUDE_SUBJECT = new ca.uhn.fhir.model.api.Include("GuidanceResponse:subject").toLocked(); 1575 1576 1577}