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 * An occurrence of information being transmitted; e.g. an alert that was sent to a responsible provider, a public health agency that was notified about a reportable condition. 050 */ 051@ResourceDef(name="Communication", profile="http://hl7.org/fhir/StructureDefinition/Communication") 052public class Communication extends DomainResource { 053 054 public enum CommunicationStatus { 055 /** 056 * 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. 057 */ 058 PREPARATION, 059 /** 060 * The event is currently occurring. 061 */ 062 INPROGRESS, 063 /** 064 * 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. 065 */ 066 NOTDONE, 067 /** 068 * The event has been temporarily stopped but is expected to resume in the future. 069 */ 070 ONHOLD, 071 /** 072 * 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. 073 */ 074 STOPPED, 075 /** 076 * The event has now concluded. 077 */ 078 COMPLETED, 079 /** 080 * 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".). 081 */ 082 ENTEREDINERROR, 083 /** 084 * 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. 085 */ 086 UNKNOWN, 087 /** 088 * added to help the parsers with the generic types 089 */ 090 NULL; 091 public static CommunicationStatus fromCode(String codeString) throws FHIRException { 092 if (codeString == null || "".equals(codeString)) 093 return null; 094 if ("preparation".equals(codeString)) 095 return PREPARATION; 096 if ("in-progress".equals(codeString)) 097 return INPROGRESS; 098 if ("not-done".equals(codeString)) 099 return NOTDONE; 100 if ("on-hold".equals(codeString)) 101 return ONHOLD; 102 if ("stopped".equals(codeString)) 103 return STOPPED; 104 if ("completed".equals(codeString)) 105 return COMPLETED; 106 if ("entered-in-error".equals(codeString)) 107 return ENTEREDINERROR; 108 if ("unknown".equals(codeString)) 109 return UNKNOWN; 110 if (Configuration.isAcceptInvalidEnums()) 111 return null; 112 else 113 throw new FHIRException("Unknown CommunicationStatus code '"+codeString+"'"); 114 } 115 public String toCode() { 116 switch (this) { 117 case PREPARATION: return "preparation"; 118 case INPROGRESS: return "in-progress"; 119 case NOTDONE: return "not-done"; 120 case ONHOLD: return "on-hold"; 121 case STOPPED: return "stopped"; 122 case COMPLETED: return "completed"; 123 case ENTEREDINERROR: return "entered-in-error"; 124 case UNKNOWN: return "unknown"; 125 default: return "?"; 126 } 127 } 128 public String getSystem() { 129 switch (this) { 130 case PREPARATION: return "http://hl7.org/fhir/event-status"; 131 case INPROGRESS: return "http://hl7.org/fhir/event-status"; 132 case NOTDONE: return "http://hl7.org/fhir/event-status"; 133 case ONHOLD: return "http://hl7.org/fhir/event-status"; 134 case STOPPED: return "http://hl7.org/fhir/event-status"; 135 case COMPLETED: return "http://hl7.org/fhir/event-status"; 136 case ENTEREDINERROR: return "http://hl7.org/fhir/event-status"; 137 case UNKNOWN: return "http://hl7.org/fhir/event-status"; 138 default: return "?"; 139 } 140 } 141 public String getDefinition() { 142 switch (this) { 143 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."; 144 case INPROGRESS: return "The event is currently occurring."; 145 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."; 146 case ONHOLD: return "The event has been temporarily stopped but is expected to resume in the future."; 147 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."; 148 case COMPLETED: return "The event has now concluded."; 149 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\".)."; 150 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."; 151 default: return "?"; 152 } 153 } 154 public String getDisplay() { 155 switch (this) { 156 case PREPARATION: return "Preparation"; 157 case INPROGRESS: return "In Progress"; 158 case NOTDONE: return "Not Done"; 159 case ONHOLD: return "On Hold"; 160 case STOPPED: return "Stopped"; 161 case COMPLETED: return "Completed"; 162 case ENTEREDINERROR: return "Entered in Error"; 163 case UNKNOWN: return "Unknown"; 164 default: return "?"; 165 } 166 } 167 } 168 169 public static class CommunicationStatusEnumFactory implements EnumFactory<CommunicationStatus> { 170 public CommunicationStatus fromCode(String codeString) throws IllegalArgumentException { 171 if (codeString == null || "".equals(codeString)) 172 if (codeString == null || "".equals(codeString)) 173 return null; 174 if ("preparation".equals(codeString)) 175 return CommunicationStatus.PREPARATION; 176 if ("in-progress".equals(codeString)) 177 return CommunicationStatus.INPROGRESS; 178 if ("not-done".equals(codeString)) 179 return CommunicationStatus.NOTDONE; 180 if ("on-hold".equals(codeString)) 181 return CommunicationStatus.ONHOLD; 182 if ("stopped".equals(codeString)) 183 return CommunicationStatus.STOPPED; 184 if ("completed".equals(codeString)) 185 return CommunicationStatus.COMPLETED; 186 if ("entered-in-error".equals(codeString)) 187 return CommunicationStatus.ENTEREDINERROR; 188 if ("unknown".equals(codeString)) 189 return CommunicationStatus.UNKNOWN; 190 throw new IllegalArgumentException("Unknown CommunicationStatus code '"+codeString+"'"); 191 } 192 public Enumeration<CommunicationStatus> fromType(Base code) throws FHIRException { 193 if (code == null) 194 return null; 195 if (code.isEmpty()) 196 return new Enumeration<CommunicationStatus>(this); 197 String codeString = ((PrimitiveType) code).asStringValue(); 198 if (codeString == null || "".equals(codeString)) 199 return null; 200 if ("preparation".equals(codeString)) 201 return new Enumeration<CommunicationStatus>(this, CommunicationStatus.PREPARATION); 202 if ("in-progress".equals(codeString)) 203 return new Enumeration<CommunicationStatus>(this, CommunicationStatus.INPROGRESS); 204 if ("not-done".equals(codeString)) 205 return new Enumeration<CommunicationStatus>(this, CommunicationStatus.NOTDONE); 206 if ("on-hold".equals(codeString)) 207 return new Enumeration<CommunicationStatus>(this, CommunicationStatus.ONHOLD); 208 if ("stopped".equals(codeString)) 209 return new Enumeration<CommunicationStatus>(this, CommunicationStatus.STOPPED); 210 if ("completed".equals(codeString)) 211 return new Enumeration<CommunicationStatus>(this, CommunicationStatus.COMPLETED); 212 if ("entered-in-error".equals(codeString)) 213 return new Enumeration<CommunicationStatus>(this, CommunicationStatus.ENTEREDINERROR); 214 if ("unknown".equals(codeString)) 215 return new Enumeration<CommunicationStatus>(this, CommunicationStatus.UNKNOWN); 216 throw new FHIRException("Unknown CommunicationStatus code '"+codeString+"'"); 217 } 218 public String toCode(CommunicationStatus code) { 219 if (code == CommunicationStatus.PREPARATION) 220 return "preparation"; 221 if (code == CommunicationStatus.INPROGRESS) 222 return "in-progress"; 223 if (code == CommunicationStatus.NOTDONE) 224 return "not-done"; 225 if (code == CommunicationStatus.ONHOLD) 226 return "on-hold"; 227 if (code == CommunicationStatus.STOPPED) 228 return "stopped"; 229 if (code == CommunicationStatus.COMPLETED) 230 return "completed"; 231 if (code == CommunicationStatus.ENTEREDINERROR) 232 return "entered-in-error"; 233 if (code == CommunicationStatus.UNKNOWN) 234 return "unknown"; 235 return "?"; 236 } 237 public String toSystem(CommunicationStatus code) { 238 return code.getSystem(); 239 } 240 } 241 242 public enum CommunicationPriority { 243 /** 244 * The request has normal priority. 245 */ 246 ROUTINE, 247 /** 248 * The request should be actioned promptly - higher priority than routine. 249 */ 250 URGENT, 251 /** 252 * The request should be actioned as soon as possible - higher priority than urgent. 253 */ 254 ASAP, 255 /** 256 * The request should be actioned immediately - highest possible priority. E.g. an emergency. 257 */ 258 STAT, 259 /** 260 * added to help the parsers with the generic types 261 */ 262 NULL; 263 public static CommunicationPriority fromCode(String codeString) throws FHIRException { 264 if (codeString == null || "".equals(codeString)) 265 return null; 266 if ("routine".equals(codeString)) 267 return ROUTINE; 268 if ("urgent".equals(codeString)) 269 return URGENT; 270 if ("asap".equals(codeString)) 271 return ASAP; 272 if ("stat".equals(codeString)) 273 return STAT; 274 if (Configuration.isAcceptInvalidEnums()) 275 return null; 276 else 277 throw new FHIRException("Unknown CommunicationPriority code '"+codeString+"'"); 278 } 279 public String toCode() { 280 switch (this) { 281 case ROUTINE: return "routine"; 282 case URGENT: return "urgent"; 283 case ASAP: return "asap"; 284 case STAT: return "stat"; 285 default: return "?"; 286 } 287 } 288 public String getSystem() { 289 switch (this) { 290 case ROUTINE: return "http://hl7.org/fhir/request-priority"; 291 case URGENT: return "http://hl7.org/fhir/request-priority"; 292 case ASAP: return "http://hl7.org/fhir/request-priority"; 293 case STAT: return "http://hl7.org/fhir/request-priority"; 294 default: return "?"; 295 } 296 } 297 public String getDefinition() { 298 switch (this) { 299 case ROUTINE: return "The request has normal priority."; 300 case URGENT: return "The request should be actioned promptly - higher priority than routine."; 301 case ASAP: return "The request should be actioned as soon as possible - higher priority than urgent."; 302 case STAT: return "The request should be actioned immediately - highest possible priority. E.g. an emergency."; 303 default: return "?"; 304 } 305 } 306 public String getDisplay() { 307 switch (this) { 308 case ROUTINE: return "Routine"; 309 case URGENT: return "Urgent"; 310 case ASAP: return "ASAP"; 311 case STAT: return "STAT"; 312 default: return "?"; 313 } 314 } 315 } 316 317 public static class CommunicationPriorityEnumFactory implements EnumFactory<CommunicationPriority> { 318 public CommunicationPriority fromCode(String codeString) throws IllegalArgumentException { 319 if (codeString == null || "".equals(codeString)) 320 if (codeString == null || "".equals(codeString)) 321 return null; 322 if ("routine".equals(codeString)) 323 return CommunicationPriority.ROUTINE; 324 if ("urgent".equals(codeString)) 325 return CommunicationPriority.URGENT; 326 if ("asap".equals(codeString)) 327 return CommunicationPriority.ASAP; 328 if ("stat".equals(codeString)) 329 return CommunicationPriority.STAT; 330 throw new IllegalArgumentException("Unknown CommunicationPriority code '"+codeString+"'"); 331 } 332 public Enumeration<CommunicationPriority> fromType(Base code) throws FHIRException { 333 if (code == null) 334 return null; 335 if (code.isEmpty()) 336 return new Enumeration<CommunicationPriority>(this); 337 String codeString = ((PrimitiveType) code).asStringValue(); 338 if (codeString == null || "".equals(codeString)) 339 return null; 340 if ("routine".equals(codeString)) 341 return new Enumeration<CommunicationPriority>(this, CommunicationPriority.ROUTINE); 342 if ("urgent".equals(codeString)) 343 return new Enumeration<CommunicationPriority>(this, CommunicationPriority.URGENT); 344 if ("asap".equals(codeString)) 345 return new Enumeration<CommunicationPriority>(this, CommunicationPriority.ASAP); 346 if ("stat".equals(codeString)) 347 return new Enumeration<CommunicationPriority>(this, CommunicationPriority.STAT); 348 throw new FHIRException("Unknown CommunicationPriority code '"+codeString+"'"); 349 } 350 public String toCode(CommunicationPriority code) { 351 if (code == CommunicationPriority.ROUTINE) 352 return "routine"; 353 if (code == CommunicationPriority.URGENT) 354 return "urgent"; 355 if (code == CommunicationPriority.ASAP) 356 return "asap"; 357 if (code == CommunicationPriority.STAT) 358 return "stat"; 359 return "?"; 360 } 361 public String toSystem(CommunicationPriority code) { 362 return code.getSystem(); 363 } 364 } 365 366 @Block() 367 public static class CommunicationPayloadComponent extends BackboneElement implements IBaseBackboneElement { 368 /** 369 * A communicated content (or for multi-part communications, one portion of the communication). 370 */ 371 @Child(name = "content", type = {StringType.class, Attachment.class, Reference.class}, order=1, min=1, max=1, modifier=false, summary=false) 372 @Description(shortDefinition="Message part content", formalDefinition="A communicated content (or for multi-part communications, one portion of the communication)." ) 373 protected Type content; 374 375 private static final long serialVersionUID = -1763459053L; 376 377 /** 378 * Constructor 379 */ 380 public CommunicationPayloadComponent() { 381 super(); 382 } 383 384 /** 385 * Constructor 386 */ 387 public CommunicationPayloadComponent(Type content) { 388 super(); 389 this.content = content; 390 } 391 392 /** 393 * @return {@link #content} (A communicated content (or for multi-part communications, one portion of the communication).) 394 */ 395 public Type getContent() { 396 return this.content; 397 } 398 399 /** 400 * @return {@link #content} (A communicated content (or for multi-part communications, one portion of the communication).) 401 */ 402 public StringType getContentStringType() throws FHIRException { 403 if (this.content == null) 404 this.content = new StringType(); 405 if (!(this.content instanceof StringType)) 406 throw new FHIRException("Type mismatch: the type StringType was expected, but "+this.content.getClass().getName()+" was encountered"); 407 return (StringType) this.content; 408 } 409 410 public boolean hasContentStringType() { 411 return this != null && this.content instanceof StringType; 412 } 413 414 /** 415 * @return {@link #content} (A communicated content (or for multi-part communications, one portion of the communication).) 416 */ 417 public Attachment getContentAttachment() throws FHIRException { 418 if (this.content == null) 419 this.content = new Attachment(); 420 if (!(this.content instanceof Attachment)) 421 throw new FHIRException("Type mismatch: the type Attachment was expected, but "+this.content.getClass().getName()+" was encountered"); 422 return (Attachment) this.content; 423 } 424 425 public boolean hasContentAttachment() { 426 return this != null && this.content instanceof Attachment; 427 } 428 429 /** 430 * @return {@link #content} (A communicated content (or for multi-part communications, one portion of the communication).) 431 */ 432 public Reference getContentReference() throws FHIRException { 433 if (this.content == null) 434 this.content = new Reference(); 435 if (!(this.content instanceof Reference)) 436 throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.content.getClass().getName()+" was encountered"); 437 return (Reference) this.content; 438 } 439 440 public boolean hasContentReference() { 441 return this != null && this.content instanceof Reference; 442 } 443 444 public boolean hasContent() { 445 return this.content != null && !this.content.isEmpty(); 446 } 447 448 /** 449 * @param value {@link #content} (A communicated content (or for multi-part communications, one portion of the communication).) 450 */ 451 public CommunicationPayloadComponent setContent(Type value) { 452 if (value != null && !(value instanceof StringType || value instanceof Attachment || value instanceof Reference)) 453 throw new Error("Not the right type for Communication.payload.content[x]: "+value.fhirType()); 454 this.content = value; 455 return this; 456 } 457 458 protected void listChildren(List<Property> children) { 459 super.listChildren(children); 460 children.add(new Property("content[x]", "string|Attachment|Reference(Any)", "A communicated content (or for multi-part communications, one portion of the communication).", 0, 1, content)); 461 } 462 463 @Override 464 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 465 switch (_hash) { 466 case 264548711: /*content[x]*/ return new Property("content[x]", "string|Attachment|Reference(Any)", "A communicated content (or for multi-part communications, one portion of the communication).", 0, 1, content); 467 case 951530617: /*content*/ return new Property("content[x]", "string|Attachment|Reference(Any)", "A communicated content (or for multi-part communications, one portion of the communication).", 0, 1, content); 468 case -326336022: /*contentString*/ return new Property("content[x]", "string|Attachment|Reference(Any)", "A communicated content (or for multi-part communications, one portion of the communication).", 0, 1, content); 469 case -702028164: /*contentAttachment*/ return new Property("content[x]", "string|Attachment|Reference(Any)", "A communicated content (or for multi-part communications, one portion of the communication).", 0, 1, content); 470 case 1193747154: /*contentReference*/ return new Property("content[x]", "string|Attachment|Reference(Any)", "A communicated content (or for multi-part communications, one portion of the communication).", 0, 1, content); 471 default: return super.getNamedProperty(_hash, _name, _checkValid); 472 } 473 474 } 475 476 @Override 477 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 478 switch (hash) { 479 case 951530617: /*content*/ return this.content == null ? new Base[0] : new Base[] {this.content}; // Type 480 default: return super.getProperty(hash, name, checkValid); 481 } 482 483 } 484 485 @Override 486 public Base setProperty(int hash, String name, Base value) throws FHIRException { 487 switch (hash) { 488 case 951530617: // content 489 this.content = castToType(value); // Type 490 return value; 491 default: return super.setProperty(hash, name, value); 492 } 493 494 } 495 496 @Override 497 public Base setProperty(String name, Base value) throws FHIRException { 498 if (name.equals("content[x]")) { 499 this.content = castToType(value); // Type 500 } else 501 return super.setProperty(name, value); 502 return value; 503 } 504 505 @Override 506 public Base makeProperty(int hash, String name) throws FHIRException { 507 switch (hash) { 508 case 264548711: return getContent(); 509 case 951530617: return getContent(); 510 default: return super.makeProperty(hash, name); 511 } 512 513 } 514 515 @Override 516 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 517 switch (hash) { 518 case 951530617: /*content*/ return new String[] {"string", "Attachment", "Reference"}; 519 default: return super.getTypesForProperty(hash, name); 520 } 521 522 } 523 524 @Override 525 public Base addChild(String name) throws FHIRException { 526 if (name.equals("contentString")) { 527 this.content = new StringType(); 528 return this.content; 529 } 530 else if (name.equals("contentAttachment")) { 531 this.content = new Attachment(); 532 return this.content; 533 } 534 else if (name.equals("contentReference")) { 535 this.content = new Reference(); 536 return this.content; 537 } 538 else 539 return super.addChild(name); 540 } 541 542 public CommunicationPayloadComponent copy() { 543 CommunicationPayloadComponent dst = new CommunicationPayloadComponent(); 544 copyValues(dst); 545 return dst; 546 } 547 548 public void copyValues(CommunicationPayloadComponent dst) { 549 super.copyValues(dst); 550 dst.content = content == null ? null : content.copy(); 551 } 552 553 @Override 554 public boolean equalsDeep(Base other_) { 555 if (!super.equalsDeep(other_)) 556 return false; 557 if (!(other_ instanceof CommunicationPayloadComponent)) 558 return false; 559 CommunicationPayloadComponent o = (CommunicationPayloadComponent) other_; 560 return compareDeep(content, o.content, true); 561 } 562 563 @Override 564 public boolean equalsShallow(Base other_) { 565 if (!super.equalsShallow(other_)) 566 return false; 567 if (!(other_ instanceof CommunicationPayloadComponent)) 568 return false; 569 CommunicationPayloadComponent o = (CommunicationPayloadComponent) other_; 570 return true; 571 } 572 573 public boolean isEmpty() { 574 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(content); 575 } 576 577 public String fhirType() { 578 return "Communication.payload"; 579 580 } 581 582 } 583 584 /** 585 * Business identifiers assigned to this communication by the performer or other systems which remain constant as the resource is updated and propagates from server to server. 586 */ 587 @Child(name = "identifier", type = {Identifier.class}, order=0, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 588 @Description(shortDefinition="Unique identifier", formalDefinition="Business identifiers assigned to this communication by the performer or other systems which remain constant as the resource is updated and propagates from server to server." ) 589 protected List<Identifier> identifier; 590 591 /** 592 * The URL pointing to a FHIR-defined protocol, guideline, orderset or other definition that is adhered to in whole or in part by this Communication. 593 */ 594 @Child(name = "instantiatesCanonical", type = {CanonicalType.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 595 @Description(shortDefinition="Instantiates FHIR protocol or definition", formalDefinition="The URL pointing to a FHIR-defined protocol, guideline, orderset or other definition that is adhered to in whole or in part by this Communication." ) 596 protected List<CanonicalType> instantiatesCanonical; 597 598 /** 599 * The URL pointing to an externally maintained protocol, guideline, orderset or other definition that is adhered to in whole or in part by this Communication. 600 */ 601 @Child(name = "instantiatesUri", type = {UriType.class}, order=2, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 602 @Description(shortDefinition="Instantiates external protocol or definition", formalDefinition="The URL pointing to an externally maintained protocol, guideline, orderset or other definition that is adhered to in whole or in part by this Communication." ) 603 protected List<UriType> instantiatesUri; 604 605 /** 606 * An order, proposal or plan fulfilled in whole or in part by this Communication. 607 */ 608 @Child(name = "basedOn", type = {Reference.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 609 @Description(shortDefinition="Request fulfilled by this communication", formalDefinition="An order, proposal or plan fulfilled in whole or in part by this Communication." ) 610 protected List<Reference> basedOn; 611 /** 612 * The actual objects that are the target of the reference (An order, proposal or plan fulfilled in whole or in part by this Communication.) 613 */ 614 protected List<Resource> basedOnTarget; 615 616 617 /** 618 * Part of this action. 619 */ 620 @Child(name = "partOf", type = {Reference.class}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 621 @Description(shortDefinition="Part of this action", formalDefinition="Part of this action." ) 622 protected List<Reference> partOf; 623 /** 624 * The actual objects that are the target of the reference (Part of this action.) 625 */ 626 protected List<Resource> partOfTarget; 627 628 629 /** 630 * Prior communication that this communication is in response to. 631 */ 632 @Child(name = "inResponseTo", type = {Communication.class}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 633 @Description(shortDefinition="Reply to", formalDefinition="Prior communication that this communication is in response to." ) 634 protected List<Reference> inResponseTo; 635 /** 636 * The actual objects that are the target of the reference (Prior communication that this communication is in response to.) 637 */ 638 protected List<Communication> inResponseToTarget; 639 640 641 /** 642 * The status of the transmission. 643 */ 644 @Child(name = "status", type = {CodeType.class}, order=6, min=1, max=1, modifier=true, summary=true) 645 @Description(shortDefinition="preparation | in-progress | not-done | on-hold | stopped | completed | entered-in-error | unknown", formalDefinition="The status of the transmission." ) 646 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/event-status") 647 protected Enumeration<CommunicationStatus> status; 648 649 /** 650 * Captures the reason for the current state of the Communication. 651 */ 652 @Child(name = "statusReason", type = {CodeableConcept.class}, order=7, min=0, max=1, modifier=false, summary=true) 653 @Description(shortDefinition="Reason for current status", formalDefinition="Captures the reason for the current state of the Communication." ) 654 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/communication-not-done-reason") 655 protected CodeableConcept statusReason; 656 657 /** 658 * The type of message conveyed such as alert, notification, reminder, instruction, etc. 659 */ 660 @Child(name = "category", type = {CodeableConcept.class}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 661 @Description(shortDefinition="Message category", formalDefinition="The type of message conveyed such as alert, notification, reminder, instruction, etc." ) 662 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/communication-category") 663 protected List<CodeableConcept> category; 664 665 /** 666 * Characterizes how quickly the planned or in progress communication must be addressed. Includes concepts such as stat, urgent, routine. 667 */ 668 @Child(name = "priority", type = {CodeType.class}, order=9, min=0, max=1, modifier=false, summary=true) 669 @Description(shortDefinition="routine | urgent | asap | stat", formalDefinition="Characterizes how quickly the planned or in progress communication must be addressed. Includes concepts such as stat, urgent, routine." ) 670 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/request-priority") 671 protected Enumeration<CommunicationPriority> priority; 672 673 /** 674 * A channel that was used for this communication (e.g. email, fax). 675 */ 676 @Child(name = "medium", type = {CodeableConcept.class}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 677 @Description(shortDefinition="A channel of communication", formalDefinition="A channel that was used for this communication (e.g. email, fax)." ) 678 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://terminology.hl7.org/ValueSet/v3-ParticipationMode") 679 protected List<CodeableConcept> medium; 680 681 /** 682 * The patient or group that was the focus of this communication. 683 */ 684 @Child(name = "subject", type = {Patient.class, Group.class}, order=11, min=0, max=1, modifier=false, summary=true) 685 @Description(shortDefinition="Focus of message", formalDefinition="The patient or group that was the focus of this communication." ) 686 protected Reference subject; 687 688 /** 689 * The actual object that is the target of the reference (The patient or group that was the focus of this communication.) 690 */ 691 protected Resource subjectTarget; 692 693 /** 694 * Description of the purpose/content, similar to a subject line in an email. 695 */ 696 @Child(name = "topic", type = {CodeableConcept.class}, order=12, min=0, max=1, modifier=false, summary=false) 697 @Description(shortDefinition="Description of the purpose/content", formalDefinition="Description of the purpose/content, similar to a subject line in an email." ) 698 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/communication-topic") 699 protected CodeableConcept topic; 700 701 /** 702 * Other resources that pertain to this communication and to which this communication should be associated. 703 */ 704 @Child(name = "about", type = {Reference.class}, order=13, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 705 @Description(shortDefinition="Resources that pertain to this communication", formalDefinition="Other resources that pertain to this communication and to which this communication should be associated." ) 706 protected List<Reference> about; 707 /** 708 * The actual objects that are the target of the reference (Other resources that pertain to this communication and to which this communication should be associated.) 709 */ 710 protected List<Resource> aboutTarget; 711 712 713 /** 714 * The Encounter during which this Communication was created or to which the creation of this record is tightly associated. 715 */ 716 @Child(name = "encounter", type = {Encounter.class}, order=14, min=0, max=1, modifier=false, summary=true) 717 @Description(shortDefinition="Encounter created as part of", formalDefinition="The Encounter during which this Communication was created or to which the creation of this record is tightly associated." ) 718 protected Reference encounter; 719 720 /** 721 * The actual object that is the target of the reference (The Encounter during which this Communication was created or to which the creation of this record is tightly associated.) 722 */ 723 protected Encounter encounterTarget; 724 725 /** 726 * The time when this communication was sent. 727 */ 728 @Child(name = "sent", type = {DateTimeType.class}, order=15, min=0, max=1, modifier=false, summary=false) 729 @Description(shortDefinition="When sent", formalDefinition="The time when this communication was sent." ) 730 protected DateTimeType sent; 731 732 /** 733 * The time when this communication arrived at the destination. 734 */ 735 @Child(name = "received", type = {DateTimeType.class}, order=16, min=0, max=1, modifier=false, summary=false) 736 @Description(shortDefinition="When received", formalDefinition="The time when this communication arrived at the destination." ) 737 protected DateTimeType received; 738 739 /** 740 * The entity (e.g. person, organization, clinical information system, care team or device) which was the target of the communication. If receipts need to be tracked by an individual, a separate resource instance will need to be created for each recipient. Multiple recipient communications are intended where either receipts are not tracked (e.g. a mass mail-out) or a receipt is captured in aggregate (all emails confirmed received by a particular time). 741 */ 742 @Child(name = "recipient", type = {Device.class, Organization.class, Patient.class, Practitioner.class, PractitionerRole.class, RelatedPerson.class, Group.class, CareTeam.class, HealthcareService.class}, order=17, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 743 @Description(shortDefinition="Message recipient", formalDefinition="The entity (e.g. person, organization, clinical information system, care team or device) which was the target of the communication. If receipts need to be tracked by an individual, a separate resource instance will need to be created for each recipient. Multiple recipient communications are intended where either receipts are not tracked (e.g. a mass mail-out) or a receipt is captured in aggregate (all emails confirmed received by a particular time)." ) 744 protected List<Reference> recipient; 745 /** 746 * The actual objects that are the target of the reference (The entity (e.g. person, organization, clinical information system, care team or device) which was the target of the communication. If receipts need to be tracked by an individual, a separate resource instance will need to be created for each recipient. Multiple recipient communications are intended where either receipts are not tracked (e.g. a mass mail-out) or a receipt is captured in aggregate (all emails confirmed received by a particular time).) 747 */ 748 protected List<Resource> recipientTarget; 749 750 751 /** 752 * The entity (e.g. person, organization, clinical information system, or device) which was the source of the communication. 753 */ 754 @Child(name = "sender", type = {Device.class, Organization.class, Patient.class, Practitioner.class, PractitionerRole.class, RelatedPerson.class, HealthcareService.class}, order=18, min=0, max=1, modifier=false, summary=false) 755 @Description(shortDefinition="Message sender", formalDefinition="The entity (e.g. person, organization, clinical information system, or device) which was the source of the communication." ) 756 protected Reference sender; 757 758 /** 759 * The actual object that is the target of the reference (The entity (e.g. person, organization, clinical information system, or device) which was the source of the communication.) 760 */ 761 protected Resource senderTarget; 762 763 /** 764 * The reason or justification for the communication. 765 */ 766 @Child(name = "reasonCode", type = {CodeableConcept.class}, order=19, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 767 @Description(shortDefinition="Indication for message", formalDefinition="The reason or justification for the communication." ) 768 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/clinical-findings") 769 protected List<CodeableConcept> reasonCode; 770 771 /** 772 * Indicates another resource whose existence justifies this communication. 773 */ 774 @Child(name = "reasonReference", type = {Condition.class, Observation.class, DiagnosticReport.class, DocumentReference.class}, order=20, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 775 @Description(shortDefinition="Why was communication done?", formalDefinition="Indicates another resource whose existence justifies this communication." ) 776 protected List<Reference> reasonReference; 777 /** 778 * The actual objects that are the target of the reference (Indicates another resource whose existence justifies this communication.) 779 */ 780 protected List<Resource> reasonReferenceTarget; 781 782 783 /** 784 * Text, attachment(s), or resource(s) that was communicated to the recipient. 785 */ 786 @Child(name = "payload", type = {}, order=21, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 787 @Description(shortDefinition="Message payload", formalDefinition="Text, attachment(s), or resource(s) that was communicated to the recipient." ) 788 protected List<CommunicationPayloadComponent> payload; 789 790 /** 791 * Additional notes or commentary about the communication by the sender, receiver or other interested parties. 792 */ 793 @Child(name = "note", type = {Annotation.class}, order=22, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 794 @Description(shortDefinition="Comments made about the communication", formalDefinition="Additional notes or commentary about the communication by the sender, receiver or other interested parties." ) 795 protected List<Annotation> note; 796 797 private static final long serialVersionUID = 1325359310L; 798 799 /** 800 * Constructor 801 */ 802 public Communication() { 803 super(); 804 } 805 806 /** 807 * Constructor 808 */ 809 public Communication(Enumeration<CommunicationStatus> status) { 810 super(); 811 this.status = status; 812 } 813 814 /** 815 * @return {@link #identifier} (Business identifiers assigned to this communication by the performer or other systems which remain constant as the resource is updated and propagates from server to server.) 816 */ 817 public List<Identifier> getIdentifier() { 818 if (this.identifier == null) 819 this.identifier = new ArrayList<Identifier>(); 820 return this.identifier; 821 } 822 823 /** 824 * @return Returns a reference to <code>this</code> for easy method chaining 825 */ 826 public Communication setIdentifier(List<Identifier> theIdentifier) { 827 this.identifier = theIdentifier; 828 return this; 829 } 830 831 public boolean hasIdentifier() { 832 if (this.identifier == null) 833 return false; 834 for (Identifier item : this.identifier) 835 if (!item.isEmpty()) 836 return true; 837 return false; 838 } 839 840 public Identifier addIdentifier() { //3 841 Identifier t = new Identifier(); 842 if (this.identifier == null) 843 this.identifier = new ArrayList<Identifier>(); 844 this.identifier.add(t); 845 return t; 846 } 847 848 public Communication addIdentifier(Identifier t) { //3 849 if (t == null) 850 return this; 851 if (this.identifier == null) 852 this.identifier = new ArrayList<Identifier>(); 853 this.identifier.add(t); 854 return this; 855 } 856 857 /** 858 * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist 859 */ 860 public Identifier getIdentifierFirstRep() { 861 if (getIdentifier().isEmpty()) { 862 addIdentifier(); 863 } 864 return getIdentifier().get(0); 865 } 866 867 /** 868 * @return {@link #instantiatesCanonical} (The URL pointing to a FHIR-defined protocol, guideline, orderset or other definition that is adhered to in whole or in part by this Communication.) 869 */ 870 public List<CanonicalType> getInstantiatesCanonical() { 871 if (this.instantiatesCanonical == null) 872 this.instantiatesCanonical = new ArrayList<CanonicalType>(); 873 return this.instantiatesCanonical; 874 } 875 876 /** 877 * @return Returns a reference to <code>this</code> for easy method chaining 878 */ 879 public Communication setInstantiatesCanonical(List<CanonicalType> theInstantiatesCanonical) { 880 this.instantiatesCanonical = theInstantiatesCanonical; 881 return this; 882 } 883 884 public boolean hasInstantiatesCanonical() { 885 if (this.instantiatesCanonical == null) 886 return false; 887 for (CanonicalType item : this.instantiatesCanonical) 888 if (!item.isEmpty()) 889 return true; 890 return false; 891 } 892 893 /** 894 * @return {@link #instantiatesCanonical} (The URL pointing to a FHIR-defined protocol, guideline, orderset or other definition that is adhered to in whole or in part by this Communication.) 895 */ 896 public CanonicalType addInstantiatesCanonicalElement() {//2 897 CanonicalType t = new CanonicalType(); 898 if (this.instantiatesCanonical == null) 899 this.instantiatesCanonical = new ArrayList<CanonicalType>(); 900 this.instantiatesCanonical.add(t); 901 return t; 902 } 903 904 /** 905 * @param value {@link #instantiatesCanonical} (The URL pointing to a FHIR-defined protocol, guideline, orderset or other definition that is adhered to in whole or in part by this Communication.) 906 */ 907 public Communication addInstantiatesCanonical(String value) { //1 908 CanonicalType t = new CanonicalType(); 909 t.setValue(value); 910 if (this.instantiatesCanonical == null) 911 this.instantiatesCanonical = new ArrayList<CanonicalType>(); 912 this.instantiatesCanonical.add(t); 913 return this; 914 } 915 916 /** 917 * @param value {@link #instantiatesCanonical} (The URL pointing to a FHIR-defined protocol, guideline, orderset or other definition that is adhered to in whole or in part by this Communication.) 918 */ 919 public boolean hasInstantiatesCanonical(String value) { 920 if (this.instantiatesCanonical == null) 921 return false; 922 for (CanonicalType v : this.instantiatesCanonical) 923 if (v.getValue().equals(value)) // canonical(PlanDefinition|ActivityDefinition|Measure|OperationDefinition|Questionnaire) 924 return true; 925 return false; 926 } 927 928 /** 929 * @return {@link #instantiatesUri} (The URL pointing to an externally maintained protocol, guideline, orderset or other definition that is adhered to in whole or in part by this Communication.) 930 */ 931 public List<UriType> getInstantiatesUri() { 932 if (this.instantiatesUri == null) 933 this.instantiatesUri = new ArrayList<UriType>(); 934 return this.instantiatesUri; 935 } 936 937 /** 938 * @return Returns a reference to <code>this</code> for easy method chaining 939 */ 940 public Communication setInstantiatesUri(List<UriType> theInstantiatesUri) { 941 this.instantiatesUri = theInstantiatesUri; 942 return this; 943 } 944 945 public boolean hasInstantiatesUri() { 946 if (this.instantiatesUri == null) 947 return false; 948 for (UriType item : this.instantiatesUri) 949 if (!item.isEmpty()) 950 return true; 951 return false; 952 } 953 954 /** 955 * @return {@link #instantiatesUri} (The URL pointing to an externally maintained protocol, guideline, orderset or other definition that is adhered to in whole or in part by this Communication.) 956 */ 957 public UriType addInstantiatesUriElement() {//2 958 UriType t = new UriType(); 959 if (this.instantiatesUri == null) 960 this.instantiatesUri = new ArrayList<UriType>(); 961 this.instantiatesUri.add(t); 962 return t; 963 } 964 965 /** 966 * @param value {@link #instantiatesUri} (The URL pointing to an externally maintained protocol, guideline, orderset or other definition that is adhered to in whole or in part by this Communication.) 967 */ 968 public Communication addInstantiatesUri(String value) { //1 969 UriType t = new UriType(); 970 t.setValue(value); 971 if (this.instantiatesUri == null) 972 this.instantiatesUri = new ArrayList<UriType>(); 973 this.instantiatesUri.add(t); 974 return this; 975 } 976 977 /** 978 * @param value {@link #instantiatesUri} (The URL pointing to an externally maintained protocol, guideline, orderset or other definition that is adhered to in whole or in part by this Communication.) 979 */ 980 public boolean hasInstantiatesUri(String value) { 981 if (this.instantiatesUri == null) 982 return false; 983 for (UriType v : this.instantiatesUri) 984 if (v.getValue().equals(value)) // uri 985 return true; 986 return false; 987 } 988 989 /** 990 * @return {@link #basedOn} (An order, proposal or plan fulfilled in whole or in part by this Communication.) 991 */ 992 public List<Reference> getBasedOn() { 993 if (this.basedOn == null) 994 this.basedOn = new ArrayList<Reference>(); 995 return this.basedOn; 996 } 997 998 /** 999 * @return Returns a reference to <code>this</code> for easy method chaining 1000 */ 1001 public Communication setBasedOn(List<Reference> theBasedOn) { 1002 this.basedOn = theBasedOn; 1003 return this; 1004 } 1005 1006 public boolean hasBasedOn() { 1007 if (this.basedOn == null) 1008 return false; 1009 for (Reference item : this.basedOn) 1010 if (!item.isEmpty()) 1011 return true; 1012 return false; 1013 } 1014 1015 public Reference addBasedOn() { //3 1016 Reference t = new Reference(); 1017 if (this.basedOn == null) 1018 this.basedOn = new ArrayList<Reference>(); 1019 this.basedOn.add(t); 1020 return t; 1021 } 1022 1023 public Communication addBasedOn(Reference t) { //3 1024 if (t == null) 1025 return this; 1026 if (this.basedOn == null) 1027 this.basedOn = new ArrayList<Reference>(); 1028 this.basedOn.add(t); 1029 return this; 1030 } 1031 1032 /** 1033 * @return The first repetition of repeating field {@link #basedOn}, creating it if it does not already exist 1034 */ 1035 public Reference getBasedOnFirstRep() { 1036 if (getBasedOn().isEmpty()) { 1037 addBasedOn(); 1038 } 1039 return getBasedOn().get(0); 1040 } 1041 1042 /** 1043 * @deprecated Use Reference#setResource(IBaseResource) instead 1044 */ 1045 @Deprecated 1046 public List<Resource> getBasedOnTarget() { 1047 if (this.basedOnTarget == null) 1048 this.basedOnTarget = new ArrayList<Resource>(); 1049 return this.basedOnTarget; 1050 } 1051 1052 /** 1053 * @return {@link #partOf} (Part of this action.) 1054 */ 1055 public List<Reference> getPartOf() { 1056 if (this.partOf == null) 1057 this.partOf = new ArrayList<Reference>(); 1058 return this.partOf; 1059 } 1060 1061 /** 1062 * @return Returns a reference to <code>this</code> for easy method chaining 1063 */ 1064 public Communication setPartOf(List<Reference> thePartOf) { 1065 this.partOf = thePartOf; 1066 return this; 1067 } 1068 1069 public boolean hasPartOf() { 1070 if (this.partOf == null) 1071 return false; 1072 for (Reference item : this.partOf) 1073 if (!item.isEmpty()) 1074 return true; 1075 return false; 1076 } 1077 1078 public Reference addPartOf() { //3 1079 Reference t = new Reference(); 1080 if (this.partOf == null) 1081 this.partOf = new ArrayList<Reference>(); 1082 this.partOf.add(t); 1083 return t; 1084 } 1085 1086 public Communication addPartOf(Reference t) { //3 1087 if (t == null) 1088 return this; 1089 if (this.partOf == null) 1090 this.partOf = new ArrayList<Reference>(); 1091 this.partOf.add(t); 1092 return this; 1093 } 1094 1095 /** 1096 * @return The first repetition of repeating field {@link #partOf}, creating it if it does not already exist 1097 */ 1098 public Reference getPartOfFirstRep() { 1099 if (getPartOf().isEmpty()) { 1100 addPartOf(); 1101 } 1102 return getPartOf().get(0); 1103 } 1104 1105 /** 1106 * @deprecated Use Reference#setResource(IBaseResource) instead 1107 */ 1108 @Deprecated 1109 public List<Resource> getPartOfTarget() { 1110 if (this.partOfTarget == null) 1111 this.partOfTarget = new ArrayList<Resource>(); 1112 return this.partOfTarget; 1113 } 1114 1115 /** 1116 * @return {@link #inResponseTo} (Prior communication that this communication is in response to.) 1117 */ 1118 public List<Reference> getInResponseTo() { 1119 if (this.inResponseTo == null) 1120 this.inResponseTo = new ArrayList<Reference>(); 1121 return this.inResponseTo; 1122 } 1123 1124 /** 1125 * @return Returns a reference to <code>this</code> for easy method chaining 1126 */ 1127 public Communication setInResponseTo(List<Reference> theInResponseTo) { 1128 this.inResponseTo = theInResponseTo; 1129 return this; 1130 } 1131 1132 public boolean hasInResponseTo() { 1133 if (this.inResponseTo == null) 1134 return false; 1135 for (Reference item : this.inResponseTo) 1136 if (!item.isEmpty()) 1137 return true; 1138 return false; 1139 } 1140 1141 public Reference addInResponseTo() { //3 1142 Reference t = new Reference(); 1143 if (this.inResponseTo == null) 1144 this.inResponseTo = new ArrayList<Reference>(); 1145 this.inResponseTo.add(t); 1146 return t; 1147 } 1148 1149 public Communication addInResponseTo(Reference t) { //3 1150 if (t == null) 1151 return this; 1152 if (this.inResponseTo == null) 1153 this.inResponseTo = new ArrayList<Reference>(); 1154 this.inResponseTo.add(t); 1155 return this; 1156 } 1157 1158 /** 1159 * @return The first repetition of repeating field {@link #inResponseTo}, creating it if it does not already exist 1160 */ 1161 public Reference getInResponseToFirstRep() { 1162 if (getInResponseTo().isEmpty()) { 1163 addInResponseTo(); 1164 } 1165 return getInResponseTo().get(0); 1166 } 1167 1168 /** 1169 * @deprecated Use Reference#setResource(IBaseResource) instead 1170 */ 1171 @Deprecated 1172 public List<Communication> getInResponseToTarget() { 1173 if (this.inResponseToTarget == null) 1174 this.inResponseToTarget = new ArrayList<Communication>(); 1175 return this.inResponseToTarget; 1176 } 1177 1178 /** 1179 * @deprecated Use Reference#setResource(IBaseResource) instead 1180 */ 1181 @Deprecated 1182 public Communication addInResponseToTarget() { 1183 Communication r = new Communication(); 1184 if (this.inResponseToTarget == null) 1185 this.inResponseToTarget = new ArrayList<Communication>(); 1186 this.inResponseToTarget.add(r); 1187 return r; 1188 } 1189 1190 /** 1191 * @return {@link #status} (The status of the transmission.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value 1192 */ 1193 public Enumeration<CommunicationStatus> getStatusElement() { 1194 if (this.status == null) 1195 if (Configuration.errorOnAutoCreate()) 1196 throw new Error("Attempt to auto-create Communication.status"); 1197 else if (Configuration.doAutoCreate()) 1198 this.status = new Enumeration<CommunicationStatus>(new CommunicationStatusEnumFactory()); // bb 1199 return this.status; 1200 } 1201 1202 public boolean hasStatusElement() { 1203 return this.status != null && !this.status.isEmpty(); 1204 } 1205 1206 public boolean hasStatus() { 1207 return this.status != null && !this.status.isEmpty(); 1208 } 1209 1210 /** 1211 * @param value {@link #status} (The status of the transmission.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value 1212 */ 1213 public Communication setStatusElement(Enumeration<CommunicationStatus> value) { 1214 this.status = value; 1215 return this; 1216 } 1217 1218 /** 1219 * @return The status of the transmission. 1220 */ 1221 public CommunicationStatus getStatus() { 1222 return this.status == null ? null : this.status.getValue(); 1223 } 1224 1225 /** 1226 * @param value The status of the transmission. 1227 */ 1228 public Communication setStatus(CommunicationStatus value) { 1229 if (this.status == null) 1230 this.status = new Enumeration<CommunicationStatus>(new CommunicationStatusEnumFactory()); 1231 this.status.setValue(value); 1232 return this; 1233 } 1234 1235 /** 1236 * @return {@link #statusReason} (Captures the reason for the current state of the Communication.) 1237 */ 1238 public CodeableConcept getStatusReason() { 1239 if (this.statusReason == null) 1240 if (Configuration.errorOnAutoCreate()) 1241 throw new Error("Attempt to auto-create Communication.statusReason"); 1242 else if (Configuration.doAutoCreate()) 1243 this.statusReason = new CodeableConcept(); // cc 1244 return this.statusReason; 1245 } 1246 1247 public boolean hasStatusReason() { 1248 return this.statusReason != null && !this.statusReason.isEmpty(); 1249 } 1250 1251 /** 1252 * @param value {@link #statusReason} (Captures the reason for the current state of the Communication.) 1253 */ 1254 public Communication setStatusReason(CodeableConcept value) { 1255 this.statusReason = value; 1256 return this; 1257 } 1258 1259 /** 1260 * @return {@link #category} (The type of message conveyed such as alert, notification, reminder, instruction, etc.) 1261 */ 1262 public List<CodeableConcept> getCategory() { 1263 if (this.category == null) 1264 this.category = new ArrayList<CodeableConcept>(); 1265 return this.category; 1266 } 1267 1268 /** 1269 * @return Returns a reference to <code>this</code> for easy method chaining 1270 */ 1271 public Communication setCategory(List<CodeableConcept> theCategory) { 1272 this.category = theCategory; 1273 return this; 1274 } 1275 1276 public boolean hasCategory() { 1277 if (this.category == null) 1278 return false; 1279 for (CodeableConcept item : this.category) 1280 if (!item.isEmpty()) 1281 return true; 1282 return false; 1283 } 1284 1285 public CodeableConcept addCategory() { //3 1286 CodeableConcept t = new CodeableConcept(); 1287 if (this.category == null) 1288 this.category = new ArrayList<CodeableConcept>(); 1289 this.category.add(t); 1290 return t; 1291 } 1292 1293 public Communication addCategory(CodeableConcept t) { //3 1294 if (t == null) 1295 return this; 1296 if (this.category == null) 1297 this.category = new ArrayList<CodeableConcept>(); 1298 this.category.add(t); 1299 return this; 1300 } 1301 1302 /** 1303 * @return The first repetition of repeating field {@link #category}, creating it if it does not already exist 1304 */ 1305 public CodeableConcept getCategoryFirstRep() { 1306 if (getCategory().isEmpty()) { 1307 addCategory(); 1308 } 1309 return getCategory().get(0); 1310 } 1311 1312 /** 1313 * @return {@link #priority} (Characterizes how quickly the planned or in progress communication must be addressed. Includes concepts such as stat, urgent, routine.). This is the underlying object with id, value and extensions. The accessor "getPriority" gives direct access to the value 1314 */ 1315 public Enumeration<CommunicationPriority> getPriorityElement() { 1316 if (this.priority == null) 1317 if (Configuration.errorOnAutoCreate()) 1318 throw new Error("Attempt to auto-create Communication.priority"); 1319 else if (Configuration.doAutoCreate()) 1320 this.priority = new Enumeration<CommunicationPriority>(new CommunicationPriorityEnumFactory()); // bb 1321 return this.priority; 1322 } 1323 1324 public boolean hasPriorityElement() { 1325 return this.priority != null && !this.priority.isEmpty(); 1326 } 1327 1328 public boolean hasPriority() { 1329 return this.priority != null && !this.priority.isEmpty(); 1330 } 1331 1332 /** 1333 * @param value {@link #priority} (Characterizes how quickly the planned or in progress communication must be addressed. Includes concepts such as stat, urgent, routine.). This is the underlying object with id, value and extensions. The accessor "getPriority" gives direct access to the value 1334 */ 1335 public Communication setPriorityElement(Enumeration<CommunicationPriority> value) { 1336 this.priority = value; 1337 return this; 1338 } 1339 1340 /** 1341 * @return Characterizes how quickly the planned or in progress communication must be addressed. Includes concepts such as stat, urgent, routine. 1342 */ 1343 public CommunicationPriority getPriority() { 1344 return this.priority == null ? null : this.priority.getValue(); 1345 } 1346 1347 /** 1348 * @param value Characterizes how quickly the planned or in progress communication must be addressed. Includes concepts such as stat, urgent, routine. 1349 */ 1350 public Communication setPriority(CommunicationPriority value) { 1351 if (value == null) 1352 this.priority = null; 1353 else { 1354 if (this.priority == null) 1355 this.priority = new Enumeration<CommunicationPriority>(new CommunicationPriorityEnumFactory()); 1356 this.priority.setValue(value); 1357 } 1358 return this; 1359 } 1360 1361 /** 1362 * @return {@link #medium} (A channel that was used for this communication (e.g. email, fax).) 1363 */ 1364 public List<CodeableConcept> getMedium() { 1365 if (this.medium == null) 1366 this.medium = new ArrayList<CodeableConcept>(); 1367 return this.medium; 1368 } 1369 1370 /** 1371 * @return Returns a reference to <code>this</code> for easy method chaining 1372 */ 1373 public Communication setMedium(List<CodeableConcept> theMedium) { 1374 this.medium = theMedium; 1375 return this; 1376 } 1377 1378 public boolean hasMedium() { 1379 if (this.medium == null) 1380 return false; 1381 for (CodeableConcept item : this.medium) 1382 if (!item.isEmpty()) 1383 return true; 1384 return false; 1385 } 1386 1387 public CodeableConcept addMedium() { //3 1388 CodeableConcept t = new CodeableConcept(); 1389 if (this.medium == null) 1390 this.medium = new ArrayList<CodeableConcept>(); 1391 this.medium.add(t); 1392 return t; 1393 } 1394 1395 public Communication addMedium(CodeableConcept t) { //3 1396 if (t == null) 1397 return this; 1398 if (this.medium == null) 1399 this.medium = new ArrayList<CodeableConcept>(); 1400 this.medium.add(t); 1401 return this; 1402 } 1403 1404 /** 1405 * @return The first repetition of repeating field {@link #medium}, creating it if it does not already exist 1406 */ 1407 public CodeableConcept getMediumFirstRep() { 1408 if (getMedium().isEmpty()) { 1409 addMedium(); 1410 } 1411 return getMedium().get(0); 1412 } 1413 1414 /** 1415 * @return {@link #subject} (The patient or group that was the focus of this communication.) 1416 */ 1417 public Reference getSubject() { 1418 if (this.subject == null) 1419 if (Configuration.errorOnAutoCreate()) 1420 throw new Error("Attempt to auto-create Communication.subject"); 1421 else if (Configuration.doAutoCreate()) 1422 this.subject = new Reference(); // cc 1423 return this.subject; 1424 } 1425 1426 public boolean hasSubject() { 1427 return this.subject != null && !this.subject.isEmpty(); 1428 } 1429 1430 /** 1431 * @param value {@link #subject} (The patient or group that was the focus of this communication.) 1432 */ 1433 public Communication setSubject(Reference value) { 1434 this.subject = value; 1435 return this; 1436 } 1437 1438 /** 1439 * @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 or group that was the focus of this communication.) 1440 */ 1441 public Resource getSubjectTarget() { 1442 return this.subjectTarget; 1443 } 1444 1445 /** 1446 * @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 or group that was the focus of this communication.) 1447 */ 1448 public Communication setSubjectTarget(Resource value) { 1449 this.subjectTarget = value; 1450 return this; 1451 } 1452 1453 /** 1454 * @return {@link #topic} (Description of the purpose/content, similar to a subject line in an email.) 1455 */ 1456 public CodeableConcept getTopic() { 1457 if (this.topic == null) 1458 if (Configuration.errorOnAutoCreate()) 1459 throw new Error("Attempt to auto-create Communication.topic"); 1460 else if (Configuration.doAutoCreate()) 1461 this.topic = new CodeableConcept(); // cc 1462 return this.topic; 1463 } 1464 1465 public boolean hasTopic() { 1466 return this.topic != null && !this.topic.isEmpty(); 1467 } 1468 1469 /** 1470 * @param value {@link #topic} (Description of the purpose/content, similar to a subject line in an email.) 1471 */ 1472 public Communication setTopic(CodeableConcept value) { 1473 this.topic = value; 1474 return this; 1475 } 1476 1477 /** 1478 * @return {@link #about} (Other resources that pertain to this communication and to which this communication should be associated.) 1479 */ 1480 public List<Reference> getAbout() { 1481 if (this.about == null) 1482 this.about = new ArrayList<Reference>(); 1483 return this.about; 1484 } 1485 1486 /** 1487 * @return Returns a reference to <code>this</code> for easy method chaining 1488 */ 1489 public Communication setAbout(List<Reference> theAbout) { 1490 this.about = theAbout; 1491 return this; 1492 } 1493 1494 public boolean hasAbout() { 1495 if (this.about == null) 1496 return false; 1497 for (Reference item : this.about) 1498 if (!item.isEmpty()) 1499 return true; 1500 return false; 1501 } 1502 1503 public Reference addAbout() { //3 1504 Reference t = new Reference(); 1505 if (this.about == null) 1506 this.about = new ArrayList<Reference>(); 1507 this.about.add(t); 1508 return t; 1509 } 1510 1511 public Communication addAbout(Reference t) { //3 1512 if (t == null) 1513 return this; 1514 if (this.about == null) 1515 this.about = new ArrayList<Reference>(); 1516 this.about.add(t); 1517 return this; 1518 } 1519 1520 /** 1521 * @return The first repetition of repeating field {@link #about}, creating it if it does not already exist 1522 */ 1523 public Reference getAboutFirstRep() { 1524 if (getAbout().isEmpty()) { 1525 addAbout(); 1526 } 1527 return getAbout().get(0); 1528 } 1529 1530 /** 1531 * @deprecated Use Reference#setResource(IBaseResource) instead 1532 */ 1533 @Deprecated 1534 public List<Resource> getAboutTarget() { 1535 if (this.aboutTarget == null) 1536 this.aboutTarget = new ArrayList<Resource>(); 1537 return this.aboutTarget; 1538 } 1539 1540 /** 1541 * @return {@link #encounter} (The Encounter during which this Communication was created or to which the creation of this record is tightly associated.) 1542 */ 1543 public Reference getEncounter() { 1544 if (this.encounter == null) 1545 if (Configuration.errorOnAutoCreate()) 1546 throw new Error("Attempt to auto-create Communication.encounter"); 1547 else if (Configuration.doAutoCreate()) 1548 this.encounter = new Reference(); // cc 1549 return this.encounter; 1550 } 1551 1552 public boolean hasEncounter() { 1553 return this.encounter != null && !this.encounter.isEmpty(); 1554 } 1555 1556 /** 1557 * @param value {@link #encounter} (The Encounter during which this Communication was created or to which the creation of this record is tightly associated.) 1558 */ 1559 public Communication setEncounter(Reference value) { 1560 this.encounter = value; 1561 return this; 1562 } 1563 1564 /** 1565 * @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 Communication was created or to which the creation of this record is tightly associated.) 1566 */ 1567 public Encounter getEncounterTarget() { 1568 if (this.encounterTarget == null) 1569 if (Configuration.errorOnAutoCreate()) 1570 throw new Error("Attempt to auto-create Communication.encounter"); 1571 else if (Configuration.doAutoCreate()) 1572 this.encounterTarget = new Encounter(); // aa 1573 return this.encounterTarget; 1574 } 1575 1576 /** 1577 * @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 Communication was created or to which the creation of this record is tightly associated.) 1578 */ 1579 public Communication setEncounterTarget(Encounter value) { 1580 this.encounterTarget = value; 1581 return this; 1582 } 1583 1584 /** 1585 * @return {@link #sent} (The time when this communication was sent.). This is the underlying object with id, value and extensions. The accessor "getSent" gives direct access to the value 1586 */ 1587 public DateTimeType getSentElement() { 1588 if (this.sent == null) 1589 if (Configuration.errorOnAutoCreate()) 1590 throw new Error("Attempt to auto-create Communication.sent"); 1591 else if (Configuration.doAutoCreate()) 1592 this.sent = new DateTimeType(); // bb 1593 return this.sent; 1594 } 1595 1596 public boolean hasSentElement() { 1597 return this.sent != null && !this.sent.isEmpty(); 1598 } 1599 1600 public boolean hasSent() { 1601 return this.sent != null && !this.sent.isEmpty(); 1602 } 1603 1604 /** 1605 * @param value {@link #sent} (The time when this communication was sent.). This is the underlying object with id, value and extensions. The accessor "getSent" gives direct access to the value 1606 */ 1607 public Communication setSentElement(DateTimeType value) { 1608 this.sent = value; 1609 return this; 1610 } 1611 1612 /** 1613 * @return The time when this communication was sent. 1614 */ 1615 public Date getSent() { 1616 return this.sent == null ? null : this.sent.getValue(); 1617 } 1618 1619 /** 1620 * @param value The time when this communication was sent. 1621 */ 1622 public Communication setSent(Date value) { 1623 if (value == null) 1624 this.sent = null; 1625 else { 1626 if (this.sent == null) 1627 this.sent = new DateTimeType(); 1628 this.sent.setValue(value); 1629 } 1630 return this; 1631 } 1632 1633 /** 1634 * @return {@link #received} (The time when this communication arrived at the destination.). This is the underlying object with id, value and extensions. The accessor "getReceived" gives direct access to the value 1635 */ 1636 public DateTimeType getReceivedElement() { 1637 if (this.received == null) 1638 if (Configuration.errorOnAutoCreate()) 1639 throw new Error("Attempt to auto-create Communication.received"); 1640 else if (Configuration.doAutoCreate()) 1641 this.received = new DateTimeType(); // bb 1642 return this.received; 1643 } 1644 1645 public boolean hasReceivedElement() { 1646 return this.received != null && !this.received.isEmpty(); 1647 } 1648 1649 public boolean hasReceived() { 1650 return this.received != null && !this.received.isEmpty(); 1651 } 1652 1653 /** 1654 * @param value {@link #received} (The time when this communication arrived at the destination.). This is the underlying object with id, value and extensions. The accessor "getReceived" gives direct access to the value 1655 */ 1656 public Communication setReceivedElement(DateTimeType value) { 1657 this.received = value; 1658 return this; 1659 } 1660 1661 /** 1662 * @return The time when this communication arrived at the destination. 1663 */ 1664 public Date getReceived() { 1665 return this.received == null ? null : this.received.getValue(); 1666 } 1667 1668 /** 1669 * @param value The time when this communication arrived at the destination. 1670 */ 1671 public Communication setReceived(Date value) { 1672 if (value == null) 1673 this.received = null; 1674 else { 1675 if (this.received == null) 1676 this.received = new DateTimeType(); 1677 this.received.setValue(value); 1678 } 1679 return this; 1680 } 1681 1682 /** 1683 * @return {@link #recipient} (The entity (e.g. person, organization, clinical information system, care team or device) which was the target of the communication. If receipts need to be tracked by an individual, a separate resource instance will need to be created for each recipient. Multiple recipient communications are intended where either receipts are not tracked (e.g. a mass mail-out) or a receipt is captured in aggregate (all emails confirmed received by a particular time).) 1684 */ 1685 public List<Reference> getRecipient() { 1686 if (this.recipient == null) 1687 this.recipient = new ArrayList<Reference>(); 1688 return this.recipient; 1689 } 1690 1691 /** 1692 * @return Returns a reference to <code>this</code> for easy method chaining 1693 */ 1694 public Communication setRecipient(List<Reference> theRecipient) { 1695 this.recipient = theRecipient; 1696 return this; 1697 } 1698 1699 public boolean hasRecipient() { 1700 if (this.recipient == null) 1701 return false; 1702 for (Reference item : this.recipient) 1703 if (!item.isEmpty()) 1704 return true; 1705 return false; 1706 } 1707 1708 public Reference addRecipient() { //3 1709 Reference t = new Reference(); 1710 if (this.recipient == null) 1711 this.recipient = new ArrayList<Reference>(); 1712 this.recipient.add(t); 1713 return t; 1714 } 1715 1716 public Communication addRecipient(Reference t) { //3 1717 if (t == null) 1718 return this; 1719 if (this.recipient == null) 1720 this.recipient = new ArrayList<Reference>(); 1721 this.recipient.add(t); 1722 return this; 1723 } 1724 1725 /** 1726 * @return The first repetition of repeating field {@link #recipient}, creating it if it does not already exist 1727 */ 1728 public Reference getRecipientFirstRep() { 1729 if (getRecipient().isEmpty()) { 1730 addRecipient(); 1731 } 1732 return getRecipient().get(0); 1733 } 1734 1735 /** 1736 * @deprecated Use Reference#setResource(IBaseResource) instead 1737 */ 1738 @Deprecated 1739 public List<Resource> getRecipientTarget() { 1740 if (this.recipientTarget == null) 1741 this.recipientTarget = new ArrayList<Resource>(); 1742 return this.recipientTarget; 1743 } 1744 1745 /** 1746 * @return {@link #sender} (The entity (e.g. person, organization, clinical information system, or device) which was the source of the communication.) 1747 */ 1748 public Reference getSender() { 1749 if (this.sender == null) 1750 if (Configuration.errorOnAutoCreate()) 1751 throw new Error("Attempt to auto-create Communication.sender"); 1752 else if (Configuration.doAutoCreate()) 1753 this.sender = new Reference(); // cc 1754 return this.sender; 1755 } 1756 1757 public boolean hasSender() { 1758 return this.sender != null && !this.sender.isEmpty(); 1759 } 1760 1761 /** 1762 * @param value {@link #sender} (The entity (e.g. person, organization, clinical information system, or device) which was the source of the communication.) 1763 */ 1764 public Communication setSender(Reference value) { 1765 this.sender = value; 1766 return this; 1767 } 1768 1769 /** 1770 * @return {@link #sender} 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 entity (e.g. person, organization, clinical information system, or device) which was the source of the communication.) 1771 */ 1772 public Resource getSenderTarget() { 1773 return this.senderTarget; 1774 } 1775 1776 /** 1777 * @param value {@link #sender} 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 entity (e.g. person, organization, clinical information system, or device) which was the source of the communication.) 1778 */ 1779 public Communication setSenderTarget(Resource value) { 1780 this.senderTarget = value; 1781 return this; 1782 } 1783 1784 /** 1785 * @return {@link #reasonCode} (The reason or justification for the communication.) 1786 */ 1787 public List<CodeableConcept> getReasonCode() { 1788 if (this.reasonCode == null) 1789 this.reasonCode = new ArrayList<CodeableConcept>(); 1790 return this.reasonCode; 1791 } 1792 1793 /** 1794 * @return Returns a reference to <code>this</code> for easy method chaining 1795 */ 1796 public Communication setReasonCode(List<CodeableConcept> theReasonCode) { 1797 this.reasonCode = theReasonCode; 1798 return this; 1799 } 1800 1801 public boolean hasReasonCode() { 1802 if (this.reasonCode == null) 1803 return false; 1804 for (CodeableConcept item : this.reasonCode) 1805 if (!item.isEmpty()) 1806 return true; 1807 return false; 1808 } 1809 1810 public CodeableConcept addReasonCode() { //3 1811 CodeableConcept t = new CodeableConcept(); 1812 if (this.reasonCode == null) 1813 this.reasonCode = new ArrayList<CodeableConcept>(); 1814 this.reasonCode.add(t); 1815 return t; 1816 } 1817 1818 public Communication addReasonCode(CodeableConcept t) { //3 1819 if (t == null) 1820 return this; 1821 if (this.reasonCode == null) 1822 this.reasonCode = new ArrayList<CodeableConcept>(); 1823 this.reasonCode.add(t); 1824 return this; 1825 } 1826 1827 /** 1828 * @return The first repetition of repeating field {@link #reasonCode}, creating it if it does not already exist 1829 */ 1830 public CodeableConcept getReasonCodeFirstRep() { 1831 if (getReasonCode().isEmpty()) { 1832 addReasonCode(); 1833 } 1834 return getReasonCode().get(0); 1835 } 1836 1837 /** 1838 * @return {@link #reasonReference} (Indicates another resource whose existence justifies this communication.) 1839 */ 1840 public List<Reference> getReasonReference() { 1841 if (this.reasonReference == null) 1842 this.reasonReference = new ArrayList<Reference>(); 1843 return this.reasonReference; 1844 } 1845 1846 /** 1847 * @return Returns a reference to <code>this</code> for easy method chaining 1848 */ 1849 public Communication setReasonReference(List<Reference> theReasonReference) { 1850 this.reasonReference = theReasonReference; 1851 return this; 1852 } 1853 1854 public boolean hasReasonReference() { 1855 if (this.reasonReference == null) 1856 return false; 1857 for (Reference item : this.reasonReference) 1858 if (!item.isEmpty()) 1859 return true; 1860 return false; 1861 } 1862 1863 public Reference addReasonReference() { //3 1864 Reference t = new Reference(); 1865 if (this.reasonReference == null) 1866 this.reasonReference = new ArrayList<Reference>(); 1867 this.reasonReference.add(t); 1868 return t; 1869 } 1870 1871 public Communication addReasonReference(Reference t) { //3 1872 if (t == null) 1873 return this; 1874 if (this.reasonReference == null) 1875 this.reasonReference = new ArrayList<Reference>(); 1876 this.reasonReference.add(t); 1877 return this; 1878 } 1879 1880 /** 1881 * @return The first repetition of repeating field {@link #reasonReference}, creating it if it does not already exist 1882 */ 1883 public Reference getReasonReferenceFirstRep() { 1884 if (getReasonReference().isEmpty()) { 1885 addReasonReference(); 1886 } 1887 return getReasonReference().get(0); 1888 } 1889 1890 /** 1891 * @deprecated Use Reference#setResource(IBaseResource) instead 1892 */ 1893 @Deprecated 1894 public List<Resource> getReasonReferenceTarget() { 1895 if (this.reasonReferenceTarget == null) 1896 this.reasonReferenceTarget = new ArrayList<Resource>(); 1897 return this.reasonReferenceTarget; 1898 } 1899 1900 /** 1901 * @return {@link #payload} (Text, attachment(s), or resource(s) that was communicated to the recipient.) 1902 */ 1903 public List<CommunicationPayloadComponent> getPayload() { 1904 if (this.payload == null) 1905 this.payload = new ArrayList<CommunicationPayloadComponent>(); 1906 return this.payload; 1907 } 1908 1909 /** 1910 * @return Returns a reference to <code>this</code> for easy method chaining 1911 */ 1912 public Communication setPayload(List<CommunicationPayloadComponent> thePayload) { 1913 this.payload = thePayload; 1914 return this; 1915 } 1916 1917 public boolean hasPayload() { 1918 if (this.payload == null) 1919 return false; 1920 for (CommunicationPayloadComponent item : this.payload) 1921 if (!item.isEmpty()) 1922 return true; 1923 return false; 1924 } 1925 1926 public CommunicationPayloadComponent addPayload() { //3 1927 CommunicationPayloadComponent t = new CommunicationPayloadComponent(); 1928 if (this.payload == null) 1929 this.payload = new ArrayList<CommunicationPayloadComponent>(); 1930 this.payload.add(t); 1931 return t; 1932 } 1933 1934 public Communication addPayload(CommunicationPayloadComponent t) { //3 1935 if (t == null) 1936 return this; 1937 if (this.payload == null) 1938 this.payload = new ArrayList<CommunicationPayloadComponent>(); 1939 this.payload.add(t); 1940 return this; 1941 } 1942 1943 /** 1944 * @return The first repetition of repeating field {@link #payload}, creating it if it does not already exist 1945 */ 1946 public CommunicationPayloadComponent getPayloadFirstRep() { 1947 if (getPayload().isEmpty()) { 1948 addPayload(); 1949 } 1950 return getPayload().get(0); 1951 } 1952 1953 /** 1954 * @return {@link #note} (Additional notes or commentary about the communication by the sender, receiver or other interested parties.) 1955 */ 1956 public List<Annotation> getNote() { 1957 if (this.note == null) 1958 this.note = new ArrayList<Annotation>(); 1959 return this.note; 1960 } 1961 1962 /** 1963 * @return Returns a reference to <code>this</code> for easy method chaining 1964 */ 1965 public Communication setNote(List<Annotation> theNote) { 1966 this.note = theNote; 1967 return this; 1968 } 1969 1970 public boolean hasNote() { 1971 if (this.note == null) 1972 return false; 1973 for (Annotation item : this.note) 1974 if (!item.isEmpty()) 1975 return true; 1976 return false; 1977 } 1978 1979 public Annotation addNote() { //3 1980 Annotation t = new Annotation(); 1981 if (this.note == null) 1982 this.note = new ArrayList<Annotation>(); 1983 this.note.add(t); 1984 return t; 1985 } 1986 1987 public Communication addNote(Annotation t) { //3 1988 if (t == null) 1989 return this; 1990 if (this.note == null) 1991 this.note = new ArrayList<Annotation>(); 1992 this.note.add(t); 1993 return this; 1994 } 1995 1996 /** 1997 * @return The first repetition of repeating field {@link #note}, creating it if it does not already exist 1998 */ 1999 public Annotation getNoteFirstRep() { 2000 if (getNote().isEmpty()) { 2001 addNote(); 2002 } 2003 return getNote().get(0); 2004 } 2005 2006 protected void listChildren(List<Property> children) { 2007 super.listChildren(children); 2008 children.add(new Property("identifier", "Identifier", "Business identifiers assigned to this communication by the performer or other systems which remain constant as the resource is updated and propagates from server to server.", 0, java.lang.Integer.MAX_VALUE, identifier)); 2009 children.add(new Property("instantiatesCanonical", "canonical(PlanDefinition|ActivityDefinition|Measure|OperationDefinition|Questionnaire)", "The URL pointing to a FHIR-defined protocol, guideline, orderset or other definition that is adhered to in whole or in part by this Communication.", 0, java.lang.Integer.MAX_VALUE, instantiatesCanonical)); 2010 children.add(new Property("instantiatesUri", "uri", "The URL pointing to an externally maintained protocol, guideline, orderset or other definition that is adhered to in whole or in part by this Communication.", 0, java.lang.Integer.MAX_VALUE, instantiatesUri)); 2011 children.add(new Property("basedOn", "Reference(Any)", "An order, proposal or plan fulfilled in whole or in part by this Communication.", 0, java.lang.Integer.MAX_VALUE, basedOn)); 2012 children.add(new Property("partOf", "Reference(Any)", "Part of this action.", 0, java.lang.Integer.MAX_VALUE, partOf)); 2013 children.add(new Property("inResponseTo", "Reference(Communication)", "Prior communication that this communication is in response to.", 0, java.lang.Integer.MAX_VALUE, inResponseTo)); 2014 children.add(new Property("status", "code", "The status of the transmission.", 0, 1, status)); 2015 children.add(new Property("statusReason", "CodeableConcept", "Captures the reason for the current state of the Communication.", 0, 1, statusReason)); 2016 children.add(new Property("category", "CodeableConcept", "The type of message conveyed such as alert, notification, reminder, instruction, etc.", 0, java.lang.Integer.MAX_VALUE, category)); 2017 children.add(new Property("priority", "code", "Characterizes how quickly the planned or in progress communication must be addressed. Includes concepts such as stat, urgent, routine.", 0, 1, priority)); 2018 children.add(new Property("medium", "CodeableConcept", "A channel that was used for this communication (e.g. email, fax).", 0, java.lang.Integer.MAX_VALUE, medium)); 2019 children.add(new Property("subject", "Reference(Patient|Group)", "The patient or group that was the focus of this communication.", 0, 1, subject)); 2020 children.add(new Property("topic", "CodeableConcept", "Description of the purpose/content, similar to a subject line in an email.", 0, 1, topic)); 2021 children.add(new Property("about", "Reference(Any)", "Other resources that pertain to this communication and to which this communication should be associated.", 0, java.lang.Integer.MAX_VALUE, about)); 2022 children.add(new Property("encounter", "Reference(Encounter)", "The Encounter during which this Communication was created or to which the creation of this record is tightly associated.", 0, 1, encounter)); 2023 children.add(new Property("sent", "dateTime", "The time when this communication was sent.", 0, 1, sent)); 2024 children.add(new Property("received", "dateTime", "The time when this communication arrived at the destination.", 0, 1, received)); 2025 children.add(new Property("recipient", "Reference(Device|Organization|Patient|Practitioner|PractitionerRole|RelatedPerson|Group|CareTeam|HealthcareService)", "The entity (e.g. person, organization, clinical information system, care team or device) which was the target of the communication. If receipts need to be tracked by an individual, a separate resource instance will need to be created for each recipient. Multiple recipient communications are intended where either receipts are not tracked (e.g. a mass mail-out) or a receipt is captured in aggregate (all emails confirmed received by a particular time).", 0, java.lang.Integer.MAX_VALUE, recipient)); 2026 children.add(new Property("sender", "Reference(Device|Organization|Patient|Practitioner|PractitionerRole|RelatedPerson|HealthcareService)", "The entity (e.g. person, organization, clinical information system, or device) which was the source of the communication.", 0, 1, sender)); 2027 children.add(new Property("reasonCode", "CodeableConcept", "The reason or justification for the communication.", 0, java.lang.Integer.MAX_VALUE, reasonCode)); 2028 children.add(new Property("reasonReference", "Reference(Condition|Observation|DiagnosticReport|DocumentReference)", "Indicates another resource whose existence justifies this communication.", 0, java.lang.Integer.MAX_VALUE, reasonReference)); 2029 children.add(new Property("payload", "", "Text, attachment(s), or resource(s) that was communicated to the recipient.", 0, java.lang.Integer.MAX_VALUE, payload)); 2030 children.add(new Property("note", "Annotation", "Additional notes or commentary about the communication by the sender, receiver or other interested parties.", 0, java.lang.Integer.MAX_VALUE, note)); 2031 } 2032 2033 @Override 2034 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 2035 switch (_hash) { 2036 case -1618432855: /*identifier*/ return new Property("identifier", "Identifier", "Business identifiers assigned to this communication by the performer or other systems which remain constant as the resource is updated and propagates from server to server.", 0, java.lang.Integer.MAX_VALUE, identifier); 2037 case 8911915: /*instantiatesCanonical*/ return new Property("instantiatesCanonical", "canonical(PlanDefinition|ActivityDefinition|Measure|OperationDefinition|Questionnaire)", "The URL pointing to a FHIR-defined protocol, guideline, orderset or other definition that is adhered to in whole or in part by this Communication.", 0, java.lang.Integer.MAX_VALUE, instantiatesCanonical); 2038 case -1926393373: /*instantiatesUri*/ return new Property("instantiatesUri", "uri", "The URL pointing to an externally maintained protocol, guideline, orderset or other definition that is adhered to in whole or in part by this Communication.", 0, java.lang.Integer.MAX_VALUE, instantiatesUri); 2039 case -332612366: /*basedOn*/ return new Property("basedOn", "Reference(Any)", "An order, proposal or plan fulfilled in whole or in part by this Communication.", 0, java.lang.Integer.MAX_VALUE, basedOn); 2040 case -995410646: /*partOf*/ return new Property("partOf", "Reference(Any)", "Part of this action.", 0, java.lang.Integer.MAX_VALUE, partOf); 2041 case 1932956065: /*inResponseTo*/ return new Property("inResponseTo", "Reference(Communication)", "Prior communication that this communication is in response to.", 0, java.lang.Integer.MAX_VALUE, inResponseTo); 2042 case -892481550: /*status*/ return new Property("status", "code", "The status of the transmission.", 0, 1, status); 2043 case 2051346646: /*statusReason*/ return new Property("statusReason", "CodeableConcept", "Captures the reason for the current state of the Communication.", 0, 1, statusReason); 2044 case 50511102: /*category*/ return new Property("category", "CodeableConcept", "The type of message conveyed such as alert, notification, reminder, instruction, etc.", 0, java.lang.Integer.MAX_VALUE, category); 2045 case -1165461084: /*priority*/ return new Property("priority", "code", "Characterizes how quickly the planned or in progress communication must be addressed. Includes concepts such as stat, urgent, routine.", 0, 1, priority); 2046 case -1078030475: /*medium*/ return new Property("medium", "CodeableConcept", "A channel that was used for this communication (e.g. email, fax).", 0, java.lang.Integer.MAX_VALUE, medium); 2047 case -1867885268: /*subject*/ return new Property("subject", "Reference(Patient|Group)", "The patient or group that was the focus of this communication.", 0, 1, subject); 2048 case 110546223: /*topic*/ return new Property("topic", "CodeableConcept", "Description of the purpose/content, similar to a subject line in an email.", 0, 1, topic); 2049 case 92611469: /*about*/ return new Property("about", "Reference(Any)", "Other resources that pertain to this communication and to which this communication should be associated.", 0, java.lang.Integer.MAX_VALUE, about); 2050 case 1524132147: /*encounter*/ return new Property("encounter", "Reference(Encounter)", "The Encounter during which this Communication was created or to which the creation of this record is tightly associated.", 0, 1, encounter); 2051 case 3526552: /*sent*/ return new Property("sent", "dateTime", "The time when this communication was sent.", 0, 1, sent); 2052 case -808719903: /*received*/ return new Property("received", "dateTime", "The time when this communication arrived at the destination.", 0, 1, received); 2053 case 820081177: /*recipient*/ return new Property("recipient", "Reference(Device|Organization|Patient|Practitioner|PractitionerRole|RelatedPerson|Group|CareTeam|HealthcareService)", "The entity (e.g. person, organization, clinical information system, care team or device) which was the target of the communication. If receipts need to be tracked by an individual, a separate resource instance will need to be created for each recipient. Multiple recipient communications are intended where either receipts are not tracked (e.g. a mass mail-out) or a receipt is captured in aggregate (all emails confirmed received by a particular time).", 0, java.lang.Integer.MAX_VALUE, recipient); 2054 case -905962955: /*sender*/ return new Property("sender", "Reference(Device|Organization|Patient|Practitioner|PractitionerRole|RelatedPerson|HealthcareService)", "The entity (e.g. person, organization, clinical information system, or device) which was the source of the communication.", 0, 1, sender); 2055 case 722137681: /*reasonCode*/ return new Property("reasonCode", "CodeableConcept", "The reason or justification for the communication.", 0, java.lang.Integer.MAX_VALUE, reasonCode); 2056 case -1146218137: /*reasonReference*/ return new Property("reasonReference", "Reference(Condition|Observation|DiagnosticReport|DocumentReference)", "Indicates another resource whose existence justifies this communication.", 0, java.lang.Integer.MAX_VALUE, reasonReference); 2057 case -786701938: /*payload*/ return new Property("payload", "", "Text, attachment(s), or resource(s) that was communicated to the recipient.", 0, java.lang.Integer.MAX_VALUE, payload); 2058 case 3387378: /*note*/ return new Property("note", "Annotation", "Additional notes or commentary about the communication by the sender, receiver or other interested parties.", 0, java.lang.Integer.MAX_VALUE, note); 2059 default: return super.getNamedProperty(_hash, _name, _checkValid); 2060 } 2061 2062 } 2063 2064 @Override 2065 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 2066 switch (hash) { 2067 case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier 2068 case 8911915: /*instantiatesCanonical*/ return this.instantiatesCanonical == null ? new Base[0] : this.instantiatesCanonical.toArray(new Base[this.instantiatesCanonical.size()]); // CanonicalType 2069 case -1926393373: /*instantiatesUri*/ return this.instantiatesUri == null ? new Base[0] : this.instantiatesUri.toArray(new Base[this.instantiatesUri.size()]); // UriType 2070 case -332612366: /*basedOn*/ return this.basedOn == null ? new Base[0] : this.basedOn.toArray(new Base[this.basedOn.size()]); // Reference 2071 case -995410646: /*partOf*/ return this.partOf == null ? new Base[0] : this.partOf.toArray(new Base[this.partOf.size()]); // Reference 2072 case 1932956065: /*inResponseTo*/ return this.inResponseTo == null ? new Base[0] : this.inResponseTo.toArray(new Base[this.inResponseTo.size()]); // Reference 2073 case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<CommunicationStatus> 2074 case 2051346646: /*statusReason*/ return this.statusReason == null ? new Base[0] : new Base[] {this.statusReason}; // CodeableConcept 2075 case 50511102: /*category*/ return this.category == null ? new Base[0] : this.category.toArray(new Base[this.category.size()]); // CodeableConcept 2076 case -1165461084: /*priority*/ return this.priority == null ? new Base[0] : new Base[] {this.priority}; // Enumeration<CommunicationPriority> 2077 case -1078030475: /*medium*/ return this.medium == null ? new Base[0] : this.medium.toArray(new Base[this.medium.size()]); // CodeableConcept 2078 case -1867885268: /*subject*/ return this.subject == null ? new Base[0] : new Base[] {this.subject}; // Reference 2079 case 110546223: /*topic*/ return this.topic == null ? new Base[0] : new Base[] {this.topic}; // CodeableConcept 2080 case 92611469: /*about*/ return this.about == null ? new Base[0] : this.about.toArray(new Base[this.about.size()]); // Reference 2081 case 1524132147: /*encounter*/ return this.encounter == null ? new Base[0] : new Base[] {this.encounter}; // Reference 2082 case 3526552: /*sent*/ return this.sent == null ? new Base[0] : new Base[] {this.sent}; // DateTimeType 2083 case -808719903: /*received*/ return this.received == null ? new Base[0] : new Base[] {this.received}; // DateTimeType 2084 case 820081177: /*recipient*/ return this.recipient == null ? new Base[0] : this.recipient.toArray(new Base[this.recipient.size()]); // Reference 2085 case -905962955: /*sender*/ return this.sender == null ? new Base[0] : new Base[] {this.sender}; // Reference 2086 case 722137681: /*reasonCode*/ return this.reasonCode == null ? new Base[0] : this.reasonCode.toArray(new Base[this.reasonCode.size()]); // CodeableConcept 2087 case -1146218137: /*reasonReference*/ return this.reasonReference == null ? new Base[0] : this.reasonReference.toArray(new Base[this.reasonReference.size()]); // Reference 2088 case -786701938: /*payload*/ return this.payload == null ? new Base[0] : this.payload.toArray(new Base[this.payload.size()]); // CommunicationPayloadComponent 2089 case 3387378: /*note*/ return this.note == null ? new Base[0] : this.note.toArray(new Base[this.note.size()]); // Annotation 2090 default: return super.getProperty(hash, name, checkValid); 2091 } 2092 2093 } 2094 2095 @Override 2096 public Base setProperty(int hash, String name, Base value) throws FHIRException { 2097 switch (hash) { 2098 case -1618432855: // identifier 2099 this.getIdentifier().add(castToIdentifier(value)); // Identifier 2100 return value; 2101 case 8911915: // instantiatesCanonical 2102 this.getInstantiatesCanonical().add(castToCanonical(value)); // CanonicalType 2103 return value; 2104 case -1926393373: // instantiatesUri 2105 this.getInstantiatesUri().add(castToUri(value)); // UriType 2106 return value; 2107 case -332612366: // basedOn 2108 this.getBasedOn().add(castToReference(value)); // Reference 2109 return value; 2110 case -995410646: // partOf 2111 this.getPartOf().add(castToReference(value)); // Reference 2112 return value; 2113 case 1932956065: // inResponseTo 2114 this.getInResponseTo().add(castToReference(value)); // Reference 2115 return value; 2116 case -892481550: // status 2117 value = new CommunicationStatusEnumFactory().fromType(castToCode(value)); 2118 this.status = (Enumeration) value; // Enumeration<CommunicationStatus> 2119 return value; 2120 case 2051346646: // statusReason 2121 this.statusReason = castToCodeableConcept(value); // CodeableConcept 2122 return value; 2123 case 50511102: // category 2124 this.getCategory().add(castToCodeableConcept(value)); // CodeableConcept 2125 return value; 2126 case -1165461084: // priority 2127 value = new CommunicationPriorityEnumFactory().fromType(castToCode(value)); 2128 this.priority = (Enumeration) value; // Enumeration<CommunicationPriority> 2129 return value; 2130 case -1078030475: // medium 2131 this.getMedium().add(castToCodeableConcept(value)); // CodeableConcept 2132 return value; 2133 case -1867885268: // subject 2134 this.subject = castToReference(value); // Reference 2135 return value; 2136 case 110546223: // topic 2137 this.topic = castToCodeableConcept(value); // CodeableConcept 2138 return value; 2139 case 92611469: // about 2140 this.getAbout().add(castToReference(value)); // Reference 2141 return value; 2142 case 1524132147: // encounter 2143 this.encounter = castToReference(value); // Reference 2144 return value; 2145 case 3526552: // sent 2146 this.sent = castToDateTime(value); // DateTimeType 2147 return value; 2148 case -808719903: // received 2149 this.received = castToDateTime(value); // DateTimeType 2150 return value; 2151 case 820081177: // recipient 2152 this.getRecipient().add(castToReference(value)); // Reference 2153 return value; 2154 case -905962955: // sender 2155 this.sender = castToReference(value); // Reference 2156 return value; 2157 case 722137681: // reasonCode 2158 this.getReasonCode().add(castToCodeableConcept(value)); // CodeableConcept 2159 return value; 2160 case -1146218137: // reasonReference 2161 this.getReasonReference().add(castToReference(value)); // Reference 2162 return value; 2163 case -786701938: // payload 2164 this.getPayload().add((CommunicationPayloadComponent) value); // CommunicationPayloadComponent 2165 return value; 2166 case 3387378: // note 2167 this.getNote().add(castToAnnotation(value)); // Annotation 2168 return value; 2169 default: return super.setProperty(hash, name, value); 2170 } 2171 2172 } 2173 2174 @Override 2175 public Base setProperty(String name, Base value) throws FHIRException { 2176 if (name.equals("identifier")) { 2177 this.getIdentifier().add(castToIdentifier(value)); 2178 } else if (name.equals("instantiatesCanonical")) { 2179 this.getInstantiatesCanonical().add(castToCanonical(value)); 2180 } else if (name.equals("instantiatesUri")) { 2181 this.getInstantiatesUri().add(castToUri(value)); 2182 } else if (name.equals("basedOn")) { 2183 this.getBasedOn().add(castToReference(value)); 2184 } else if (name.equals("partOf")) { 2185 this.getPartOf().add(castToReference(value)); 2186 } else if (name.equals("inResponseTo")) { 2187 this.getInResponseTo().add(castToReference(value)); 2188 } else if (name.equals("status")) { 2189 value = new CommunicationStatusEnumFactory().fromType(castToCode(value)); 2190 this.status = (Enumeration) value; // Enumeration<CommunicationStatus> 2191 } else if (name.equals("statusReason")) { 2192 this.statusReason = castToCodeableConcept(value); // CodeableConcept 2193 } else if (name.equals("category")) { 2194 this.getCategory().add(castToCodeableConcept(value)); 2195 } else if (name.equals("priority")) { 2196 value = new CommunicationPriorityEnumFactory().fromType(castToCode(value)); 2197 this.priority = (Enumeration) value; // Enumeration<CommunicationPriority> 2198 } else if (name.equals("medium")) { 2199 this.getMedium().add(castToCodeableConcept(value)); 2200 } else if (name.equals("subject")) { 2201 this.subject = castToReference(value); // Reference 2202 } else if (name.equals("topic")) { 2203 this.topic = castToCodeableConcept(value); // CodeableConcept 2204 } else if (name.equals("about")) { 2205 this.getAbout().add(castToReference(value)); 2206 } else if (name.equals("encounter")) { 2207 this.encounter = castToReference(value); // Reference 2208 } else if (name.equals("sent")) { 2209 this.sent = castToDateTime(value); // DateTimeType 2210 } else if (name.equals("received")) { 2211 this.received = castToDateTime(value); // DateTimeType 2212 } else if (name.equals("recipient")) { 2213 this.getRecipient().add(castToReference(value)); 2214 } else if (name.equals("sender")) { 2215 this.sender = castToReference(value); // Reference 2216 } else if (name.equals("reasonCode")) { 2217 this.getReasonCode().add(castToCodeableConcept(value)); 2218 } else if (name.equals("reasonReference")) { 2219 this.getReasonReference().add(castToReference(value)); 2220 } else if (name.equals("payload")) { 2221 this.getPayload().add((CommunicationPayloadComponent) value); 2222 } else if (name.equals("note")) { 2223 this.getNote().add(castToAnnotation(value)); 2224 } else 2225 return super.setProperty(name, value); 2226 return value; 2227 } 2228 2229 @Override 2230 public Base makeProperty(int hash, String name) throws FHIRException { 2231 switch (hash) { 2232 case -1618432855: return addIdentifier(); 2233 case 8911915: return addInstantiatesCanonicalElement(); 2234 case -1926393373: return addInstantiatesUriElement(); 2235 case -332612366: return addBasedOn(); 2236 case -995410646: return addPartOf(); 2237 case 1932956065: return addInResponseTo(); 2238 case -892481550: return getStatusElement(); 2239 case 2051346646: return getStatusReason(); 2240 case 50511102: return addCategory(); 2241 case -1165461084: return getPriorityElement(); 2242 case -1078030475: return addMedium(); 2243 case -1867885268: return getSubject(); 2244 case 110546223: return getTopic(); 2245 case 92611469: return addAbout(); 2246 case 1524132147: return getEncounter(); 2247 case 3526552: return getSentElement(); 2248 case -808719903: return getReceivedElement(); 2249 case 820081177: return addRecipient(); 2250 case -905962955: return getSender(); 2251 case 722137681: return addReasonCode(); 2252 case -1146218137: return addReasonReference(); 2253 case -786701938: return addPayload(); 2254 case 3387378: return addNote(); 2255 default: return super.makeProperty(hash, name); 2256 } 2257 2258 } 2259 2260 @Override 2261 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 2262 switch (hash) { 2263 case -1618432855: /*identifier*/ return new String[] {"Identifier"}; 2264 case 8911915: /*instantiatesCanonical*/ return new String[] {"canonical"}; 2265 case -1926393373: /*instantiatesUri*/ return new String[] {"uri"}; 2266 case -332612366: /*basedOn*/ return new String[] {"Reference"}; 2267 case -995410646: /*partOf*/ return new String[] {"Reference"}; 2268 case 1932956065: /*inResponseTo*/ return new String[] {"Reference"}; 2269 case -892481550: /*status*/ return new String[] {"code"}; 2270 case 2051346646: /*statusReason*/ return new String[] {"CodeableConcept"}; 2271 case 50511102: /*category*/ return new String[] {"CodeableConcept"}; 2272 case -1165461084: /*priority*/ return new String[] {"code"}; 2273 case -1078030475: /*medium*/ return new String[] {"CodeableConcept"}; 2274 case -1867885268: /*subject*/ return new String[] {"Reference"}; 2275 case 110546223: /*topic*/ return new String[] {"CodeableConcept"}; 2276 case 92611469: /*about*/ return new String[] {"Reference"}; 2277 case 1524132147: /*encounter*/ return new String[] {"Reference"}; 2278 case 3526552: /*sent*/ return new String[] {"dateTime"}; 2279 case -808719903: /*received*/ return new String[] {"dateTime"}; 2280 case 820081177: /*recipient*/ return new String[] {"Reference"}; 2281 case -905962955: /*sender*/ return new String[] {"Reference"}; 2282 case 722137681: /*reasonCode*/ return new String[] {"CodeableConcept"}; 2283 case -1146218137: /*reasonReference*/ return new String[] {"Reference"}; 2284 case -786701938: /*payload*/ return new String[] {}; 2285 case 3387378: /*note*/ return new String[] {"Annotation"}; 2286 default: return super.getTypesForProperty(hash, name); 2287 } 2288 2289 } 2290 2291 @Override 2292 public Base addChild(String name) throws FHIRException { 2293 if (name.equals("identifier")) { 2294 return addIdentifier(); 2295 } 2296 else if (name.equals("instantiatesCanonical")) { 2297 throw new FHIRException("Cannot call addChild on a primitive type Communication.instantiatesCanonical"); 2298 } 2299 else if (name.equals("instantiatesUri")) { 2300 throw new FHIRException("Cannot call addChild on a primitive type Communication.instantiatesUri"); 2301 } 2302 else if (name.equals("basedOn")) { 2303 return addBasedOn(); 2304 } 2305 else if (name.equals("partOf")) { 2306 return addPartOf(); 2307 } 2308 else if (name.equals("inResponseTo")) { 2309 return addInResponseTo(); 2310 } 2311 else if (name.equals("status")) { 2312 throw new FHIRException("Cannot call addChild on a primitive type Communication.status"); 2313 } 2314 else if (name.equals("statusReason")) { 2315 this.statusReason = new CodeableConcept(); 2316 return this.statusReason; 2317 } 2318 else if (name.equals("category")) { 2319 return addCategory(); 2320 } 2321 else if (name.equals("priority")) { 2322 throw new FHIRException("Cannot call addChild on a primitive type Communication.priority"); 2323 } 2324 else if (name.equals("medium")) { 2325 return addMedium(); 2326 } 2327 else if (name.equals("subject")) { 2328 this.subject = new Reference(); 2329 return this.subject; 2330 } 2331 else if (name.equals("topic")) { 2332 this.topic = new CodeableConcept(); 2333 return this.topic; 2334 } 2335 else if (name.equals("about")) { 2336 return addAbout(); 2337 } 2338 else if (name.equals("encounter")) { 2339 this.encounter = new Reference(); 2340 return this.encounter; 2341 } 2342 else if (name.equals("sent")) { 2343 throw new FHIRException("Cannot call addChild on a primitive type Communication.sent"); 2344 } 2345 else if (name.equals("received")) { 2346 throw new FHIRException("Cannot call addChild on a primitive type Communication.received"); 2347 } 2348 else if (name.equals("recipient")) { 2349 return addRecipient(); 2350 } 2351 else if (name.equals("sender")) { 2352 this.sender = new Reference(); 2353 return this.sender; 2354 } 2355 else if (name.equals("reasonCode")) { 2356 return addReasonCode(); 2357 } 2358 else if (name.equals("reasonReference")) { 2359 return addReasonReference(); 2360 } 2361 else if (name.equals("payload")) { 2362 return addPayload(); 2363 } 2364 else if (name.equals("note")) { 2365 return addNote(); 2366 } 2367 else 2368 return super.addChild(name); 2369 } 2370 2371 public String fhirType() { 2372 return "Communication"; 2373 2374 } 2375 2376 public Communication copy() { 2377 Communication dst = new Communication(); 2378 copyValues(dst); 2379 return dst; 2380 } 2381 2382 public void copyValues(Communication dst) { 2383 super.copyValues(dst); 2384 if (identifier != null) { 2385 dst.identifier = new ArrayList<Identifier>(); 2386 for (Identifier i : identifier) 2387 dst.identifier.add(i.copy()); 2388 }; 2389 if (instantiatesCanonical != null) { 2390 dst.instantiatesCanonical = new ArrayList<CanonicalType>(); 2391 for (CanonicalType i : instantiatesCanonical) 2392 dst.instantiatesCanonical.add(i.copy()); 2393 }; 2394 if (instantiatesUri != null) { 2395 dst.instantiatesUri = new ArrayList<UriType>(); 2396 for (UriType i : instantiatesUri) 2397 dst.instantiatesUri.add(i.copy()); 2398 }; 2399 if (basedOn != null) { 2400 dst.basedOn = new ArrayList<Reference>(); 2401 for (Reference i : basedOn) 2402 dst.basedOn.add(i.copy()); 2403 }; 2404 if (partOf != null) { 2405 dst.partOf = new ArrayList<Reference>(); 2406 for (Reference i : partOf) 2407 dst.partOf.add(i.copy()); 2408 }; 2409 if (inResponseTo != null) { 2410 dst.inResponseTo = new ArrayList<Reference>(); 2411 for (Reference i : inResponseTo) 2412 dst.inResponseTo.add(i.copy()); 2413 }; 2414 dst.status = status == null ? null : status.copy(); 2415 dst.statusReason = statusReason == null ? null : statusReason.copy(); 2416 if (category != null) { 2417 dst.category = new ArrayList<CodeableConcept>(); 2418 for (CodeableConcept i : category) 2419 dst.category.add(i.copy()); 2420 }; 2421 dst.priority = priority == null ? null : priority.copy(); 2422 if (medium != null) { 2423 dst.medium = new ArrayList<CodeableConcept>(); 2424 for (CodeableConcept i : medium) 2425 dst.medium.add(i.copy()); 2426 }; 2427 dst.subject = subject == null ? null : subject.copy(); 2428 dst.topic = topic == null ? null : topic.copy(); 2429 if (about != null) { 2430 dst.about = new ArrayList<Reference>(); 2431 for (Reference i : about) 2432 dst.about.add(i.copy()); 2433 }; 2434 dst.encounter = encounter == null ? null : encounter.copy(); 2435 dst.sent = sent == null ? null : sent.copy(); 2436 dst.received = received == null ? null : received.copy(); 2437 if (recipient != null) { 2438 dst.recipient = new ArrayList<Reference>(); 2439 for (Reference i : recipient) 2440 dst.recipient.add(i.copy()); 2441 }; 2442 dst.sender = sender == null ? null : sender.copy(); 2443 if (reasonCode != null) { 2444 dst.reasonCode = new ArrayList<CodeableConcept>(); 2445 for (CodeableConcept i : reasonCode) 2446 dst.reasonCode.add(i.copy()); 2447 }; 2448 if (reasonReference != null) { 2449 dst.reasonReference = new ArrayList<Reference>(); 2450 for (Reference i : reasonReference) 2451 dst.reasonReference.add(i.copy()); 2452 }; 2453 if (payload != null) { 2454 dst.payload = new ArrayList<CommunicationPayloadComponent>(); 2455 for (CommunicationPayloadComponent i : payload) 2456 dst.payload.add(i.copy()); 2457 }; 2458 if (note != null) { 2459 dst.note = new ArrayList<Annotation>(); 2460 for (Annotation i : note) 2461 dst.note.add(i.copy()); 2462 }; 2463 } 2464 2465 protected Communication typedCopy() { 2466 return copy(); 2467 } 2468 2469 @Override 2470 public boolean equalsDeep(Base other_) { 2471 if (!super.equalsDeep(other_)) 2472 return false; 2473 if (!(other_ instanceof Communication)) 2474 return false; 2475 Communication o = (Communication) other_; 2476 return compareDeep(identifier, o.identifier, true) && compareDeep(instantiatesCanonical, o.instantiatesCanonical, true) 2477 && compareDeep(instantiatesUri, o.instantiatesUri, true) && compareDeep(basedOn, o.basedOn, true) 2478 && compareDeep(partOf, o.partOf, true) && compareDeep(inResponseTo, o.inResponseTo, true) && compareDeep(status, o.status, true) 2479 && compareDeep(statusReason, o.statusReason, true) && compareDeep(category, o.category, true) && compareDeep(priority, o.priority, true) 2480 && compareDeep(medium, o.medium, true) && compareDeep(subject, o.subject, true) && compareDeep(topic, o.topic, true) 2481 && compareDeep(about, o.about, true) && compareDeep(encounter, o.encounter, true) && compareDeep(sent, o.sent, true) 2482 && compareDeep(received, o.received, true) && compareDeep(recipient, o.recipient, true) && compareDeep(sender, o.sender, true) 2483 && compareDeep(reasonCode, o.reasonCode, true) && compareDeep(reasonReference, o.reasonReference, true) 2484 && compareDeep(payload, o.payload, true) && compareDeep(note, o.note, true); 2485 } 2486 2487 @Override 2488 public boolean equalsShallow(Base other_) { 2489 if (!super.equalsShallow(other_)) 2490 return false; 2491 if (!(other_ instanceof Communication)) 2492 return false; 2493 Communication o = (Communication) other_; 2494 return compareValues(instantiatesUri, o.instantiatesUri, true) && compareValues(status, o.status, true) 2495 && compareValues(priority, o.priority, true) && compareValues(sent, o.sent, true) && compareValues(received, o.received, true) 2496 ; 2497 } 2498 2499 public boolean isEmpty() { 2500 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, instantiatesCanonical 2501 , instantiatesUri, basedOn, partOf, inResponseTo, status, statusReason, category 2502 , priority, medium, subject, topic, about, encounter, sent, received, recipient 2503 , sender, reasonCode, reasonReference, payload, note); 2504 } 2505 2506 @Override 2507 public ResourceType getResourceType() { 2508 return ResourceType.Communication; 2509 } 2510 2511 /** 2512 * Search parameter: <b>identifier</b> 2513 * <p> 2514 * Description: <b>Unique identifier</b><br> 2515 * Type: <b>token</b><br> 2516 * Path: <b>Communication.identifier</b><br> 2517 * </p> 2518 */ 2519 @SearchParamDefinition(name="identifier", path="Communication.identifier", description="Unique identifier", type="token" ) 2520 public static final String SP_IDENTIFIER = "identifier"; 2521 /** 2522 * <b>Fluent Client</b> search parameter constant for <b>identifier</b> 2523 * <p> 2524 * Description: <b>Unique identifier</b><br> 2525 * Type: <b>token</b><br> 2526 * Path: <b>Communication.identifier</b><br> 2527 * </p> 2528 */ 2529 public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER); 2530 2531 /** 2532 * Search parameter: <b>subject</b> 2533 * <p> 2534 * Description: <b>Focus of message</b><br> 2535 * Type: <b>reference</b><br> 2536 * Path: <b>Communication.subject</b><br> 2537 * </p> 2538 */ 2539 @SearchParamDefinition(name="subject", path="Communication.subject", description="Focus of message", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient") }, target={Group.class, Patient.class } ) 2540 public static final String SP_SUBJECT = "subject"; 2541 /** 2542 * <b>Fluent Client</b> search parameter constant for <b>subject</b> 2543 * <p> 2544 * Description: <b>Focus of message</b><br> 2545 * Type: <b>reference</b><br> 2546 * Path: <b>Communication.subject</b><br> 2547 * </p> 2548 */ 2549 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SUBJECT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_SUBJECT); 2550 2551/** 2552 * Constant for fluent queries to be used to add include statements. Specifies 2553 * the path value of "<b>Communication:subject</b>". 2554 */ 2555 public static final ca.uhn.fhir.model.api.Include INCLUDE_SUBJECT = new ca.uhn.fhir.model.api.Include("Communication:subject").toLocked(); 2556 2557 /** 2558 * Search parameter: <b>instantiates-canonical</b> 2559 * <p> 2560 * Description: <b>Instantiates FHIR protocol or definition</b><br> 2561 * Type: <b>reference</b><br> 2562 * Path: <b>Communication.instantiatesCanonical</b><br> 2563 * </p> 2564 */ 2565 @SearchParamDefinition(name="instantiates-canonical", path="Communication.instantiatesCanonical", description="Instantiates FHIR protocol or definition", type="reference", target={ActivityDefinition.class, Measure.class, OperationDefinition.class, PlanDefinition.class, Questionnaire.class } ) 2566 public static final String SP_INSTANTIATES_CANONICAL = "instantiates-canonical"; 2567 /** 2568 * <b>Fluent Client</b> search parameter constant for <b>instantiates-canonical</b> 2569 * <p> 2570 * Description: <b>Instantiates FHIR protocol or definition</b><br> 2571 * Type: <b>reference</b><br> 2572 * Path: <b>Communication.instantiatesCanonical</b><br> 2573 * </p> 2574 */ 2575 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam INSTANTIATES_CANONICAL = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_INSTANTIATES_CANONICAL); 2576 2577/** 2578 * Constant for fluent queries to be used to add include statements. Specifies 2579 * the path value of "<b>Communication:instantiates-canonical</b>". 2580 */ 2581 public static final ca.uhn.fhir.model.api.Include INCLUDE_INSTANTIATES_CANONICAL = new ca.uhn.fhir.model.api.Include("Communication:instantiates-canonical").toLocked(); 2582 2583 /** 2584 * Search parameter: <b>received</b> 2585 * <p> 2586 * Description: <b>When received</b><br> 2587 * Type: <b>date</b><br> 2588 * Path: <b>Communication.received</b><br> 2589 * </p> 2590 */ 2591 @SearchParamDefinition(name="received", path="Communication.received", description="When received", type="date" ) 2592 public static final String SP_RECEIVED = "received"; 2593 /** 2594 * <b>Fluent Client</b> search parameter constant for <b>received</b> 2595 * <p> 2596 * Description: <b>When received</b><br> 2597 * Type: <b>date</b><br> 2598 * Path: <b>Communication.received</b><br> 2599 * </p> 2600 */ 2601 public static final ca.uhn.fhir.rest.gclient.DateClientParam RECEIVED = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_RECEIVED); 2602 2603 /** 2604 * Search parameter: <b>part-of</b> 2605 * <p> 2606 * Description: <b>Part of this action</b><br> 2607 * Type: <b>reference</b><br> 2608 * Path: <b>Communication.partOf</b><br> 2609 * </p> 2610 */ 2611 @SearchParamDefinition(name="part-of", path="Communication.partOf", description="Part of this action", type="reference" ) 2612 public static final String SP_PART_OF = "part-of"; 2613 /** 2614 * <b>Fluent Client</b> search parameter constant for <b>part-of</b> 2615 * <p> 2616 * Description: <b>Part of this action</b><br> 2617 * Type: <b>reference</b><br> 2618 * Path: <b>Communication.partOf</b><br> 2619 * </p> 2620 */ 2621 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PART_OF = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_PART_OF); 2622 2623/** 2624 * Constant for fluent queries to be used to add include statements. Specifies 2625 * the path value of "<b>Communication:part-of</b>". 2626 */ 2627 public static final ca.uhn.fhir.model.api.Include INCLUDE_PART_OF = new ca.uhn.fhir.model.api.Include("Communication:part-of").toLocked(); 2628 2629 /** 2630 * Search parameter: <b>medium</b> 2631 * <p> 2632 * Description: <b>A channel of communication</b><br> 2633 * Type: <b>token</b><br> 2634 * Path: <b>Communication.medium</b><br> 2635 * </p> 2636 */ 2637 @SearchParamDefinition(name="medium", path="Communication.medium", description="A channel of communication", type="token" ) 2638 public static final String SP_MEDIUM = "medium"; 2639 /** 2640 * <b>Fluent Client</b> search parameter constant for <b>medium</b> 2641 * <p> 2642 * Description: <b>A channel of communication</b><br> 2643 * Type: <b>token</b><br> 2644 * Path: <b>Communication.medium</b><br> 2645 * </p> 2646 */ 2647 public static final ca.uhn.fhir.rest.gclient.TokenClientParam MEDIUM = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_MEDIUM); 2648 2649 /** 2650 * Search parameter: <b>encounter</b> 2651 * <p> 2652 * Description: <b>Encounter created as part of</b><br> 2653 * Type: <b>reference</b><br> 2654 * Path: <b>Communication.encounter</b><br> 2655 * </p> 2656 */ 2657 @SearchParamDefinition(name="encounter", path="Communication.encounter", description="Encounter created as part of", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Encounter") }, target={Encounter.class } ) 2658 public static final String SP_ENCOUNTER = "encounter"; 2659 /** 2660 * <b>Fluent Client</b> search parameter constant for <b>encounter</b> 2661 * <p> 2662 * Description: <b>Encounter created as part of</b><br> 2663 * Type: <b>reference</b><br> 2664 * Path: <b>Communication.encounter</b><br> 2665 * </p> 2666 */ 2667 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam ENCOUNTER = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_ENCOUNTER); 2668 2669/** 2670 * Constant for fluent queries to be used to add include statements. Specifies 2671 * the path value of "<b>Communication:encounter</b>". 2672 */ 2673 public static final ca.uhn.fhir.model.api.Include INCLUDE_ENCOUNTER = new ca.uhn.fhir.model.api.Include("Communication:encounter").toLocked(); 2674 2675 /** 2676 * Search parameter: <b>sent</b> 2677 * <p> 2678 * Description: <b>When sent</b><br> 2679 * Type: <b>date</b><br> 2680 * Path: <b>Communication.sent</b><br> 2681 * </p> 2682 */ 2683 @SearchParamDefinition(name="sent", path="Communication.sent", description="When sent", type="date" ) 2684 public static final String SP_SENT = "sent"; 2685 /** 2686 * <b>Fluent Client</b> search parameter constant for <b>sent</b> 2687 * <p> 2688 * Description: <b>When sent</b><br> 2689 * Type: <b>date</b><br> 2690 * Path: <b>Communication.sent</b><br> 2691 * </p> 2692 */ 2693 public static final ca.uhn.fhir.rest.gclient.DateClientParam SENT = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_SENT); 2694 2695 /** 2696 * Search parameter: <b>based-on</b> 2697 * <p> 2698 * Description: <b>Request fulfilled by this communication</b><br> 2699 * Type: <b>reference</b><br> 2700 * Path: <b>Communication.basedOn</b><br> 2701 * </p> 2702 */ 2703 @SearchParamDefinition(name="based-on", path="Communication.basedOn", description="Request fulfilled by this communication", type="reference" ) 2704 public static final String SP_BASED_ON = "based-on"; 2705 /** 2706 * <b>Fluent Client</b> search parameter constant for <b>based-on</b> 2707 * <p> 2708 * Description: <b>Request fulfilled by this communication</b><br> 2709 * Type: <b>reference</b><br> 2710 * Path: <b>Communication.basedOn</b><br> 2711 * </p> 2712 */ 2713 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam BASED_ON = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_BASED_ON); 2714 2715/** 2716 * Constant for fluent queries to be used to add include statements. Specifies 2717 * the path value of "<b>Communication:based-on</b>". 2718 */ 2719 public static final ca.uhn.fhir.model.api.Include INCLUDE_BASED_ON = new ca.uhn.fhir.model.api.Include("Communication:based-on").toLocked(); 2720 2721 /** 2722 * Search parameter: <b>sender</b> 2723 * <p> 2724 * Description: <b>Message sender</b><br> 2725 * Type: <b>reference</b><br> 2726 * Path: <b>Communication.sender</b><br> 2727 * </p> 2728 */ 2729 @SearchParamDefinition(name="sender", path="Communication.sender", description="Message sender", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Device"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner"), @ca.uhn.fhir.model.api.annotation.Compartment(name="RelatedPerson") }, target={Device.class, HealthcareService.class, Organization.class, Patient.class, Practitioner.class, PractitionerRole.class, RelatedPerson.class } ) 2730 public static final String SP_SENDER = "sender"; 2731 /** 2732 * <b>Fluent Client</b> search parameter constant for <b>sender</b> 2733 * <p> 2734 * Description: <b>Message sender</b><br> 2735 * Type: <b>reference</b><br> 2736 * Path: <b>Communication.sender</b><br> 2737 * </p> 2738 */ 2739 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SENDER = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_SENDER); 2740 2741/** 2742 * Constant for fluent queries to be used to add include statements. Specifies 2743 * the path value of "<b>Communication:sender</b>". 2744 */ 2745 public static final ca.uhn.fhir.model.api.Include INCLUDE_SENDER = new ca.uhn.fhir.model.api.Include("Communication:sender").toLocked(); 2746 2747 /** 2748 * Search parameter: <b>patient</b> 2749 * <p> 2750 * Description: <b>Focus of message</b><br> 2751 * Type: <b>reference</b><br> 2752 * Path: <b>Communication.subject</b><br> 2753 * </p> 2754 */ 2755 @SearchParamDefinition(name="patient", path="Communication.subject.where(resolve() is Patient)", description="Focus of message", type="reference", target={Patient.class } ) 2756 public static final String SP_PATIENT = "patient"; 2757 /** 2758 * <b>Fluent Client</b> search parameter constant for <b>patient</b> 2759 * <p> 2760 * Description: <b>Focus of message</b><br> 2761 * Type: <b>reference</b><br> 2762 * Path: <b>Communication.subject</b><br> 2763 * </p> 2764 */ 2765 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PATIENT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_PATIENT); 2766 2767/** 2768 * Constant for fluent queries to be used to add include statements. Specifies 2769 * the path value of "<b>Communication:patient</b>". 2770 */ 2771 public static final ca.uhn.fhir.model.api.Include INCLUDE_PATIENT = new ca.uhn.fhir.model.api.Include("Communication:patient").toLocked(); 2772 2773 /** 2774 * Search parameter: <b>recipient</b> 2775 * <p> 2776 * Description: <b>Message recipient</b><br> 2777 * Type: <b>reference</b><br> 2778 * Path: <b>Communication.recipient</b><br> 2779 * </p> 2780 */ 2781 @SearchParamDefinition(name="recipient", path="Communication.recipient", description="Message recipient", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Device"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner"), @ca.uhn.fhir.model.api.annotation.Compartment(name="RelatedPerson") }, target={CareTeam.class, Device.class, Group.class, HealthcareService.class, Organization.class, Patient.class, Practitioner.class, PractitionerRole.class, RelatedPerson.class } ) 2782 public static final String SP_RECIPIENT = "recipient"; 2783 /** 2784 * <b>Fluent Client</b> search parameter constant for <b>recipient</b> 2785 * <p> 2786 * Description: <b>Message recipient</b><br> 2787 * Type: <b>reference</b><br> 2788 * Path: <b>Communication.recipient</b><br> 2789 * </p> 2790 */ 2791 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam RECIPIENT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_RECIPIENT); 2792 2793/** 2794 * Constant for fluent queries to be used to add include statements. Specifies 2795 * the path value of "<b>Communication:recipient</b>". 2796 */ 2797 public static final ca.uhn.fhir.model.api.Include INCLUDE_RECIPIENT = new ca.uhn.fhir.model.api.Include("Communication:recipient").toLocked(); 2798 2799 /** 2800 * Search parameter: <b>instantiates-uri</b> 2801 * <p> 2802 * Description: <b>Instantiates external protocol or definition</b><br> 2803 * Type: <b>uri</b><br> 2804 * Path: <b>Communication.instantiatesUri</b><br> 2805 * </p> 2806 */ 2807 @SearchParamDefinition(name="instantiates-uri", path="Communication.instantiatesUri", description="Instantiates external protocol or definition", type="uri" ) 2808 public static final String SP_INSTANTIATES_URI = "instantiates-uri"; 2809 /** 2810 * <b>Fluent Client</b> search parameter constant for <b>instantiates-uri</b> 2811 * <p> 2812 * Description: <b>Instantiates external protocol or definition</b><br> 2813 * Type: <b>uri</b><br> 2814 * Path: <b>Communication.instantiatesUri</b><br> 2815 * </p> 2816 */ 2817 public static final ca.uhn.fhir.rest.gclient.UriClientParam INSTANTIATES_URI = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_INSTANTIATES_URI); 2818 2819 /** 2820 * Search parameter: <b>category</b> 2821 * <p> 2822 * Description: <b>Message category</b><br> 2823 * Type: <b>token</b><br> 2824 * Path: <b>Communication.category</b><br> 2825 * </p> 2826 */ 2827 @SearchParamDefinition(name="category", path="Communication.category", description="Message category", type="token" ) 2828 public static final String SP_CATEGORY = "category"; 2829 /** 2830 * <b>Fluent Client</b> search parameter constant for <b>category</b> 2831 * <p> 2832 * Description: <b>Message category</b><br> 2833 * Type: <b>token</b><br> 2834 * Path: <b>Communication.category</b><br> 2835 * </p> 2836 */ 2837 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CATEGORY = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CATEGORY); 2838 2839 /** 2840 * Search parameter: <b>status</b> 2841 * <p> 2842 * Description: <b>preparation | in-progress | not-done | on-hold | stopped | completed | entered-in-error | unknown</b><br> 2843 * Type: <b>token</b><br> 2844 * Path: <b>Communication.status</b><br> 2845 * </p> 2846 */ 2847 @SearchParamDefinition(name="status", path="Communication.status", description="preparation | in-progress | not-done | on-hold | stopped | completed | entered-in-error | unknown", type="token" ) 2848 public static final String SP_STATUS = "status"; 2849 /** 2850 * <b>Fluent Client</b> search parameter constant for <b>status</b> 2851 * <p> 2852 * Description: <b>preparation | in-progress | not-done | on-hold | stopped | completed | entered-in-error | unknown</b><br> 2853 * Type: <b>token</b><br> 2854 * Path: <b>Communication.status</b><br> 2855 * </p> 2856 */ 2857 public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS); 2858 2859 2860}