001package org.hl7.fhir.r4b.model; 002 003 004/* 005 Copyright (c) 2011+, HL7, Inc. 006 All rights reserved. 007 008 Redistribution and use in source and binary forms, with or without modification, \ 009 are permitted provided that the following conditions are met: 010 011 * Redistributions of source code must retain the above copyright notice, this \ 012 list of conditions and the following disclaimer. 013 * Redistributions in binary form must reproduce the above copyright notice, \ 014 this list of conditions and the following disclaimer in the documentation \ 015 and/or other materials provided with the distribution. 016 * Neither the name of HL7 nor the names of its contributors may be used to 017 endorse or promote products derived from this software without specific 018 prior written permission. 019 020 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \ 021 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \ 022 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \ 023 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \ 024 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \ 025 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \ 026 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \ 027 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \ 028 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \ 029 POSSIBILITY OF SUCH DAMAGE. 030 */ 031 032// Generated on Fri, Dec 31, 2021 05:58+1100 for FHIR v4.3.0-snapshot1 033 034import java.util.ArrayList; 035import java.util.Date; 036import java.util.List; 037import org.hl7.fhir.utilities.Utilities; 038import org.hl7.fhir.r4b.model.Enumerations.*; 039import org.hl7.fhir.instance.model.api.IBaseBackboneElement; 040import org.hl7.fhir.exceptions.FHIRException; 041import org.hl7.fhir.instance.model.api.ICompositeType; 042import ca.uhn.fhir.model.api.annotation.ResourceDef; 043import ca.uhn.fhir.model.api.annotation.SearchParamDefinition; 044import org.hl7.fhir.instance.model.api.IBaseBackboneElement; 045import ca.uhn.fhir.model.api.annotation.Child; 046import ca.uhn.fhir.model.api.annotation.ChildOrder; 047import ca.uhn.fhir.model.api.annotation.Description; 048import ca.uhn.fhir.model.api.annotation.Block; 049 050import org.hl7.fhir.instance.model.api.IBaseConformance; 051/** 052 * A Capability Statement documents a set of capabilities (behaviors) of a FHIR Server for a particular version of FHIR that may be used as a statement of actual server functionality or a statement of required or desired server implementation. 053 */ 054@ResourceDef(name="CapabilityStatement", profile="http://hl7.org/fhir/StructureDefinition/CapabilityStatement") 055public class CapabilityStatement extends CanonicalResource implements IBaseConformance { 056 057 public enum ConditionalDeleteStatus { 058 /** 059 * No support for conditional deletes. 060 */ 061 NOTSUPPORTED, 062 /** 063 * Conditional deletes are supported, but only single resources at a time. 064 */ 065 SINGLE, 066 /** 067 * Conditional deletes are supported, and multiple resources can be deleted in a single interaction. 068 */ 069 MULTIPLE, 070 /** 071 * added to help the parsers with the generic types 072 */ 073 NULL; 074 public static ConditionalDeleteStatus fromCode(String codeString) throws FHIRException { 075 if (codeString == null || "".equals(codeString)) 076 return null; 077 if ("not-supported".equals(codeString)) 078 return NOTSUPPORTED; 079 if ("single".equals(codeString)) 080 return SINGLE; 081 if ("multiple".equals(codeString)) 082 return MULTIPLE; 083 if (Configuration.isAcceptInvalidEnums()) 084 return null; 085 else 086 throw new FHIRException("Unknown ConditionalDeleteStatus code '"+codeString+"'"); 087 } 088 public String toCode() { 089 switch (this) { 090 case NOTSUPPORTED: return "not-supported"; 091 case SINGLE: return "single"; 092 case MULTIPLE: return "multiple"; 093 case NULL: return null; 094 default: return "?"; 095 } 096 } 097 public String getSystem() { 098 switch (this) { 099 case NOTSUPPORTED: return "http://hl7.org/fhir/conditional-delete-status"; 100 case SINGLE: return "http://hl7.org/fhir/conditional-delete-status"; 101 case MULTIPLE: return "http://hl7.org/fhir/conditional-delete-status"; 102 case NULL: return null; 103 default: return "?"; 104 } 105 } 106 public String getDefinition() { 107 switch (this) { 108 case NOTSUPPORTED: return "No support for conditional deletes."; 109 case SINGLE: return "Conditional deletes are supported, but only single resources at a time."; 110 case MULTIPLE: return "Conditional deletes are supported, and multiple resources can be deleted in a single interaction."; 111 case NULL: return null; 112 default: return "?"; 113 } 114 } 115 public String getDisplay() { 116 switch (this) { 117 case NOTSUPPORTED: return "Not Supported"; 118 case SINGLE: return "Single Deletes Supported"; 119 case MULTIPLE: return "Multiple Deletes Supported"; 120 case NULL: return null; 121 default: return "?"; 122 } 123 } 124 } 125 126 public static class ConditionalDeleteStatusEnumFactory implements EnumFactory<ConditionalDeleteStatus> { 127 public ConditionalDeleteStatus fromCode(String codeString) throws IllegalArgumentException { 128 if (codeString == null || "".equals(codeString)) 129 if (codeString == null || "".equals(codeString)) 130 return null; 131 if ("not-supported".equals(codeString)) 132 return ConditionalDeleteStatus.NOTSUPPORTED; 133 if ("single".equals(codeString)) 134 return ConditionalDeleteStatus.SINGLE; 135 if ("multiple".equals(codeString)) 136 return ConditionalDeleteStatus.MULTIPLE; 137 throw new IllegalArgumentException("Unknown ConditionalDeleteStatus code '"+codeString+"'"); 138 } 139 public Enumeration<ConditionalDeleteStatus> fromType(Base code) throws FHIRException { 140 if (code == null) 141 return null; 142 if (code.isEmpty()) 143 return new Enumeration<ConditionalDeleteStatus>(this); 144 String codeString = ((PrimitiveType) code).asStringValue(); 145 if (codeString == null || "".equals(codeString)) 146 return null; 147 if ("not-supported".equals(codeString)) 148 return new Enumeration<ConditionalDeleteStatus>(this, ConditionalDeleteStatus.NOTSUPPORTED); 149 if ("single".equals(codeString)) 150 return new Enumeration<ConditionalDeleteStatus>(this, ConditionalDeleteStatus.SINGLE); 151 if ("multiple".equals(codeString)) 152 return new Enumeration<ConditionalDeleteStatus>(this, ConditionalDeleteStatus.MULTIPLE); 153 throw new FHIRException("Unknown ConditionalDeleteStatus code '"+codeString+"'"); 154 } 155 public String toCode(ConditionalDeleteStatus code) { 156 if (code == ConditionalDeleteStatus.NOTSUPPORTED) 157 return "not-supported"; 158 if (code == ConditionalDeleteStatus.SINGLE) 159 return "single"; 160 if (code == ConditionalDeleteStatus.MULTIPLE) 161 return "multiple"; 162 return "?"; 163 } 164 public String toSystem(ConditionalDeleteStatus code) { 165 return code.getSystem(); 166 } 167 } 168 169 public enum ConditionalReadStatus { 170 /** 171 * No support for conditional reads. 172 */ 173 NOTSUPPORTED, 174 /** 175 * Conditional reads are supported, but only with the If-Modified-Since HTTP Header. 176 */ 177 MODIFIEDSINCE, 178 /** 179 * Conditional reads are supported, but only with the If-None-Match HTTP Header. 180 */ 181 NOTMATCH, 182 /** 183 * Conditional reads are supported, with both If-Modified-Since and If-None-Match HTTP Headers. 184 */ 185 FULLSUPPORT, 186 /** 187 * added to help the parsers with the generic types 188 */ 189 NULL; 190 public static ConditionalReadStatus fromCode(String codeString) throws FHIRException { 191 if (codeString == null || "".equals(codeString)) 192 return null; 193 if ("not-supported".equals(codeString)) 194 return NOTSUPPORTED; 195 if ("modified-since".equals(codeString)) 196 return MODIFIEDSINCE; 197 if ("not-match".equals(codeString)) 198 return NOTMATCH; 199 if ("full-support".equals(codeString)) 200 return FULLSUPPORT; 201 if (Configuration.isAcceptInvalidEnums()) 202 return null; 203 else 204 throw new FHIRException("Unknown ConditionalReadStatus code '"+codeString+"'"); 205 } 206 public String toCode() { 207 switch (this) { 208 case NOTSUPPORTED: return "not-supported"; 209 case MODIFIEDSINCE: return "modified-since"; 210 case NOTMATCH: return "not-match"; 211 case FULLSUPPORT: return "full-support"; 212 case NULL: return null; 213 default: return "?"; 214 } 215 } 216 public String getSystem() { 217 switch (this) { 218 case NOTSUPPORTED: return "http://hl7.org/fhir/conditional-read-status"; 219 case MODIFIEDSINCE: return "http://hl7.org/fhir/conditional-read-status"; 220 case NOTMATCH: return "http://hl7.org/fhir/conditional-read-status"; 221 case FULLSUPPORT: return "http://hl7.org/fhir/conditional-read-status"; 222 case NULL: return null; 223 default: return "?"; 224 } 225 } 226 public String getDefinition() { 227 switch (this) { 228 case NOTSUPPORTED: return "No support for conditional reads."; 229 case MODIFIEDSINCE: return "Conditional reads are supported, but only with the If-Modified-Since HTTP Header."; 230 case NOTMATCH: return "Conditional reads are supported, but only with the If-None-Match HTTP Header."; 231 case FULLSUPPORT: return "Conditional reads are supported, with both If-Modified-Since and If-None-Match HTTP Headers."; 232 case NULL: return null; 233 default: return "?"; 234 } 235 } 236 public String getDisplay() { 237 switch (this) { 238 case NOTSUPPORTED: return "Not Supported"; 239 case MODIFIEDSINCE: return "If-Modified-Since"; 240 case NOTMATCH: return "If-None-Match"; 241 case FULLSUPPORT: return "Full Support"; 242 case NULL: return null; 243 default: return "?"; 244 } 245 } 246 } 247 248 public static class ConditionalReadStatusEnumFactory implements EnumFactory<ConditionalReadStatus> { 249 public ConditionalReadStatus fromCode(String codeString) throws IllegalArgumentException { 250 if (codeString == null || "".equals(codeString)) 251 if (codeString == null || "".equals(codeString)) 252 return null; 253 if ("not-supported".equals(codeString)) 254 return ConditionalReadStatus.NOTSUPPORTED; 255 if ("modified-since".equals(codeString)) 256 return ConditionalReadStatus.MODIFIEDSINCE; 257 if ("not-match".equals(codeString)) 258 return ConditionalReadStatus.NOTMATCH; 259 if ("full-support".equals(codeString)) 260 return ConditionalReadStatus.FULLSUPPORT; 261 throw new IllegalArgumentException("Unknown ConditionalReadStatus code '"+codeString+"'"); 262 } 263 public Enumeration<ConditionalReadStatus> fromType(Base code) throws FHIRException { 264 if (code == null) 265 return null; 266 if (code.isEmpty()) 267 return new Enumeration<ConditionalReadStatus>(this); 268 String codeString = ((PrimitiveType) code).asStringValue(); 269 if (codeString == null || "".equals(codeString)) 270 return null; 271 if ("not-supported".equals(codeString)) 272 return new Enumeration<ConditionalReadStatus>(this, ConditionalReadStatus.NOTSUPPORTED); 273 if ("modified-since".equals(codeString)) 274 return new Enumeration<ConditionalReadStatus>(this, ConditionalReadStatus.MODIFIEDSINCE); 275 if ("not-match".equals(codeString)) 276 return new Enumeration<ConditionalReadStatus>(this, ConditionalReadStatus.NOTMATCH); 277 if ("full-support".equals(codeString)) 278 return new Enumeration<ConditionalReadStatus>(this, ConditionalReadStatus.FULLSUPPORT); 279 throw new FHIRException("Unknown ConditionalReadStatus code '"+codeString+"'"); 280 } 281 public String toCode(ConditionalReadStatus code) { 282 if (code == ConditionalReadStatus.NOTSUPPORTED) 283 return "not-supported"; 284 if (code == ConditionalReadStatus.MODIFIEDSINCE) 285 return "modified-since"; 286 if (code == ConditionalReadStatus.NOTMATCH) 287 return "not-match"; 288 if (code == ConditionalReadStatus.FULLSUPPORT) 289 return "full-support"; 290 return "?"; 291 } 292 public String toSystem(ConditionalReadStatus code) { 293 return code.getSystem(); 294 } 295 } 296 297 public enum DocumentMode { 298 /** 299 * The application produces documents of the specified type. 300 */ 301 PRODUCER, 302 /** 303 * The application consumes documents of the specified type. 304 */ 305 CONSUMER, 306 /** 307 * added to help the parsers with the generic types 308 */ 309 NULL; 310 public static DocumentMode fromCode(String codeString) throws FHIRException { 311 if (codeString == null || "".equals(codeString)) 312 return null; 313 if ("producer".equals(codeString)) 314 return PRODUCER; 315 if ("consumer".equals(codeString)) 316 return CONSUMER; 317 if (Configuration.isAcceptInvalidEnums()) 318 return null; 319 else 320 throw new FHIRException("Unknown DocumentMode code '"+codeString+"'"); 321 } 322 public String toCode() { 323 switch (this) { 324 case PRODUCER: return "producer"; 325 case CONSUMER: return "consumer"; 326 case NULL: return null; 327 default: return "?"; 328 } 329 } 330 public String getSystem() { 331 switch (this) { 332 case PRODUCER: return "http://hl7.org/fhir/document-mode"; 333 case CONSUMER: return "http://hl7.org/fhir/document-mode"; 334 case NULL: return null; 335 default: return "?"; 336 } 337 } 338 public String getDefinition() { 339 switch (this) { 340 case PRODUCER: return "The application produces documents of the specified type."; 341 case CONSUMER: return "The application consumes documents of the specified type."; 342 case NULL: return null; 343 default: return "?"; 344 } 345 } 346 public String getDisplay() { 347 switch (this) { 348 case PRODUCER: return "Producer"; 349 case CONSUMER: return "Consumer"; 350 case NULL: return null; 351 default: return "?"; 352 } 353 } 354 } 355 356 public static class DocumentModeEnumFactory implements EnumFactory<DocumentMode> { 357 public DocumentMode fromCode(String codeString) throws IllegalArgumentException { 358 if (codeString == null || "".equals(codeString)) 359 if (codeString == null || "".equals(codeString)) 360 return null; 361 if ("producer".equals(codeString)) 362 return DocumentMode.PRODUCER; 363 if ("consumer".equals(codeString)) 364 return DocumentMode.CONSUMER; 365 throw new IllegalArgumentException("Unknown DocumentMode code '"+codeString+"'"); 366 } 367 public Enumeration<DocumentMode> fromType(Base code) throws FHIRException { 368 if (code == null) 369 return null; 370 if (code.isEmpty()) 371 return new Enumeration<DocumentMode>(this); 372 String codeString = ((PrimitiveType) code).asStringValue(); 373 if (codeString == null || "".equals(codeString)) 374 return null; 375 if ("producer".equals(codeString)) 376 return new Enumeration<DocumentMode>(this, DocumentMode.PRODUCER); 377 if ("consumer".equals(codeString)) 378 return new Enumeration<DocumentMode>(this, DocumentMode.CONSUMER); 379 throw new FHIRException("Unknown DocumentMode code '"+codeString+"'"); 380 } 381 public String toCode(DocumentMode code) { 382 if (code == DocumentMode.PRODUCER) 383 return "producer"; 384 if (code == DocumentMode.CONSUMER) 385 return "consumer"; 386 return "?"; 387 } 388 public String toSystem(DocumentMode code) { 389 return code.getSystem(); 390 } 391 } 392 393 public enum EventCapabilityMode { 394 /** 395 * The application sends requests and receives responses. 396 */ 397 SENDER, 398 /** 399 * The application receives requests and sends responses. 400 */ 401 RECEIVER, 402 /** 403 * added to help the parsers with the generic types 404 */ 405 NULL; 406 public static EventCapabilityMode fromCode(String codeString) throws FHIRException { 407 if (codeString == null || "".equals(codeString)) 408 return null; 409 if ("sender".equals(codeString)) 410 return SENDER; 411 if ("receiver".equals(codeString)) 412 return RECEIVER; 413 if (Configuration.isAcceptInvalidEnums()) 414 return null; 415 else 416 throw new FHIRException("Unknown EventCapabilityMode code '"+codeString+"'"); 417 } 418 public String toCode() { 419 switch (this) { 420 case SENDER: return "sender"; 421 case RECEIVER: return "receiver"; 422 case NULL: return null; 423 default: return "?"; 424 } 425 } 426 public String getSystem() { 427 switch (this) { 428 case SENDER: return "http://hl7.org/fhir/event-capability-mode"; 429 case RECEIVER: return "http://hl7.org/fhir/event-capability-mode"; 430 case NULL: return null; 431 default: return "?"; 432 } 433 } 434 public String getDefinition() { 435 switch (this) { 436 case SENDER: return "The application sends requests and receives responses."; 437 case RECEIVER: return "The application receives requests and sends responses."; 438 case NULL: return null; 439 default: return "?"; 440 } 441 } 442 public String getDisplay() { 443 switch (this) { 444 case SENDER: return "Sender"; 445 case RECEIVER: return "Receiver"; 446 case NULL: return null; 447 default: return "?"; 448 } 449 } 450 } 451 452 public static class EventCapabilityModeEnumFactory implements EnumFactory<EventCapabilityMode> { 453 public EventCapabilityMode fromCode(String codeString) throws IllegalArgumentException { 454 if (codeString == null || "".equals(codeString)) 455 if (codeString == null || "".equals(codeString)) 456 return null; 457 if ("sender".equals(codeString)) 458 return EventCapabilityMode.SENDER; 459 if ("receiver".equals(codeString)) 460 return EventCapabilityMode.RECEIVER; 461 throw new IllegalArgumentException("Unknown EventCapabilityMode code '"+codeString+"'"); 462 } 463 public Enumeration<EventCapabilityMode> fromType(Base code) throws FHIRException { 464 if (code == null) 465 return null; 466 if (code.isEmpty()) 467 return new Enumeration<EventCapabilityMode>(this); 468 String codeString = ((PrimitiveType) code).asStringValue(); 469 if (codeString == null || "".equals(codeString)) 470 return null; 471 if ("sender".equals(codeString)) 472 return new Enumeration<EventCapabilityMode>(this, EventCapabilityMode.SENDER); 473 if ("receiver".equals(codeString)) 474 return new Enumeration<EventCapabilityMode>(this, EventCapabilityMode.RECEIVER); 475 throw new FHIRException("Unknown EventCapabilityMode code '"+codeString+"'"); 476 } 477 public String toCode(EventCapabilityMode code) { 478 if (code == EventCapabilityMode.SENDER) 479 return "sender"; 480 if (code == EventCapabilityMode.RECEIVER) 481 return "receiver"; 482 return "?"; 483 } 484 public String toSystem(EventCapabilityMode code) { 485 return code.getSystem(); 486 } 487 } 488 489 public enum ReferenceHandlingPolicy { 490 /** 491 * The server supports and populates Literal references (i.e. using Reference.reference) where they are known (this code does not guarantee that all references are literal; see 'enforced'). 492 */ 493 LITERAL, 494 /** 495 * The server allows logical references (i.e. using Reference.identifier). 496 */ 497 LOGICAL, 498 /** 499 * The server will attempt to resolve logical references to literal references - i.e. converting Reference.identifier to Reference.reference (if resolution fails, the server may still accept resources; see logical). 500 */ 501 RESOLVES, 502 /** 503 * The server enforces that references have integrity - e.g. it ensures that references can always be resolved. This is typically the case for clinical record systems, but often not the case for middleware/proxy systems. 504 */ 505 ENFORCED, 506 /** 507 * The server does not support references that point to other servers. 508 */ 509 LOCAL, 510 /** 511 * added to help the parsers with the generic types 512 */ 513 NULL; 514 public static ReferenceHandlingPolicy fromCode(String codeString) throws FHIRException { 515 if (codeString == null || "".equals(codeString)) 516 return null; 517 if ("literal".equals(codeString)) 518 return LITERAL; 519 if ("logical".equals(codeString)) 520 return LOGICAL; 521 if ("resolves".equals(codeString)) 522 return RESOLVES; 523 if ("enforced".equals(codeString)) 524 return ENFORCED; 525 if ("local".equals(codeString)) 526 return LOCAL; 527 if (Configuration.isAcceptInvalidEnums()) 528 return null; 529 else 530 throw new FHIRException("Unknown ReferenceHandlingPolicy code '"+codeString+"'"); 531 } 532 public String toCode() { 533 switch (this) { 534 case LITERAL: return "literal"; 535 case LOGICAL: return "logical"; 536 case RESOLVES: return "resolves"; 537 case ENFORCED: return "enforced"; 538 case LOCAL: return "local"; 539 case NULL: return null; 540 default: return "?"; 541 } 542 } 543 public String getSystem() { 544 switch (this) { 545 case LITERAL: return "http://hl7.org/fhir/reference-handling-policy"; 546 case LOGICAL: return "http://hl7.org/fhir/reference-handling-policy"; 547 case RESOLVES: return "http://hl7.org/fhir/reference-handling-policy"; 548 case ENFORCED: return "http://hl7.org/fhir/reference-handling-policy"; 549 case LOCAL: return "http://hl7.org/fhir/reference-handling-policy"; 550 case NULL: return null; 551 default: return "?"; 552 } 553 } 554 public String getDefinition() { 555 switch (this) { 556 case LITERAL: return "The server supports and populates Literal references (i.e. using Reference.reference) where they are known (this code does not guarantee that all references are literal; see 'enforced')."; 557 case LOGICAL: return "The server allows logical references (i.e. using Reference.identifier)."; 558 case RESOLVES: return "The server will attempt to resolve logical references to literal references - i.e. converting Reference.identifier to Reference.reference (if resolution fails, the server may still accept resources; see logical)."; 559 case ENFORCED: return "The server enforces that references have integrity - e.g. it ensures that references can always be resolved. This is typically the case for clinical record systems, but often not the case for middleware/proxy systems."; 560 case LOCAL: return "The server does not support references that point to other servers."; 561 case NULL: return null; 562 default: return "?"; 563 } 564 } 565 public String getDisplay() { 566 switch (this) { 567 case LITERAL: return "Literal References"; 568 case LOGICAL: return "Logical References"; 569 case RESOLVES: return "Resolves References"; 570 case ENFORCED: return "Reference Integrity Enforced"; 571 case LOCAL: return "Local References Only"; 572 case NULL: return null; 573 default: return "?"; 574 } 575 } 576 } 577 578 public static class ReferenceHandlingPolicyEnumFactory implements EnumFactory<ReferenceHandlingPolicy> { 579 public ReferenceHandlingPolicy fromCode(String codeString) throws IllegalArgumentException { 580 if (codeString == null || "".equals(codeString)) 581 if (codeString == null || "".equals(codeString)) 582 return null; 583 if ("literal".equals(codeString)) 584 return ReferenceHandlingPolicy.LITERAL; 585 if ("logical".equals(codeString)) 586 return ReferenceHandlingPolicy.LOGICAL; 587 if ("resolves".equals(codeString)) 588 return ReferenceHandlingPolicy.RESOLVES; 589 if ("enforced".equals(codeString)) 590 return ReferenceHandlingPolicy.ENFORCED; 591 if ("local".equals(codeString)) 592 return ReferenceHandlingPolicy.LOCAL; 593 throw new IllegalArgumentException("Unknown ReferenceHandlingPolicy code '"+codeString+"'"); 594 } 595 public Enumeration<ReferenceHandlingPolicy> fromType(Base code) throws FHIRException { 596 if (code == null) 597 return null; 598 if (code.isEmpty()) 599 return new Enumeration<ReferenceHandlingPolicy>(this); 600 String codeString = ((PrimitiveType) code).asStringValue(); 601 if (codeString == null || "".equals(codeString)) 602 return null; 603 if ("literal".equals(codeString)) 604 return new Enumeration<ReferenceHandlingPolicy>(this, ReferenceHandlingPolicy.LITERAL); 605 if ("logical".equals(codeString)) 606 return new Enumeration<ReferenceHandlingPolicy>(this, ReferenceHandlingPolicy.LOGICAL); 607 if ("resolves".equals(codeString)) 608 return new Enumeration<ReferenceHandlingPolicy>(this, ReferenceHandlingPolicy.RESOLVES); 609 if ("enforced".equals(codeString)) 610 return new Enumeration<ReferenceHandlingPolicy>(this, ReferenceHandlingPolicy.ENFORCED); 611 if ("local".equals(codeString)) 612 return new Enumeration<ReferenceHandlingPolicy>(this, ReferenceHandlingPolicy.LOCAL); 613 throw new FHIRException("Unknown ReferenceHandlingPolicy code '"+codeString+"'"); 614 } 615 public String toCode(ReferenceHandlingPolicy code) { 616 if (code == ReferenceHandlingPolicy.LITERAL) 617 return "literal"; 618 if (code == ReferenceHandlingPolicy.LOGICAL) 619 return "logical"; 620 if (code == ReferenceHandlingPolicy.RESOLVES) 621 return "resolves"; 622 if (code == ReferenceHandlingPolicy.ENFORCED) 623 return "enforced"; 624 if (code == ReferenceHandlingPolicy.LOCAL) 625 return "local"; 626 return "?"; 627 } 628 public String toSystem(ReferenceHandlingPolicy code) { 629 return code.getSystem(); 630 } 631 } 632 633 public enum ResourceVersionPolicy { 634 /** 635 * VersionId meta-property is not supported (server) or used (client). 636 */ 637 NOVERSION, 638 /** 639 * VersionId meta-property is supported (server) or used (client). 640 */ 641 VERSIONED, 642 /** 643 * VersionId must be correct for updates (server) or will be specified (If-match header) for updates (client). 644 */ 645 VERSIONEDUPDATE, 646 /** 647 * added to help the parsers with the generic types 648 */ 649 NULL; 650 public static ResourceVersionPolicy fromCode(String codeString) throws FHIRException { 651 if (codeString == null || "".equals(codeString)) 652 return null; 653 if ("no-version".equals(codeString)) 654 return NOVERSION; 655 if ("versioned".equals(codeString)) 656 return VERSIONED; 657 if ("versioned-update".equals(codeString)) 658 return VERSIONEDUPDATE; 659 if (Configuration.isAcceptInvalidEnums()) 660 return null; 661 else 662 throw new FHIRException("Unknown ResourceVersionPolicy code '"+codeString+"'"); 663 } 664 public String toCode() { 665 switch (this) { 666 case NOVERSION: return "no-version"; 667 case VERSIONED: return "versioned"; 668 case VERSIONEDUPDATE: return "versioned-update"; 669 case NULL: return null; 670 default: return "?"; 671 } 672 } 673 public String getSystem() { 674 switch (this) { 675 case NOVERSION: return "http://hl7.org/fhir/versioning-policy"; 676 case VERSIONED: return "http://hl7.org/fhir/versioning-policy"; 677 case VERSIONEDUPDATE: return "http://hl7.org/fhir/versioning-policy"; 678 case NULL: return null; 679 default: return "?"; 680 } 681 } 682 public String getDefinition() { 683 switch (this) { 684 case NOVERSION: return "VersionId meta-property is not supported (server) or used (client)."; 685 case VERSIONED: return "VersionId meta-property is supported (server) or used (client)."; 686 case VERSIONEDUPDATE: return "VersionId must be correct for updates (server) or will be specified (If-match header) for updates (client)."; 687 case NULL: return null; 688 default: return "?"; 689 } 690 } 691 public String getDisplay() { 692 switch (this) { 693 case NOVERSION: return "No VersionId Support"; 694 case VERSIONED: return "Versioned"; 695 case VERSIONEDUPDATE: return "VersionId tracked fully"; 696 case NULL: return null; 697 default: return "?"; 698 } 699 } 700 } 701 702 public static class ResourceVersionPolicyEnumFactory implements EnumFactory<ResourceVersionPolicy> { 703 public ResourceVersionPolicy fromCode(String codeString) throws IllegalArgumentException { 704 if (codeString == null || "".equals(codeString)) 705 if (codeString == null || "".equals(codeString)) 706 return null; 707 if ("no-version".equals(codeString)) 708 return ResourceVersionPolicy.NOVERSION; 709 if ("versioned".equals(codeString)) 710 return ResourceVersionPolicy.VERSIONED; 711 if ("versioned-update".equals(codeString)) 712 return ResourceVersionPolicy.VERSIONEDUPDATE; 713 throw new IllegalArgumentException("Unknown ResourceVersionPolicy code '"+codeString+"'"); 714 } 715 public Enumeration<ResourceVersionPolicy> fromType(Base code) throws FHIRException { 716 if (code == null) 717 return null; 718 if (code.isEmpty()) 719 return new Enumeration<ResourceVersionPolicy>(this); 720 String codeString = ((PrimitiveType) code).asStringValue(); 721 if (codeString == null || "".equals(codeString)) 722 return null; 723 if ("no-version".equals(codeString)) 724 return new Enumeration<ResourceVersionPolicy>(this, ResourceVersionPolicy.NOVERSION); 725 if ("versioned".equals(codeString)) 726 return new Enumeration<ResourceVersionPolicy>(this, ResourceVersionPolicy.VERSIONED); 727 if ("versioned-update".equals(codeString)) 728 return new Enumeration<ResourceVersionPolicy>(this, ResourceVersionPolicy.VERSIONEDUPDATE); 729 throw new FHIRException("Unknown ResourceVersionPolicy code '"+codeString+"'"); 730 } 731 public String toCode(ResourceVersionPolicy code) { 732 if (code == ResourceVersionPolicy.NOVERSION) 733 return "no-version"; 734 if (code == ResourceVersionPolicy.VERSIONED) 735 return "versioned"; 736 if (code == ResourceVersionPolicy.VERSIONEDUPDATE) 737 return "versioned-update"; 738 return "?"; 739 } 740 public String toSystem(ResourceVersionPolicy code) { 741 return code.getSystem(); 742 } 743 } 744 745 public enum RestfulCapabilityMode { 746 /** 747 * The application acts as a client for this resource. 748 */ 749 CLIENT, 750 /** 751 * The application acts as a server for this resource. 752 */ 753 SERVER, 754 /** 755 * added to help the parsers with the generic types 756 */ 757 NULL; 758 public static RestfulCapabilityMode fromCode(String codeString) throws FHIRException { 759 if (codeString == null || "".equals(codeString)) 760 return null; 761 if ("client".equals(codeString)) 762 return CLIENT; 763 if ("server".equals(codeString)) 764 return SERVER; 765 if (Configuration.isAcceptInvalidEnums()) 766 return null; 767 else 768 throw new FHIRException("Unknown RestfulCapabilityMode code '"+codeString+"'"); 769 } 770 public String toCode() { 771 switch (this) { 772 case CLIENT: return "client"; 773 case SERVER: return "server"; 774 case NULL: return null; 775 default: return "?"; 776 } 777 } 778 public String getSystem() { 779 switch (this) { 780 case CLIENT: return "http://hl7.org/fhir/restful-capability-mode"; 781 case SERVER: return "http://hl7.org/fhir/restful-capability-mode"; 782 case NULL: return null; 783 default: return "?"; 784 } 785 } 786 public String getDefinition() { 787 switch (this) { 788 case CLIENT: return "The application acts as a client for this resource."; 789 case SERVER: return "The application acts as a server for this resource."; 790 case NULL: return null; 791 default: return "?"; 792 } 793 } 794 public String getDisplay() { 795 switch (this) { 796 case CLIENT: return "Client"; 797 case SERVER: return "Server"; 798 case NULL: return null; 799 default: return "?"; 800 } 801 } 802 } 803 804 public static class RestfulCapabilityModeEnumFactory implements EnumFactory<RestfulCapabilityMode> { 805 public RestfulCapabilityMode fromCode(String codeString) throws IllegalArgumentException { 806 if (codeString == null || "".equals(codeString)) 807 if (codeString == null || "".equals(codeString)) 808 return null; 809 if ("client".equals(codeString)) 810 return RestfulCapabilityMode.CLIENT; 811 if ("server".equals(codeString)) 812 return RestfulCapabilityMode.SERVER; 813 throw new IllegalArgumentException("Unknown RestfulCapabilityMode code '"+codeString+"'"); 814 } 815 public Enumeration<RestfulCapabilityMode> fromType(Base code) throws FHIRException { 816 if (code == null) 817 return null; 818 if (code.isEmpty()) 819 return new Enumeration<RestfulCapabilityMode>(this); 820 String codeString = ((PrimitiveType) code).asStringValue(); 821 if (codeString == null || "".equals(codeString)) 822 return null; 823 if ("client".equals(codeString)) 824 return new Enumeration<RestfulCapabilityMode>(this, RestfulCapabilityMode.CLIENT); 825 if ("server".equals(codeString)) 826 return new Enumeration<RestfulCapabilityMode>(this, RestfulCapabilityMode.SERVER); 827 throw new FHIRException("Unknown RestfulCapabilityMode code '"+codeString+"'"); 828 } 829 public String toCode(RestfulCapabilityMode code) { 830 if (code == RestfulCapabilityMode.CLIENT) 831 return "client"; 832 if (code == RestfulCapabilityMode.SERVER) 833 return "server"; 834 return "?"; 835 } 836 public String toSystem(RestfulCapabilityMode code) { 837 return code.getSystem(); 838 } 839 } 840 841 public enum SystemRestfulInteraction { 842 /** 843 * Update, create or delete a set of resources as a single transaction. 844 */ 845 TRANSACTION, 846 /** 847 * perform a set of a separate interactions in a single http operation 848 */ 849 BATCH, 850 /** 851 * Search all resources based on some filter criteria. 852 */ 853 SEARCHSYSTEM, 854 /** 855 * Retrieve the change history for all resources on a system. 856 */ 857 HISTORYSYSTEM, 858 /** 859 * added to help the parsers with the generic types 860 */ 861 NULL; 862 public static SystemRestfulInteraction fromCode(String codeString) throws FHIRException { 863 if (codeString == null || "".equals(codeString)) 864 return null; 865 if ("transaction".equals(codeString)) 866 return TRANSACTION; 867 if ("batch".equals(codeString)) 868 return BATCH; 869 if ("search-system".equals(codeString)) 870 return SEARCHSYSTEM; 871 if ("history-system".equals(codeString)) 872 return HISTORYSYSTEM; 873 if (Configuration.isAcceptInvalidEnums()) 874 return null; 875 else 876 throw new FHIRException("Unknown SystemRestfulInteraction code '"+codeString+"'"); 877 } 878 public String toCode() { 879 switch (this) { 880 case TRANSACTION: return "transaction"; 881 case BATCH: return "batch"; 882 case SEARCHSYSTEM: return "search-system"; 883 case HISTORYSYSTEM: return "history-system"; 884 case NULL: return null; 885 default: return "?"; 886 } 887 } 888 public String getSystem() { 889 switch (this) { 890 case TRANSACTION: return "http://hl7.org/fhir/restful-interaction"; 891 case BATCH: return "http://hl7.org/fhir/restful-interaction"; 892 case SEARCHSYSTEM: return "http://hl7.org/fhir/restful-interaction"; 893 case HISTORYSYSTEM: return "http://hl7.org/fhir/restful-interaction"; 894 case NULL: return null; 895 default: return "?"; 896 } 897 } 898 public String getDefinition() { 899 switch (this) { 900 case TRANSACTION: return "Update, create or delete a set of resources as a single transaction."; 901 case BATCH: return "perform a set of a separate interactions in a single http operation"; 902 case SEARCHSYSTEM: return "Search all resources based on some filter criteria."; 903 case HISTORYSYSTEM: return "Retrieve the change history for all resources on a system."; 904 case NULL: return null; 905 default: return "?"; 906 } 907 } 908 public String getDisplay() { 909 switch (this) { 910 case TRANSACTION: return "transaction"; 911 case BATCH: return "batch"; 912 case SEARCHSYSTEM: return "search-system"; 913 case HISTORYSYSTEM: return "history-system"; 914 case NULL: return null; 915 default: return "?"; 916 } 917 } 918 } 919 920 public static class SystemRestfulInteractionEnumFactory implements EnumFactory<SystemRestfulInteraction> { 921 public SystemRestfulInteraction fromCode(String codeString) throws IllegalArgumentException { 922 if (codeString == null || "".equals(codeString)) 923 if (codeString == null || "".equals(codeString)) 924 return null; 925 if ("transaction".equals(codeString)) 926 return SystemRestfulInteraction.TRANSACTION; 927 if ("batch".equals(codeString)) 928 return SystemRestfulInteraction.BATCH; 929 if ("search-system".equals(codeString)) 930 return SystemRestfulInteraction.SEARCHSYSTEM; 931 if ("history-system".equals(codeString)) 932 return SystemRestfulInteraction.HISTORYSYSTEM; 933 throw new IllegalArgumentException("Unknown SystemRestfulInteraction code '"+codeString+"'"); 934 } 935 public Enumeration<SystemRestfulInteraction> fromType(Base code) throws FHIRException { 936 if (code == null) 937 return null; 938 if (code.isEmpty()) 939 return new Enumeration<SystemRestfulInteraction>(this); 940 String codeString = ((PrimitiveType) code).asStringValue(); 941 if (codeString == null || "".equals(codeString)) 942 return null; 943 if ("transaction".equals(codeString)) 944 return new Enumeration<SystemRestfulInteraction>(this, SystemRestfulInteraction.TRANSACTION); 945 if ("batch".equals(codeString)) 946 return new Enumeration<SystemRestfulInteraction>(this, SystemRestfulInteraction.BATCH); 947 if ("search-system".equals(codeString)) 948 return new Enumeration<SystemRestfulInteraction>(this, SystemRestfulInteraction.SEARCHSYSTEM); 949 if ("history-system".equals(codeString)) 950 return new Enumeration<SystemRestfulInteraction>(this, SystemRestfulInteraction.HISTORYSYSTEM); 951 throw new FHIRException("Unknown SystemRestfulInteraction code '"+codeString+"'"); 952 } 953 public String toCode(SystemRestfulInteraction code) { 954 if (code == SystemRestfulInteraction.TRANSACTION) 955 return "transaction"; 956 if (code == SystemRestfulInteraction.BATCH) 957 return "batch"; 958 if (code == SystemRestfulInteraction.SEARCHSYSTEM) 959 return "search-system"; 960 if (code == SystemRestfulInteraction.HISTORYSYSTEM) 961 return "history-system"; 962 return "?"; 963 } 964 public String toSystem(SystemRestfulInteraction code) { 965 return code.getSystem(); 966 } 967 } 968 969 public enum TypeRestfulInteraction { 970 /** 971 * Read the current state of the resource. 972 */ 973 READ, 974 /** 975 * Read the state of a specific version of the resource. 976 */ 977 VREAD, 978 /** 979 * Update an existing resource by its id (or create it if it is new). 980 */ 981 UPDATE, 982 /** 983 * Update an existing resource by posting a set of changes to it. 984 */ 985 PATCH, 986 /** 987 * Delete a resource. 988 */ 989 DELETE, 990 /** 991 * Retrieve the change history for a particular resource. 992 */ 993 HISTORYINSTANCE, 994 /** 995 * Retrieve the change history for all resources of a particular type. 996 */ 997 HISTORYTYPE, 998 /** 999 * Create a new resource with a server assigned id. 1000 */ 1001 CREATE, 1002 /** 1003 * Search all resources of the specified type based on some filter criteria. 1004 */ 1005 SEARCHTYPE, 1006 /** 1007 * added to help the parsers with the generic types 1008 */ 1009 NULL; 1010 public static TypeRestfulInteraction fromCode(String codeString) throws FHIRException { 1011 if (codeString == null || "".equals(codeString)) 1012 return null; 1013 if ("read".equals(codeString)) 1014 return READ; 1015 if ("vread".equals(codeString)) 1016 return VREAD; 1017 if ("update".equals(codeString)) 1018 return UPDATE; 1019 if ("patch".equals(codeString)) 1020 return PATCH; 1021 if ("delete".equals(codeString)) 1022 return DELETE; 1023 if ("history-instance".equals(codeString)) 1024 return HISTORYINSTANCE; 1025 if ("history-type".equals(codeString)) 1026 return HISTORYTYPE; 1027 if ("create".equals(codeString)) 1028 return CREATE; 1029 if ("search-type".equals(codeString)) 1030 return SEARCHTYPE; 1031 if (Configuration.isAcceptInvalidEnums()) 1032 return null; 1033 else 1034 throw new FHIRException("Unknown TypeRestfulInteraction code '"+codeString+"'"); 1035 } 1036 public String toCode() { 1037 switch (this) { 1038 case READ: return "read"; 1039 case VREAD: return "vread"; 1040 case UPDATE: return "update"; 1041 case PATCH: return "patch"; 1042 case DELETE: return "delete"; 1043 case HISTORYINSTANCE: return "history-instance"; 1044 case HISTORYTYPE: return "history-type"; 1045 case CREATE: return "create"; 1046 case SEARCHTYPE: return "search-type"; 1047 case NULL: return null; 1048 default: return "?"; 1049 } 1050 } 1051 public String getSystem() { 1052 switch (this) { 1053 case READ: return "http://hl7.org/fhir/restful-interaction"; 1054 case VREAD: return "http://hl7.org/fhir/restful-interaction"; 1055 case UPDATE: return "http://hl7.org/fhir/restful-interaction"; 1056 case PATCH: return "http://hl7.org/fhir/restful-interaction"; 1057 case DELETE: return "http://hl7.org/fhir/restful-interaction"; 1058 case HISTORYINSTANCE: return "http://hl7.org/fhir/restful-interaction"; 1059 case HISTORYTYPE: return "http://hl7.org/fhir/restful-interaction"; 1060 case CREATE: return "http://hl7.org/fhir/restful-interaction"; 1061 case SEARCHTYPE: return "http://hl7.org/fhir/restful-interaction"; 1062 case NULL: return null; 1063 default: return "?"; 1064 } 1065 } 1066 public String getDefinition() { 1067 switch (this) { 1068 case READ: return "Read the current state of the resource."; 1069 case VREAD: return "Read the state of a specific version of the resource."; 1070 case UPDATE: return "Update an existing resource by its id (or create it if it is new)."; 1071 case PATCH: return "Update an existing resource by posting a set of changes to it."; 1072 case DELETE: return "Delete a resource."; 1073 case HISTORYINSTANCE: return "Retrieve the change history for a particular resource."; 1074 case HISTORYTYPE: return "Retrieve the change history for all resources of a particular type."; 1075 case CREATE: return "Create a new resource with a server assigned id."; 1076 case SEARCHTYPE: return "Search all resources of the specified type based on some filter criteria."; 1077 case NULL: return null; 1078 default: return "?"; 1079 } 1080 } 1081 public String getDisplay() { 1082 switch (this) { 1083 case READ: return "read"; 1084 case VREAD: return "vread"; 1085 case UPDATE: return "update"; 1086 case PATCH: return "patch"; 1087 case DELETE: return "delete"; 1088 case HISTORYINSTANCE: return "history-instance"; 1089 case HISTORYTYPE: return "history-type"; 1090 case CREATE: return "create"; 1091 case SEARCHTYPE: return "search-type"; 1092 case NULL: return null; 1093 default: return "?"; 1094 } 1095 } 1096 } 1097 1098 public static class TypeRestfulInteractionEnumFactory implements EnumFactory<TypeRestfulInteraction> { 1099 public TypeRestfulInteraction fromCode(String codeString) throws IllegalArgumentException { 1100 if (codeString == null || "".equals(codeString)) 1101 if (codeString == null || "".equals(codeString)) 1102 return null; 1103 if ("read".equals(codeString)) 1104 return TypeRestfulInteraction.READ; 1105 if ("vread".equals(codeString)) 1106 return TypeRestfulInteraction.VREAD; 1107 if ("update".equals(codeString)) 1108 return TypeRestfulInteraction.UPDATE; 1109 if ("patch".equals(codeString)) 1110 return TypeRestfulInteraction.PATCH; 1111 if ("delete".equals(codeString)) 1112 return TypeRestfulInteraction.DELETE; 1113 if ("history-instance".equals(codeString)) 1114 return TypeRestfulInteraction.HISTORYINSTANCE; 1115 if ("history-type".equals(codeString)) 1116 return TypeRestfulInteraction.HISTORYTYPE; 1117 if ("create".equals(codeString)) 1118 return TypeRestfulInteraction.CREATE; 1119 if ("search-type".equals(codeString)) 1120 return TypeRestfulInteraction.SEARCHTYPE; 1121 throw new IllegalArgumentException("Unknown TypeRestfulInteraction code '"+codeString+"'"); 1122 } 1123 public Enumeration<TypeRestfulInteraction> fromType(Base code) throws FHIRException { 1124 if (code == null) 1125 return null; 1126 if (code.isEmpty()) 1127 return new Enumeration<TypeRestfulInteraction>(this); 1128 String codeString = ((PrimitiveType) code).asStringValue(); 1129 if (codeString == null || "".equals(codeString)) 1130 return null; 1131 if ("read".equals(codeString)) 1132 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.READ); 1133 if ("vread".equals(codeString)) 1134 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.VREAD); 1135 if ("update".equals(codeString)) 1136 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.UPDATE); 1137 if ("patch".equals(codeString)) 1138 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.PATCH); 1139 if ("delete".equals(codeString)) 1140 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.DELETE); 1141 if ("history-instance".equals(codeString)) 1142 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.HISTORYINSTANCE); 1143 if ("history-type".equals(codeString)) 1144 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.HISTORYTYPE); 1145 if ("create".equals(codeString)) 1146 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.CREATE); 1147 if ("search-type".equals(codeString)) 1148 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.SEARCHTYPE); 1149 throw new FHIRException("Unknown TypeRestfulInteraction code '"+codeString+"'"); 1150 } 1151 public String toCode(TypeRestfulInteraction code) { 1152 if (code == TypeRestfulInteraction.READ) 1153 return "read"; 1154 if (code == TypeRestfulInteraction.VREAD) 1155 return "vread"; 1156 if (code == TypeRestfulInteraction.UPDATE) 1157 return "update"; 1158 if (code == TypeRestfulInteraction.PATCH) 1159 return "patch"; 1160 if (code == TypeRestfulInteraction.DELETE) 1161 return "delete"; 1162 if (code == TypeRestfulInteraction.HISTORYINSTANCE) 1163 return "history-instance"; 1164 if (code == TypeRestfulInteraction.HISTORYTYPE) 1165 return "history-type"; 1166 if (code == TypeRestfulInteraction.CREATE) 1167 return "create"; 1168 if (code == TypeRestfulInteraction.SEARCHTYPE) 1169 return "search-type"; 1170 return "?"; 1171 } 1172 public String toSystem(TypeRestfulInteraction code) { 1173 return code.getSystem(); 1174 } 1175 } 1176 1177 @Block() 1178 public static class CapabilityStatementSoftwareComponent extends BackboneElement implements IBaseBackboneElement { 1179 /** 1180 * Name the software is known by. 1181 */ 1182 @Child(name = "name", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true) 1183 @Description(shortDefinition="A name the software is known by", formalDefinition="Name the software is known by." ) 1184 protected StringType name; 1185 1186 /** 1187 * The version identifier for the software covered by this statement. 1188 */ 1189 @Child(name = "version", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true) 1190 @Description(shortDefinition="Version covered by this statement", formalDefinition="The version identifier for the software covered by this statement." ) 1191 protected StringType version; 1192 1193 /** 1194 * Date this version of the software was released. 1195 */ 1196 @Child(name = "releaseDate", type = {DateTimeType.class}, order=3, min=0, max=1, modifier=false, summary=true) 1197 @Description(shortDefinition="Date this version was released", formalDefinition="Date this version of the software was released." ) 1198 protected DateTimeType releaseDate; 1199 1200 private static final long serialVersionUID = 1819769027L; 1201 1202 /** 1203 * Constructor 1204 */ 1205 public CapabilityStatementSoftwareComponent() { 1206 super(); 1207 } 1208 1209 /** 1210 * Constructor 1211 */ 1212 public CapabilityStatementSoftwareComponent(String name) { 1213 super(); 1214 this.setName(name); 1215 } 1216 1217 /** 1218 * @return {@link #name} (Name the software is known by.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value 1219 */ 1220 public StringType getNameElement() { 1221 if (this.name == null) 1222 if (Configuration.errorOnAutoCreate()) 1223 throw new Error("Attempt to auto-create CapabilityStatementSoftwareComponent.name"); 1224 else if (Configuration.doAutoCreate()) 1225 this.name = new StringType(); // bb 1226 return this.name; 1227 } 1228 1229 public boolean hasNameElement() { 1230 return this.name != null && !this.name.isEmpty(); 1231 } 1232 1233 public boolean hasName() { 1234 return this.name != null && !this.name.isEmpty(); 1235 } 1236 1237 /** 1238 * @param value {@link #name} (Name the software is known by.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value 1239 */ 1240 public CapabilityStatementSoftwareComponent setNameElement(StringType value) { 1241 this.name = value; 1242 return this; 1243 } 1244 1245 /** 1246 * @return Name the software is known by. 1247 */ 1248 public String getName() { 1249 return this.name == null ? null : this.name.getValue(); 1250 } 1251 1252 /** 1253 * @param value Name the software is known by. 1254 */ 1255 public CapabilityStatementSoftwareComponent setName(String value) { 1256 if (this.name == null) 1257 this.name = new StringType(); 1258 this.name.setValue(value); 1259 return this; 1260 } 1261 1262 /** 1263 * @return {@link #version} (The version identifier for the software covered by this statement.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value 1264 */ 1265 public StringType getVersionElement() { 1266 if (this.version == null) 1267 if (Configuration.errorOnAutoCreate()) 1268 throw new Error("Attempt to auto-create CapabilityStatementSoftwareComponent.version"); 1269 else if (Configuration.doAutoCreate()) 1270 this.version = new StringType(); // bb 1271 return this.version; 1272 } 1273 1274 public boolean hasVersionElement() { 1275 return this.version != null && !this.version.isEmpty(); 1276 } 1277 1278 public boolean hasVersion() { 1279 return this.version != null && !this.version.isEmpty(); 1280 } 1281 1282 /** 1283 * @param value {@link #version} (The version identifier for the software covered by this statement.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value 1284 */ 1285 public CapabilityStatementSoftwareComponent setVersionElement(StringType value) { 1286 this.version = value; 1287 return this; 1288 } 1289 1290 /** 1291 * @return The version identifier for the software covered by this statement. 1292 */ 1293 public String getVersion() { 1294 return this.version == null ? null : this.version.getValue(); 1295 } 1296 1297 /** 1298 * @param value The version identifier for the software covered by this statement. 1299 */ 1300 public CapabilityStatementSoftwareComponent setVersion(String value) { 1301 if (Utilities.noString(value)) 1302 this.version = null; 1303 else { 1304 if (this.version == null) 1305 this.version = new StringType(); 1306 this.version.setValue(value); 1307 } 1308 return this; 1309 } 1310 1311 /** 1312 * @return {@link #releaseDate} (Date this version of the software was released.). This is the underlying object with id, value and extensions. The accessor "getReleaseDate" gives direct access to the value 1313 */ 1314 public DateTimeType getReleaseDateElement() { 1315 if (this.releaseDate == null) 1316 if (Configuration.errorOnAutoCreate()) 1317 throw new Error("Attempt to auto-create CapabilityStatementSoftwareComponent.releaseDate"); 1318 else if (Configuration.doAutoCreate()) 1319 this.releaseDate = new DateTimeType(); // bb 1320 return this.releaseDate; 1321 } 1322 1323 public boolean hasReleaseDateElement() { 1324 return this.releaseDate != null && !this.releaseDate.isEmpty(); 1325 } 1326 1327 public boolean hasReleaseDate() { 1328 return this.releaseDate != null && !this.releaseDate.isEmpty(); 1329 } 1330 1331 /** 1332 * @param value {@link #releaseDate} (Date this version of the software was released.). This is the underlying object with id, value and extensions. The accessor "getReleaseDate" gives direct access to the value 1333 */ 1334 public CapabilityStatementSoftwareComponent setReleaseDateElement(DateTimeType value) { 1335 this.releaseDate = value; 1336 return this; 1337 } 1338 1339 /** 1340 * @return Date this version of the software was released. 1341 */ 1342 public Date getReleaseDate() { 1343 return this.releaseDate == null ? null : this.releaseDate.getValue(); 1344 } 1345 1346 /** 1347 * @param value Date this version of the software was released. 1348 */ 1349 public CapabilityStatementSoftwareComponent setReleaseDate(Date value) { 1350 if (value == null) 1351 this.releaseDate = null; 1352 else { 1353 if (this.releaseDate == null) 1354 this.releaseDate = new DateTimeType(); 1355 this.releaseDate.setValue(value); 1356 } 1357 return this; 1358 } 1359 1360 protected void listChildren(List<Property> children) { 1361 super.listChildren(children); 1362 children.add(new Property("name", "string", "Name the software is known by.", 0, 1, name)); 1363 children.add(new Property("version", "string", "The version identifier for the software covered by this statement.", 0, 1, version)); 1364 children.add(new Property("releaseDate", "dateTime", "Date this version of the software was released.", 0, 1, releaseDate)); 1365 } 1366 1367 @Override 1368 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1369 switch (_hash) { 1370 case 3373707: /*name*/ return new Property("name", "string", "Name the software is known by.", 0, 1, name); 1371 case 351608024: /*version*/ return new Property("version", "string", "The version identifier for the software covered by this statement.", 0, 1, version); 1372 case 212873301: /*releaseDate*/ return new Property("releaseDate", "dateTime", "Date this version of the software was released.", 0, 1, releaseDate); 1373 default: return super.getNamedProperty(_hash, _name, _checkValid); 1374 } 1375 1376 } 1377 1378 @Override 1379 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1380 switch (hash) { 1381 case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType 1382 case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType 1383 case 212873301: /*releaseDate*/ return this.releaseDate == null ? new Base[0] : new Base[] {this.releaseDate}; // DateTimeType 1384 default: return super.getProperty(hash, name, checkValid); 1385 } 1386 1387 } 1388 1389 @Override 1390 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1391 switch (hash) { 1392 case 3373707: // name 1393 this.name = TypeConvertor.castToString(value); // StringType 1394 return value; 1395 case 351608024: // version 1396 this.version = TypeConvertor.castToString(value); // StringType 1397 return value; 1398 case 212873301: // releaseDate 1399 this.releaseDate = TypeConvertor.castToDateTime(value); // DateTimeType 1400 return value; 1401 default: return super.setProperty(hash, name, value); 1402 } 1403 1404 } 1405 1406 @Override 1407 public Base setProperty(String name, Base value) throws FHIRException { 1408 if (name.equals("name")) { 1409 this.name = TypeConvertor.castToString(value); // StringType 1410 } else if (name.equals("version")) { 1411 this.version = TypeConvertor.castToString(value); // StringType 1412 } else if (name.equals("releaseDate")) { 1413 this.releaseDate = TypeConvertor.castToDateTime(value); // DateTimeType 1414 } else 1415 return super.setProperty(name, value); 1416 return value; 1417 } 1418 1419 @Override 1420 public Base makeProperty(int hash, String name) throws FHIRException { 1421 switch (hash) { 1422 case 3373707: return getNameElement(); 1423 case 351608024: return getVersionElement(); 1424 case 212873301: return getReleaseDateElement(); 1425 default: return super.makeProperty(hash, name); 1426 } 1427 1428 } 1429 1430 @Override 1431 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1432 switch (hash) { 1433 case 3373707: /*name*/ return new String[] {"string"}; 1434 case 351608024: /*version*/ return new String[] {"string"}; 1435 case 212873301: /*releaseDate*/ return new String[] {"dateTime"}; 1436 default: return super.getTypesForProperty(hash, name); 1437 } 1438 1439 } 1440 1441 @Override 1442 public Base addChild(String name) throws FHIRException { 1443 if (name.equals("name")) { 1444 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.software.name"); 1445 } 1446 else if (name.equals("version")) { 1447 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.software.version"); 1448 } 1449 else if (name.equals("releaseDate")) { 1450 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.software.releaseDate"); 1451 } 1452 else 1453 return super.addChild(name); 1454 } 1455 1456 public CapabilityStatementSoftwareComponent copy() { 1457 CapabilityStatementSoftwareComponent dst = new CapabilityStatementSoftwareComponent(); 1458 copyValues(dst); 1459 return dst; 1460 } 1461 1462 public void copyValues(CapabilityStatementSoftwareComponent dst) { 1463 super.copyValues(dst); 1464 dst.name = name == null ? null : name.copy(); 1465 dst.version = version == null ? null : version.copy(); 1466 dst.releaseDate = releaseDate == null ? null : releaseDate.copy(); 1467 } 1468 1469 @Override 1470 public boolean equalsDeep(Base other_) { 1471 if (!super.equalsDeep(other_)) 1472 return false; 1473 if (!(other_ instanceof CapabilityStatementSoftwareComponent)) 1474 return false; 1475 CapabilityStatementSoftwareComponent o = (CapabilityStatementSoftwareComponent) other_; 1476 return compareDeep(name, o.name, true) && compareDeep(version, o.version, true) && compareDeep(releaseDate, o.releaseDate, true) 1477 ; 1478 } 1479 1480 @Override 1481 public boolean equalsShallow(Base other_) { 1482 if (!super.equalsShallow(other_)) 1483 return false; 1484 if (!(other_ instanceof CapabilityStatementSoftwareComponent)) 1485 return false; 1486 CapabilityStatementSoftwareComponent o = (CapabilityStatementSoftwareComponent) other_; 1487 return compareValues(name, o.name, true) && compareValues(version, o.version, true) && compareValues(releaseDate, o.releaseDate, true) 1488 ; 1489 } 1490 1491 public boolean isEmpty() { 1492 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, version, releaseDate 1493 ); 1494 } 1495 1496 public String fhirType() { 1497 return "CapabilityStatement.software"; 1498 1499 } 1500 1501 } 1502 1503 @Block() 1504 public static class CapabilityStatementImplementationComponent extends BackboneElement implements IBaseBackboneElement { 1505 /** 1506 * Information about the specific installation that this capability statement relates to. 1507 */ 1508 @Child(name = "description", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true) 1509 @Description(shortDefinition="Describes this specific instance", formalDefinition="Information about the specific installation that this capability statement relates to." ) 1510 protected StringType description; 1511 1512 /** 1513 * An absolute base URL for the implementation. This forms the base for REST interfaces as well as the mailbox and document interfaces. 1514 */ 1515 @Child(name = "url", type = {UrlType.class}, order=2, min=0, max=1, modifier=false, summary=true) 1516 @Description(shortDefinition="Base URL for the installation", formalDefinition="An absolute base URL for the implementation. This forms the base for REST interfaces as well as the mailbox and document interfaces." ) 1517 protected UrlType url; 1518 1519 /** 1520 * The organization responsible for the management of the instance and oversight of the data on the server at the specified URL. 1521 */ 1522 @Child(name = "custodian", type = {Organization.class}, order=3, min=0, max=1, modifier=false, summary=true) 1523 @Description(shortDefinition="Organization that manages the data", formalDefinition="The organization responsible for the management of the instance and oversight of the data on the server at the specified URL." ) 1524 protected Reference custodian; 1525 1526 private static final long serialVersionUID = 1681322786L; 1527 1528 /** 1529 * Constructor 1530 */ 1531 public CapabilityStatementImplementationComponent() { 1532 super(); 1533 } 1534 1535 /** 1536 * Constructor 1537 */ 1538 public CapabilityStatementImplementationComponent(String description) { 1539 super(); 1540 this.setDescription(description); 1541 } 1542 1543 /** 1544 * @return {@link #description} (Information about the specific installation that this capability statement relates to.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 1545 */ 1546 public StringType getDescriptionElement() { 1547 if (this.description == null) 1548 if (Configuration.errorOnAutoCreate()) 1549 throw new Error("Attempt to auto-create CapabilityStatementImplementationComponent.description"); 1550 else if (Configuration.doAutoCreate()) 1551 this.description = new StringType(); // bb 1552 return this.description; 1553 } 1554 1555 public boolean hasDescriptionElement() { 1556 return this.description != null && !this.description.isEmpty(); 1557 } 1558 1559 public boolean hasDescription() { 1560 return this.description != null && !this.description.isEmpty(); 1561 } 1562 1563 /** 1564 * @param value {@link #description} (Information about the specific installation that this capability statement relates to.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 1565 */ 1566 public CapabilityStatementImplementationComponent setDescriptionElement(StringType value) { 1567 this.description = value; 1568 return this; 1569 } 1570 1571 /** 1572 * @return Information about the specific installation that this capability statement relates to. 1573 */ 1574 public String getDescription() { 1575 return this.description == null ? null : this.description.getValue(); 1576 } 1577 1578 /** 1579 * @param value Information about the specific installation that this capability statement relates to. 1580 */ 1581 public CapabilityStatementImplementationComponent setDescription(String value) { 1582 if (this.description == null) 1583 this.description = new StringType(); 1584 this.description.setValue(value); 1585 return this; 1586 } 1587 1588 /** 1589 * @return {@link #url} (An absolute base URL for the implementation. This forms the base for REST interfaces as well as the mailbox and document interfaces.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value 1590 */ 1591 public UrlType getUrlElement() { 1592 if (this.url == null) 1593 if (Configuration.errorOnAutoCreate()) 1594 throw new Error("Attempt to auto-create CapabilityStatementImplementationComponent.url"); 1595 else if (Configuration.doAutoCreate()) 1596 this.url = new UrlType(); // bb 1597 return this.url; 1598 } 1599 1600 public boolean hasUrlElement() { 1601 return this.url != null && !this.url.isEmpty(); 1602 } 1603 1604 public boolean hasUrl() { 1605 return this.url != null && !this.url.isEmpty(); 1606 } 1607 1608 /** 1609 * @param value {@link #url} (An absolute base URL for the implementation. This forms the base for REST interfaces as well as the mailbox and document interfaces.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value 1610 */ 1611 public CapabilityStatementImplementationComponent setUrlElement(UrlType value) { 1612 this.url = value; 1613 return this; 1614 } 1615 1616 /** 1617 * @return An absolute base URL for the implementation. This forms the base for REST interfaces as well as the mailbox and document interfaces. 1618 */ 1619 public String getUrl() { 1620 return this.url == null ? null : this.url.getValue(); 1621 } 1622 1623 /** 1624 * @param value An absolute base URL for the implementation. This forms the base for REST interfaces as well as the mailbox and document interfaces. 1625 */ 1626 public CapabilityStatementImplementationComponent setUrl(String value) { 1627 if (Utilities.noString(value)) 1628 this.url = null; 1629 else { 1630 if (this.url == null) 1631 this.url = new UrlType(); 1632 this.url.setValue(value); 1633 } 1634 return this; 1635 } 1636 1637 /** 1638 * @return {@link #custodian} (The organization responsible for the management of the instance and oversight of the data on the server at the specified URL.) 1639 */ 1640 public Reference getCustodian() { 1641 if (this.custodian == null) 1642 if (Configuration.errorOnAutoCreate()) 1643 throw new Error("Attempt to auto-create CapabilityStatementImplementationComponent.custodian"); 1644 else if (Configuration.doAutoCreate()) 1645 this.custodian = new Reference(); // cc 1646 return this.custodian; 1647 } 1648 1649 public boolean hasCustodian() { 1650 return this.custodian != null && !this.custodian.isEmpty(); 1651 } 1652 1653 /** 1654 * @param value {@link #custodian} (The organization responsible for the management of the instance and oversight of the data on the server at the specified URL.) 1655 */ 1656 public CapabilityStatementImplementationComponent setCustodian(Reference value) { 1657 this.custodian = value; 1658 return this; 1659 } 1660 1661 protected void listChildren(List<Property> children) { 1662 super.listChildren(children); 1663 children.add(new Property("description", "string", "Information about the specific installation that this capability statement relates to.", 0, 1, description)); 1664 children.add(new Property("url", "url", "An absolute base URL for the implementation. This forms the base for REST interfaces as well as the mailbox and document interfaces.", 0, 1, url)); 1665 children.add(new Property("custodian", "Reference(Organization)", "The organization responsible for the management of the instance and oversight of the data on the server at the specified URL.", 0, 1, custodian)); 1666 } 1667 1668 @Override 1669 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1670 switch (_hash) { 1671 case -1724546052: /*description*/ return new Property("description", "string", "Information about the specific installation that this capability statement relates to.", 0, 1, description); 1672 case 116079: /*url*/ return new Property("url", "url", "An absolute base URL for the implementation. This forms the base for REST interfaces as well as the mailbox and document interfaces.", 0, 1, url); 1673 case 1611297262: /*custodian*/ return new Property("custodian", "Reference(Organization)", "The organization responsible for the management of the instance and oversight of the data on the server at the specified URL.", 0, 1, custodian); 1674 default: return super.getNamedProperty(_hash, _name, _checkValid); 1675 } 1676 1677 } 1678 1679 @Override 1680 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1681 switch (hash) { 1682 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType 1683 case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UrlType 1684 case 1611297262: /*custodian*/ return this.custodian == null ? new Base[0] : new Base[] {this.custodian}; // Reference 1685 default: return super.getProperty(hash, name, checkValid); 1686 } 1687 1688 } 1689 1690 @Override 1691 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1692 switch (hash) { 1693 case -1724546052: // description 1694 this.description = TypeConvertor.castToString(value); // StringType 1695 return value; 1696 case 116079: // url 1697 this.url = TypeConvertor.castToUrl(value); // UrlType 1698 return value; 1699 case 1611297262: // custodian 1700 this.custodian = TypeConvertor.castToReference(value); // Reference 1701 return value; 1702 default: return super.setProperty(hash, name, value); 1703 } 1704 1705 } 1706 1707 @Override 1708 public Base setProperty(String name, Base value) throws FHIRException { 1709 if (name.equals("description")) { 1710 this.description = TypeConvertor.castToString(value); // StringType 1711 } else if (name.equals("url")) { 1712 this.url = TypeConvertor.castToUrl(value); // UrlType 1713 } else if (name.equals("custodian")) { 1714 this.custodian = TypeConvertor.castToReference(value); // Reference 1715 } else 1716 return super.setProperty(name, value); 1717 return value; 1718 } 1719 1720 @Override 1721 public Base makeProperty(int hash, String name) throws FHIRException { 1722 switch (hash) { 1723 case -1724546052: return getDescriptionElement(); 1724 case 116079: return getUrlElement(); 1725 case 1611297262: return getCustodian(); 1726 default: return super.makeProperty(hash, name); 1727 } 1728 1729 } 1730 1731 @Override 1732 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1733 switch (hash) { 1734 case -1724546052: /*description*/ return new String[] {"string"}; 1735 case 116079: /*url*/ return new String[] {"url"}; 1736 case 1611297262: /*custodian*/ return new String[] {"Reference"}; 1737 default: return super.getTypesForProperty(hash, name); 1738 } 1739 1740 } 1741 1742 @Override 1743 public Base addChild(String name) throws FHIRException { 1744 if (name.equals("description")) { 1745 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.implementation.description"); 1746 } 1747 else if (name.equals("url")) { 1748 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.implementation.url"); 1749 } 1750 else if (name.equals("custodian")) { 1751 this.custodian = new Reference(); 1752 return this.custodian; 1753 } 1754 else 1755 return super.addChild(name); 1756 } 1757 1758 public CapabilityStatementImplementationComponent copy() { 1759 CapabilityStatementImplementationComponent dst = new CapabilityStatementImplementationComponent(); 1760 copyValues(dst); 1761 return dst; 1762 } 1763 1764 public void copyValues(CapabilityStatementImplementationComponent dst) { 1765 super.copyValues(dst); 1766 dst.description = description == null ? null : description.copy(); 1767 dst.url = url == null ? null : url.copy(); 1768 dst.custodian = custodian == null ? null : custodian.copy(); 1769 } 1770 1771 @Override 1772 public boolean equalsDeep(Base other_) { 1773 if (!super.equalsDeep(other_)) 1774 return false; 1775 if (!(other_ instanceof CapabilityStatementImplementationComponent)) 1776 return false; 1777 CapabilityStatementImplementationComponent o = (CapabilityStatementImplementationComponent) other_; 1778 return compareDeep(description, o.description, true) && compareDeep(url, o.url, true) && compareDeep(custodian, o.custodian, true) 1779 ; 1780 } 1781 1782 @Override 1783 public boolean equalsShallow(Base other_) { 1784 if (!super.equalsShallow(other_)) 1785 return false; 1786 if (!(other_ instanceof CapabilityStatementImplementationComponent)) 1787 return false; 1788 CapabilityStatementImplementationComponent o = (CapabilityStatementImplementationComponent) other_; 1789 return compareValues(description, o.description, true) && compareValues(url, o.url, true); 1790 } 1791 1792 public boolean isEmpty() { 1793 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(description, url, custodian 1794 ); 1795 } 1796 1797 public String fhirType() { 1798 return "CapabilityStatement.implementation"; 1799 1800 } 1801 1802 } 1803 1804 @Block() 1805 public static class CapabilityStatementRestComponent extends BackboneElement implements IBaseBackboneElement { 1806 /** 1807 * Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations. 1808 */ 1809 @Child(name = "mode", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true) 1810 @Description(shortDefinition="client | server", formalDefinition="Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations." ) 1811 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/restful-capability-mode") 1812 protected Enumeration<RestfulCapabilityMode> mode; 1813 1814 /** 1815 * Information about the system's restful capabilities that apply across all applications, such as security. 1816 */ 1817 @Child(name = "documentation", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=false) 1818 @Description(shortDefinition="General description of implementation", formalDefinition="Information about the system's restful capabilities that apply across all applications, such as security." ) 1819 protected MarkdownType documentation; 1820 1821 /** 1822 * Information about security implementation from an interface perspective - what a client needs to know. 1823 */ 1824 @Child(name = "security", type = {}, order=3, min=0, max=1, modifier=false, summary=true) 1825 @Description(shortDefinition="Information about security of implementation", formalDefinition="Information about security implementation from an interface perspective - what a client needs to know." ) 1826 protected CapabilityStatementRestSecurityComponent security; 1827 1828 /** 1829 * A specification of the restful capabilities of the solution for a specific resource type. 1830 */ 1831 @Child(name = "resource", type = {}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 1832 @Description(shortDefinition="Resource served on the REST interface", formalDefinition="A specification of the restful capabilities of the solution for a specific resource type." ) 1833 protected List<CapabilityStatementRestResourceComponent> resource; 1834 1835 /** 1836 * A specification of restful operations supported by the system. 1837 */ 1838 @Child(name = "interaction", type = {}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1839 @Description(shortDefinition="What operations are supported?", formalDefinition="A specification of restful operations supported by the system." ) 1840 protected List<SystemInteractionComponent> interaction; 1841 1842 /** 1843 * Search parameters that are supported for searching all resources for implementations to support and/or make use of - either references to ones defined in the specification, or additional ones defined for/by the implementation. 1844 */ 1845 @Child(name = "searchParam", type = {CapabilityStatementRestResourceSearchParamComponent.class}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1846 @Description(shortDefinition="Search parameters for searching all resources", formalDefinition="Search parameters that are supported for searching all resources for implementations to support and/or make use of - either references to ones defined in the specification, or additional ones defined for/by the implementation." ) 1847 protected List<CapabilityStatementRestResourceSearchParamComponent> searchParam; 1848 1849 /** 1850 * Definition of an operation or a named query together with its parameters and their meaning and type. 1851 */ 1852 @Child(name = "operation", type = {CapabilityStatementRestResourceOperationComponent.class}, order=7, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 1853 @Description(shortDefinition="Definition of a system level operation", formalDefinition="Definition of an operation or a named query together with its parameters and their meaning and type." ) 1854 protected List<CapabilityStatementRestResourceOperationComponent> operation; 1855 1856 /** 1857 * An absolute URI which is a reference to the definition of a compartment that the system supports. The reference is to a CompartmentDefinition resource by its canonical URL . 1858 */ 1859 @Child(name = "compartment", type = {CanonicalType.class}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1860 @Description(shortDefinition="Compartments served/used by system", formalDefinition="An absolute URI which is a reference to the definition of a compartment that the system supports. The reference is to a CompartmentDefinition resource by its canonical URL ." ) 1861 protected List<CanonicalType> compartment; 1862 1863 private static final long serialVersionUID = -1442029817L; 1864 1865 /** 1866 * Constructor 1867 */ 1868 public CapabilityStatementRestComponent() { 1869 super(); 1870 } 1871 1872 /** 1873 * Constructor 1874 */ 1875 public CapabilityStatementRestComponent(RestfulCapabilityMode mode) { 1876 super(); 1877 this.setMode(mode); 1878 } 1879 1880 /** 1881 * @return {@link #mode} (Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations.). This is the underlying object with id, value and extensions. The accessor "getMode" gives direct access to the value 1882 */ 1883 public Enumeration<RestfulCapabilityMode> getModeElement() { 1884 if (this.mode == null) 1885 if (Configuration.errorOnAutoCreate()) 1886 throw new Error("Attempt to auto-create CapabilityStatementRestComponent.mode"); 1887 else if (Configuration.doAutoCreate()) 1888 this.mode = new Enumeration<RestfulCapabilityMode>(new RestfulCapabilityModeEnumFactory()); // bb 1889 return this.mode; 1890 } 1891 1892 public boolean hasModeElement() { 1893 return this.mode != null && !this.mode.isEmpty(); 1894 } 1895 1896 public boolean hasMode() { 1897 return this.mode != null && !this.mode.isEmpty(); 1898 } 1899 1900 /** 1901 * @param value {@link #mode} (Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations.). This is the underlying object with id, value and extensions. The accessor "getMode" gives direct access to the value 1902 */ 1903 public CapabilityStatementRestComponent setModeElement(Enumeration<RestfulCapabilityMode> value) { 1904 this.mode = value; 1905 return this; 1906 } 1907 1908 /** 1909 * @return Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations. 1910 */ 1911 public RestfulCapabilityMode getMode() { 1912 return this.mode == null ? null : this.mode.getValue(); 1913 } 1914 1915 /** 1916 * @param value Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations. 1917 */ 1918 public CapabilityStatementRestComponent setMode(RestfulCapabilityMode value) { 1919 if (this.mode == null) 1920 this.mode = new Enumeration<RestfulCapabilityMode>(new RestfulCapabilityModeEnumFactory()); 1921 this.mode.setValue(value); 1922 return this; 1923 } 1924 1925 /** 1926 * @return {@link #documentation} (Information about the system's restful capabilities that apply across all applications, such as security.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value 1927 */ 1928 public MarkdownType getDocumentationElement() { 1929 if (this.documentation == null) 1930 if (Configuration.errorOnAutoCreate()) 1931 throw new Error("Attempt to auto-create CapabilityStatementRestComponent.documentation"); 1932 else if (Configuration.doAutoCreate()) 1933 this.documentation = new MarkdownType(); // bb 1934 return this.documentation; 1935 } 1936 1937 public boolean hasDocumentationElement() { 1938 return this.documentation != null && !this.documentation.isEmpty(); 1939 } 1940 1941 public boolean hasDocumentation() { 1942 return this.documentation != null && !this.documentation.isEmpty(); 1943 } 1944 1945 /** 1946 * @param value {@link #documentation} (Information about the system's restful capabilities that apply across all applications, such as security.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value 1947 */ 1948 public CapabilityStatementRestComponent setDocumentationElement(MarkdownType value) { 1949 this.documentation = value; 1950 return this; 1951 } 1952 1953 /** 1954 * @return Information about the system's restful capabilities that apply across all applications, such as security. 1955 */ 1956 public String getDocumentation() { 1957 return this.documentation == null ? null : this.documentation.getValue(); 1958 } 1959 1960 /** 1961 * @param value Information about the system's restful capabilities that apply across all applications, such as security. 1962 */ 1963 public CapabilityStatementRestComponent setDocumentation(String value) { 1964 if (value == null) 1965 this.documentation = null; 1966 else { 1967 if (this.documentation == null) 1968 this.documentation = new MarkdownType(); 1969 this.documentation.setValue(value); 1970 } 1971 return this; 1972 } 1973 1974 /** 1975 * @return {@link #security} (Information about security implementation from an interface perspective - what a client needs to know.) 1976 */ 1977 public CapabilityStatementRestSecurityComponent getSecurity() { 1978 if (this.security == null) 1979 if (Configuration.errorOnAutoCreate()) 1980 throw new Error("Attempt to auto-create CapabilityStatementRestComponent.security"); 1981 else if (Configuration.doAutoCreate()) 1982 this.security = new CapabilityStatementRestSecurityComponent(); // cc 1983 return this.security; 1984 } 1985 1986 public boolean hasSecurity() { 1987 return this.security != null && !this.security.isEmpty(); 1988 } 1989 1990 /** 1991 * @param value {@link #security} (Information about security implementation from an interface perspective - what a client needs to know.) 1992 */ 1993 public CapabilityStatementRestComponent setSecurity(CapabilityStatementRestSecurityComponent value) { 1994 this.security = value; 1995 return this; 1996 } 1997 1998 /** 1999 * @return {@link #resource} (A specification of the restful capabilities of the solution for a specific resource type.) 2000 */ 2001 public List<CapabilityStatementRestResourceComponent> getResource() { 2002 if (this.resource == null) 2003 this.resource = new ArrayList<CapabilityStatementRestResourceComponent>(); 2004 return this.resource; 2005 } 2006 2007 /** 2008 * @return Returns a reference to <code>this</code> for easy method chaining 2009 */ 2010 public CapabilityStatementRestComponent setResource(List<CapabilityStatementRestResourceComponent> theResource) { 2011 this.resource = theResource; 2012 return this; 2013 } 2014 2015 public boolean hasResource() { 2016 if (this.resource == null) 2017 return false; 2018 for (CapabilityStatementRestResourceComponent item : this.resource) 2019 if (!item.isEmpty()) 2020 return true; 2021 return false; 2022 } 2023 2024 public CapabilityStatementRestResourceComponent addResource() { //3 2025 CapabilityStatementRestResourceComponent t = new CapabilityStatementRestResourceComponent(); 2026 if (this.resource == null) 2027 this.resource = new ArrayList<CapabilityStatementRestResourceComponent>(); 2028 this.resource.add(t); 2029 return t; 2030 } 2031 2032 public CapabilityStatementRestComponent addResource(CapabilityStatementRestResourceComponent t) { //3 2033 if (t == null) 2034 return this; 2035 if (this.resource == null) 2036 this.resource = new ArrayList<CapabilityStatementRestResourceComponent>(); 2037 this.resource.add(t); 2038 return this; 2039 } 2040 2041 /** 2042 * @return The first repetition of repeating field {@link #resource}, creating it if it does not already exist {3} 2043 */ 2044 public CapabilityStatementRestResourceComponent getResourceFirstRep() { 2045 if (getResource().isEmpty()) { 2046 addResource(); 2047 } 2048 return getResource().get(0); 2049 } 2050 2051 /** 2052 * @return {@link #interaction} (A specification of restful operations supported by the system.) 2053 */ 2054 public List<SystemInteractionComponent> getInteraction() { 2055 if (this.interaction == null) 2056 this.interaction = new ArrayList<SystemInteractionComponent>(); 2057 return this.interaction; 2058 } 2059 2060 /** 2061 * @return Returns a reference to <code>this</code> for easy method chaining 2062 */ 2063 public CapabilityStatementRestComponent setInteraction(List<SystemInteractionComponent> theInteraction) { 2064 this.interaction = theInteraction; 2065 return this; 2066 } 2067 2068 public boolean hasInteraction() { 2069 if (this.interaction == null) 2070 return false; 2071 for (SystemInteractionComponent item : this.interaction) 2072 if (!item.isEmpty()) 2073 return true; 2074 return false; 2075 } 2076 2077 public SystemInteractionComponent addInteraction() { //3 2078 SystemInteractionComponent t = new SystemInteractionComponent(); 2079 if (this.interaction == null) 2080 this.interaction = new ArrayList<SystemInteractionComponent>(); 2081 this.interaction.add(t); 2082 return t; 2083 } 2084 2085 public CapabilityStatementRestComponent addInteraction(SystemInteractionComponent t) { //3 2086 if (t == null) 2087 return this; 2088 if (this.interaction == null) 2089 this.interaction = new ArrayList<SystemInteractionComponent>(); 2090 this.interaction.add(t); 2091 return this; 2092 } 2093 2094 /** 2095 * @return The first repetition of repeating field {@link #interaction}, creating it if it does not already exist {3} 2096 */ 2097 public SystemInteractionComponent getInteractionFirstRep() { 2098 if (getInteraction().isEmpty()) { 2099 addInteraction(); 2100 } 2101 return getInteraction().get(0); 2102 } 2103 2104 /** 2105 * @return {@link #searchParam} (Search parameters that are supported for searching all resources for implementations to support and/or make use of - either references to ones defined in the specification, or additional ones defined for/by the implementation.) 2106 */ 2107 public List<CapabilityStatementRestResourceSearchParamComponent> getSearchParam() { 2108 if (this.searchParam == null) 2109 this.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>(); 2110 return this.searchParam; 2111 } 2112 2113 /** 2114 * @return Returns a reference to <code>this</code> for easy method chaining 2115 */ 2116 public CapabilityStatementRestComponent setSearchParam(List<CapabilityStatementRestResourceSearchParamComponent> theSearchParam) { 2117 this.searchParam = theSearchParam; 2118 return this; 2119 } 2120 2121 public boolean hasSearchParam() { 2122 if (this.searchParam == null) 2123 return false; 2124 for (CapabilityStatementRestResourceSearchParamComponent item : this.searchParam) 2125 if (!item.isEmpty()) 2126 return true; 2127 return false; 2128 } 2129 2130 public CapabilityStatementRestResourceSearchParamComponent addSearchParam() { //3 2131 CapabilityStatementRestResourceSearchParamComponent t = new CapabilityStatementRestResourceSearchParamComponent(); 2132 if (this.searchParam == null) 2133 this.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>(); 2134 this.searchParam.add(t); 2135 return t; 2136 } 2137 2138 public CapabilityStatementRestComponent addSearchParam(CapabilityStatementRestResourceSearchParamComponent t) { //3 2139 if (t == null) 2140 return this; 2141 if (this.searchParam == null) 2142 this.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>(); 2143 this.searchParam.add(t); 2144 return this; 2145 } 2146 2147 /** 2148 * @return The first repetition of repeating field {@link #searchParam}, creating it if it does not already exist {3} 2149 */ 2150 public CapabilityStatementRestResourceSearchParamComponent getSearchParamFirstRep() { 2151 if (getSearchParam().isEmpty()) { 2152 addSearchParam(); 2153 } 2154 return getSearchParam().get(0); 2155 } 2156 2157 /** 2158 * @return {@link #operation} (Definition of an operation or a named query together with its parameters and their meaning and type.) 2159 */ 2160 public List<CapabilityStatementRestResourceOperationComponent> getOperation() { 2161 if (this.operation == null) 2162 this.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>(); 2163 return this.operation; 2164 } 2165 2166 /** 2167 * @return Returns a reference to <code>this</code> for easy method chaining 2168 */ 2169 public CapabilityStatementRestComponent setOperation(List<CapabilityStatementRestResourceOperationComponent> theOperation) { 2170 this.operation = theOperation; 2171 return this; 2172 } 2173 2174 public boolean hasOperation() { 2175 if (this.operation == null) 2176 return false; 2177 for (CapabilityStatementRestResourceOperationComponent item : this.operation) 2178 if (!item.isEmpty()) 2179 return true; 2180 return false; 2181 } 2182 2183 public CapabilityStatementRestResourceOperationComponent addOperation() { //3 2184 CapabilityStatementRestResourceOperationComponent t = new CapabilityStatementRestResourceOperationComponent(); 2185 if (this.operation == null) 2186 this.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>(); 2187 this.operation.add(t); 2188 return t; 2189 } 2190 2191 public CapabilityStatementRestComponent addOperation(CapabilityStatementRestResourceOperationComponent t) { //3 2192 if (t == null) 2193 return this; 2194 if (this.operation == null) 2195 this.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>(); 2196 this.operation.add(t); 2197 return this; 2198 } 2199 2200 /** 2201 * @return The first repetition of repeating field {@link #operation}, creating it if it does not already exist {3} 2202 */ 2203 public CapabilityStatementRestResourceOperationComponent getOperationFirstRep() { 2204 if (getOperation().isEmpty()) { 2205 addOperation(); 2206 } 2207 return getOperation().get(0); 2208 } 2209 2210 /** 2211 * @return {@link #compartment} (An absolute URI which is a reference to the definition of a compartment that the system supports. The reference is to a CompartmentDefinition resource by its canonical URL .) 2212 */ 2213 public List<CanonicalType> getCompartment() { 2214 if (this.compartment == null) 2215 this.compartment = new ArrayList<CanonicalType>(); 2216 return this.compartment; 2217 } 2218 2219 /** 2220 * @return Returns a reference to <code>this</code> for easy method chaining 2221 */ 2222 public CapabilityStatementRestComponent setCompartment(List<CanonicalType> theCompartment) { 2223 this.compartment = theCompartment; 2224 return this; 2225 } 2226 2227 public boolean hasCompartment() { 2228 if (this.compartment == null) 2229 return false; 2230 for (CanonicalType item : this.compartment) 2231 if (!item.isEmpty()) 2232 return true; 2233 return false; 2234 } 2235 2236 /** 2237 * @return {@link #compartment} (An absolute URI which is a reference to the definition of a compartment that the system supports. The reference is to a CompartmentDefinition resource by its canonical URL .) 2238 */ 2239 public CanonicalType addCompartmentElement() {//2 2240 CanonicalType t = new CanonicalType(); 2241 if (this.compartment == null) 2242 this.compartment = new ArrayList<CanonicalType>(); 2243 this.compartment.add(t); 2244 return t; 2245 } 2246 2247 /** 2248 * @param value {@link #compartment} (An absolute URI which is a reference to the definition of a compartment that the system supports. The reference is to a CompartmentDefinition resource by its canonical URL .) 2249 */ 2250 public CapabilityStatementRestComponent addCompartment(String value) { //1 2251 CanonicalType t = new CanonicalType(); 2252 t.setValue(value); 2253 if (this.compartment == null) 2254 this.compartment = new ArrayList<CanonicalType>(); 2255 this.compartment.add(t); 2256 return this; 2257 } 2258 2259 /** 2260 * @param value {@link #compartment} (An absolute URI which is a reference to the definition of a compartment that the system supports. The reference is to a CompartmentDefinition resource by its canonical URL .) 2261 */ 2262 public boolean hasCompartment(String value) { 2263 if (this.compartment == null) 2264 return false; 2265 for (CanonicalType v : this.compartment) 2266 if (v.getValue().equals(value)) // canonical 2267 return true; 2268 return false; 2269 } 2270 2271 protected void listChildren(List<Property> children) { 2272 super.listChildren(children); 2273 children.add(new Property("mode", "code", "Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations.", 0, 1, mode)); 2274 children.add(new Property("documentation", "markdown", "Information about the system's restful capabilities that apply across all applications, such as security.", 0, 1, documentation)); 2275 children.add(new Property("security", "", "Information about security implementation from an interface perspective - what a client needs to know.", 0, 1, security)); 2276 children.add(new Property("resource", "", "A specification of the restful capabilities of the solution for a specific resource type.", 0, java.lang.Integer.MAX_VALUE, resource)); 2277 children.add(new Property("interaction", "", "A specification of restful operations supported by the system.", 0, java.lang.Integer.MAX_VALUE, interaction)); 2278 children.add(new Property("searchParam", "@CapabilityStatement.rest.resource.searchParam", "Search parameters that are supported for searching all resources for implementations to support and/or make use of - either references to ones defined in the specification, or additional ones defined for/by the implementation.", 0, java.lang.Integer.MAX_VALUE, searchParam)); 2279 children.add(new Property("operation", "@CapabilityStatement.rest.resource.operation", "Definition of an operation or a named query together with its parameters and their meaning and type.", 0, java.lang.Integer.MAX_VALUE, operation)); 2280 children.add(new Property("compartment", "canonical(CompartmentDefinition)", "An absolute URI which is a reference to the definition of a compartment that the system supports. The reference is to a CompartmentDefinition resource by its canonical URL .", 0, java.lang.Integer.MAX_VALUE, compartment)); 2281 } 2282 2283 @Override 2284 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 2285 switch (_hash) { 2286 case 3357091: /*mode*/ return new Property("mode", "code", "Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations.", 0, 1, mode); 2287 case 1587405498: /*documentation*/ return new Property("documentation", "markdown", "Information about the system's restful capabilities that apply across all applications, such as security.", 0, 1, documentation); 2288 case 949122880: /*security*/ return new Property("security", "", "Information about security implementation from an interface perspective - what a client needs to know.", 0, 1, security); 2289 case -341064690: /*resource*/ return new Property("resource", "", "A specification of the restful capabilities of the solution for a specific resource type.", 0, java.lang.Integer.MAX_VALUE, resource); 2290 case 1844104722: /*interaction*/ return new Property("interaction", "", "A specification of restful operations supported by the system.", 0, java.lang.Integer.MAX_VALUE, interaction); 2291 case -553645115: /*searchParam*/ return new Property("searchParam", "@CapabilityStatement.rest.resource.searchParam", "Search parameters that are supported for searching all resources for implementations to support and/or make use of - either references to ones defined in the specification, or additional ones defined for/by the implementation.", 0, java.lang.Integer.MAX_VALUE, searchParam); 2292 case 1662702951: /*operation*/ return new Property("operation", "@CapabilityStatement.rest.resource.operation", "Definition of an operation or a named query together with its parameters and their meaning and type.", 0, java.lang.Integer.MAX_VALUE, operation); 2293 case -397756334: /*compartment*/ return new Property("compartment", "canonical(CompartmentDefinition)", "An absolute URI which is a reference to the definition of a compartment that the system supports. The reference is to a CompartmentDefinition resource by its canonical URL .", 0, java.lang.Integer.MAX_VALUE, compartment); 2294 default: return super.getNamedProperty(_hash, _name, _checkValid); 2295 } 2296 2297 } 2298 2299 @Override 2300 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 2301 switch (hash) { 2302 case 3357091: /*mode*/ return this.mode == null ? new Base[0] : new Base[] {this.mode}; // Enumeration<RestfulCapabilityMode> 2303 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 2304 case 949122880: /*security*/ return this.security == null ? new Base[0] : new Base[] {this.security}; // CapabilityStatementRestSecurityComponent 2305 case -341064690: /*resource*/ return this.resource == null ? new Base[0] : this.resource.toArray(new Base[this.resource.size()]); // CapabilityStatementRestResourceComponent 2306 case 1844104722: /*interaction*/ return this.interaction == null ? new Base[0] : this.interaction.toArray(new Base[this.interaction.size()]); // SystemInteractionComponent 2307 case -553645115: /*searchParam*/ return this.searchParam == null ? new Base[0] : this.searchParam.toArray(new Base[this.searchParam.size()]); // CapabilityStatementRestResourceSearchParamComponent 2308 case 1662702951: /*operation*/ return this.operation == null ? new Base[0] : this.operation.toArray(new Base[this.operation.size()]); // CapabilityStatementRestResourceOperationComponent 2309 case -397756334: /*compartment*/ return this.compartment == null ? new Base[0] : this.compartment.toArray(new Base[this.compartment.size()]); // CanonicalType 2310 default: return super.getProperty(hash, name, checkValid); 2311 } 2312 2313 } 2314 2315 @Override 2316 public Base setProperty(int hash, String name, Base value) throws FHIRException { 2317 switch (hash) { 2318 case 3357091: // mode 2319 value = new RestfulCapabilityModeEnumFactory().fromType(TypeConvertor.castToCode(value)); 2320 this.mode = (Enumeration) value; // Enumeration<RestfulCapabilityMode> 2321 return value; 2322 case 1587405498: // documentation 2323 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 2324 return value; 2325 case 949122880: // security 2326 this.security = (CapabilityStatementRestSecurityComponent) value; // CapabilityStatementRestSecurityComponent 2327 return value; 2328 case -341064690: // resource 2329 this.getResource().add((CapabilityStatementRestResourceComponent) value); // CapabilityStatementRestResourceComponent 2330 return value; 2331 case 1844104722: // interaction 2332 this.getInteraction().add((SystemInteractionComponent) value); // SystemInteractionComponent 2333 return value; 2334 case -553645115: // searchParam 2335 this.getSearchParam().add((CapabilityStatementRestResourceSearchParamComponent) value); // CapabilityStatementRestResourceSearchParamComponent 2336 return value; 2337 case 1662702951: // operation 2338 this.getOperation().add((CapabilityStatementRestResourceOperationComponent) value); // CapabilityStatementRestResourceOperationComponent 2339 return value; 2340 case -397756334: // compartment 2341 this.getCompartment().add(TypeConvertor.castToCanonical(value)); // CanonicalType 2342 return value; 2343 default: return super.setProperty(hash, name, value); 2344 } 2345 2346 } 2347 2348 @Override 2349 public Base setProperty(String name, Base value) throws FHIRException { 2350 if (name.equals("mode")) { 2351 value = new RestfulCapabilityModeEnumFactory().fromType(TypeConvertor.castToCode(value)); 2352 this.mode = (Enumeration) value; // Enumeration<RestfulCapabilityMode> 2353 } else if (name.equals("documentation")) { 2354 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 2355 } else if (name.equals("security")) { 2356 this.security = (CapabilityStatementRestSecurityComponent) value; // CapabilityStatementRestSecurityComponent 2357 } else if (name.equals("resource")) { 2358 this.getResource().add((CapabilityStatementRestResourceComponent) value); 2359 } else if (name.equals("interaction")) { 2360 this.getInteraction().add((SystemInteractionComponent) value); 2361 } else if (name.equals("searchParam")) { 2362 this.getSearchParam().add((CapabilityStatementRestResourceSearchParamComponent) value); 2363 } else if (name.equals("operation")) { 2364 this.getOperation().add((CapabilityStatementRestResourceOperationComponent) value); 2365 } else if (name.equals("compartment")) { 2366 this.getCompartment().add(TypeConvertor.castToCanonical(value)); 2367 } else 2368 return super.setProperty(name, value); 2369 return value; 2370 } 2371 2372 @Override 2373 public Base makeProperty(int hash, String name) throws FHIRException { 2374 switch (hash) { 2375 case 3357091: return getModeElement(); 2376 case 1587405498: return getDocumentationElement(); 2377 case 949122880: return getSecurity(); 2378 case -341064690: return addResource(); 2379 case 1844104722: return addInteraction(); 2380 case -553645115: return addSearchParam(); 2381 case 1662702951: return addOperation(); 2382 case -397756334: return addCompartmentElement(); 2383 default: return super.makeProperty(hash, name); 2384 } 2385 2386 } 2387 2388 @Override 2389 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 2390 switch (hash) { 2391 case 3357091: /*mode*/ return new String[] {"code"}; 2392 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 2393 case 949122880: /*security*/ return new String[] {}; 2394 case -341064690: /*resource*/ return new String[] {}; 2395 case 1844104722: /*interaction*/ return new String[] {}; 2396 case -553645115: /*searchParam*/ return new String[] {"@CapabilityStatement.rest.resource.searchParam"}; 2397 case 1662702951: /*operation*/ return new String[] {"@CapabilityStatement.rest.resource.operation"}; 2398 case -397756334: /*compartment*/ return new String[] {"canonical"}; 2399 default: return super.getTypesForProperty(hash, name); 2400 } 2401 2402 } 2403 2404 @Override 2405 public Base addChild(String name) throws FHIRException { 2406 if (name.equals("mode")) { 2407 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.mode"); 2408 } 2409 else if (name.equals("documentation")) { 2410 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.documentation"); 2411 } 2412 else if (name.equals("security")) { 2413 this.security = new CapabilityStatementRestSecurityComponent(); 2414 return this.security; 2415 } 2416 else if (name.equals("resource")) { 2417 return addResource(); 2418 } 2419 else if (name.equals("interaction")) { 2420 return addInteraction(); 2421 } 2422 else if (name.equals("searchParam")) { 2423 return addSearchParam(); 2424 } 2425 else if (name.equals("operation")) { 2426 return addOperation(); 2427 } 2428 else if (name.equals("compartment")) { 2429 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.compartment"); 2430 } 2431 else 2432 return super.addChild(name); 2433 } 2434 2435 public CapabilityStatementRestComponent copy() { 2436 CapabilityStatementRestComponent dst = new CapabilityStatementRestComponent(); 2437 copyValues(dst); 2438 return dst; 2439 } 2440 2441 public void copyValues(CapabilityStatementRestComponent dst) { 2442 super.copyValues(dst); 2443 dst.mode = mode == null ? null : mode.copy(); 2444 dst.documentation = documentation == null ? null : documentation.copy(); 2445 dst.security = security == null ? null : security.copy(); 2446 if (resource != null) { 2447 dst.resource = new ArrayList<CapabilityStatementRestResourceComponent>(); 2448 for (CapabilityStatementRestResourceComponent i : resource) 2449 dst.resource.add(i.copy()); 2450 }; 2451 if (interaction != null) { 2452 dst.interaction = new ArrayList<SystemInteractionComponent>(); 2453 for (SystemInteractionComponent i : interaction) 2454 dst.interaction.add(i.copy()); 2455 }; 2456 if (searchParam != null) { 2457 dst.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>(); 2458 for (CapabilityStatementRestResourceSearchParamComponent i : searchParam) 2459 dst.searchParam.add(i.copy()); 2460 }; 2461 if (operation != null) { 2462 dst.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>(); 2463 for (CapabilityStatementRestResourceOperationComponent i : operation) 2464 dst.operation.add(i.copy()); 2465 }; 2466 if (compartment != null) { 2467 dst.compartment = new ArrayList<CanonicalType>(); 2468 for (CanonicalType i : compartment) 2469 dst.compartment.add(i.copy()); 2470 }; 2471 } 2472 2473 @Override 2474 public boolean equalsDeep(Base other_) { 2475 if (!super.equalsDeep(other_)) 2476 return false; 2477 if (!(other_ instanceof CapabilityStatementRestComponent)) 2478 return false; 2479 CapabilityStatementRestComponent o = (CapabilityStatementRestComponent) other_; 2480 return compareDeep(mode, o.mode, true) && compareDeep(documentation, o.documentation, true) && compareDeep(security, o.security, true) 2481 && compareDeep(resource, o.resource, true) && compareDeep(interaction, o.interaction, true) && compareDeep(searchParam, o.searchParam, true) 2482 && compareDeep(operation, o.operation, true) && compareDeep(compartment, o.compartment, true); 2483 } 2484 2485 @Override 2486 public boolean equalsShallow(Base other_) { 2487 if (!super.equalsShallow(other_)) 2488 return false; 2489 if (!(other_ instanceof CapabilityStatementRestComponent)) 2490 return false; 2491 CapabilityStatementRestComponent o = (CapabilityStatementRestComponent) other_; 2492 return compareValues(mode, o.mode, true) && compareValues(documentation, o.documentation, true) && compareValues(compartment, o.compartment, true) 2493 ; 2494 } 2495 2496 public boolean isEmpty() { 2497 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(mode, documentation, security 2498 , resource, interaction, searchParam, operation, compartment); 2499 } 2500 2501 public String fhirType() { 2502 return "CapabilityStatement.rest"; 2503 2504 } 2505 2506 } 2507 2508 @Block() 2509 public static class CapabilityStatementRestSecurityComponent extends BackboneElement implements IBaseBackboneElement { 2510 /** 2511 * Server adds CORS headers when responding to requests - this enables Javascript applications to use the server. 2512 */ 2513 @Child(name = "cors", type = {BooleanType.class}, order=1, min=0, max=1, modifier=false, summary=true) 2514 @Description(shortDefinition="Adds CORS Headers (http://enable-cors.org/)", formalDefinition="Server adds CORS headers when responding to requests - this enables Javascript applications to use the server." ) 2515 protected BooleanType cors; 2516 2517 /** 2518 * Types of security services that are supported/required by the system. 2519 */ 2520 @Child(name = "service", type = {CodeableConcept.class}, order=2, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 2521 @Description(shortDefinition="OAuth | SMART-on-FHIR | NTLM | Basic | Kerberos | Certificates", formalDefinition="Types of security services that are supported/required by the system." ) 2522 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/restful-security-service") 2523 protected List<CodeableConcept> service; 2524 2525 /** 2526 * General description of how security works. 2527 */ 2528 @Child(name = "description", type = {MarkdownType.class}, order=3, min=0, max=1, modifier=false, summary=false) 2529 @Description(shortDefinition="General description of how security works", formalDefinition="General description of how security works." ) 2530 protected MarkdownType description; 2531 2532 private static final long serialVersionUID = -1348900500L; 2533 2534 /** 2535 * Constructor 2536 */ 2537 public CapabilityStatementRestSecurityComponent() { 2538 super(); 2539 } 2540 2541 /** 2542 * @return {@link #cors} (Server adds CORS headers when responding to requests - this enables Javascript applications to use the server.). This is the underlying object with id, value and extensions. The accessor "getCors" gives direct access to the value 2543 */ 2544 public BooleanType getCorsElement() { 2545 if (this.cors == null) 2546 if (Configuration.errorOnAutoCreate()) 2547 throw new Error("Attempt to auto-create CapabilityStatementRestSecurityComponent.cors"); 2548 else if (Configuration.doAutoCreate()) 2549 this.cors = new BooleanType(); // bb 2550 return this.cors; 2551 } 2552 2553 public boolean hasCorsElement() { 2554 return this.cors != null && !this.cors.isEmpty(); 2555 } 2556 2557 public boolean hasCors() { 2558 return this.cors != null && !this.cors.isEmpty(); 2559 } 2560 2561 /** 2562 * @param value {@link #cors} (Server adds CORS headers when responding to requests - this enables Javascript applications to use the server.). This is the underlying object with id, value and extensions. The accessor "getCors" gives direct access to the value 2563 */ 2564 public CapabilityStatementRestSecurityComponent setCorsElement(BooleanType value) { 2565 this.cors = value; 2566 return this; 2567 } 2568 2569 /** 2570 * @return Server adds CORS headers when responding to requests - this enables Javascript applications to use the server. 2571 */ 2572 public boolean getCors() { 2573 return this.cors == null || this.cors.isEmpty() ? false : this.cors.getValue(); 2574 } 2575 2576 /** 2577 * @param value Server adds CORS headers when responding to requests - this enables Javascript applications to use the server. 2578 */ 2579 public CapabilityStatementRestSecurityComponent setCors(boolean value) { 2580 if (this.cors == null) 2581 this.cors = new BooleanType(); 2582 this.cors.setValue(value); 2583 return this; 2584 } 2585 2586 /** 2587 * @return {@link #service} (Types of security services that are supported/required by the system.) 2588 */ 2589 public List<CodeableConcept> getService() { 2590 if (this.service == null) 2591 this.service = new ArrayList<CodeableConcept>(); 2592 return this.service; 2593 } 2594 2595 /** 2596 * @return Returns a reference to <code>this</code> for easy method chaining 2597 */ 2598 public CapabilityStatementRestSecurityComponent setService(List<CodeableConcept> theService) { 2599 this.service = theService; 2600 return this; 2601 } 2602 2603 public boolean hasService() { 2604 if (this.service == null) 2605 return false; 2606 for (CodeableConcept item : this.service) 2607 if (!item.isEmpty()) 2608 return true; 2609 return false; 2610 } 2611 2612 public CodeableConcept addService() { //3 2613 CodeableConcept t = new CodeableConcept(); 2614 if (this.service == null) 2615 this.service = new ArrayList<CodeableConcept>(); 2616 this.service.add(t); 2617 return t; 2618 } 2619 2620 public CapabilityStatementRestSecurityComponent addService(CodeableConcept t) { //3 2621 if (t == null) 2622 return this; 2623 if (this.service == null) 2624 this.service = new ArrayList<CodeableConcept>(); 2625 this.service.add(t); 2626 return this; 2627 } 2628 2629 /** 2630 * @return The first repetition of repeating field {@link #service}, creating it if it does not already exist {3} 2631 */ 2632 public CodeableConcept getServiceFirstRep() { 2633 if (getService().isEmpty()) { 2634 addService(); 2635 } 2636 return getService().get(0); 2637 } 2638 2639 /** 2640 * @return {@link #description} (General description of how security works.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 2641 */ 2642 public MarkdownType getDescriptionElement() { 2643 if (this.description == null) 2644 if (Configuration.errorOnAutoCreate()) 2645 throw new Error("Attempt to auto-create CapabilityStatementRestSecurityComponent.description"); 2646 else if (Configuration.doAutoCreate()) 2647 this.description = new MarkdownType(); // bb 2648 return this.description; 2649 } 2650 2651 public boolean hasDescriptionElement() { 2652 return this.description != null && !this.description.isEmpty(); 2653 } 2654 2655 public boolean hasDescription() { 2656 return this.description != null && !this.description.isEmpty(); 2657 } 2658 2659 /** 2660 * @param value {@link #description} (General description of how security works.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 2661 */ 2662 public CapabilityStatementRestSecurityComponent setDescriptionElement(MarkdownType value) { 2663 this.description = value; 2664 return this; 2665 } 2666 2667 /** 2668 * @return General description of how security works. 2669 */ 2670 public String getDescription() { 2671 return this.description == null ? null : this.description.getValue(); 2672 } 2673 2674 /** 2675 * @param value General description of how security works. 2676 */ 2677 public CapabilityStatementRestSecurityComponent setDescription(String value) { 2678 if (value == null) 2679 this.description = null; 2680 else { 2681 if (this.description == null) 2682 this.description = new MarkdownType(); 2683 this.description.setValue(value); 2684 } 2685 return this; 2686 } 2687 2688 protected void listChildren(List<Property> children) { 2689 super.listChildren(children); 2690 children.add(new Property("cors", "boolean", "Server adds CORS headers when responding to requests - this enables Javascript applications to use the server.", 0, 1, cors)); 2691 children.add(new Property("service", "CodeableConcept", "Types of security services that are supported/required by the system.", 0, java.lang.Integer.MAX_VALUE, service)); 2692 children.add(new Property("description", "markdown", "General description of how security works.", 0, 1, description)); 2693 } 2694 2695 @Override 2696 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 2697 switch (_hash) { 2698 case 3059629: /*cors*/ return new Property("cors", "boolean", "Server adds CORS headers when responding to requests - this enables Javascript applications to use the server.", 0, 1, cors); 2699 case 1984153269: /*service*/ return new Property("service", "CodeableConcept", "Types of security services that are supported/required by the system.", 0, java.lang.Integer.MAX_VALUE, service); 2700 case -1724546052: /*description*/ return new Property("description", "markdown", "General description of how security works.", 0, 1, description); 2701 default: return super.getNamedProperty(_hash, _name, _checkValid); 2702 } 2703 2704 } 2705 2706 @Override 2707 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 2708 switch (hash) { 2709 case 3059629: /*cors*/ return this.cors == null ? new Base[0] : new Base[] {this.cors}; // BooleanType 2710 case 1984153269: /*service*/ return this.service == null ? new Base[0] : this.service.toArray(new Base[this.service.size()]); // CodeableConcept 2711 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType 2712 default: return super.getProperty(hash, name, checkValid); 2713 } 2714 2715 } 2716 2717 @Override 2718 public Base setProperty(int hash, String name, Base value) throws FHIRException { 2719 switch (hash) { 2720 case 3059629: // cors 2721 this.cors = TypeConvertor.castToBoolean(value); // BooleanType 2722 return value; 2723 case 1984153269: // service 2724 this.getService().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept 2725 return value; 2726 case -1724546052: // description 2727 this.description = TypeConvertor.castToMarkdown(value); // MarkdownType 2728 return value; 2729 default: return super.setProperty(hash, name, value); 2730 } 2731 2732 } 2733 2734 @Override 2735 public Base setProperty(String name, Base value) throws FHIRException { 2736 if (name.equals("cors")) { 2737 this.cors = TypeConvertor.castToBoolean(value); // BooleanType 2738 } else if (name.equals("service")) { 2739 this.getService().add(TypeConvertor.castToCodeableConcept(value)); 2740 } else if (name.equals("description")) { 2741 this.description = TypeConvertor.castToMarkdown(value); // MarkdownType 2742 } else 2743 return super.setProperty(name, value); 2744 return value; 2745 } 2746 2747 @Override 2748 public Base makeProperty(int hash, String name) throws FHIRException { 2749 switch (hash) { 2750 case 3059629: return getCorsElement(); 2751 case 1984153269: return addService(); 2752 case -1724546052: return getDescriptionElement(); 2753 default: return super.makeProperty(hash, name); 2754 } 2755 2756 } 2757 2758 @Override 2759 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 2760 switch (hash) { 2761 case 3059629: /*cors*/ return new String[] {"boolean"}; 2762 case 1984153269: /*service*/ return new String[] {"CodeableConcept"}; 2763 case -1724546052: /*description*/ return new String[] {"markdown"}; 2764 default: return super.getTypesForProperty(hash, name); 2765 } 2766 2767 } 2768 2769 @Override 2770 public Base addChild(String name) throws FHIRException { 2771 if (name.equals("cors")) { 2772 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.security.cors"); 2773 } 2774 else if (name.equals("service")) { 2775 return addService(); 2776 } 2777 else if (name.equals("description")) { 2778 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.security.description"); 2779 } 2780 else 2781 return super.addChild(name); 2782 } 2783 2784 public CapabilityStatementRestSecurityComponent copy() { 2785 CapabilityStatementRestSecurityComponent dst = new CapabilityStatementRestSecurityComponent(); 2786 copyValues(dst); 2787 return dst; 2788 } 2789 2790 public void copyValues(CapabilityStatementRestSecurityComponent dst) { 2791 super.copyValues(dst); 2792 dst.cors = cors == null ? null : cors.copy(); 2793 if (service != null) { 2794 dst.service = new ArrayList<CodeableConcept>(); 2795 for (CodeableConcept i : service) 2796 dst.service.add(i.copy()); 2797 }; 2798 dst.description = description == null ? null : description.copy(); 2799 } 2800 2801 @Override 2802 public boolean equalsDeep(Base other_) { 2803 if (!super.equalsDeep(other_)) 2804 return false; 2805 if (!(other_ instanceof CapabilityStatementRestSecurityComponent)) 2806 return false; 2807 CapabilityStatementRestSecurityComponent o = (CapabilityStatementRestSecurityComponent) other_; 2808 return compareDeep(cors, o.cors, true) && compareDeep(service, o.service, true) && compareDeep(description, o.description, true) 2809 ; 2810 } 2811 2812 @Override 2813 public boolean equalsShallow(Base other_) { 2814 if (!super.equalsShallow(other_)) 2815 return false; 2816 if (!(other_ instanceof CapabilityStatementRestSecurityComponent)) 2817 return false; 2818 CapabilityStatementRestSecurityComponent o = (CapabilityStatementRestSecurityComponent) other_; 2819 return compareValues(cors, o.cors, true) && compareValues(description, o.description, true); 2820 } 2821 2822 public boolean isEmpty() { 2823 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(cors, service, description 2824 ); 2825 } 2826 2827 public String fhirType() { 2828 return "CapabilityStatement.rest.security"; 2829 2830 } 2831 2832 } 2833 2834 @Block() 2835 public static class CapabilityStatementRestResourceComponent extends BackboneElement implements IBaseBackboneElement { 2836 /** 2837 * A type of resource exposed via the restful interface. 2838 */ 2839 @Child(name = "type", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true) 2840 @Description(shortDefinition="A resource type that is supported", formalDefinition="A type of resource exposed via the restful interface." ) 2841 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/resource-types") 2842 protected CodeType type; 2843 2844 /** 2845 * A specification of the profile that describes the solution's overall support for the resource, including any constraints on cardinality, bindings, lengths or other limitations. See further discussion in [Using Profiles](profiling.html#profile-uses). 2846 */ 2847 @Child(name = "profile", type = {CanonicalType.class}, order=2, min=0, max=1, modifier=false, summary=true) 2848 @Description(shortDefinition="Base System profile for all uses of resource", formalDefinition="A specification of the profile that describes the solution's overall support for the resource, including any constraints on cardinality, bindings, lengths or other limitations. See further discussion in [Using Profiles](profiling.html#profile-uses)." ) 2849 protected CanonicalType profile; 2850 2851 /** 2852 * A list of profiles that represent different use cases supported by the system. For a server, "supported by the system" means the system hosts/produces a set of resources that are conformant to a particular profile, and allows clients that use its services to search using this profile and to find appropriate data. For a client, it means the system will search by this profile and process data according to the guidance implicit in the profile. See further discussion in [Using Profiles](profiling.html#profile-uses). 2853 */ 2854 @Child(name = "supportedProfile", type = {CanonicalType.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 2855 @Description(shortDefinition="Profiles for use cases supported", formalDefinition="A list of profiles that represent different use cases supported by the system. For a server, \"supported by the system\" means the system hosts/produces a set of resources that are conformant to a particular profile, and allows clients that use its services to search using this profile and to find appropriate data. For a client, it means the system will search by this profile and process data according to the guidance implicit in the profile. See further discussion in [Using Profiles](profiling.html#profile-uses)." ) 2856 protected List<CanonicalType> supportedProfile; 2857 2858 /** 2859 * Additional information about the resource type used by the system. 2860 */ 2861 @Child(name = "documentation", type = {MarkdownType.class}, order=4, min=0, max=1, modifier=false, summary=false) 2862 @Description(shortDefinition="Additional information about the use of the resource type", formalDefinition="Additional information about the resource type used by the system." ) 2863 protected MarkdownType documentation; 2864 2865 /** 2866 * Identifies a restful operation supported by the solution. 2867 */ 2868 @Child(name = "interaction", type = {}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 2869 @Description(shortDefinition="What operations are supported?", formalDefinition="Identifies a restful operation supported by the solution." ) 2870 protected List<ResourceInteractionComponent> interaction; 2871 2872 /** 2873 * This field is set to no-version to specify that the system does not support (server) or use (client) versioning for this resource type. If this has some other value, the server must at least correctly track and populate the versionId meta-property on resources. If the value is 'versioned-update', then the server supports all the versioning features, including using e-tags for version integrity in the API. 2874 */ 2875 @Child(name = "versioning", type = {CodeType.class}, order=6, min=0, max=1, modifier=false, summary=false) 2876 @Description(shortDefinition="no-version | versioned | versioned-update", formalDefinition="This field is set to no-version to specify that the system does not support (server) or use (client) versioning for this resource type. If this has some other value, the server must at least correctly track and populate the versionId meta-property on resources. If the value is 'versioned-update', then the server supports all the versioning features, including using e-tags for version integrity in the API." ) 2877 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/versioning-policy") 2878 protected Enumeration<ResourceVersionPolicy> versioning; 2879 2880 /** 2881 * A flag for whether the server is able to return past versions as part of the vRead operation. 2882 */ 2883 @Child(name = "readHistory", type = {BooleanType.class}, order=7, min=0, max=1, modifier=false, summary=false) 2884 @Description(shortDefinition="Whether vRead can return past versions", formalDefinition="A flag for whether the server is able to return past versions as part of the vRead operation." ) 2885 protected BooleanType readHistory; 2886 2887 /** 2888 * A flag to indicate that the server allows or needs to allow the client to create new identities on the server (that is, the client PUTs to a location where there is no existing resource). Allowing this operation means that the server allows the client to create new identities on the server. 2889 */ 2890 @Child(name = "updateCreate", type = {BooleanType.class}, order=8, min=0, max=1, modifier=false, summary=false) 2891 @Description(shortDefinition="If update can commit to a new identity", formalDefinition="A flag to indicate that the server allows or needs to allow the client to create new identities on the server (that is, the client PUTs to a location where there is no existing resource). Allowing this operation means that the server allows the client to create new identities on the server." ) 2892 protected BooleanType updateCreate; 2893 2894 /** 2895 * A flag that indicates that the server supports conditional create. 2896 */ 2897 @Child(name = "conditionalCreate", type = {BooleanType.class}, order=9, min=0, max=1, modifier=false, summary=false) 2898 @Description(shortDefinition="If allows/uses conditional create", formalDefinition="A flag that indicates that the server supports conditional create." ) 2899 protected BooleanType conditionalCreate; 2900 2901 /** 2902 * A code that indicates how the server supports conditional read. 2903 */ 2904 @Child(name = "conditionalRead", type = {CodeType.class}, order=10, min=0, max=1, modifier=false, summary=false) 2905 @Description(shortDefinition="not-supported | modified-since | not-match | full-support", formalDefinition="A code that indicates how the server supports conditional read." ) 2906 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/conditional-read-status") 2907 protected Enumeration<ConditionalReadStatus> conditionalRead; 2908 2909 /** 2910 * A flag that indicates that the server supports conditional update. 2911 */ 2912 @Child(name = "conditionalUpdate", type = {BooleanType.class}, order=11, min=0, max=1, modifier=false, summary=false) 2913 @Description(shortDefinition="If allows/uses conditional update", formalDefinition="A flag that indicates that the server supports conditional update." ) 2914 protected BooleanType conditionalUpdate; 2915 2916 /** 2917 * A code that indicates how the server supports conditional delete. 2918 */ 2919 @Child(name = "conditionalDelete", type = {CodeType.class}, order=12, min=0, max=1, modifier=false, summary=false) 2920 @Description(shortDefinition="not-supported | single | multiple - how conditional delete is supported", formalDefinition="A code that indicates how the server supports conditional delete." ) 2921 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/conditional-delete-status") 2922 protected Enumeration<ConditionalDeleteStatus> conditionalDelete; 2923 2924 /** 2925 * A set of flags that defines how references are supported. 2926 */ 2927 @Child(name = "referencePolicy", type = {CodeType.class}, order=13, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 2928 @Description(shortDefinition="literal | logical | resolves | enforced | local", formalDefinition="A set of flags that defines how references are supported." ) 2929 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/reference-handling-policy") 2930 protected List<Enumeration<ReferenceHandlingPolicy>> referencePolicy; 2931 2932 /** 2933 * A list of _include values supported by the server. 2934 */ 2935 @Child(name = "searchInclude", type = {StringType.class}, order=14, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 2936 @Description(shortDefinition="_include values supported by the server", formalDefinition="A list of _include values supported by the server." ) 2937 protected List<StringType> searchInclude; 2938 2939 /** 2940 * A list of _revinclude (reverse include) values supported by the server. 2941 */ 2942 @Child(name = "searchRevInclude", type = {StringType.class}, order=15, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 2943 @Description(shortDefinition="_revinclude values supported by the server", formalDefinition="A list of _revinclude (reverse include) values supported by the server." ) 2944 protected List<StringType> searchRevInclude; 2945 2946 /** 2947 * Search parameters for implementations to support and/or make use of - either references to ones defined in the specification, or additional ones defined for/by the implementation. 2948 */ 2949 @Child(name = "searchParam", type = {}, order=16, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 2950 @Description(shortDefinition="Search parameters supported by implementation", formalDefinition="Search parameters for implementations to support and/or make use of - either references to ones defined in the specification, or additional ones defined for/by the implementation." ) 2951 protected List<CapabilityStatementRestResourceSearchParamComponent> searchParam; 2952 2953 /** 2954 * Definition of an operation or a named query together with its parameters and their meaning and type. Consult the definition of the operation for details about how to invoke the operation, and the parameters. 2955 */ 2956 @Child(name = "operation", type = {}, order=17, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 2957 @Description(shortDefinition="Definition of a resource operation", formalDefinition="Definition of an operation or a named query together with its parameters and their meaning and type. Consult the definition of the operation for details about how to invoke the operation, and the parameters." ) 2958 protected List<CapabilityStatementRestResourceOperationComponent> operation; 2959 2960 private static final long serialVersionUID = -1843372337L; 2961 2962 /** 2963 * Constructor 2964 */ 2965 public CapabilityStatementRestResourceComponent() { 2966 super(); 2967 } 2968 2969 /** 2970 * Constructor 2971 */ 2972 public CapabilityStatementRestResourceComponent(String type) { 2973 super(); 2974 this.setType(type); 2975 } 2976 2977 /** 2978 * @return {@link #type} (A type of resource exposed via the restful interface.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 2979 */ 2980 public CodeType getTypeElement() { 2981 if (this.type == null) 2982 if (Configuration.errorOnAutoCreate()) 2983 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.type"); 2984 else if (Configuration.doAutoCreate()) 2985 this.type = new CodeType(); // bb 2986 return this.type; 2987 } 2988 2989 public boolean hasTypeElement() { 2990 return this.type != null && !this.type.isEmpty(); 2991 } 2992 2993 public boolean hasType() { 2994 return this.type != null && !this.type.isEmpty(); 2995 } 2996 2997 /** 2998 * @param value {@link #type} (A type of resource exposed via the restful interface.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 2999 */ 3000 public CapabilityStatementRestResourceComponent setTypeElement(CodeType value) { 3001 this.type = value; 3002 return this; 3003 } 3004 3005 /** 3006 * @return A type of resource exposed via the restful interface. 3007 */ 3008 public String getType() { 3009 return this.type == null ? null : this.type.getValue(); 3010 } 3011 3012 /** 3013 * @param value A type of resource exposed via the restful interface. 3014 */ 3015 public CapabilityStatementRestResourceComponent setType(String value) { 3016 if (this.type == null) 3017 this.type = new CodeType(); 3018 this.type.setValue(value); 3019 return this; 3020 } 3021 3022 /** 3023 * @return {@link #profile} (A specification of the profile that describes the solution's overall support for the resource, including any constraints on cardinality, bindings, lengths or other limitations. See further discussion in [Using Profiles](profiling.html#profile-uses).). This is the underlying object with id, value and extensions. The accessor "getProfile" gives direct access to the value 3024 */ 3025 public CanonicalType getProfileElement() { 3026 if (this.profile == null) 3027 if (Configuration.errorOnAutoCreate()) 3028 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.profile"); 3029 else if (Configuration.doAutoCreate()) 3030 this.profile = new CanonicalType(); // bb 3031 return this.profile; 3032 } 3033 3034 public boolean hasProfileElement() { 3035 return this.profile != null && !this.profile.isEmpty(); 3036 } 3037 3038 public boolean hasProfile() { 3039 return this.profile != null && !this.profile.isEmpty(); 3040 } 3041 3042 /** 3043 * @param value {@link #profile} (A specification of the profile that describes the solution's overall support for the resource, including any constraints on cardinality, bindings, lengths or other limitations. See further discussion in [Using Profiles](profiling.html#profile-uses).). This is the underlying object with id, value and extensions. The accessor "getProfile" gives direct access to the value 3044 */ 3045 public CapabilityStatementRestResourceComponent setProfileElement(CanonicalType value) { 3046 this.profile = value; 3047 return this; 3048 } 3049 3050 /** 3051 * @return A specification of the profile that describes the solution's overall support for the resource, including any constraints on cardinality, bindings, lengths or other limitations. See further discussion in [Using Profiles](profiling.html#profile-uses). 3052 */ 3053 public String getProfile() { 3054 return this.profile == null ? null : this.profile.getValue(); 3055 } 3056 3057 /** 3058 * @param value A specification of the profile that describes the solution's overall support for the resource, including any constraints on cardinality, bindings, lengths or other limitations. See further discussion in [Using Profiles](profiling.html#profile-uses). 3059 */ 3060 public CapabilityStatementRestResourceComponent setProfile(String value) { 3061 if (Utilities.noString(value)) 3062 this.profile = null; 3063 else { 3064 if (this.profile == null) 3065 this.profile = new CanonicalType(); 3066 this.profile.setValue(value); 3067 } 3068 return this; 3069 } 3070 3071 /** 3072 * @return {@link #supportedProfile} (A list of profiles that represent different use cases supported by the system. For a server, "supported by the system" means the system hosts/produces a set of resources that are conformant to a particular profile, and allows clients that use its services to search using this profile and to find appropriate data. For a client, it means the system will search by this profile and process data according to the guidance implicit in the profile. See further discussion in [Using Profiles](profiling.html#profile-uses).) 3073 */ 3074 public List<CanonicalType> getSupportedProfile() { 3075 if (this.supportedProfile == null) 3076 this.supportedProfile = new ArrayList<CanonicalType>(); 3077 return this.supportedProfile; 3078 } 3079 3080 /** 3081 * @return Returns a reference to <code>this</code> for easy method chaining 3082 */ 3083 public CapabilityStatementRestResourceComponent setSupportedProfile(List<CanonicalType> theSupportedProfile) { 3084 this.supportedProfile = theSupportedProfile; 3085 return this; 3086 } 3087 3088 public boolean hasSupportedProfile() { 3089 if (this.supportedProfile == null) 3090 return false; 3091 for (CanonicalType item : this.supportedProfile) 3092 if (!item.isEmpty()) 3093 return true; 3094 return false; 3095 } 3096 3097 /** 3098 * @return {@link #supportedProfile} (A list of profiles that represent different use cases supported by the system. For a server, "supported by the system" means the system hosts/produces a set of resources that are conformant to a particular profile, and allows clients that use its services to search using this profile and to find appropriate data. For a client, it means the system will search by this profile and process data according to the guidance implicit in the profile. See further discussion in [Using Profiles](profiling.html#profile-uses).) 3099 */ 3100 public CanonicalType addSupportedProfileElement() {//2 3101 CanonicalType t = new CanonicalType(); 3102 if (this.supportedProfile == null) 3103 this.supportedProfile = new ArrayList<CanonicalType>(); 3104 this.supportedProfile.add(t); 3105 return t; 3106 } 3107 3108 /** 3109 * @param value {@link #supportedProfile} (A list of profiles that represent different use cases supported by the system. For a server, "supported by the system" means the system hosts/produces a set of resources that are conformant to a particular profile, and allows clients that use its services to search using this profile and to find appropriate data. For a client, it means the system will search by this profile and process data according to the guidance implicit in the profile. See further discussion in [Using Profiles](profiling.html#profile-uses).) 3110 */ 3111 public CapabilityStatementRestResourceComponent addSupportedProfile(String value) { //1 3112 CanonicalType t = new CanonicalType(); 3113 t.setValue(value); 3114 if (this.supportedProfile == null) 3115 this.supportedProfile = new ArrayList<CanonicalType>(); 3116 this.supportedProfile.add(t); 3117 return this; 3118 } 3119 3120 /** 3121 * @param value {@link #supportedProfile} (A list of profiles that represent different use cases supported by the system. For a server, "supported by the system" means the system hosts/produces a set of resources that are conformant to a particular profile, and allows clients that use its services to search using this profile and to find appropriate data. For a client, it means the system will search by this profile and process data according to the guidance implicit in the profile. See further discussion in [Using Profiles](profiling.html#profile-uses).) 3122 */ 3123 public boolean hasSupportedProfile(String value) { 3124 if (this.supportedProfile == null) 3125 return false; 3126 for (CanonicalType v : this.supportedProfile) 3127 if (v.getValue().equals(value)) // canonical 3128 return true; 3129 return false; 3130 } 3131 3132 /** 3133 * @return {@link #documentation} (Additional information about the resource type used by the system.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value 3134 */ 3135 public MarkdownType getDocumentationElement() { 3136 if (this.documentation == null) 3137 if (Configuration.errorOnAutoCreate()) 3138 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.documentation"); 3139 else if (Configuration.doAutoCreate()) 3140 this.documentation = new MarkdownType(); // bb 3141 return this.documentation; 3142 } 3143 3144 public boolean hasDocumentationElement() { 3145 return this.documentation != null && !this.documentation.isEmpty(); 3146 } 3147 3148 public boolean hasDocumentation() { 3149 return this.documentation != null && !this.documentation.isEmpty(); 3150 } 3151 3152 /** 3153 * @param value {@link #documentation} (Additional information about the resource type used by the system.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value 3154 */ 3155 public CapabilityStatementRestResourceComponent setDocumentationElement(MarkdownType value) { 3156 this.documentation = value; 3157 return this; 3158 } 3159 3160 /** 3161 * @return Additional information about the resource type used by the system. 3162 */ 3163 public String getDocumentation() { 3164 return this.documentation == null ? null : this.documentation.getValue(); 3165 } 3166 3167 /** 3168 * @param value Additional information about the resource type used by the system. 3169 */ 3170 public CapabilityStatementRestResourceComponent setDocumentation(String value) { 3171 if (value == null) 3172 this.documentation = null; 3173 else { 3174 if (this.documentation == null) 3175 this.documentation = new MarkdownType(); 3176 this.documentation.setValue(value); 3177 } 3178 return this; 3179 } 3180 3181 /** 3182 * @return {@link #interaction} (Identifies a restful operation supported by the solution.) 3183 */ 3184 public List<ResourceInteractionComponent> getInteraction() { 3185 if (this.interaction == null) 3186 this.interaction = new ArrayList<ResourceInteractionComponent>(); 3187 return this.interaction; 3188 } 3189 3190 /** 3191 * @return Returns a reference to <code>this</code> for easy method chaining 3192 */ 3193 public CapabilityStatementRestResourceComponent setInteraction(List<ResourceInteractionComponent> theInteraction) { 3194 this.interaction = theInteraction; 3195 return this; 3196 } 3197 3198 public boolean hasInteraction() { 3199 if (this.interaction == null) 3200 return false; 3201 for (ResourceInteractionComponent item : this.interaction) 3202 if (!item.isEmpty()) 3203 return true; 3204 return false; 3205 } 3206 3207 public ResourceInteractionComponent addInteraction() { //3 3208 ResourceInteractionComponent t = new ResourceInteractionComponent(); 3209 if (this.interaction == null) 3210 this.interaction = new ArrayList<ResourceInteractionComponent>(); 3211 this.interaction.add(t); 3212 return t; 3213 } 3214 3215 public CapabilityStatementRestResourceComponent addInteraction(ResourceInteractionComponent t) { //3 3216 if (t == null) 3217 return this; 3218 if (this.interaction == null) 3219 this.interaction = new ArrayList<ResourceInteractionComponent>(); 3220 this.interaction.add(t); 3221 return this; 3222 } 3223 3224 /** 3225 * @return The first repetition of repeating field {@link #interaction}, creating it if it does not already exist {3} 3226 */ 3227 public ResourceInteractionComponent getInteractionFirstRep() { 3228 if (getInteraction().isEmpty()) { 3229 addInteraction(); 3230 } 3231 return getInteraction().get(0); 3232 } 3233 3234 /** 3235 * @return {@link #versioning} (This field is set to no-version to specify that the system does not support (server) or use (client) versioning for this resource type. If this has some other value, the server must at least correctly track and populate the versionId meta-property on resources. If the value is 'versioned-update', then the server supports all the versioning features, including using e-tags for version integrity in the API.). This is the underlying object with id, value and extensions. The accessor "getVersioning" gives direct access to the value 3236 */ 3237 public Enumeration<ResourceVersionPolicy> getVersioningElement() { 3238 if (this.versioning == null) 3239 if (Configuration.errorOnAutoCreate()) 3240 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.versioning"); 3241 else if (Configuration.doAutoCreate()) 3242 this.versioning = new Enumeration<ResourceVersionPolicy>(new ResourceVersionPolicyEnumFactory()); // bb 3243 return this.versioning; 3244 } 3245 3246 public boolean hasVersioningElement() { 3247 return this.versioning != null && !this.versioning.isEmpty(); 3248 } 3249 3250 public boolean hasVersioning() { 3251 return this.versioning != null && !this.versioning.isEmpty(); 3252 } 3253 3254 /** 3255 * @param value {@link #versioning} (This field is set to no-version to specify that the system does not support (server) or use (client) versioning for this resource type. If this has some other value, the server must at least correctly track and populate the versionId meta-property on resources. If the value is 'versioned-update', then the server supports all the versioning features, including using e-tags for version integrity in the API.). This is the underlying object with id, value and extensions. The accessor "getVersioning" gives direct access to the value 3256 */ 3257 public CapabilityStatementRestResourceComponent setVersioningElement(Enumeration<ResourceVersionPolicy> value) { 3258 this.versioning = value; 3259 return this; 3260 } 3261 3262 /** 3263 * @return This field is set to no-version to specify that the system does not support (server) or use (client) versioning for this resource type. If this has some other value, the server must at least correctly track and populate the versionId meta-property on resources. If the value is 'versioned-update', then the server supports all the versioning features, including using e-tags for version integrity in the API. 3264 */ 3265 public ResourceVersionPolicy getVersioning() { 3266 return this.versioning == null ? null : this.versioning.getValue(); 3267 } 3268 3269 /** 3270 * @param value This field is set to no-version to specify that the system does not support (server) or use (client) versioning for this resource type. If this has some other value, the server must at least correctly track and populate the versionId meta-property on resources. If the value is 'versioned-update', then the server supports all the versioning features, including using e-tags for version integrity in the API. 3271 */ 3272 public CapabilityStatementRestResourceComponent setVersioning(ResourceVersionPolicy value) { 3273 if (value == null) 3274 this.versioning = null; 3275 else { 3276 if (this.versioning == null) 3277 this.versioning = new Enumeration<ResourceVersionPolicy>(new ResourceVersionPolicyEnumFactory()); 3278 this.versioning.setValue(value); 3279 } 3280 return this; 3281 } 3282 3283 /** 3284 * @return {@link #readHistory} (A flag for whether the server is able to return past versions as part of the vRead operation.). This is the underlying object with id, value and extensions. The accessor "getReadHistory" gives direct access to the value 3285 */ 3286 public BooleanType getReadHistoryElement() { 3287 if (this.readHistory == null) 3288 if (Configuration.errorOnAutoCreate()) 3289 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.readHistory"); 3290 else if (Configuration.doAutoCreate()) 3291 this.readHistory = new BooleanType(); // bb 3292 return this.readHistory; 3293 } 3294 3295 public boolean hasReadHistoryElement() { 3296 return this.readHistory != null && !this.readHistory.isEmpty(); 3297 } 3298 3299 public boolean hasReadHistory() { 3300 return this.readHistory != null && !this.readHistory.isEmpty(); 3301 } 3302 3303 /** 3304 * @param value {@link #readHistory} (A flag for whether the server is able to return past versions as part of the vRead operation.). This is the underlying object with id, value and extensions. The accessor "getReadHistory" gives direct access to the value 3305 */ 3306 public CapabilityStatementRestResourceComponent setReadHistoryElement(BooleanType value) { 3307 this.readHistory = value; 3308 return this; 3309 } 3310 3311 /** 3312 * @return A flag for whether the server is able to return past versions as part of the vRead operation. 3313 */ 3314 public boolean getReadHistory() { 3315 return this.readHistory == null || this.readHistory.isEmpty() ? false : this.readHistory.getValue(); 3316 } 3317 3318 /** 3319 * @param value A flag for whether the server is able to return past versions as part of the vRead operation. 3320 */ 3321 public CapabilityStatementRestResourceComponent setReadHistory(boolean value) { 3322 if (this.readHistory == null) 3323 this.readHistory = new BooleanType(); 3324 this.readHistory.setValue(value); 3325 return this; 3326 } 3327 3328 /** 3329 * @return {@link #updateCreate} (A flag to indicate that the server allows or needs to allow the client to create new identities on the server (that is, the client PUTs to a location where there is no existing resource). Allowing this operation means that the server allows the client to create new identities on the server.). This is the underlying object with id, value and extensions. The accessor "getUpdateCreate" gives direct access to the value 3330 */ 3331 public BooleanType getUpdateCreateElement() { 3332 if (this.updateCreate == null) 3333 if (Configuration.errorOnAutoCreate()) 3334 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.updateCreate"); 3335 else if (Configuration.doAutoCreate()) 3336 this.updateCreate = new BooleanType(); // bb 3337 return this.updateCreate; 3338 } 3339 3340 public boolean hasUpdateCreateElement() { 3341 return this.updateCreate != null && !this.updateCreate.isEmpty(); 3342 } 3343 3344 public boolean hasUpdateCreate() { 3345 return this.updateCreate != null && !this.updateCreate.isEmpty(); 3346 } 3347 3348 /** 3349 * @param value {@link #updateCreate} (A flag to indicate that the server allows or needs to allow the client to create new identities on the server (that is, the client PUTs to a location where there is no existing resource). Allowing this operation means that the server allows the client to create new identities on the server.). This is the underlying object with id, value and extensions. The accessor "getUpdateCreate" gives direct access to the value 3350 */ 3351 public CapabilityStatementRestResourceComponent setUpdateCreateElement(BooleanType value) { 3352 this.updateCreate = value; 3353 return this; 3354 } 3355 3356 /** 3357 * @return A flag to indicate that the server allows or needs to allow the client to create new identities on the server (that is, the client PUTs to a location where there is no existing resource). Allowing this operation means that the server allows the client to create new identities on the server. 3358 */ 3359 public boolean getUpdateCreate() { 3360 return this.updateCreate == null || this.updateCreate.isEmpty() ? false : this.updateCreate.getValue(); 3361 } 3362 3363 /** 3364 * @param value A flag to indicate that the server allows or needs to allow the client to create new identities on the server (that is, the client PUTs to a location where there is no existing resource). Allowing this operation means that the server allows the client to create new identities on the server. 3365 */ 3366 public CapabilityStatementRestResourceComponent setUpdateCreate(boolean value) { 3367 if (this.updateCreate == null) 3368 this.updateCreate = new BooleanType(); 3369 this.updateCreate.setValue(value); 3370 return this; 3371 } 3372 3373 /** 3374 * @return {@link #conditionalCreate} (A flag that indicates that the server supports conditional create.). This is the underlying object with id, value and extensions. The accessor "getConditionalCreate" gives direct access to the value 3375 */ 3376 public BooleanType getConditionalCreateElement() { 3377 if (this.conditionalCreate == null) 3378 if (Configuration.errorOnAutoCreate()) 3379 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.conditionalCreate"); 3380 else if (Configuration.doAutoCreate()) 3381 this.conditionalCreate = new BooleanType(); // bb 3382 return this.conditionalCreate; 3383 } 3384 3385 public boolean hasConditionalCreateElement() { 3386 return this.conditionalCreate != null && !this.conditionalCreate.isEmpty(); 3387 } 3388 3389 public boolean hasConditionalCreate() { 3390 return this.conditionalCreate != null && !this.conditionalCreate.isEmpty(); 3391 } 3392 3393 /** 3394 * @param value {@link #conditionalCreate} (A flag that indicates that the server supports conditional create.). This is the underlying object with id, value and extensions. The accessor "getConditionalCreate" gives direct access to the value 3395 */ 3396 public CapabilityStatementRestResourceComponent setConditionalCreateElement(BooleanType value) { 3397 this.conditionalCreate = value; 3398 return this; 3399 } 3400 3401 /** 3402 * @return A flag that indicates that the server supports conditional create. 3403 */ 3404 public boolean getConditionalCreate() { 3405 return this.conditionalCreate == null || this.conditionalCreate.isEmpty() ? false : this.conditionalCreate.getValue(); 3406 } 3407 3408 /** 3409 * @param value A flag that indicates that the server supports conditional create. 3410 */ 3411 public CapabilityStatementRestResourceComponent setConditionalCreate(boolean value) { 3412 if (this.conditionalCreate == null) 3413 this.conditionalCreate = new BooleanType(); 3414 this.conditionalCreate.setValue(value); 3415 return this; 3416 } 3417 3418 /** 3419 * @return {@link #conditionalRead} (A code that indicates how the server supports conditional read.). This is the underlying object with id, value and extensions. The accessor "getConditionalRead" gives direct access to the value 3420 */ 3421 public Enumeration<ConditionalReadStatus> getConditionalReadElement() { 3422 if (this.conditionalRead == null) 3423 if (Configuration.errorOnAutoCreate()) 3424 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.conditionalRead"); 3425 else if (Configuration.doAutoCreate()) 3426 this.conditionalRead = new Enumeration<ConditionalReadStatus>(new ConditionalReadStatusEnumFactory()); // bb 3427 return this.conditionalRead; 3428 } 3429 3430 public boolean hasConditionalReadElement() { 3431 return this.conditionalRead != null && !this.conditionalRead.isEmpty(); 3432 } 3433 3434 public boolean hasConditionalRead() { 3435 return this.conditionalRead != null && !this.conditionalRead.isEmpty(); 3436 } 3437 3438 /** 3439 * @param value {@link #conditionalRead} (A code that indicates how the server supports conditional read.). This is the underlying object with id, value and extensions. The accessor "getConditionalRead" gives direct access to the value 3440 */ 3441 public CapabilityStatementRestResourceComponent setConditionalReadElement(Enumeration<ConditionalReadStatus> value) { 3442 this.conditionalRead = value; 3443 return this; 3444 } 3445 3446 /** 3447 * @return A code that indicates how the server supports conditional read. 3448 */ 3449 public ConditionalReadStatus getConditionalRead() { 3450 return this.conditionalRead == null ? null : this.conditionalRead.getValue(); 3451 } 3452 3453 /** 3454 * @param value A code that indicates how the server supports conditional read. 3455 */ 3456 public CapabilityStatementRestResourceComponent setConditionalRead(ConditionalReadStatus value) { 3457 if (value == null) 3458 this.conditionalRead = null; 3459 else { 3460 if (this.conditionalRead == null) 3461 this.conditionalRead = new Enumeration<ConditionalReadStatus>(new ConditionalReadStatusEnumFactory()); 3462 this.conditionalRead.setValue(value); 3463 } 3464 return this; 3465 } 3466 3467 /** 3468 * @return {@link #conditionalUpdate} (A flag that indicates that the server supports conditional update.). This is the underlying object with id, value and extensions. The accessor "getConditionalUpdate" gives direct access to the value 3469 */ 3470 public BooleanType getConditionalUpdateElement() { 3471 if (this.conditionalUpdate == null) 3472 if (Configuration.errorOnAutoCreate()) 3473 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.conditionalUpdate"); 3474 else if (Configuration.doAutoCreate()) 3475 this.conditionalUpdate = new BooleanType(); // bb 3476 return this.conditionalUpdate; 3477 } 3478 3479 public boolean hasConditionalUpdateElement() { 3480 return this.conditionalUpdate != null && !this.conditionalUpdate.isEmpty(); 3481 } 3482 3483 public boolean hasConditionalUpdate() { 3484 return this.conditionalUpdate != null && !this.conditionalUpdate.isEmpty(); 3485 } 3486 3487 /** 3488 * @param value {@link #conditionalUpdate} (A flag that indicates that the server supports conditional update.). This is the underlying object with id, value and extensions. The accessor "getConditionalUpdate" gives direct access to the value 3489 */ 3490 public CapabilityStatementRestResourceComponent setConditionalUpdateElement(BooleanType value) { 3491 this.conditionalUpdate = value; 3492 return this; 3493 } 3494 3495 /** 3496 * @return A flag that indicates that the server supports conditional update. 3497 */ 3498 public boolean getConditionalUpdate() { 3499 return this.conditionalUpdate == null || this.conditionalUpdate.isEmpty() ? false : this.conditionalUpdate.getValue(); 3500 } 3501 3502 /** 3503 * @param value A flag that indicates that the server supports conditional update. 3504 */ 3505 public CapabilityStatementRestResourceComponent setConditionalUpdate(boolean value) { 3506 if (this.conditionalUpdate == null) 3507 this.conditionalUpdate = new BooleanType(); 3508 this.conditionalUpdate.setValue(value); 3509 return this; 3510 } 3511 3512 /** 3513 * @return {@link #conditionalDelete} (A code that indicates how the server supports conditional delete.). This is the underlying object with id, value and extensions. The accessor "getConditionalDelete" gives direct access to the value 3514 */ 3515 public Enumeration<ConditionalDeleteStatus> getConditionalDeleteElement() { 3516 if (this.conditionalDelete == null) 3517 if (Configuration.errorOnAutoCreate()) 3518 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.conditionalDelete"); 3519 else if (Configuration.doAutoCreate()) 3520 this.conditionalDelete = new Enumeration<ConditionalDeleteStatus>(new ConditionalDeleteStatusEnumFactory()); // bb 3521 return this.conditionalDelete; 3522 } 3523 3524 public boolean hasConditionalDeleteElement() { 3525 return this.conditionalDelete != null && !this.conditionalDelete.isEmpty(); 3526 } 3527 3528 public boolean hasConditionalDelete() { 3529 return this.conditionalDelete != null && !this.conditionalDelete.isEmpty(); 3530 } 3531 3532 /** 3533 * @param value {@link #conditionalDelete} (A code that indicates how the server supports conditional delete.). This is the underlying object with id, value and extensions. The accessor "getConditionalDelete" gives direct access to the value 3534 */ 3535 public CapabilityStatementRestResourceComponent setConditionalDeleteElement(Enumeration<ConditionalDeleteStatus> value) { 3536 this.conditionalDelete = value; 3537 return this; 3538 } 3539 3540 /** 3541 * @return A code that indicates how the server supports conditional delete. 3542 */ 3543 public ConditionalDeleteStatus getConditionalDelete() { 3544 return this.conditionalDelete == null ? null : this.conditionalDelete.getValue(); 3545 } 3546 3547 /** 3548 * @param value A code that indicates how the server supports conditional delete. 3549 */ 3550 public CapabilityStatementRestResourceComponent setConditionalDelete(ConditionalDeleteStatus value) { 3551 if (value == null) 3552 this.conditionalDelete = null; 3553 else { 3554 if (this.conditionalDelete == null) 3555 this.conditionalDelete = new Enumeration<ConditionalDeleteStatus>(new ConditionalDeleteStatusEnumFactory()); 3556 this.conditionalDelete.setValue(value); 3557 } 3558 return this; 3559 } 3560 3561 /** 3562 * @return {@link #referencePolicy} (A set of flags that defines how references are supported.) 3563 */ 3564 public List<Enumeration<ReferenceHandlingPolicy>> getReferencePolicy() { 3565 if (this.referencePolicy == null) 3566 this.referencePolicy = new ArrayList<Enumeration<ReferenceHandlingPolicy>>(); 3567 return this.referencePolicy; 3568 } 3569 3570 /** 3571 * @return Returns a reference to <code>this</code> for easy method chaining 3572 */ 3573 public CapabilityStatementRestResourceComponent setReferencePolicy(List<Enumeration<ReferenceHandlingPolicy>> theReferencePolicy) { 3574 this.referencePolicy = theReferencePolicy; 3575 return this; 3576 } 3577 3578 public boolean hasReferencePolicy() { 3579 if (this.referencePolicy == null) 3580 return false; 3581 for (Enumeration<ReferenceHandlingPolicy> item : this.referencePolicy) 3582 if (!item.isEmpty()) 3583 return true; 3584 return false; 3585 } 3586 3587 /** 3588 * @return {@link #referencePolicy} (A set of flags that defines how references are supported.) 3589 */ 3590 public Enumeration<ReferenceHandlingPolicy> addReferencePolicyElement() {//2 3591 Enumeration<ReferenceHandlingPolicy> t = new Enumeration<ReferenceHandlingPolicy>(new ReferenceHandlingPolicyEnumFactory()); 3592 if (this.referencePolicy == null) 3593 this.referencePolicy = new ArrayList<Enumeration<ReferenceHandlingPolicy>>(); 3594 this.referencePolicy.add(t); 3595 return t; 3596 } 3597 3598 /** 3599 * @param value {@link #referencePolicy} (A set of flags that defines how references are supported.) 3600 */ 3601 public CapabilityStatementRestResourceComponent addReferencePolicy(ReferenceHandlingPolicy value) { //1 3602 Enumeration<ReferenceHandlingPolicy> t = new Enumeration<ReferenceHandlingPolicy>(new ReferenceHandlingPolicyEnumFactory()); 3603 t.setValue(value); 3604 if (this.referencePolicy == null) 3605 this.referencePolicy = new ArrayList<Enumeration<ReferenceHandlingPolicy>>(); 3606 this.referencePolicy.add(t); 3607 return this; 3608 } 3609 3610 /** 3611 * @param value {@link #referencePolicy} (A set of flags that defines how references are supported.) 3612 */ 3613 public boolean hasReferencePolicy(ReferenceHandlingPolicy value) { 3614 if (this.referencePolicy == null) 3615 return false; 3616 for (Enumeration<ReferenceHandlingPolicy> v : this.referencePolicy) 3617 if (v.getValue().equals(value)) // code 3618 return true; 3619 return false; 3620 } 3621 3622 /** 3623 * @return {@link #searchInclude} (A list of _include values supported by the server.) 3624 */ 3625 public List<StringType> getSearchInclude() { 3626 if (this.searchInclude == null) 3627 this.searchInclude = new ArrayList<StringType>(); 3628 return this.searchInclude; 3629 } 3630 3631 /** 3632 * @return Returns a reference to <code>this</code> for easy method chaining 3633 */ 3634 public CapabilityStatementRestResourceComponent setSearchInclude(List<StringType> theSearchInclude) { 3635 this.searchInclude = theSearchInclude; 3636 return this; 3637 } 3638 3639 public boolean hasSearchInclude() { 3640 if (this.searchInclude == null) 3641 return false; 3642 for (StringType item : this.searchInclude) 3643 if (!item.isEmpty()) 3644 return true; 3645 return false; 3646 } 3647 3648 /** 3649 * @return {@link #searchInclude} (A list of _include values supported by the server.) 3650 */ 3651 public StringType addSearchIncludeElement() {//2 3652 StringType t = new StringType(); 3653 if (this.searchInclude == null) 3654 this.searchInclude = new ArrayList<StringType>(); 3655 this.searchInclude.add(t); 3656 return t; 3657 } 3658 3659 /** 3660 * @param value {@link #searchInclude} (A list of _include values supported by the server.) 3661 */ 3662 public CapabilityStatementRestResourceComponent addSearchInclude(String value) { //1 3663 StringType t = new StringType(); 3664 t.setValue(value); 3665 if (this.searchInclude == null) 3666 this.searchInclude = new ArrayList<StringType>(); 3667 this.searchInclude.add(t); 3668 return this; 3669 } 3670 3671 /** 3672 * @param value {@link #searchInclude} (A list of _include values supported by the server.) 3673 */ 3674 public boolean hasSearchInclude(String value) { 3675 if (this.searchInclude == null) 3676 return false; 3677 for (StringType v : this.searchInclude) 3678 if (v.getValue().equals(value)) // string 3679 return true; 3680 return false; 3681 } 3682 3683 /** 3684 * @return {@link #searchRevInclude} (A list of _revinclude (reverse include) values supported by the server.) 3685 */ 3686 public List<StringType> getSearchRevInclude() { 3687 if (this.searchRevInclude == null) 3688 this.searchRevInclude = new ArrayList<StringType>(); 3689 return this.searchRevInclude; 3690 } 3691 3692 /** 3693 * @return Returns a reference to <code>this</code> for easy method chaining 3694 */ 3695 public CapabilityStatementRestResourceComponent setSearchRevInclude(List<StringType> theSearchRevInclude) { 3696 this.searchRevInclude = theSearchRevInclude; 3697 return this; 3698 } 3699 3700 public boolean hasSearchRevInclude() { 3701 if (this.searchRevInclude == null) 3702 return false; 3703 for (StringType item : this.searchRevInclude) 3704 if (!item.isEmpty()) 3705 return true; 3706 return false; 3707 } 3708 3709 /** 3710 * @return {@link #searchRevInclude} (A list of _revinclude (reverse include) values supported by the server.) 3711 */ 3712 public StringType addSearchRevIncludeElement() {//2 3713 StringType t = new StringType(); 3714 if (this.searchRevInclude == null) 3715 this.searchRevInclude = new ArrayList<StringType>(); 3716 this.searchRevInclude.add(t); 3717 return t; 3718 } 3719 3720 /** 3721 * @param value {@link #searchRevInclude} (A list of _revinclude (reverse include) values supported by the server.) 3722 */ 3723 public CapabilityStatementRestResourceComponent addSearchRevInclude(String value) { //1 3724 StringType t = new StringType(); 3725 t.setValue(value); 3726 if (this.searchRevInclude == null) 3727 this.searchRevInclude = new ArrayList<StringType>(); 3728 this.searchRevInclude.add(t); 3729 return this; 3730 } 3731 3732 /** 3733 * @param value {@link #searchRevInclude} (A list of _revinclude (reverse include) values supported by the server.) 3734 */ 3735 public boolean hasSearchRevInclude(String value) { 3736 if (this.searchRevInclude == null) 3737 return false; 3738 for (StringType v : this.searchRevInclude) 3739 if (v.getValue().equals(value)) // string 3740 return true; 3741 return false; 3742 } 3743 3744 /** 3745 * @return {@link #searchParam} (Search parameters for implementations to support and/or make use of - either references to ones defined in the specification, or additional ones defined for/by the implementation.) 3746 */ 3747 public List<CapabilityStatementRestResourceSearchParamComponent> getSearchParam() { 3748 if (this.searchParam == null) 3749 this.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>(); 3750 return this.searchParam; 3751 } 3752 3753 /** 3754 * @return Returns a reference to <code>this</code> for easy method chaining 3755 */ 3756 public CapabilityStatementRestResourceComponent setSearchParam(List<CapabilityStatementRestResourceSearchParamComponent> theSearchParam) { 3757 this.searchParam = theSearchParam; 3758 return this; 3759 } 3760 3761 public boolean hasSearchParam() { 3762 if (this.searchParam == null) 3763 return false; 3764 for (CapabilityStatementRestResourceSearchParamComponent item : this.searchParam) 3765 if (!item.isEmpty()) 3766 return true; 3767 return false; 3768 } 3769 3770 public CapabilityStatementRestResourceSearchParamComponent addSearchParam() { //3 3771 CapabilityStatementRestResourceSearchParamComponent t = new CapabilityStatementRestResourceSearchParamComponent(); 3772 if (this.searchParam == null) 3773 this.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>(); 3774 this.searchParam.add(t); 3775 return t; 3776 } 3777 3778 public CapabilityStatementRestResourceComponent addSearchParam(CapabilityStatementRestResourceSearchParamComponent t) { //3 3779 if (t == null) 3780 return this; 3781 if (this.searchParam == null) 3782 this.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>(); 3783 this.searchParam.add(t); 3784 return this; 3785 } 3786 3787 /** 3788 * @return The first repetition of repeating field {@link #searchParam}, creating it if it does not already exist {3} 3789 */ 3790 public CapabilityStatementRestResourceSearchParamComponent getSearchParamFirstRep() { 3791 if (getSearchParam().isEmpty()) { 3792 addSearchParam(); 3793 } 3794 return getSearchParam().get(0); 3795 } 3796 3797 /** 3798 * @return {@link #operation} (Definition of an operation or a named query together with its parameters and their meaning and type. Consult the definition of the operation for details about how to invoke the operation, and the parameters.) 3799 */ 3800 public List<CapabilityStatementRestResourceOperationComponent> getOperation() { 3801 if (this.operation == null) 3802 this.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>(); 3803 return this.operation; 3804 } 3805 3806 /** 3807 * @return Returns a reference to <code>this</code> for easy method chaining 3808 */ 3809 public CapabilityStatementRestResourceComponent setOperation(List<CapabilityStatementRestResourceOperationComponent> theOperation) { 3810 this.operation = theOperation; 3811 return this; 3812 } 3813 3814 public boolean hasOperation() { 3815 if (this.operation == null) 3816 return false; 3817 for (CapabilityStatementRestResourceOperationComponent item : this.operation) 3818 if (!item.isEmpty()) 3819 return true; 3820 return false; 3821 } 3822 3823 public CapabilityStatementRestResourceOperationComponent addOperation() { //3 3824 CapabilityStatementRestResourceOperationComponent t = new CapabilityStatementRestResourceOperationComponent(); 3825 if (this.operation == null) 3826 this.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>(); 3827 this.operation.add(t); 3828 return t; 3829 } 3830 3831 public CapabilityStatementRestResourceComponent addOperation(CapabilityStatementRestResourceOperationComponent t) { //3 3832 if (t == null) 3833 return this; 3834 if (this.operation == null) 3835 this.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>(); 3836 this.operation.add(t); 3837 return this; 3838 } 3839 3840 /** 3841 * @return The first repetition of repeating field {@link #operation}, creating it if it does not already exist {3} 3842 */ 3843 public CapabilityStatementRestResourceOperationComponent getOperationFirstRep() { 3844 if (getOperation().isEmpty()) { 3845 addOperation(); 3846 } 3847 return getOperation().get(0); 3848 } 3849 3850 protected void listChildren(List<Property> children) { 3851 super.listChildren(children); 3852 children.add(new Property("type", "code", "A type of resource exposed via the restful interface.", 0, 1, type)); 3853 children.add(new Property("profile", "canonical(StructureDefinition)", "A specification of the profile that describes the solution's overall support for the resource, including any constraints on cardinality, bindings, lengths or other limitations. See further discussion in [Using Profiles](profiling.html#profile-uses).", 0, 1, profile)); 3854 children.add(new Property("supportedProfile", "canonical(StructureDefinition)", "A list of profiles that represent different use cases supported by the system. For a server, \"supported by the system\" means the system hosts/produces a set of resources that are conformant to a particular profile, and allows clients that use its services to search using this profile and to find appropriate data. For a client, it means the system will search by this profile and process data according to the guidance implicit in the profile. See further discussion in [Using Profiles](profiling.html#profile-uses).", 0, java.lang.Integer.MAX_VALUE, supportedProfile)); 3855 children.add(new Property("documentation", "markdown", "Additional information about the resource type used by the system.", 0, 1, documentation)); 3856 children.add(new Property("interaction", "", "Identifies a restful operation supported by the solution.", 0, java.lang.Integer.MAX_VALUE, interaction)); 3857 children.add(new Property("versioning", "code", "This field is set to no-version to specify that the system does not support (server) or use (client) versioning for this resource type. If this has some other value, the server must at least correctly track and populate the versionId meta-property on resources. If the value is 'versioned-update', then the server supports all the versioning features, including using e-tags for version integrity in the API.", 0, 1, versioning)); 3858 children.add(new Property("readHistory", "boolean", "A flag for whether the server is able to return past versions as part of the vRead operation.", 0, 1, readHistory)); 3859 children.add(new Property("updateCreate", "boolean", "A flag to indicate that the server allows or needs to allow the client to create new identities on the server (that is, the client PUTs to a location where there is no existing resource). Allowing this operation means that the server allows the client to create new identities on the server.", 0, 1, updateCreate)); 3860 children.add(new Property("conditionalCreate", "boolean", "A flag that indicates that the server supports conditional create.", 0, 1, conditionalCreate)); 3861 children.add(new Property("conditionalRead", "code", "A code that indicates how the server supports conditional read.", 0, 1, conditionalRead)); 3862 children.add(new Property("conditionalUpdate", "boolean", "A flag that indicates that the server supports conditional update.", 0, 1, conditionalUpdate)); 3863 children.add(new Property("conditionalDelete", "code", "A code that indicates how the server supports conditional delete.", 0, 1, conditionalDelete)); 3864 children.add(new Property("referencePolicy", "code", "A set of flags that defines how references are supported.", 0, java.lang.Integer.MAX_VALUE, referencePolicy)); 3865 children.add(new Property("searchInclude", "string", "A list of _include values supported by the server.", 0, java.lang.Integer.MAX_VALUE, searchInclude)); 3866 children.add(new Property("searchRevInclude", "string", "A list of _revinclude (reverse include) values supported by the server.", 0, java.lang.Integer.MAX_VALUE, searchRevInclude)); 3867 children.add(new Property("searchParam", "", "Search parameters for implementations to support and/or make use of - either references to ones defined in the specification, or additional ones defined for/by the implementation.", 0, java.lang.Integer.MAX_VALUE, searchParam)); 3868 children.add(new Property("operation", "", "Definition of an operation or a named query together with its parameters and their meaning and type. Consult the definition of the operation for details about how to invoke the operation, and the parameters.", 0, java.lang.Integer.MAX_VALUE, operation)); 3869 } 3870 3871 @Override 3872 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 3873 switch (_hash) { 3874 case 3575610: /*type*/ return new Property("type", "code", "A type of resource exposed via the restful interface.", 0, 1, type); 3875 case -309425751: /*profile*/ return new Property("profile", "canonical(StructureDefinition)", "A specification of the profile that describes the solution's overall support for the resource, including any constraints on cardinality, bindings, lengths or other limitations. See further discussion in [Using Profiles](profiling.html#profile-uses).", 0, 1, profile); 3876 case 1225477403: /*supportedProfile*/ return new Property("supportedProfile", "canonical(StructureDefinition)", "A list of profiles that represent different use cases supported by the system. For a server, \"supported by the system\" means the system hosts/produces a set of resources that are conformant to a particular profile, and allows clients that use its services to search using this profile and to find appropriate data. For a client, it means the system will search by this profile and process data according to the guidance implicit in the profile. See further discussion in [Using Profiles](profiling.html#profile-uses).", 0, java.lang.Integer.MAX_VALUE, supportedProfile); 3877 case 1587405498: /*documentation*/ return new Property("documentation", "markdown", "Additional information about the resource type used by the system.", 0, 1, documentation); 3878 case 1844104722: /*interaction*/ return new Property("interaction", "", "Identifies a restful operation supported by the solution.", 0, java.lang.Integer.MAX_VALUE, interaction); 3879 case -670487542: /*versioning*/ return new Property("versioning", "code", "This field is set to no-version to specify that the system does not support (server) or use (client) versioning for this resource type. If this has some other value, the server must at least correctly track and populate the versionId meta-property on resources. If the value is 'versioned-update', then the server supports all the versioning features, including using e-tags for version integrity in the API.", 0, 1, versioning); 3880 case 187518494: /*readHistory*/ return new Property("readHistory", "boolean", "A flag for whether the server is able to return past versions as part of the vRead operation.", 0, 1, readHistory); 3881 case -1400550619: /*updateCreate*/ return new Property("updateCreate", "boolean", "A flag to indicate that the server allows or needs to allow the client to create new identities on the server (that is, the client PUTs to a location where there is no existing resource). Allowing this operation means that the server allows the client to create new identities on the server.", 0, 1, updateCreate); 3882 case 6401826: /*conditionalCreate*/ return new Property("conditionalCreate", "boolean", "A flag that indicates that the server supports conditional create.", 0, 1, conditionalCreate); 3883 case 822786364: /*conditionalRead*/ return new Property("conditionalRead", "code", "A code that indicates how the server supports conditional read.", 0, 1, conditionalRead); 3884 case 519849711: /*conditionalUpdate*/ return new Property("conditionalUpdate", "boolean", "A flag that indicates that the server supports conditional update.", 0, 1, conditionalUpdate); 3885 case 23237585: /*conditionalDelete*/ return new Property("conditionalDelete", "code", "A code that indicates how the server supports conditional delete.", 0, 1, conditionalDelete); 3886 case 796257373: /*referencePolicy*/ return new Property("referencePolicy", "code", "A set of flags that defines how references are supported.", 0, java.lang.Integer.MAX_VALUE, referencePolicy); 3887 case -1035904544: /*searchInclude*/ return new Property("searchInclude", "string", "A list of _include values supported by the server.", 0, java.lang.Integer.MAX_VALUE, searchInclude); 3888 case -2123884979: /*searchRevInclude*/ return new Property("searchRevInclude", "string", "A list of _revinclude (reverse include) values supported by the server.", 0, java.lang.Integer.MAX_VALUE, searchRevInclude); 3889 case -553645115: /*searchParam*/ return new Property("searchParam", "", "Search parameters for implementations to support and/or make use of - either references to ones defined in the specification, or additional ones defined for/by the implementation.", 0, java.lang.Integer.MAX_VALUE, searchParam); 3890 case 1662702951: /*operation*/ return new Property("operation", "", "Definition of an operation or a named query together with its parameters and their meaning and type. Consult the definition of the operation for details about how to invoke the operation, and the parameters.", 0, java.lang.Integer.MAX_VALUE, operation); 3891 default: return super.getNamedProperty(_hash, _name, _checkValid); 3892 } 3893 3894 } 3895 3896 @Override 3897 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 3898 switch (hash) { 3899 case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // CodeType 3900 case -309425751: /*profile*/ return this.profile == null ? new Base[0] : new Base[] {this.profile}; // CanonicalType 3901 case 1225477403: /*supportedProfile*/ return this.supportedProfile == null ? new Base[0] : this.supportedProfile.toArray(new Base[this.supportedProfile.size()]); // CanonicalType 3902 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 3903 case 1844104722: /*interaction*/ return this.interaction == null ? new Base[0] : this.interaction.toArray(new Base[this.interaction.size()]); // ResourceInteractionComponent 3904 case -670487542: /*versioning*/ return this.versioning == null ? new Base[0] : new Base[] {this.versioning}; // Enumeration<ResourceVersionPolicy> 3905 case 187518494: /*readHistory*/ return this.readHistory == null ? new Base[0] : new Base[] {this.readHistory}; // BooleanType 3906 case -1400550619: /*updateCreate*/ return this.updateCreate == null ? new Base[0] : new Base[] {this.updateCreate}; // BooleanType 3907 case 6401826: /*conditionalCreate*/ return this.conditionalCreate == null ? new Base[0] : new Base[] {this.conditionalCreate}; // BooleanType 3908 case 822786364: /*conditionalRead*/ return this.conditionalRead == null ? new Base[0] : new Base[] {this.conditionalRead}; // Enumeration<ConditionalReadStatus> 3909 case 519849711: /*conditionalUpdate*/ return this.conditionalUpdate == null ? new Base[0] : new Base[] {this.conditionalUpdate}; // BooleanType 3910 case 23237585: /*conditionalDelete*/ return this.conditionalDelete == null ? new Base[0] : new Base[] {this.conditionalDelete}; // Enumeration<ConditionalDeleteStatus> 3911 case 796257373: /*referencePolicy*/ return this.referencePolicy == null ? new Base[0] : this.referencePolicy.toArray(new Base[this.referencePolicy.size()]); // Enumeration<ReferenceHandlingPolicy> 3912 case -1035904544: /*searchInclude*/ return this.searchInclude == null ? new Base[0] : this.searchInclude.toArray(new Base[this.searchInclude.size()]); // StringType 3913 case -2123884979: /*searchRevInclude*/ return this.searchRevInclude == null ? new Base[0] : this.searchRevInclude.toArray(new Base[this.searchRevInclude.size()]); // StringType 3914 case -553645115: /*searchParam*/ return this.searchParam == null ? new Base[0] : this.searchParam.toArray(new Base[this.searchParam.size()]); // CapabilityStatementRestResourceSearchParamComponent 3915 case 1662702951: /*operation*/ return this.operation == null ? new Base[0] : this.operation.toArray(new Base[this.operation.size()]); // CapabilityStatementRestResourceOperationComponent 3916 default: return super.getProperty(hash, name, checkValid); 3917 } 3918 3919 } 3920 3921 @Override 3922 public Base setProperty(int hash, String name, Base value) throws FHIRException { 3923 switch (hash) { 3924 case 3575610: // type 3925 this.type = TypeConvertor.castToCode(value); // CodeType 3926 return value; 3927 case -309425751: // profile 3928 this.profile = TypeConvertor.castToCanonical(value); // CanonicalType 3929 return value; 3930 case 1225477403: // supportedProfile 3931 this.getSupportedProfile().add(TypeConvertor.castToCanonical(value)); // CanonicalType 3932 return value; 3933 case 1587405498: // documentation 3934 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 3935 return value; 3936 case 1844104722: // interaction 3937 this.getInteraction().add((ResourceInteractionComponent) value); // ResourceInteractionComponent 3938 return value; 3939 case -670487542: // versioning 3940 value = new ResourceVersionPolicyEnumFactory().fromType(TypeConvertor.castToCode(value)); 3941 this.versioning = (Enumeration) value; // Enumeration<ResourceVersionPolicy> 3942 return value; 3943 case 187518494: // readHistory 3944 this.readHistory = TypeConvertor.castToBoolean(value); // BooleanType 3945 return value; 3946 case -1400550619: // updateCreate 3947 this.updateCreate = TypeConvertor.castToBoolean(value); // BooleanType 3948 return value; 3949 case 6401826: // conditionalCreate 3950 this.conditionalCreate = TypeConvertor.castToBoolean(value); // BooleanType 3951 return value; 3952 case 822786364: // conditionalRead 3953 value = new ConditionalReadStatusEnumFactory().fromType(TypeConvertor.castToCode(value)); 3954 this.conditionalRead = (Enumeration) value; // Enumeration<ConditionalReadStatus> 3955 return value; 3956 case 519849711: // conditionalUpdate 3957 this.conditionalUpdate = TypeConvertor.castToBoolean(value); // BooleanType 3958 return value; 3959 case 23237585: // conditionalDelete 3960 value = new ConditionalDeleteStatusEnumFactory().fromType(TypeConvertor.castToCode(value)); 3961 this.conditionalDelete = (Enumeration) value; // Enumeration<ConditionalDeleteStatus> 3962 return value; 3963 case 796257373: // referencePolicy 3964 value = new ReferenceHandlingPolicyEnumFactory().fromType(TypeConvertor.castToCode(value)); 3965 this.getReferencePolicy().add((Enumeration) value); // Enumeration<ReferenceHandlingPolicy> 3966 return value; 3967 case -1035904544: // searchInclude 3968 this.getSearchInclude().add(TypeConvertor.castToString(value)); // StringType 3969 return value; 3970 case -2123884979: // searchRevInclude 3971 this.getSearchRevInclude().add(TypeConvertor.castToString(value)); // StringType 3972 return value; 3973 case -553645115: // searchParam 3974 this.getSearchParam().add((CapabilityStatementRestResourceSearchParamComponent) value); // CapabilityStatementRestResourceSearchParamComponent 3975 return value; 3976 case 1662702951: // operation 3977 this.getOperation().add((CapabilityStatementRestResourceOperationComponent) value); // CapabilityStatementRestResourceOperationComponent 3978 return value; 3979 default: return super.setProperty(hash, name, value); 3980 } 3981 3982 } 3983 3984 @Override 3985 public Base setProperty(String name, Base value) throws FHIRException { 3986 if (name.equals("type")) { 3987 this.type = TypeConvertor.castToCode(value); // CodeType 3988 } else if (name.equals("profile")) { 3989 this.profile = TypeConvertor.castToCanonical(value); // CanonicalType 3990 } else if (name.equals("supportedProfile")) { 3991 this.getSupportedProfile().add(TypeConvertor.castToCanonical(value)); 3992 } else if (name.equals("documentation")) { 3993 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 3994 } else if (name.equals("interaction")) { 3995 this.getInteraction().add((ResourceInteractionComponent) value); 3996 } else if (name.equals("versioning")) { 3997 value = new ResourceVersionPolicyEnumFactory().fromType(TypeConvertor.castToCode(value)); 3998 this.versioning = (Enumeration) value; // Enumeration<ResourceVersionPolicy> 3999 } else if (name.equals("readHistory")) { 4000 this.readHistory = TypeConvertor.castToBoolean(value); // BooleanType 4001 } else if (name.equals("updateCreate")) { 4002 this.updateCreate = TypeConvertor.castToBoolean(value); // BooleanType 4003 } else if (name.equals("conditionalCreate")) { 4004 this.conditionalCreate = TypeConvertor.castToBoolean(value); // BooleanType 4005 } else if (name.equals("conditionalRead")) { 4006 value = new ConditionalReadStatusEnumFactory().fromType(TypeConvertor.castToCode(value)); 4007 this.conditionalRead = (Enumeration) value; // Enumeration<ConditionalReadStatus> 4008 } else if (name.equals("conditionalUpdate")) { 4009 this.conditionalUpdate = TypeConvertor.castToBoolean(value); // BooleanType 4010 } else if (name.equals("conditionalDelete")) { 4011 value = new ConditionalDeleteStatusEnumFactory().fromType(TypeConvertor.castToCode(value)); 4012 this.conditionalDelete = (Enumeration) value; // Enumeration<ConditionalDeleteStatus> 4013 } else if (name.equals("referencePolicy")) { 4014 value = new ReferenceHandlingPolicyEnumFactory().fromType(TypeConvertor.castToCode(value)); 4015 this.getReferencePolicy().add((Enumeration) value); 4016 } else if (name.equals("searchInclude")) { 4017 this.getSearchInclude().add(TypeConvertor.castToString(value)); 4018 } else if (name.equals("searchRevInclude")) { 4019 this.getSearchRevInclude().add(TypeConvertor.castToString(value)); 4020 } else if (name.equals("searchParam")) { 4021 this.getSearchParam().add((CapabilityStatementRestResourceSearchParamComponent) value); 4022 } else if (name.equals("operation")) { 4023 this.getOperation().add((CapabilityStatementRestResourceOperationComponent) value); 4024 } else 4025 return super.setProperty(name, value); 4026 return value; 4027 } 4028 4029 @Override 4030 public Base makeProperty(int hash, String name) throws FHIRException { 4031 switch (hash) { 4032 case 3575610: return getTypeElement(); 4033 case -309425751: return getProfileElement(); 4034 case 1225477403: return addSupportedProfileElement(); 4035 case 1587405498: return getDocumentationElement(); 4036 case 1844104722: return addInteraction(); 4037 case -670487542: return getVersioningElement(); 4038 case 187518494: return getReadHistoryElement(); 4039 case -1400550619: return getUpdateCreateElement(); 4040 case 6401826: return getConditionalCreateElement(); 4041 case 822786364: return getConditionalReadElement(); 4042 case 519849711: return getConditionalUpdateElement(); 4043 case 23237585: return getConditionalDeleteElement(); 4044 case 796257373: return addReferencePolicyElement(); 4045 case -1035904544: return addSearchIncludeElement(); 4046 case -2123884979: return addSearchRevIncludeElement(); 4047 case -553645115: return addSearchParam(); 4048 case 1662702951: return addOperation(); 4049 default: return super.makeProperty(hash, name); 4050 } 4051 4052 } 4053 4054 @Override 4055 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 4056 switch (hash) { 4057 case 3575610: /*type*/ return new String[] {"code"}; 4058 case -309425751: /*profile*/ return new String[] {"canonical"}; 4059 case 1225477403: /*supportedProfile*/ return new String[] {"canonical"}; 4060 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 4061 case 1844104722: /*interaction*/ return new String[] {}; 4062 case -670487542: /*versioning*/ return new String[] {"code"}; 4063 case 187518494: /*readHistory*/ return new String[] {"boolean"}; 4064 case -1400550619: /*updateCreate*/ return new String[] {"boolean"}; 4065 case 6401826: /*conditionalCreate*/ return new String[] {"boolean"}; 4066 case 822786364: /*conditionalRead*/ return new String[] {"code"}; 4067 case 519849711: /*conditionalUpdate*/ return new String[] {"boolean"}; 4068 case 23237585: /*conditionalDelete*/ return new String[] {"code"}; 4069 case 796257373: /*referencePolicy*/ return new String[] {"code"}; 4070 case -1035904544: /*searchInclude*/ return new String[] {"string"}; 4071 case -2123884979: /*searchRevInclude*/ return new String[] {"string"}; 4072 case -553645115: /*searchParam*/ return new String[] {}; 4073 case 1662702951: /*operation*/ return new String[] {}; 4074 default: return super.getTypesForProperty(hash, name); 4075 } 4076 4077 } 4078 4079 @Override 4080 public Base addChild(String name) throws FHIRException { 4081 if (name.equals("type")) { 4082 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.type"); 4083 } 4084 else if (name.equals("profile")) { 4085 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.profile"); 4086 } 4087 else if (name.equals("supportedProfile")) { 4088 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.supportedProfile"); 4089 } 4090 else if (name.equals("documentation")) { 4091 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.documentation"); 4092 } 4093 else if (name.equals("interaction")) { 4094 return addInteraction(); 4095 } 4096 else if (name.equals("versioning")) { 4097 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.versioning"); 4098 } 4099 else if (name.equals("readHistory")) { 4100 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.readHistory"); 4101 } 4102 else if (name.equals("updateCreate")) { 4103 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.updateCreate"); 4104 } 4105 else if (name.equals("conditionalCreate")) { 4106 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.conditionalCreate"); 4107 } 4108 else if (name.equals("conditionalRead")) { 4109 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.conditionalRead"); 4110 } 4111 else if (name.equals("conditionalUpdate")) { 4112 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.conditionalUpdate"); 4113 } 4114 else if (name.equals("conditionalDelete")) { 4115 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.conditionalDelete"); 4116 } 4117 else if (name.equals("referencePolicy")) { 4118 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.referencePolicy"); 4119 } 4120 else if (name.equals("searchInclude")) { 4121 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.searchInclude"); 4122 } 4123 else if (name.equals("searchRevInclude")) { 4124 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.searchRevInclude"); 4125 } 4126 else if (name.equals("searchParam")) { 4127 return addSearchParam(); 4128 } 4129 else if (name.equals("operation")) { 4130 return addOperation(); 4131 } 4132 else 4133 return super.addChild(name); 4134 } 4135 4136 public CapabilityStatementRestResourceComponent copy() { 4137 CapabilityStatementRestResourceComponent dst = new CapabilityStatementRestResourceComponent(); 4138 copyValues(dst); 4139 return dst; 4140 } 4141 4142 public void copyValues(CapabilityStatementRestResourceComponent dst) { 4143 super.copyValues(dst); 4144 dst.type = type == null ? null : type.copy(); 4145 dst.profile = profile == null ? null : profile.copy(); 4146 if (supportedProfile != null) { 4147 dst.supportedProfile = new ArrayList<CanonicalType>(); 4148 for (CanonicalType i : supportedProfile) 4149 dst.supportedProfile.add(i.copy()); 4150 }; 4151 dst.documentation = documentation == null ? null : documentation.copy(); 4152 if (interaction != null) { 4153 dst.interaction = new ArrayList<ResourceInteractionComponent>(); 4154 for (ResourceInteractionComponent i : interaction) 4155 dst.interaction.add(i.copy()); 4156 }; 4157 dst.versioning = versioning == null ? null : versioning.copy(); 4158 dst.readHistory = readHistory == null ? null : readHistory.copy(); 4159 dst.updateCreate = updateCreate == null ? null : updateCreate.copy(); 4160 dst.conditionalCreate = conditionalCreate == null ? null : conditionalCreate.copy(); 4161 dst.conditionalRead = conditionalRead == null ? null : conditionalRead.copy(); 4162 dst.conditionalUpdate = conditionalUpdate == null ? null : conditionalUpdate.copy(); 4163 dst.conditionalDelete = conditionalDelete == null ? null : conditionalDelete.copy(); 4164 if (referencePolicy != null) { 4165 dst.referencePolicy = new ArrayList<Enumeration<ReferenceHandlingPolicy>>(); 4166 for (Enumeration<ReferenceHandlingPolicy> i : referencePolicy) 4167 dst.referencePolicy.add(i.copy()); 4168 }; 4169 if (searchInclude != null) { 4170 dst.searchInclude = new ArrayList<StringType>(); 4171 for (StringType i : searchInclude) 4172 dst.searchInclude.add(i.copy()); 4173 }; 4174 if (searchRevInclude != null) { 4175 dst.searchRevInclude = new ArrayList<StringType>(); 4176 for (StringType i : searchRevInclude) 4177 dst.searchRevInclude.add(i.copy()); 4178 }; 4179 if (searchParam != null) { 4180 dst.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>(); 4181 for (CapabilityStatementRestResourceSearchParamComponent i : searchParam) 4182 dst.searchParam.add(i.copy()); 4183 }; 4184 if (operation != null) { 4185 dst.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>(); 4186 for (CapabilityStatementRestResourceOperationComponent i : operation) 4187 dst.operation.add(i.copy()); 4188 }; 4189 } 4190 4191 @Override 4192 public boolean equalsDeep(Base other_) { 4193 if (!super.equalsDeep(other_)) 4194 return false; 4195 if (!(other_ instanceof CapabilityStatementRestResourceComponent)) 4196 return false; 4197 CapabilityStatementRestResourceComponent o = (CapabilityStatementRestResourceComponent) other_; 4198 return compareDeep(type, o.type, true) && compareDeep(profile, o.profile, true) && compareDeep(supportedProfile, o.supportedProfile, true) 4199 && compareDeep(documentation, o.documentation, true) && compareDeep(interaction, o.interaction, true) 4200 && compareDeep(versioning, o.versioning, true) && compareDeep(readHistory, o.readHistory, true) 4201 && compareDeep(updateCreate, o.updateCreate, true) && compareDeep(conditionalCreate, o.conditionalCreate, true) 4202 && compareDeep(conditionalRead, o.conditionalRead, true) && compareDeep(conditionalUpdate, o.conditionalUpdate, true) 4203 && compareDeep(conditionalDelete, o.conditionalDelete, true) && compareDeep(referencePolicy, o.referencePolicy, true) 4204 && compareDeep(searchInclude, o.searchInclude, true) && compareDeep(searchRevInclude, o.searchRevInclude, true) 4205 && compareDeep(searchParam, o.searchParam, true) && compareDeep(operation, o.operation, true); 4206 } 4207 4208 @Override 4209 public boolean equalsShallow(Base other_) { 4210 if (!super.equalsShallow(other_)) 4211 return false; 4212 if (!(other_ instanceof CapabilityStatementRestResourceComponent)) 4213 return false; 4214 CapabilityStatementRestResourceComponent o = (CapabilityStatementRestResourceComponent) other_; 4215 return compareValues(type, o.type, true) && compareValues(profile, o.profile, true) && compareValues(supportedProfile, o.supportedProfile, true) 4216 && compareValues(documentation, o.documentation, true) && compareValues(versioning, o.versioning, true) 4217 && compareValues(readHistory, o.readHistory, true) && compareValues(updateCreate, o.updateCreate, true) 4218 && compareValues(conditionalCreate, o.conditionalCreate, true) && compareValues(conditionalRead, o.conditionalRead, true) 4219 && compareValues(conditionalUpdate, o.conditionalUpdate, true) && compareValues(conditionalDelete, o.conditionalDelete, true) 4220 && compareValues(referencePolicy, o.referencePolicy, true) && compareValues(searchInclude, o.searchInclude, true) 4221 && compareValues(searchRevInclude, o.searchRevInclude, true); 4222 } 4223 4224 public boolean isEmpty() { 4225 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, profile, supportedProfile 4226 , documentation, interaction, versioning, readHistory, updateCreate, conditionalCreate 4227 , conditionalRead, conditionalUpdate, conditionalDelete, referencePolicy, searchInclude 4228 , searchRevInclude, searchParam, operation); 4229 } 4230 4231 public String fhirType() { 4232 return "CapabilityStatement.rest.resource"; 4233 4234 } 4235 4236 } 4237 4238 @Block() 4239 public static class ResourceInteractionComponent extends BackboneElement implements IBaseBackboneElement { 4240 /** 4241 * Coded identifier of the operation, supported by the system resource. 4242 */ 4243 @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=false) 4244 @Description(shortDefinition="read | vread | update | patch | delete | history-instance | history-type | create | search-type", formalDefinition="Coded identifier of the operation, supported by the system resource." ) 4245 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/type-restful-interaction") 4246 protected Enumeration<TypeRestfulInteraction> code; 4247 4248 /** 4249 * Guidance specific to the implementation of this operation, such as 'delete is a logical delete' or 'updates are only allowed with version id' or 'creates permitted from pre-authorized certificates only'. 4250 */ 4251 @Child(name = "documentation", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=false) 4252 @Description(shortDefinition="Anything special about operation behavior", formalDefinition="Guidance specific to the implementation of this operation, such as 'delete is a logical delete' or 'updates are only allowed with version id' or 'creates permitted from pre-authorized certificates only'." ) 4253 protected MarkdownType documentation; 4254 4255 private static final long serialVersionUID = 2128937796L; 4256 4257 /** 4258 * Constructor 4259 */ 4260 public ResourceInteractionComponent() { 4261 super(); 4262 } 4263 4264 /** 4265 * Constructor 4266 */ 4267 public ResourceInteractionComponent(TypeRestfulInteraction code) { 4268 super(); 4269 this.setCode(code); 4270 } 4271 4272 /** 4273 * @return {@link #code} (Coded identifier of the operation, supported by the system resource.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value 4274 */ 4275 public Enumeration<TypeRestfulInteraction> getCodeElement() { 4276 if (this.code == null) 4277 if (Configuration.errorOnAutoCreate()) 4278 throw new Error("Attempt to auto-create ResourceInteractionComponent.code"); 4279 else if (Configuration.doAutoCreate()) 4280 this.code = new Enumeration<TypeRestfulInteraction>(new TypeRestfulInteractionEnumFactory()); // bb 4281 return this.code; 4282 } 4283 4284 public boolean hasCodeElement() { 4285 return this.code != null && !this.code.isEmpty(); 4286 } 4287 4288 public boolean hasCode() { 4289 return this.code != null && !this.code.isEmpty(); 4290 } 4291 4292 /** 4293 * @param value {@link #code} (Coded identifier of the operation, supported by the system resource.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value 4294 */ 4295 public ResourceInteractionComponent setCodeElement(Enumeration<TypeRestfulInteraction> value) { 4296 this.code = value; 4297 return this; 4298 } 4299 4300 /** 4301 * @return Coded identifier of the operation, supported by the system resource. 4302 */ 4303 public TypeRestfulInteraction getCode() { 4304 return this.code == null ? null : this.code.getValue(); 4305 } 4306 4307 /** 4308 * @param value Coded identifier of the operation, supported by the system resource. 4309 */ 4310 public ResourceInteractionComponent setCode(TypeRestfulInteraction value) { 4311 if (this.code == null) 4312 this.code = new Enumeration<TypeRestfulInteraction>(new TypeRestfulInteractionEnumFactory()); 4313 this.code.setValue(value); 4314 return this; 4315 } 4316 4317 /** 4318 * @return {@link #documentation} (Guidance specific to the implementation of this operation, such as 'delete is a logical delete' or 'updates are only allowed with version id' or 'creates permitted from pre-authorized certificates only'.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value 4319 */ 4320 public MarkdownType getDocumentationElement() { 4321 if (this.documentation == null) 4322 if (Configuration.errorOnAutoCreate()) 4323 throw new Error("Attempt to auto-create ResourceInteractionComponent.documentation"); 4324 else if (Configuration.doAutoCreate()) 4325 this.documentation = new MarkdownType(); // bb 4326 return this.documentation; 4327 } 4328 4329 public boolean hasDocumentationElement() { 4330 return this.documentation != null && !this.documentation.isEmpty(); 4331 } 4332 4333 public boolean hasDocumentation() { 4334 return this.documentation != null && !this.documentation.isEmpty(); 4335 } 4336 4337 /** 4338 * @param value {@link #documentation} (Guidance specific to the implementation of this operation, such as 'delete is a logical delete' or 'updates are only allowed with version id' or 'creates permitted from pre-authorized certificates only'.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value 4339 */ 4340 public ResourceInteractionComponent setDocumentationElement(MarkdownType value) { 4341 this.documentation = value; 4342 return this; 4343 } 4344 4345 /** 4346 * @return Guidance specific to the implementation of this operation, such as 'delete is a logical delete' or 'updates are only allowed with version id' or 'creates permitted from pre-authorized certificates only'. 4347 */ 4348 public String getDocumentation() { 4349 return this.documentation == null ? null : this.documentation.getValue(); 4350 } 4351 4352 /** 4353 * @param value Guidance specific to the implementation of this operation, such as 'delete is a logical delete' or 'updates are only allowed with version id' or 'creates permitted from pre-authorized certificates only'. 4354 */ 4355 public ResourceInteractionComponent setDocumentation(String value) { 4356 if (value == null) 4357 this.documentation = null; 4358 else { 4359 if (this.documentation == null) 4360 this.documentation = new MarkdownType(); 4361 this.documentation.setValue(value); 4362 } 4363 return this; 4364 } 4365 4366 protected void listChildren(List<Property> children) { 4367 super.listChildren(children); 4368 children.add(new Property("code", "code", "Coded identifier of the operation, supported by the system resource.", 0, 1, code)); 4369 children.add(new Property("documentation", "markdown", "Guidance specific to the implementation of this operation, such as 'delete is a logical delete' or 'updates are only allowed with version id' or 'creates permitted from pre-authorized certificates only'.", 0, 1, documentation)); 4370 } 4371 4372 @Override 4373 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 4374 switch (_hash) { 4375 case 3059181: /*code*/ return new Property("code", "code", "Coded identifier of the operation, supported by the system resource.", 0, 1, code); 4376 case 1587405498: /*documentation*/ return new Property("documentation", "markdown", "Guidance specific to the implementation of this operation, such as 'delete is a logical delete' or 'updates are only allowed with version id' or 'creates permitted from pre-authorized certificates only'.", 0, 1, documentation); 4377 default: return super.getNamedProperty(_hash, _name, _checkValid); 4378 } 4379 4380 } 4381 4382 @Override 4383 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 4384 switch (hash) { 4385 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // Enumeration<TypeRestfulInteraction> 4386 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 4387 default: return super.getProperty(hash, name, checkValid); 4388 } 4389 4390 } 4391 4392 @Override 4393 public Base setProperty(int hash, String name, Base value) throws FHIRException { 4394 switch (hash) { 4395 case 3059181: // code 4396 value = new TypeRestfulInteractionEnumFactory().fromType(TypeConvertor.castToCode(value)); 4397 this.code = (Enumeration) value; // Enumeration<TypeRestfulInteraction> 4398 return value; 4399 case 1587405498: // documentation 4400 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 4401 return value; 4402 default: return super.setProperty(hash, name, value); 4403 } 4404 4405 } 4406 4407 @Override 4408 public Base setProperty(String name, Base value) throws FHIRException { 4409 if (name.equals("code")) { 4410 value = new TypeRestfulInteractionEnumFactory().fromType(TypeConvertor.castToCode(value)); 4411 this.code = (Enumeration) value; // Enumeration<TypeRestfulInteraction> 4412 } else if (name.equals("documentation")) { 4413 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 4414 } else 4415 return super.setProperty(name, value); 4416 return value; 4417 } 4418 4419 @Override 4420 public Base makeProperty(int hash, String name) throws FHIRException { 4421 switch (hash) { 4422 case 3059181: return getCodeElement(); 4423 case 1587405498: return getDocumentationElement(); 4424 default: return super.makeProperty(hash, name); 4425 } 4426 4427 } 4428 4429 @Override 4430 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 4431 switch (hash) { 4432 case 3059181: /*code*/ return new String[] {"code"}; 4433 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 4434 default: return super.getTypesForProperty(hash, name); 4435 } 4436 4437 } 4438 4439 @Override 4440 public Base addChild(String name) throws FHIRException { 4441 if (name.equals("code")) { 4442 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.interaction.code"); 4443 } 4444 else if (name.equals("documentation")) { 4445 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.interaction.documentation"); 4446 } 4447 else 4448 return super.addChild(name); 4449 } 4450 4451 public ResourceInteractionComponent copy() { 4452 ResourceInteractionComponent dst = new ResourceInteractionComponent(); 4453 copyValues(dst); 4454 return dst; 4455 } 4456 4457 public void copyValues(ResourceInteractionComponent dst) { 4458 super.copyValues(dst); 4459 dst.code = code == null ? null : code.copy(); 4460 dst.documentation = documentation == null ? null : documentation.copy(); 4461 } 4462 4463 @Override 4464 public boolean equalsDeep(Base other_) { 4465 if (!super.equalsDeep(other_)) 4466 return false; 4467 if (!(other_ instanceof ResourceInteractionComponent)) 4468 return false; 4469 ResourceInteractionComponent o = (ResourceInteractionComponent) other_; 4470 return compareDeep(code, o.code, true) && compareDeep(documentation, o.documentation, true); 4471 } 4472 4473 @Override 4474 public boolean equalsShallow(Base other_) { 4475 if (!super.equalsShallow(other_)) 4476 return false; 4477 if (!(other_ instanceof ResourceInteractionComponent)) 4478 return false; 4479 ResourceInteractionComponent o = (ResourceInteractionComponent) other_; 4480 return compareValues(code, o.code, true) && compareValues(documentation, o.documentation, true); 4481 } 4482 4483 public boolean isEmpty() { 4484 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, documentation); 4485 } 4486 4487 public String fhirType() { 4488 return "CapabilityStatement.rest.resource.interaction"; 4489 4490 } 4491 4492 } 4493 4494 @Block() 4495 public static class CapabilityStatementRestResourceSearchParamComponent extends BackboneElement implements IBaseBackboneElement { 4496 /** 4497 * The name of the search parameter used in the interface. 4498 */ 4499 @Child(name = "name", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=false) 4500 @Description(shortDefinition="Name of search parameter", formalDefinition="The name of the search parameter used in the interface." ) 4501 protected StringType name; 4502 4503 /** 4504 * An absolute URI that is a formal reference to where this parameter was first defined, so that a client can be confident of the meaning of the search parameter (a reference to [SearchParameter.url](searchparameter-definitions.html#SearchParameter.url)). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs. 4505 */ 4506 @Child(name = "definition", type = {CanonicalType.class}, order=2, min=0, max=1, modifier=false, summary=false) 4507 @Description(shortDefinition="Source of definition for parameter", formalDefinition="An absolute URI that is a formal reference to where this parameter was first defined, so that a client can be confident of the meaning of the search parameter (a reference to [SearchParameter.url](searchparameter-definitions.html#SearchParameter.url)). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs." ) 4508 protected CanonicalType definition; 4509 4510 /** 4511 * The type of value a search parameter refers to, and how the content is interpreted. 4512 */ 4513 @Child(name = "type", type = {CodeType.class}, order=3, min=1, max=1, modifier=false, summary=false) 4514 @Description(shortDefinition="number | date | string | token | reference | composite | quantity | uri | special", formalDefinition="The type of value a search parameter refers to, and how the content is interpreted." ) 4515 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/search-param-type") 4516 protected Enumeration<SearchParamType> type; 4517 4518 /** 4519 * This allows documentation of any distinct behaviors about how the search parameter is used. For example, text matching algorithms. 4520 */ 4521 @Child(name = "documentation", type = {MarkdownType.class}, order=4, min=0, max=1, modifier=false, summary=false) 4522 @Description(shortDefinition="Server-specific usage", formalDefinition="This allows documentation of any distinct behaviors about how the search parameter is used. For example, text matching algorithms." ) 4523 protected MarkdownType documentation; 4524 4525 private static final long serialVersionUID = -171123928L; 4526 4527 /** 4528 * Constructor 4529 */ 4530 public CapabilityStatementRestResourceSearchParamComponent() { 4531 super(); 4532 } 4533 4534 /** 4535 * Constructor 4536 */ 4537 public CapabilityStatementRestResourceSearchParamComponent(String name, SearchParamType type) { 4538 super(); 4539 this.setName(name); 4540 this.setType(type); 4541 } 4542 4543 /** 4544 * @return {@link #name} (The name of the search parameter used in the interface.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value 4545 */ 4546 public StringType getNameElement() { 4547 if (this.name == null) 4548 if (Configuration.errorOnAutoCreate()) 4549 throw new Error("Attempt to auto-create CapabilityStatementRestResourceSearchParamComponent.name"); 4550 else if (Configuration.doAutoCreate()) 4551 this.name = new StringType(); // bb 4552 return this.name; 4553 } 4554 4555 public boolean hasNameElement() { 4556 return this.name != null && !this.name.isEmpty(); 4557 } 4558 4559 public boolean hasName() { 4560 return this.name != null && !this.name.isEmpty(); 4561 } 4562 4563 /** 4564 * @param value {@link #name} (The name of the search parameter used in the interface.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value 4565 */ 4566 public CapabilityStatementRestResourceSearchParamComponent setNameElement(StringType value) { 4567 this.name = value; 4568 return this; 4569 } 4570 4571 /** 4572 * @return The name of the search parameter used in the interface. 4573 */ 4574 public String getName() { 4575 return this.name == null ? null : this.name.getValue(); 4576 } 4577 4578 /** 4579 * @param value The name of the search parameter used in the interface. 4580 */ 4581 public CapabilityStatementRestResourceSearchParamComponent setName(String value) { 4582 if (this.name == null) 4583 this.name = new StringType(); 4584 this.name.setValue(value); 4585 return this; 4586 } 4587 4588 /** 4589 * @return {@link #definition} (An absolute URI that is a formal reference to where this parameter was first defined, so that a client can be confident of the meaning of the search parameter (a reference to [SearchParameter.url](searchparameter-definitions.html#SearchParameter.url)). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs.). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value 4590 */ 4591 public CanonicalType getDefinitionElement() { 4592 if (this.definition == null) 4593 if (Configuration.errorOnAutoCreate()) 4594 throw new Error("Attempt to auto-create CapabilityStatementRestResourceSearchParamComponent.definition"); 4595 else if (Configuration.doAutoCreate()) 4596 this.definition = new CanonicalType(); // bb 4597 return this.definition; 4598 } 4599 4600 public boolean hasDefinitionElement() { 4601 return this.definition != null && !this.definition.isEmpty(); 4602 } 4603 4604 public boolean hasDefinition() { 4605 return this.definition != null && !this.definition.isEmpty(); 4606 } 4607 4608 /** 4609 * @param value {@link #definition} (An absolute URI that is a formal reference to where this parameter was first defined, so that a client can be confident of the meaning of the search parameter (a reference to [SearchParameter.url](searchparameter-definitions.html#SearchParameter.url)). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs.). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value 4610 */ 4611 public CapabilityStatementRestResourceSearchParamComponent setDefinitionElement(CanonicalType value) { 4612 this.definition = value; 4613 return this; 4614 } 4615 4616 /** 4617 * @return An absolute URI that is a formal reference to where this parameter was first defined, so that a client can be confident of the meaning of the search parameter (a reference to [SearchParameter.url](searchparameter-definitions.html#SearchParameter.url)). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs. 4618 */ 4619 public String getDefinition() { 4620 return this.definition == null ? null : this.definition.getValue(); 4621 } 4622 4623 /** 4624 * @param value An absolute URI that is a formal reference to where this parameter was first defined, so that a client can be confident of the meaning of the search parameter (a reference to [SearchParameter.url](searchparameter-definitions.html#SearchParameter.url)). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs. 4625 */ 4626 public CapabilityStatementRestResourceSearchParamComponent setDefinition(String value) { 4627 if (Utilities.noString(value)) 4628 this.definition = null; 4629 else { 4630 if (this.definition == null) 4631 this.definition = new CanonicalType(); 4632 this.definition.setValue(value); 4633 } 4634 return this; 4635 } 4636 4637 /** 4638 * @return {@link #type} (The type of value a search parameter refers to, and how the content is interpreted.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 4639 */ 4640 public Enumeration<SearchParamType> getTypeElement() { 4641 if (this.type == null) 4642 if (Configuration.errorOnAutoCreate()) 4643 throw new Error("Attempt to auto-create CapabilityStatementRestResourceSearchParamComponent.type"); 4644 else if (Configuration.doAutoCreate()) 4645 this.type = new Enumeration<SearchParamType>(new SearchParamTypeEnumFactory()); // bb 4646 return this.type; 4647 } 4648 4649 public boolean hasTypeElement() { 4650 return this.type != null && !this.type.isEmpty(); 4651 } 4652 4653 public boolean hasType() { 4654 return this.type != null && !this.type.isEmpty(); 4655 } 4656 4657 /** 4658 * @param value {@link #type} (The type of value a search parameter refers to, and how the content is interpreted.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value 4659 */ 4660 public CapabilityStatementRestResourceSearchParamComponent setTypeElement(Enumeration<SearchParamType> value) { 4661 this.type = value; 4662 return this; 4663 } 4664 4665 /** 4666 * @return The type of value a search parameter refers to, and how the content is interpreted. 4667 */ 4668 public SearchParamType getType() { 4669 return this.type == null ? null : this.type.getValue(); 4670 } 4671 4672 /** 4673 * @param value The type of value a search parameter refers to, and how the content is interpreted. 4674 */ 4675 public CapabilityStatementRestResourceSearchParamComponent setType(SearchParamType value) { 4676 if (this.type == null) 4677 this.type = new Enumeration<SearchParamType>(new SearchParamTypeEnumFactory()); 4678 this.type.setValue(value); 4679 return this; 4680 } 4681 4682 /** 4683 * @return {@link #documentation} (This allows documentation of any distinct behaviors about how the search parameter is used. For example, text matching algorithms.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value 4684 */ 4685 public MarkdownType getDocumentationElement() { 4686 if (this.documentation == null) 4687 if (Configuration.errorOnAutoCreate()) 4688 throw new Error("Attempt to auto-create CapabilityStatementRestResourceSearchParamComponent.documentation"); 4689 else if (Configuration.doAutoCreate()) 4690 this.documentation = new MarkdownType(); // bb 4691 return this.documentation; 4692 } 4693 4694 public boolean hasDocumentationElement() { 4695 return this.documentation != null && !this.documentation.isEmpty(); 4696 } 4697 4698 public boolean hasDocumentation() { 4699 return this.documentation != null && !this.documentation.isEmpty(); 4700 } 4701 4702 /** 4703 * @param value {@link #documentation} (This allows documentation of any distinct behaviors about how the search parameter is used. For example, text matching algorithms.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value 4704 */ 4705 public CapabilityStatementRestResourceSearchParamComponent setDocumentationElement(MarkdownType value) { 4706 this.documentation = value; 4707 return this; 4708 } 4709 4710 /** 4711 * @return This allows documentation of any distinct behaviors about how the search parameter is used. For example, text matching algorithms. 4712 */ 4713 public String getDocumentation() { 4714 return this.documentation == null ? null : this.documentation.getValue(); 4715 } 4716 4717 /** 4718 * @param value This allows documentation of any distinct behaviors about how the search parameter is used. For example, text matching algorithms. 4719 */ 4720 public CapabilityStatementRestResourceSearchParamComponent setDocumentation(String value) { 4721 if (value == null) 4722 this.documentation = null; 4723 else { 4724 if (this.documentation == null) 4725 this.documentation = new MarkdownType(); 4726 this.documentation.setValue(value); 4727 } 4728 return this; 4729 } 4730 4731 protected void listChildren(List<Property> children) { 4732 super.listChildren(children); 4733 children.add(new Property("name", "string", "The name of the search parameter used in the interface.", 0, 1, name)); 4734 children.add(new Property("definition", "canonical(SearchParameter)", "An absolute URI that is a formal reference to where this parameter was first defined, so that a client can be confident of the meaning of the search parameter (a reference to [SearchParameter.url](searchparameter-definitions.html#SearchParameter.url)). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs.", 0, 1, definition)); 4735 children.add(new Property("type", "code", "The type of value a search parameter refers to, and how the content is interpreted.", 0, 1, type)); 4736 children.add(new Property("documentation", "markdown", "This allows documentation of any distinct behaviors about how the search parameter is used. For example, text matching algorithms.", 0, 1, documentation)); 4737 } 4738 4739 @Override 4740 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 4741 switch (_hash) { 4742 case 3373707: /*name*/ return new Property("name", "string", "The name of the search parameter used in the interface.", 0, 1, name); 4743 case -1014418093: /*definition*/ return new Property("definition", "canonical(SearchParameter)", "An absolute URI that is a formal reference to where this parameter was first defined, so that a client can be confident of the meaning of the search parameter (a reference to [SearchParameter.url](searchparameter-definitions.html#SearchParameter.url)). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs.", 0, 1, definition); 4744 case 3575610: /*type*/ return new Property("type", "code", "The type of value a search parameter refers to, and how the content is interpreted.", 0, 1, type); 4745 case 1587405498: /*documentation*/ return new Property("documentation", "markdown", "This allows documentation of any distinct behaviors about how the search parameter is used. For example, text matching algorithms.", 0, 1, documentation); 4746 default: return super.getNamedProperty(_hash, _name, _checkValid); 4747 } 4748 4749 } 4750 4751 @Override 4752 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 4753 switch (hash) { 4754 case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType 4755 case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : new Base[] {this.definition}; // CanonicalType 4756 case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<SearchParamType> 4757 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 4758 default: return super.getProperty(hash, name, checkValid); 4759 } 4760 4761 } 4762 4763 @Override 4764 public Base setProperty(int hash, String name, Base value) throws FHIRException { 4765 switch (hash) { 4766 case 3373707: // name 4767 this.name = TypeConvertor.castToString(value); // StringType 4768 return value; 4769 case -1014418093: // definition 4770 this.definition = TypeConvertor.castToCanonical(value); // CanonicalType 4771 return value; 4772 case 3575610: // type 4773 value = new SearchParamTypeEnumFactory().fromType(TypeConvertor.castToCode(value)); 4774 this.type = (Enumeration) value; // Enumeration<SearchParamType> 4775 return value; 4776 case 1587405498: // documentation 4777 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 4778 return value; 4779 default: return super.setProperty(hash, name, value); 4780 } 4781 4782 } 4783 4784 @Override 4785 public Base setProperty(String name, Base value) throws FHIRException { 4786 if (name.equals("name")) { 4787 this.name = TypeConvertor.castToString(value); // StringType 4788 } else if (name.equals("definition")) { 4789 this.definition = TypeConvertor.castToCanonical(value); // CanonicalType 4790 } else if (name.equals("type")) { 4791 value = new SearchParamTypeEnumFactory().fromType(TypeConvertor.castToCode(value)); 4792 this.type = (Enumeration) value; // Enumeration<SearchParamType> 4793 } else if (name.equals("documentation")) { 4794 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 4795 } else 4796 return super.setProperty(name, value); 4797 return value; 4798 } 4799 4800 @Override 4801 public Base makeProperty(int hash, String name) throws FHIRException { 4802 switch (hash) { 4803 case 3373707: return getNameElement(); 4804 case -1014418093: return getDefinitionElement(); 4805 case 3575610: return getTypeElement(); 4806 case 1587405498: return getDocumentationElement(); 4807 default: return super.makeProperty(hash, name); 4808 } 4809 4810 } 4811 4812 @Override 4813 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 4814 switch (hash) { 4815 case 3373707: /*name*/ return new String[] {"string"}; 4816 case -1014418093: /*definition*/ return new String[] {"canonical"}; 4817 case 3575610: /*type*/ return new String[] {"code"}; 4818 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 4819 default: return super.getTypesForProperty(hash, name); 4820 } 4821 4822 } 4823 4824 @Override 4825 public Base addChild(String name) throws FHIRException { 4826 if (name.equals("name")) { 4827 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.searchParam.name"); 4828 } 4829 else if (name.equals("definition")) { 4830 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.searchParam.definition"); 4831 } 4832 else if (name.equals("type")) { 4833 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.searchParam.type"); 4834 } 4835 else if (name.equals("documentation")) { 4836 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.searchParam.documentation"); 4837 } 4838 else 4839 return super.addChild(name); 4840 } 4841 4842 public CapabilityStatementRestResourceSearchParamComponent copy() { 4843 CapabilityStatementRestResourceSearchParamComponent dst = new CapabilityStatementRestResourceSearchParamComponent(); 4844 copyValues(dst); 4845 return dst; 4846 } 4847 4848 public void copyValues(CapabilityStatementRestResourceSearchParamComponent dst) { 4849 super.copyValues(dst); 4850 dst.name = name == null ? null : name.copy(); 4851 dst.definition = definition == null ? null : definition.copy(); 4852 dst.type = type == null ? null : type.copy(); 4853 dst.documentation = documentation == null ? null : documentation.copy(); 4854 } 4855 4856 @Override 4857 public boolean equalsDeep(Base other_) { 4858 if (!super.equalsDeep(other_)) 4859 return false; 4860 if (!(other_ instanceof CapabilityStatementRestResourceSearchParamComponent)) 4861 return false; 4862 CapabilityStatementRestResourceSearchParamComponent o = (CapabilityStatementRestResourceSearchParamComponent) other_; 4863 return compareDeep(name, o.name, true) && compareDeep(definition, o.definition, true) && compareDeep(type, o.type, true) 4864 && compareDeep(documentation, o.documentation, true); 4865 } 4866 4867 @Override 4868 public boolean equalsShallow(Base other_) { 4869 if (!super.equalsShallow(other_)) 4870 return false; 4871 if (!(other_ instanceof CapabilityStatementRestResourceSearchParamComponent)) 4872 return false; 4873 CapabilityStatementRestResourceSearchParamComponent o = (CapabilityStatementRestResourceSearchParamComponent) other_; 4874 return compareValues(name, o.name, true) && compareValues(definition, o.definition, true) && compareValues(type, o.type, true) 4875 && compareValues(documentation, o.documentation, true); 4876 } 4877 4878 public boolean isEmpty() { 4879 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, definition, type, documentation 4880 ); 4881 } 4882 4883 public String fhirType() { 4884 return "CapabilityStatement.rest.resource.searchParam"; 4885 4886 } 4887 4888 } 4889 4890 @Block() 4891 public static class CapabilityStatementRestResourceOperationComponent extends BackboneElement implements IBaseBackboneElement { 4892 /** 4893 * The name of the operation or query. For an operation, this is the name prefixed with $ and used in the URL. For a query, this is the name used in the _query parameter when the query is called. 4894 */ 4895 @Child(name = "name", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true) 4896 @Description(shortDefinition="Name by which the operation/query is invoked", formalDefinition="The name of the operation or query. For an operation, this is the name prefixed with $ and used in the URL. For a query, this is the name used in the _query parameter when the query is called." ) 4897 protected StringType name; 4898 4899 /** 4900 * Where the formal definition can be found. If a server references the base definition of an Operation (i.e. from the specification itself such as ```http://hl7.org/fhir/OperationDefinition/ValueSet-expand```), that means it supports the full capabilities of the operation - e.g. both GET and POST invocation. If it only supports a subset, it must define its own custom [OperationDefinition](operationdefinition.html#) with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported. 4901 */ 4902 @Child(name = "definition", type = {CanonicalType.class}, order=2, min=1, max=1, modifier=false, summary=true) 4903 @Description(shortDefinition="The defined operation/query", formalDefinition="Where the formal definition can be found. If a server references the base definition of an Operation (i.e. from the specification itself such as ```http://hl7.org/fhir/OperationDefinition/ValueSet-expand```), that means it supports the full capabilities of the operation - e.g. both GET and POST invocation. If it only supports a subset, it must define its own custom [OperationDefinition](operationdefinition.html#) with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported." ) 4904 protected CanonicalType definition; 4905 4906 /** 4907 * Documentation that describes anything special about the operation behavior, possibly detailing different behavior for system, type and instance-level invocation of the operation. 4908 */ 4909 @Child(name = "documentation", type = {MarkdownType.class}, order=3, min=0, max=1, modifier=false, summary=false) 4910 @Description(shortDefinition="Specific details about operation behavior", formalDefinition="Documentation that describes anything special about the operation behavior, possibly detailing different behavior for system, type and instance-level invocation of the operation." ) 4911 protected MarkdownType documentation; 4912 4913 private static final long serialVersionUID = -388608084L; 4914 4915 /** 4916 * Constructor 4917 */ 4918 public CapabilityStatementRestResourceOperationComponent() { 4919 super(); 4920 } 4921 4922 /** 4923 * Constructor 4924 */ 4925 public CapabilityStatementRestResourceOperationComponent(String name, String definition) { 4926 super(); 4927 this.setName(name); 4928 this.setDefinition(definition); 4929 } 4930 4931 /** 4932 * @return {@link #name} (The name of the operation or query. For an operation, this is the name prefixed with $ and used in the URL. For a query, this is the name used in the _query parameter when the query is called.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value 4933 */ 4934 public StringType getNameElement() { 4935 if (this.name == null) 4936 if (Configuration.errorOnAutoCreate()) 4937 throw new Error("Attempt to auto-create CapabilityStatementRestResourceOperationComponent.name"); 4938 else if (Configuration.doAutoCreate()) 4939 this.name = new StringType(); // bb 4940 return this.name; 4941 } 4942 4943 public boolean hasNameElement() { 4944 return this.name != null && !this.name.isEmpty(); 4945 } 4946 4947 public boolean hasName() { 4948 return this.name != null && !this.name.isEmpty(); 4949 } 4950 4951 /** 4952 * @param value {@link #name} (The name of the operation or query. For an operation, this is the name prefixed with $ and used in the URL. For a query, this is the name used in the _query parameter when the query is called.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value 4953 */ 4954 public CapabilityStatementRestResourceOperationComponent setNameElement(StringType value) { 4955 this.name = value; 4956 return this; 4957 } 4958 4959 /** 4960 * @return The name of the operation or query. For an operation, this is the name prefixed with $ and used in the URL. For a query, this is the name used in the _query parameter when the query is called. 4961 */ 4962 public String getName() { 4963 return this.name == null ? null : this.name.getValue(); 4964 } 4965 4966 /** 4967 * @param value The name of the operation or query. For an operation, this is the name prefixed with $ and used in the URL. For a query, this is the name used in the _query parameter when the query is called. 4968 */ 4969 public CapabilityStatementRestResourceOperationComponent setName(String value) { 4970 if (this.name == null) 4971 this.name = new StringType(); 4972 this.name.setValue(value); 4973 return this; 4974 } 4975 4976 /** 4977 * @return {@link #definition} (Where the formal definition can be found. If a server references the base definition of an Operation (i.e. from the specification itself such as ```http://hl7.org/fhir/OperationDefinition/ValueSet-expand```), that means it supports the full capabilities of the operation - e.g. both GET and POST invocation. If it only supports a subset, it must define its own custom [OperationDefinition](operationdefinition.html#) with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported.). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value 4978 */ 4979 public CanonicalType getDefinitionElement() { 4980 if (this.definition == null) 4981 if (Configuration.errorOnAutoCreate()) 4982 throw new Error("Attempt to auto-create CapabilityStatementRestResourceOperationComponent.definition"); 4983 else if (Configuration.doAutoCreate()) 4984 this.definition = new CanonicalType(); // bb 4985 return this.definition; 4986 } 4987 4988 public boolean hasDefinitionElement() { 4989 return this.definition != null && !this.definition.isEmpty(); 4990 } 4991 4992 public boolean hasDefinition() { 4993 return this.definition != null && !this.definition.isEmpty(); 4994 } 4995 4996 /** 4997 * @param value {@link #definition} (Where the formal definition can be found. If a server references the base definition of an Operation (i.e. from the specification itself such as ```http://hl7.org/fhir/OperationDefinition/ValueSet-expand```), that means it supports the full capabilities of the operation - e.g. both GET and POST invocation. If it only supports a subset, it must define its own custom [OperationDefinition](operationdefinition.html#) with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported.). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value 4998 */ 4999 public CapabilityStatementRestResourceOperationComponent setDefinitionElement(CanonicalType value) { 5000 this.definition = value; 5001 return this; 5002 } 5003 5004 /** 5005 * @return Where the formal definition can be found. If a server references the base definition of an Operation (i.e. from the specification itself such as ```http://hl7.org/fhir/OperationDefinition/ValueSet-expand```), that means it supports the full capabilities of the operation - e.g. both GET and POST invocation. If it only supports a subset, it must define its own custom [OperationDefinition](operationdefinition.html#) with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported. 5006 */ 5007 public String getDefinition() { 5008 return this.definition == null ? null : this.definition.getValue(); 5009 } 5010 5011 /** 5012 * @param value Where the formal definition can be found. If a server references the base definition of an Operation (i.e. from the specification itself such as ```http://hl7.org/fhir/OperationDefinition/ValueSet-expand```), that means it supports the full capabilities of the operation - e.g. both GET and POST invocation. If it only supports a subset, it must define its own custom [OperationDefinition](operationdefinition.html#) with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported. 5013 */ 5014 public CapabilityStatementRestResourceOperationComponent setDefinition(String value) { 5015 if (this.definition == null) 5016 this.definition = new CanonicalType(); 5017 this.definition.setValue(value); 5018 return this; 5019 } 5020 5021 /** 5022 * @return {@link #documentation} (Documentation that describes anything special about the operation behavior, possibly detailing different behavior for system, type and instance-level invocation of the operation.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value 5023 */ 5024 public MarkdownType getDocumentationElement() { 5025 if (this.documentation == null) 5026 if (Configuration.errorOnAutoCreate()) 5027 throw new Error("Attempt to auto-create CapabilityStatementRestResourceOperationComponent.documentation"); 5028 else if (Configuration.doAutoCreate()) 5029 this.documentation = new MarkdownType(); // bb 5030 return this.documentation; 5031 } 5032 5033 public boolean hasDocumentationElement() { 5034 return this.documentation != null && !this.documentation.isEmpty(); 5035 } 5036 5037 public boolean hasDocumentation() { 5038 return this.documentation != null && !this.documentation.isEmpty(); 5039 } 5040 5041 /** 5042 * @param value {@link #documentation} (Documentation that describes anything special about the operation behavior, possibly detailing different behavior for system, type and instance-level invocation of the operation.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value 5043 */ 5044 public CapabilityStatementRestResourceOperationComponent setDocumentationElement(MarkdownType value) { 5045 this.documentation = value; 5046 return this; 5047 } 5048 5049 /** 5050 * @return Documentation that describes anything special about the operation behavior, possibly detailing different behavior for system, type and instance-level invocation of the operation. 5051 */ 5052 public String getDocumentation() { 5053 return this.documentation == null ? null : this.documentation.getValue(); 5054 } 5055 5056 /** 5057 * @param value Documentation that describes anything special about the operation behavior, possibly detailing different behavior for system, type and instance-level invocation of the operation. 5058 */ 5059 public CapabilityStatementRestResourceOperationComponent setDocumentation(String value) { 5060 if (value == null) 5061 this.documentation = null; 5062 else { 5063 if (this.documentation == null) 5064 this.documentation = new MarkdownType(); 5065 this.documentation.setValue(value); 5066 } 5067 return this; 5068 } 5069 5070 protected void listChildren(List<Property> children) { 5071 super.listChildren(children); 5072 children.add(new Property("name", "string", "The name of the operation or query. For an operation, this is the name prefixed with $ and used in the URL. For a query, this is the name used in the _query parameter when the query is called.", 0, 1, name)); 5073 children.add(new Property("definition", "canonical(OperationDefinition)", "Where the formal definition can be found. If a server references the base definition of an Operation (i.e. from the specification itself such as ```http://hl7.org/fhir/OperationDefinition/ValueSet-expand```), that means it supports the full capabilities of the operation - e.g. both GET and POST invocation. If it only supports a subset, it must define its own custom [OperationDefinition](operationdefinition.html#) with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported.", 0, 1, definition)); 5074 children.add(new Property("documentation", "markdown", "Documentation that describes anything special about the operation behavior, possibly detailing different behavior for system, type and instance-level invocation of the operation.", 0, 1, documentation)); 5075 } 5076 5077 @Override 5078 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 5079 switch (_hash) { 5080 case 3373707: /*name*/ return new Property("name", "string", "The name of the operation or query. For an operation, this is the name prefixed with $ and used in the URL. For a query, this is the name used in the _query parameter when the query is called.", 0, 1, name); 5081 case -1014418093: /*definition*/ return new Property("definition", "canonical(OperationDefinition)", "Where the formal definition can be found. If a server references the base definition of an Operation (i.e. from the specification itself such as ```http://hl7.org/fhir/OperationDefinition/ValueSet-expand```), that means it supports the full capabilities of the operation - e.g. both GET and POST invocation. If it only supports a subset, it must define its own custom [OperationDefinition](operationdefinition.html#) with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported.", 0, 1, definition); 5082 case 1587405498: /*documentation*/ return new Property("documentation", "markdown", "Documentation that describes anything special about the operation behavior, possibly detailing different behavior for system, type and instance-level invocation of the operation.", 0, 1, documentation); 5083 default: return super.getNamedProperty(_hash, _name, _checkValid); 5084 } 5085 5086 } 5087 5088 @Override 5089 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 5090 switch (hash) { 5091 case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType 5092 case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : new Base[] {this.definition}; // CanonicalType 5093 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 5094 default: return super.getProperty(hash, name, checkValid); 5095 } 5096 5097 } 5098 5099 @Override 5100 public Base setProperty(int hash, String name, Base value) throws FHIRException { 5101 switch (hash) { 5102 case 3373707: // name 5103 this.name = TypeConvertor.castToString(value); // StringType 5104 return value; 5105 case -1014418093: // definition 5106 this.definition = TypeConvertor.castToCanonical(value); // CanonicalType 5107 return value; 5108 case 1587405498: // documentation 5109 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 5110 return value; 5111 default: return super.setProperty(hash, name, value); 5112 } 5113 5114 } 5115 5116 @Override 5117 public Base setProperty(String name, Base value) throws FHIRException { 5118 if (name.equals("name")) { 5119 this.name = TypeConvertor.castToString(value); // StringType 5120 } else if (name.equals("definition")) { 5121 this.definition = TypeConvertor.castToCanonical(value); // CanonicalType 5122 } else if (name.equals("documentation")) { 5123 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 5124 } else 5125 return super.setProperty(name, value); 5126 return value; 5127 } 5128 5129 @Override 5130 public Base makeProperty(int hash, String name) throws FHIRException { 5131 switch (hash) { 5132 case 3373707: return getNameElement(); 5133 case -1014418093: return getDefinitionElement(); 5134 case 1587405498: return getDocumentationElement(); 5135 default: return super.makeProperty(hash, name); 5136 } 5137 5138 } 5139 5140 @Override 5141 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 5142 switch (hash) { 5143 case 3373707: /*name*/ return new String[] {"string"}; 5144 case -1014418093: /*definition*/ return new String[] {"canonical"}; 5145 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 5146 default: return super.getTypesForProperty(hash, name); 5147 } 5148 5149 } 5150 5151 @Override 5152 public Base addChild(String name) throws FHIRException { 5153 if (name.equals("name")) { 5154 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.operation.name"); 5155 } 5156 else if (name.equals("definition")) { 5157 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.operation.definition"); 5158 } 5159 else if (name.equals("documentation")) { 5160 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.resource.operation.documentation"); 5161 } 5162 else 5163 return super.addChild(name); 5164 } 5165 5166 public CapabilityStatementRestResourceOperationComponent copy() { 5167 CapabilityStatementRestResourceOperationComponent dst = new CapabilityStatementRestResourceOperationComponent(); 5168 copyValues(dst); 5169 return dst; 5170 } 5171 5172 public void copyValues(CapabilityStatementRestResourceOperationComponent dst) { 5173 super.copyValues(dst); 5174 dst.name = name == null ? null : name.copy(); 5175 dst.definition = definition == null ? null : definition.copy(); 5176 dst.documentation = documentation == null ? null : documentation.copy(); 5177 } 5178 5179 @Override 5180 public boolean equalsDeep(Base other_) { 5181 if (!super.equalsDeep(other_)) 5182 return false; 5183 if (!(other_ instanceof CapabilityStatementRestResourceOperationComponent)) 5184 return false; 5185 CapabilityStatementRestResourceOperationComponent o = (CapabilityStatementRestResourceOperationComponent) other_; 5186 return compareDeep(name, o.name, true) && compareDeep(definition, o.definition, true) && compareDeep(documentation, o.documentation, true) 5187 ; 5188 } 5189 5190 @Override 5191 public boolean equalsShallow(Base other_) { 5192 if (!super.equalsShallow(other_)) 5193 return false; 5194 if (!(other_ instanceof CapabilityStatementRestResourceOperationComponent)) 5195 return false; 5196 CapabilityStatementRestResourceOperationComponent o = (CapabilityStatementRestResourceOperationComponent) other_; 5197 return compareValues(name, o.name, true) && compareValues(definition, o.definition, true) && compareValues(documentation, o.documentation, true) 5198 ; 5199 } 5200 5201 public boolean isEmpty() { 5202 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, definition, documentation 5203 ); 5204 } 5205 5206 public String fhirType() { 5207 return "CapabilityStatement.rest.resource.operation"; 5208 5209 } 5210 5211 } 5212 5213 @Block() 5214 public static class SystemInteractionComponent extends BackboneElement implements IBaseBackboneElement { 5215 /** 5216 * A coded identifier of the operation, supported by the system. 5217 */ 5218 @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=false) 5219 @Description(shortDefinition="transaction | batch | search-system | history-system", formalDefinition="A coded identifier of the operation, supported by the system." ) 5220 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/system-restful-interaction") 5221 protected Enumeration<SystemRestfulInteraction> code; 5222 5223 /** 5224 * Guidance specific to the implementation of this operation, such as limitations on the kind of transactions allowed, or information about system wide search is implemented. 5225 */ 5226 @Child(name = "documentation", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=false) 5227 @Description(shortDefinition="Anything special about operation behavior", formalDefinition="Guidance specific to the implementation of this operation, such as limitations on the kind of transactions allowed, or information about system wide search is implemented." ) 5228 protected MarkdownType documentation; 5229 5230 private static final long serialVersionUID = -1495143879L; 5231 5232 /** 5233 * Constructor 5234 */ 5235 public SystemInteractionComponent() { 5236 super(); 5237 } 5238 5239 /** 5240 * Constructor 5241 */ 5242 public SystemInteractionComponent(SystemRestfulInteraction code) { 5243 super(); 5244 this.setCode(code); 5245 } 5246 5247 /** 5248 * @return {@link #code} (A coded identifier of the operation, supported by the system.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value 5249 */ 5250 public Enumeration<SystemRestfulInteraction> getCodeElement() { 5251 if (this.code == null) 5252 if (Configuration.errorOnAutoCreate()) 5253 throw new Error("Attempt to auto-create SystemInteractionComponent.code"); 5254 else if (Configuration.doAutoCreate()) 5255 this.code = new Enumeration<SystemRestfulInteraction>(new SystemRestfulInteractionEnumFactory()); // bb 5256 return this.code; 5257 } 5258 5259 public boolean hasCodeElement() { 5260 return this.code != null && !this.code.isEmpty(); 5261 } 5262 5263 public boolean hasCode() { 5264 return this.code != null && !this.code.isEmpty(); 5265 } 5266 5267 /** 5268 * @param value {@link #code} (A coded identifier of the operation, supported by the system.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value 5269 */ 5270 public SystemInteractionComponent setCodeElement(Enumeration<SystemRestfulInteraction> value) { 5271 this.code = value; 5272 return this; 5273 } 5274 5275 /** 5276 * @return A coded identifier of the operation, supported by the system. 5277 */ 5278 public SystemRestfulInteraction getCode() { 5279 return this.code == null ? null : this.code.getValue(); 5280 } 5281 5282 /** 5283 * @param value A coded identifier of the operation, supported by the system. 5284 */ 5285 public SystemInteractionComponent setCode(SystemRestfulInteraction value) { 5286 if (this.code == null) 5287 this.code = new Enumeration<SystemRestfulInteraction>(new SystemRestfulInteractionEnumFactory()); 5288 this.code.setValue(value); 5289 return this; 5290 } 5291 5292 /** 5293 * @return {@link #documentation} (Guidance specific to the implementation of this operation, such as limitations on the kind of transactions allowed, or information about system wide search is implemented.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value 5294 */ 5295 public MarkdownType getDocumentationElement() { 5296 if (this.documentation == null) 5297 if (Configuration.errorOnAutoCreate()) 5298 throw new Error("Attempt to auto-create SystemInteractionComponent.documentation"); 5299 else if (Configuration.doAutoCreate()) 5300 this.documentation = new MarkdownType(); // bb 5301 return this.documentation; 5302 } 5303 5304 public boolean hasDocumentationElement() { 5305 return this.documentation != null && !this.documentation.isEmpty(); 5306 } 5307 5308 public boolean hasDocumentation() { 5309 return this.documentation != null && !this.documentation.isEmpty(); 5310 } 5311 5312 /** 5313 * @param value {@link #documentation} (Guidance specific to the implementation of this operation, such as limitations on the kind of transactions allowed, or information about system wide search is implemented.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value 5314 */ 5315 public SystemInteractionComponent setDocumentationElement(MarkdownType value) { 5316 this.documentation = value; 5317 return this; 5318 } 5319 5320 /** 5321 * @return Guidance specific to the implementation of this operation, such as limitations on the kind of transactions allowed, or information about system wide search is implemented. 5322 */ 5323 public String getDocumentation() { 5324 return this.documentation == null ? null : this.documentation.getValue(); 5325 } 5326 5327 /** 5328 * @param value Guidance specific to the implementation of this operation, such as limitations on the kind of transactions allowed, or information about system wide search is implemented. 5329 */ 5330 public SystemInteractionComponent setDocumentation(String value) { 5331 if (value == null) 5332 this.documentation = null; 5333 else { 5334 if (this.documentation == null) 5335 this.documentation = new MarkdownType(); 5336 this.documentation.setValue(value); 5337 } 5338 return this; 5339 } 5340 5341 protected void listChildren(List<Property> children) { 5342 super.listChildren(children); 5343 children.add(new Property("code", "code", "A coded identifier of the operation, supported by the system.", 0, 1, code)); 5344 children.add(new Property("documentation", "markdown", "Guidance specific to the implementation of this operation, such as limitations on the kind of transactions allowed, or information about system wide search is implemented.", 0, 1, documentation)); 5345 } 5346 5347 @Override 5348 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 5349 switch (_hash) { 5350 case 3059181: /*code*/ return new Property("code", "code", "A coded identifier of the operation, supported by the system.", 0, 1, code); 5351 case 1587405498: /*documentation*/ return new Property("documentation", "markdown", "Guidance specific to the implementation of this operation, such as limitations on the kind of transactions allowed, or information about system wide search is implemented.", 0, 1, documentation); 5352 default: return super.getNamedProperty(_hash, _name, _checkValid); 5353 } 5354 5355 } 5356 5357 @Override 5358 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 5359 switch (hash) { 5360 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // Enumeration<SystemRestfulInteraction> 5361 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 5362 default: return super.getProperty(hash, name, checkValid); 5363 } 5364 5365 } 5366 5367 @Override 5368 public Base setProperty(int hash, String name, Base value) throws FHIRException { 5369 switch (hash) { 5370 case 3059181: // code 5371 value = new SystemRestfulInteractionEnumFactory().fromType(TypeConvertor.castToCode(value)); 5372 this.code = (Enumeration) value; // Enumeration<SystemRestfulInteraction> 5373 return value; 5374 case 1587405498: // documentation 5375 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 5376 return value; 5377 default: return super.setProperty(hash, name, value); 5378 } 5379 5380 } 5381 5382 @Override 5383 public Base setProperty(String name, Base value) throws FHIRException { 5384 if (name.equals("code")) { 5385 value = new SystemRestfulInteractionEnumFactory().fromType(TypeConvertor.castToCode(value)); 5386 this.code = (Enumeration) value; // Enumeration<SystemRestfulInteraction> 5387 } else if (name.equals("documentation")) { 5388 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 5389 } else 5390 return super.setProperty(name, value); 5391 return value; 5392 } 5393 5394 @Override 5395 public Base makeProperty(int hash, String name) throws FHIRException { 5396 switch (hash) { 5397 case 3059181: return getCodeElement(); 5398 case 1587405498: return getDocumentationElement(); 5399 default: return super.makeProperty(hash, name); 5400 } 5401 5402 } 5403 5404 @Override 5405 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 5406 switch (hash) { 5407 case 3059181: /*code*/ return new String[] {"code"}; 5408 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 5409 default: return super.getTypesForProperty(hash, name); 5410 } 5411 5412 } 5413 5414 @Override 5415 public Base addChild(String name) throws FHIRException { 5416 if (name.equals("code")) { 5417 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.interaction.code"); 5418 } 5419 else if (name.equals("documentation")) { 5420 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.rest.interaction.documentation"); 5421 } 5422 else 5423 return super.addChild(name); 5424 } 5425 5426 public SystemInteractionComponent copy() { 5427 SystemInteractionComponent dst = new SystemInteractionComponent(); 5428 copyValues(dst); 5429 return dst; 5430 } 5431 5432 public void copyValues(SystemInteractionComponent dst) { 5433 super.copyValues(dst); 5434 dst.code = code == null ? null : code.copy(); 5435 dst.documentation = documentation == null ? null : documentation.copy(); 5436 } 5437 5438 @Override 5439 public boolean equalsDeep(Base other_) { 5440 if (!super.equalsDeep(other_)) 5441 return false; 5442 if (!(other_ instanceof SystemInteractionComponent)) 5443 return false; 5444 SystemInteractionComponent o = (SystemInteractionComponent) other_; 5445 return compareDeep(code, o.code, true) && compareDeep(documentation, o.documentation, true); 5446 } 5447 5448 @Override 5449 public boolean equalsShallow(Base other_) { 5450 if (!super.equalsShallow(other_)) 5451 return false; 5452 if (!(other_ instanceof SystemInteractionComponent)) 5453 return false; 5454 SystemInteractionComponent o = (SystemInteractionComponent) other_; 5455 return compareValues(code, o.code, true) && compareValues(documentation, o.documentation, true); 5456 } 5457 5458 public boolean isEmpty() { 5459 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, documentation); 5460 } 5461 5462 public String fhirType() { 5463 return "CapabilityStatement.rest.interaction"; 5464 5465 } 5466 5467 } 5468 5469 @Block() 5470 public static class CapabilityStatementMessagingComponent extends BackboneElement implements IBaseBackboneElement { 5471 /** 5472 * An endpoint (network accessible address) to which messages and/or replies are to be sent. 5473 */ 5474 @Child(name = "endpoint", type = {}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 5475 @Description(shortDefinition="Where messages should be sent", formalDefinition="An endpoint (network accessible address) to which messages and/or replies are to be sent." ) 5476 protected List<CapabilityStatementMessagingEndpointComponent> endpoint; 5477 5478 /** 5479 * Length if the receiver's reliable messaging cache in minutes (if a receiver) or how long the cache length on the receiver should be (if a sender). 5480 */ 5481 @Child(name = "reliableCache", type = {UnsignedIntType.class}, order=2, min=0, max=1, modifier=false, summary=false) 5482 @Description(shortDefinition="Reliable Message Cache Length (min)", formalDefinition="Length if the receiver's reliable messaging cache in minutes (if a receiver) or how long the cache length on the receiver should be (if a sender)." ) 5483 protected UnsignedIntType reliableCache; 5484 5485 /** 5486 * Documentation about the system's messaging capabilities for this endpoint not otherwise documented by the capability statement. For example, the process for becoming an authorized messaging exchange partner. 5487 */ 5488 @Child(name = "documentation", type = {MarkdownType.class}, order=3, min=0, max=1, modifier=false, summary=false) 5489 @Description(shortDefinition="Messaging interface behavior details", formalDefinition="Documentation about the system's messaging capabilities for this endpoint not otherwise documented by the capability statement. For example, the process for becoming an authorized messaging exchange partner." ) 5490 protected MarkdownType documentation; 5491 5492 /** 5493 * References to message definitions for messages this system can send or receive. 5494 */ 5495 @Child(name = "supportedMessage", type = {}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 5496 @Description(shortDefinition="Messages supported by this system", formalDefinition="References to message definitions for messages this system can send or receive." ) 5497 protected List<CapabilityStatementMessagingSupportedMessageComponent> supportedMessage; 5498 5499 private static final long serialVersionUID = 300411231L; 5500 5501 /** 5502 * Constructor 5503 */ 5504 public CapabilityStatementMessagingComponent() { 5505 super(); 5506 } 5507 5508 /** 5509 * @return {@link #endpoint} (An endpoint (network accessible address) to which messages and/or replies are to be sent.) 5510 */ 5511 public List<CapabilityStatementMessagingEndpointComponent> getEndpoint() { 5512 if (this.endpoint == null) 5513 this.endpoint = new ArrayList<CapabilityStatementMessagingEndpointComponent>(); 5514 return this.endpoint; 5515 } 5516 5517 /** 5518 * @return Returns a reference to <code>this</code> for easy method chaining 5519 */ 5520 public CapabilityStatementMessagingComponent setEndpoint(List<CapabilityStatementMessagingEndpointComponent> theEndpoint) { 5521 this.endpoint = theEndpoint; 5522 return this; 5523 } 5524 5525 public boolean hasEndpoint() { 5526 if (this.endpoint == null) 5527 return false; 5528 for (CapabilityStatementMessagingEndpointComponent item : this.endpoint) 5529 if (!item.isEmpty()) 5530 return true; 5531 return false; 5532 } 5533 5534 public CapabilityStatementMessagingEndpointComponent addEndpoint() { //3 5535 CapabilityStatementMessagingEndpointComponent t = new CapabilityStatementMessagingEndpointComponent(); 5536 if (this.endpoint == null) 5537 this.endpoint = new ArrayList<CapabilityStatementMessagingEndpointComponent>(); 5538 this.endpoint.add(t); 5539 return t; 5540 } 5541 5542 public CapabilityStatementMessagingComponent addEndpoint(CapabilityStatementMessagingEndpointComponent t) { //3 5543 if (t == null) 5544 return this; 5545 if (this.endpoint == null) 5546 this.endpoint = new ArrayList<CapabilityStatementMessagingEndpointComponent>(); 5547 this.endpoint.add(t); 5548 return this; 5549 } 5550 5551 /** 5552 * @return The first repetition of repeating field {@link #endpoint}, creating it if it does not already exist {3} 5553 */ 5554 public CapabilityStatementMessagingEndpointComponent getEndpointFirstRep() { 5555 if (getEndpoint().isEmpty()) { 5556 addEndpoint(); 5557 } 5558 return getEndpoint().get(0); 5559 } 5560 5561 /** 5562 * @return {@link #reliableCache} (Length if the receiver's reliable messaging cache in minutes (if a receiver) or how long the cache length on the receiver should be (if a sender).). This is the underlying object with id, value and extensions. The accessor "getReliableCache" gives direct access to the value 5563 */ 5564 public UnsignedIntType getReliableCacheElement() { 5565 if (this.reliableCache == null) 5566 if (Configuration.errorOnAutoCreate()) 5567 throw new Error("Attempt to auto-create CapabilityStatementMessagingComponent.reliableCache"); 5568 else if (Configuration.doAutoCreate()) 5569 this.reliableCache = new UnsignedIntType(); // bb 5570 return this.reliableCache; 5571 } 5572 5573 public boolean hasReliableCacheElement() { 5574 return this.reliableCache != null && !this.reliableCache.isEmpty(); 5575 } 5576 5577 public boolean hasReliableCache() { 5578 return this.reliableCache != null && !this.reliableCache.isEmpty(); 5579 } 5580 5581 /** 5582 * @param value {@link #reliableCache} (Length if the receiver's reliable messaging cache in minutes (if a receiver) or how long the cache length on the receiver should be (if a sender).). This is the underlying object with id, value and extensions. The accessor "getReliableCache" gives direct access to the value 5583 */ 5584 public CapabilityStatementMessagingComponent setReliableCacheElement(UnsignedIntType value) { 5585 this.reliableCache = value; 5586 return this; 5587 } 5588 5589 /** 5590 * @return Length if the receiver's reliable messaging cache in minutes (if a receiver) or how long the cache length on the receiver should be (if a sender). 5591 */ 5592 public int getReliableCache() { 5593 return this.reliableCache == null || this.reliableCache.isEmpty() ? 0 : this.reliableCache.getValue(); 5594 } 5595 5596 /** 5597 * @param value Length if the receiver's reliable messaging cache in minutes (if a receiver) or how long the cache length on the receiver should be (if a sender). 5598 */ 5599 public CapabilityStatementMessagingComponent setReliableCache(int value) { 5600 if (this.reliableCache == null) 5601 this.reliableCache = new UnsignedIntType(); 5602 this.reliableCache.setValue(value); 5603 return this; 5604 } 5605 5606 /** 5607 * @return {@link #documentation} (Documentation about the system's messaging capabilities for this endpoint not otherwise documented by the capability statement. For example, the process for becoming an authorized messaging exchange partner.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value 5608 */ 5609 public MarkdownType getDocumentationElement() { 5610 if (this.documentation == null) 5611 if (Configuration.errorOnAutoCreate()) 5612 throw new Error("Attempt to auto-create CapabilityStatementMessagingComponent.documentation"); 5613 else if (Configuration.doAutoCreate()) 5614 this.documentation = new MarkdownType(); // bb 5615 return this.documentation; 5616 } 5617 5618 public boolean hasDocumentationElement() { 5619 return this.documentation != null && !this.documentation.isEmpty(); 5620 } 5621 5622 public boolean hasDocumentation() { 5623 return this.documentation != null && !this.documentation.isEmpty(); 5624 } 5625 5626 /** 5627 * @param value {@link #documentation} (Documentation about the system's messaging capabilities for this endpoint not otherwise documented by the capability statement. For example, the process for becoming an authorized messaging exchange partner.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value 5628 */ 5629 public CapabilityStatementMessagingComponent setDocumentationElement(MarkdownType value) { 5630 this.documentation = value; 5631 return this; 5632 } 5633 5634 /** 5635 * @return Documentation about the system's messaging capabilities for this endpoint not otherwise documented by the capability statement. For example, the process for becoming an authorized messaging exchange partner. 5636 */ 5637 public String getDocumentation() { 5638 return this.documentation == null ? null : this.documentation.getValue(); 5639 } 5640 5641 /** 5642 * @param value Documentation about the system's messaging capabilities for this endpoint not otherwise documented by the capability statement. For example, the process for becoming an authorized messaging exchange partner. 5643 */ 5644 public CapabilityStatementMessagingComponent setDocumentation(String value) { 5645 if (value == null) 5646 this.documentation = null; 5647 else { 5648 if (this.documentation == null) 5649 this.documentation = new MarkdownType(); 5650 this.documentation.setValue(value); 5651 } 5652 return this; 5653 } 5654 5655 /** 5656 * @return {@link #supportedMessage} (References to message definitions for messages this system can send or receive.) 5657 */ 5658 public List<CapabilityStatementMessagingSupportedMessageComponent> getSupportedMessage() { 5659 if (this.supportedMessage == null) 5660 this.supportedMessage = new ArrayList<CapabilityStatementMessagingSupportedMessageComponent>(); 5661 return this.supportedMessage; 5662 } 5663 5664 /** 5665 * @return Returns a reference to <code>this</code> for easy method chaining 5666 */ 5667 public CapabilityStatementMessagingComponent setSupportedMessage(List<CapabilityStatementMessagingSupportedMessageComponent> theSupportedMessage) { 5668 this.supportedMessage = theSupportedMessage; 5669 return this; 5670 } 5671 5672 public boolean hasSupportedMessage() { 5673 if (this.supportedMessage == null) 5674 return false; 5675 for (CapabilityStatementMessagingSupportedMessageComponent item : this.supportedMessage) 5676 if (!item.isEmpty()) 5677 return true; 5678 return false; 5679 } 5680 5681 public CapabilityStatementMessagingSupportedMessageComponent addSupportedMessage() { //3 5682 CapabilityStatementMessagingSupportedMessageComponent t = new CapabilityStatementMessagingSupportedMessageComponent(); 5683 if (this.supportedMessage == null) 5684 this.supportedMessage = new ArrayList<CapabilityStatementMessagingSupportedMessageComponent>(); 5685 this.supportedMessage.add(t); 5686 return t; 5687 } 5688 5689 public CapabilityStatementMessagingComponent addSupportedMessage(CapabilityStatementMessagingSupportedMessageComponent t) { //3 5690 if (t == null) 5691 return this; 5692 if (this.supportedMessage == null) 5693 this.supportedMessage = new ArrayList<CapabilityStatementMessagingSupportedMessageComponent>(); 5694 this.supportedMessage.add(t); 5695 return this; 5696 } 5697 5698 /** 5699 * @return The first repetition of repeating field {@link #supportedMessage}, creating it if it does not already exist {3} 5700 */ 5701 public CapabilityStatementMessagingSupportedMessageComponent getSupportedMessageFirstRep() { 5702 if (getSupportedMessage().isEmpty()) { 5703 addSupportedMessage(); 5704 } 5705 return getSupportedMessage().get(0); 5706 } 5707 5708 protected void listChildren(List<Property> children) { 5709 super.listChildren(children); 5710 children.add(new Property("endpoint", "", "An endpoint (network accessible address) to which messages and/or replies are to be sent.", 0, java.lang.Integer.MAX_VALUE, endpoint)); 5711 children.add(new Property("reliableCache", "unsignedInt", "Length if the receiver's reliable messaging cache in minutes (if a receiver) or how long the cache length on the receiver should be (if a sender).", 0, 1, reliableCache)); 5712 children.add(new Property("documentation", "markdown", "Documentation about the system's messaging capabilities for this endpoint not otherwise documented by the capability statement. For example, the process for becoming an authorized messaging exchange partner.", 0, 1, documentation)); 5713 children.add(new Property("supportedMessage", "", "References to message definitions for messages this system can send or receive.", 0, java.lang.Integer.MAX_VALUE, supportedMessage)); 5714 } 5715 5716 @Override 5717 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 5718 switch (_hash) { 5719 case 1741102485: /*endpoint*/ return new Property("endpoint", "", "An endpoint (network accessible address) to which messages and/or replies are to be sent.", 0, java.lang.Integer.MAX_VALUE, endpoint); 5720 case 897803608: /*reliableCache*/ return new Property("reliableCache", "unsignedInt", "Length if the receiver's reliable messaging cache in minutes (if a receiver) or how long the cache length on the receiver should be (if a sender).", 0, 1, reliableCache); 5721 case 1587405498: /*documentation*/ return new Property("documentation", "markdown", "Documentation about the system's messaging capabilities for this endpoint not otherwise documented by the capability statement. For example, the process for becoming an authorized messaging exchange partner.", 0, 1, documentation); 5722 case -1805139079: /*supportedMessage*/ return new Property("supportedMessage", "", "References to message definitions for messages this system can send or receive.", 0, java.lang.Integer.MAX_VALUE, supportedMessage); 5723 default: return super.getNamedProperty(_hash, _name, _checkValid); 5724 } 5725 5726 } 5727 5728 @Override 5729 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 5730 switch (hash) { 5731 case 1741102485: /*endpoint*/ return this.endpoint == null ? new Base[0] : this.endpoint.toArray(new Base[this.endpoint.size()]); // CapabilityStatementMessagingEndpointComponent 5732 case 897803608: /*reliableCache*/ return this.reliableCache == null ? new Base[0] : new Base[] {this.reliableCache}; // UnsignedIntType 5733 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 5734 case -1805139079: /*supportedMessage*/ return this.supportedMessage == null ? new Base[0] : this.supportedMessage.toArray(new Base[this.supportedMessage.size()]); // CapabilityStatementMessagingSupportedMessageComponent 5735 default: return super.getProperty(hash, name, checkValid); 5736 } 5737 5738 } 5739 5740 @Override 5741 public Base setProperty(int hash, String name, Base value) throws FHIRException { 5742 switch (hash) { 5743 case 1741102485: // endpoint 5744 this.getEndpoint().add((CapabilityStatementMessagingEndpointComponent) value); // CapabilityStatementMessagingEndpointComponent 5745 return value; 5746 case 897803608: // reliableCache 5747 this.reliableCache = TypeConvertor.castToUnsignedInt(value); // UnsignedIntType 5748 return value; 5749 case 1587405498: // documentation 5750 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 5751 return value; 5752 case -1805139079: // supportedMessage 5753 this.getSupportedMessage().add((CapabilityStatementMessagingSupportedMessageComponent) value); // CapabilityStatementMessagingSupportedMessageComponent 5754 return value; 5755 default: return super.setProperty(hash, name, value); 5756 } 5757 5758 } 5759 5760 @Override 5761 public Base setProperty(String name, Base value) throws FHIRException { 5762 if (name.equals("endpoint")) { 5763 this.getEndpoint().add((CapabilityStatementMessagingEndpointComponent) value); 5764 } else if (name.equals("reliableCache")) { 5765 this.reliableCache = TypeConvertor.castToUnsignedInt(value); // UnsignedIntType 5766 } else if (name.equals("documentation")) { 5767 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 5768 } else if (name.equals("supportedMessage")) { 5769 this.getSupportedMessage().add((CapabilityStatementMessagingSupportedMessageComponent) value); 5770 } else 5771 return super.setProperty(name, value); 5772 return value; 5773 } 5774 5775 @Override 5776 public Base makeProperty(int hash, String name) throws FHIRException { 5777 switch (hash) { 5778 case 1741102485: return addEndpoint(); 5779 case 897803608: return getReliableCacheElement(); 5780 case 1587405498: return getDocumentationElement(); 5781 case -1805139079: return addSupportedMessage(); 5782 default: return super.makeProperty(hash, name); 5783 } 5784 5785 } 5786 5787 @Override 5788 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 5789 switch (hash) { 5790 case 1741102485: /*endpoint*/ return new String[] {}; 5791 case 897803608: /*reliableCache*/ return new String[] {"unsignedInt"}; 5792 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 5793 case -1805139079: /*supportedMessage*/ return new String[] {}; 5794 default: return super.getTypesForProperty(hash, name); 5795 } 5796 5797 } 5798 5799 @Override 5800 public Base addChild(String name) throws FHIRException { 5801 if (name.equals("endpoint")) { 5802 return addEndpoint(); 5803 } 5804 else if (name.equals("reliableCache")) { 5805 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.messaging.reliableCache"); 5806 } 5807 else if (name.equals("documentation")) { 5808 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.messaging.documentation"); 5809 } 5810 else if (name.equals("supportedMessage")) { 5811 return addSupportedMessage(); 5812 } 5813 else 5814 return super.addChild(name); 5815 } 5816 5817 public CapabilityStatementMessagingComponent copy() { 5818 CapabilityStatementMessagingComponent dst = new CapabilityStatementMessagingComponent(); 5819 copyValues(dst); 5820 return dst; 5821 } 5822 5823 public void copyValues(CapabilityStatementMessagingComponent dst) { 5824 super.copyValues(dst); 5825 if (endpoint != null) { 5826 dst.endpoint = new ArrayList<CapabilityStatementMessagingEndpointComponent>(); 5827 for (CapabilityStatementMessagingEndpointComponent i : endpoint) 5828 dst.endpoint.add(i.copy()); 5829 }; 5830 dst.reliableCache = reliableCache == null ? null : reliableCache.copy(); 5831 dst.documentation = documentation == null ? null : documentation.copy(); 5832 if (supportedMessage != null) { 5833 dst.supportedMessage = new ArrayList<CapabilityStatementMessagingSupportedMessageComponent>(); 5834 for (CapabilityStatementMessagingSupportedMessageComponent i : supportedMessage) 5835 dst.supportedMessage.add(i.copy()); 5836 }; 5837 } 5838 5839 @Override 5840 public boolean equalsDeep(Base other_) { 5841 if (!super.equalsDeep(other_)) 5842 return false; 5843 if (!(other_ instanceof CapabilityStatementMessagingComponent)) 5844 return false; 5845 CapabilityStatementMessagingComponent o = (CapabilityStatementMessagingComponent) other_; 5846 return compareDeep(endpoint, o.endpoint, true) && compareDeep(reliableCache, o.reliableCache, true) 5847 && compareDeep(documentation, o.documentation, true) && compareDeep(supportedMessage, o.supportedMessage, true) 5848 ; 5849 } 5850 5851 @Override 5852 public boolean equalsShallow(Base other_) { 5853 if (!super.equalsShallow(other_)) 5854 return false; 5855 if (!(other_ instanceof CapabilityStatementMessagingComponent)) 5856 return false; 5857 CapabilityStatementMessagingComponent o = (CapabilityStatementMessagingComponent) other_; 5858 return compareValues(reliableCache, o.reliableCache, true) && compareValues(documentation, o.documentation, true) 5859 ; 5860 } 5861 5862 public boolean isEmpty() { 5863 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(endpoint, reliableCache, documentation 5864 , supportedMessage); 5865 } 5866 5867 public String fhirType() { 5868 return "CapabilityStatement.messaging"; 5869 5870 } 5871 5872 } 5873 5874 @Block() 5875 public static class CapabilityStatementMessagingEndpointComponent extends BackboneElement implements IBaseBackboneElement { 5876 /** 5877 * A list of the messaging transport protocol(s) identifiers, supported by this endpoint. 5878 */ 5879 @Child(name = "protocol", type = {Coding.class}, order=1, min=1, max=1, modifier=false, summary=false) 5880 @Description(shortDefinition="http | ftp | mllp +", formalDefinition="A list of the messaging transport protocol(s) identifiers, supported by this endpoint." ) 5881 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/message-transport") 5882 protected Coding protocol; 5883 5884 /** 5885 * The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier. 5886 */ 5887 @Child(name = "address", type = {UrlType.class}, order=2, min=1, max=1, modifier=false, summary=false) 5888 @Description(shortDefinition="Network address or identifier of the end-point", formalDefinition="The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier." ) 5889 protected UrlType address; 5890 5891 private static final long serialVersionUID = -236946103L; 5892 5893 /** 5894 * Constructor 5895 */ 5896 public CapabilityStatementMessagingEndpointComponent() { 5897 super(); 5898 } 5899 5900 /** 5901 * Constructor 5902 */ 5903 public CapabilityStatementMessagingEndpointComponent(Coding protocol, String address) { 5904 super(); 5905 this.setProtocol(protocol); 5906 this.setAddress(address); 5907 } 5908 5909 /** 5910 * @return {@link #protocol} (A list of the messaging transport protocol(s) identifiers, supported by this endpoint.) 5911 */ 5912 public Coding getProtocol() { 5913 if (this.protocol == null) 5914 if (Configuration.errorOnAutoCreate()) 5915 throw new Error("Attempt to auto-create CapabilityStatementMessagingEndpointComponent.protocol"); 5916 else if (Configuration.doAutoCreate()) 5917 this.protocol = new Coding(); // cc 5918 return this.protocol; 5919 } 5920 5921 public boolean hasProtocol() { 5922 return this.protocol != null && !this.protocol.isEmpty(); 5923 } 5924 5925 /** 5926 * @param value {@link #protocol} (A list of the messaging transport protocol(s) identifiers, supported by this endpoint.) 5927 */ 5928 public CapabilityStatementMessagingEndpointComponent setProtocol(Coding value) { 5929 this.protocol = value; 5930 return this; 5931 } 5932 5933 /** 5934 * @return {@link #address} (The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier.). This is the underlying object with id, value and extensions. The accessor "getAddress" gives direct access to the value 5935 */ 5936 public UrlType getAddressElement() { 5937 if (this.address == null) 5938 if (Configuration.errorOnAutoCreate()) 5939 throw new Error("Attempt to auto-create CapabilityStatementMessagingEndpointComponent.address"); 5940 else if (Configuration.doAutoCreate()) 5941 this.address = new UrlType(); // bb 5942 return this.address; 5943 } 5944 5945 public boolean hasAddressElement() { 5946 return this.address != null && !this.address.isEmpty(); 5947 } 5948 5949 public boolean hasAddress() { 5950 return this.address != null && !this.address.isEmpty(); 5951 } 5952 5953 /** 5954 * @param value {@link #address} (The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier.). This is the underlying object with id, value and extensions. The accessor "getAddress" gives direct access to the value 5955 */ 5956 public CapabilityStatementMessagingEndpointComponent setAddressElement(UrlType value) { 5957 this.address = value; 5958 return this; 5959 } 5960 5961 /** 5962 * @return The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier. 5963 */ 5964 public String getAddress() { 5965 return this.address == null ? null : this.address.getValue(); 5966 } 5967 5968 /** 5969 * @param value The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier. 5970 */ 5971 public CapabilityStatementMessagingEndpointComponent setAddress(String value) { 5972 if (this.address == null) 5973 this.address = new UrlType(); 5974 this.address.setValue(value); 5975 return this; 5976 } 5977 5978 protected void listChildren(List<Property> children) { 5979 super.listChildren(children); 5980 children.add(new Property("protocol", "Coding", "A list of the messaging transport protocol(s) identifiers, supported by this endpoint.", 0, 1, protocol)); 5981 children.add(new Property("address", "url", "The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier.", 0, 1, address)); 5982 } 5983 5984 @Override 5985 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 5986 switch (_hash) { 5987 case -989163880: /*protocol*/ return new Property("protocol", "Coding", "A list of the messaging transport protocol(s) identifiers, supported by this endpoint.", 0, 1, protocol); 5988 case -1147692044: /*address*/ return new Property("address", "url", "The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier.", 0, 1, address); 5989 default: return super.getNamedProperty(_hash, _name, _checkValid); 5990 } 5991 5992 } 5993 5994 @Override 5995 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 5996 switch (hash) { 5997 case -989163880: /*protocol*/ return this.protocol == null ? new Base[0] : new Base[] {this.protocol}; // Coding 5998 case -1147692044: /*address*/ return this.address == null ? new Base[0] : new Base[] {this.address}; // UrlType 5999 default: return super.getProperty(hash, name, checkValid); 6000 } 6001 6002 } 6003 6004 @Override 6005 public Base setProperty(int hash, String name, Base value) throws FHIRException { 6006 switch (hash) { 6007 case -989163880: // protocol 6008 this.protocol = TypeConvertor.castToCoding(value); // Coding 6009 return value; 6010 case -1147692044: // address 6011 this.address = TypeConvertor.castToUrl(value); // UrlType 6012 return value; 6013 default: return super.setProperty(hash, name, value); 6014 } 6015 6016 } 6017 6018 @Override 6019 public Base setProperty(String name, Base value) throws FHIRException { 6020 if (name.equals("protocol")) { 6021 this.protocol = TypeConvertor.castToCoding(value); // Coding 6022 } else if (name.equals("address")) { 6023 this.address = TypeConvertor.castToUrl(value); // UrlType 6024 } else 6025 return super.setProperty(name, value); 6026 return value; 6027 } 6028 6029 @Override 6030 public Base makeProperty(int hash, String name) throws FHIRException { 6031 switch (hash) { 6032 case -989163880: return getProtocol(); 6033 case -1147692044: return getAddressElement(); 6034 default: return super.makeProperty(hash, name); 6035 } 6036 6037 } 6038 6039 @Override 6040 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 6041 switch (hash) { 6042 case -989163880: /*protocol*/ return new String[] {"Coding"}; 6043 case -1147692044: /*address*/ return new String[] {"url"}; 6044 default: return super.getTypesForProperty(hash, name); 6045 } 6046 6047 } 6048 6049 @Override 6050 public Base addChild(String name) throws FHIRException { 6051 if (name.equals("protocol")) { 6052 this.protocol = new Coding(); 6053 return this.protocol; 6054 } 6055 else if (name.equals("address")) { 6056 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.messaging.endpoint.address"); 6057 } 6058 else 6059 return super.addChild(name); 6060 } 6061 6062 public CapabilityStatementMessagingEndpointComponent copy() { 6063 CapabilityStatementMessagingEndpointComponent dst = new CapabilityStatementMessagingEndpointComponent(); 6064 copyValues(dst); 6065 return dst; 6066 } 6067 6068 public void copyValues(CapabilityStatementMessagingEndpointComponent dst) { 6069 super.copyValues(dst); 6070 dst.protocol = protocol == null ? null : protocol.copy(); 6071 dst.address = address == null ? null : address.copy(); 6072 } 6073 6074 @Override 6075 public boolean equalsDeep(Base other_) { 6076 if (!super.equalsDeep(other_)) 6077 return false; 6078 if (!(other_ instanceof CapabilityStatementMessagingEndpointComponent)) 6079 return false; 6080 CapabilityStatementMessagingEndpointComponent o = (CapabilityStatementMessagingEndpointComponent) other_; 6081 return compareDeep(protocol, o.protocol, true) && compareDeep(address, o.address, true); 6082 } 6083 6084 @Override 6085 public boolean equalsShallow(Base other_) { 6086 if (!super.equalsShallow(other_)) 6087 return false; 6088 if (!(other_ instanceof CapabilityStatementMessagingEndpointComponent)) 6089 return false; 6090 CapabilityStatementMessagingEndpointComponent o = (CapabilityStatementMessagingEndpointComponent) other_; 6091 return compareValues(address, o.address, true); 6092 } 6093 6094 public boolean isEmpty() { 6095 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(protocol, address); 6096 } 6097 6098 public String fhirType() { 6099 return "CapabilityStatement.messaging.endpoint"; 6100 6101 } 6102 6103 } 6104 6105 @Block() 6106 public static class CapabilityStatementMessagingSupportedMessageComponent extends BackboneElement implements IBaseBackboneElement { 6107 /** 6108 * The mode of this event declaration - whether application is sender or receiver. 6109 */ 6110 @Child(name = "mode", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true) 6111 @Description(shortDefinition="sender | receiver", formalDefinition="The mode of this event declaration - whether application is sender or receiver." ) 6112 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/event-capability-mode") 6113 protected Enumeration<EventCapabilityMode> mode; 6114 6115 /** 6116 * Points to a message definition that identifies the messaging event, message structure, allowed responses, etc. 6117 */ 6118 @Child(name = "definition", type = {CanonicalType.class}, order=2, min=1, max=1, modifier=false, summary=true) 6119 @Description(shortDefinition="Message supported by this system", formalDefinition="Points to a message definition that identifies the messaging event, message structure, allowed responses, etc." ) 6120 protected CanonicalType definition; 6121 6122 private static final long serialVersionUID = -1172840676L; 6123 6124 /** 6125 * Constructor 6126 */ 6127 public CapabilityStatementMessagingSupportedMessageComponent() { 6128 super(); 6129 } 6130 6131 /** 6132 * Constructor 6133 */ 6134 public CapabilityStatementMessagingSupportedMessageComponent(EventCapabilityMode mode, String definition) { 6135 super(); 6136 this.setMode(mode); 6137 this.setDefinition(definition); 6138 } 6139 6140 /** 6141 * @return {@link #mode} (The mode of this event declaration - whether application is sender or receiver.). This is the underlying object with id, value and extensions. The accessor "getMode" gives direct access to the value 6142 */ 6143 public Enumeration<EventCapabilityMode> getModeElement() { 6144 if (this.mode == null) 6145 if (Configuration.errorOnAutoCreate()) 6146 throw new Error("Attempt to auto-create CapabilityStatementMessagingSupportedMessageComponent.mode"); 6147 else if (Configuration.doAutoCreate()) 6148 this.mode = new Enumeration<EventCapabilityMode>(new EventCapabilityModeEnumFactory()); // bb 6149 return this.mode; 6150 } 6151 6152 public boolean hasModeElement() { 6153 return this.mode != null && !this.mode.isEmpty(); 6154 } 6155 6156 public boolean hasMode() { 6157 return this.mode != null && !this.mode.isEmpty(); 6158 } 6159 6160 /** 6161 * @param value {@link #mode} (The mode of this event declaration - whether application is sender or receiver.). This is the underlying object with id, value and extensions. The accessor "getMode" gives direct access to the value 6162 */ 6163 public CapabilityStatementMessagingSupportedMessageComponent setModeElement(Enumeration<EventCapabilityMode> value) { 6164 this.mode = value; 6165 return this; 6166 } 6167 6168 /** 6169 * @return The mode of this event declaration - whether application is sender or receiver. 6170 */ 6171 public EventCapabilityMode getMode() { 6172 return this.mode == null ? null : this.mode.getValue(); 6173 } 6174 6175 /** 6176 * @param value The mode of this event declaration - whether application is sender or receiver. 6177 */ 6178 public CapabilityStatementMessagingSupportedMessageComponent setMode(EventCapabilityMode value) { 6179 if (this.mode == null) 6180 this.mode = new Enumeration<EventCapabilityMode>(new EventCapabilityModeEnumFactory()); 6181 this.mode.setValue(value); 6182 return this; 6183 } 6184 6185 /** 6186 * @return {@link #definition} (Points to a message definition that identifies the messaging event, message structure, allowed responses, etc.). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value 6187 */ 6188 public CanonicalType getDefinitionElement() { 6189 if (this.definition == null) 6190 if (Configuration.errorOnAutoCreate()) 6191 throw new Error("Attempt to auto-create CapabilityStatementMessagingSupportedMessageComponent.definition"); 6192 else if (Configuration.doAutoCreate()) 6193 this.definition = new CanonicalType(); // bb 6194 return this.definition; 6195 } 6196 6197 public boolean hasDefinitionElement() { 6198 return this.definition != null && !this.definition.isEmpty(); 6199 } 6200 6201 public boolean hasDefinition() { 6202 return this.definition != null && !this.definition.isEmpty(); 6203 } 6204 6205 /** 6206 * @param value {@link #definition} (Points to a message definition that identifies the messaging event, message structure, allowed responses, etc.). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value 6207 */ 6208 public CapabilityStatementMessagingSupportedMessageComponent setDefinitionElement(CanonicalType value) { 6209 this.definition = value; 6210 return this; 6211 } 6212 6213 /** 6214 * @return Points to a message definition that identifies the messaging event, message structure, allowed responses, etc. 6215 */ 6216 public String getDefinition() { 6217 return this.definition == null ? null : this.definition.getValue(); 6218 } 6219 6220 /** 6221 * @param value Points to a message definition that identifies the messaging event, message structure, allowed responses, etc. 6222 */ 6223 public CapabilityStatementMessagingSupportedMessageComponent setDefinition(String value) { 6224 if (this.definition == null) 6225 this.definition = new CanonicalType(); 6226 this.definition.setValue(value); 6227 return this; 6228 } 6229 6230 protected void listChildren(List<Property> children) { 6231 super.listChildren(children); 6232 children.add(new Property("mode", "code", "The mode of this event declaration - whether application is sender or receiver.", 0, 1, mode)); 6233 children.add(new Property("definition", "canonical(MessageDefinition)", "Points to a message definition that identifies the messaging event, message structure, allowed responses, etc.", 0, 1, definition)); 6234 } 6235 6236 @Override 6237 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 6238 switch (_hash) { 6239 case 3357091: /*mode*/ return new Property("mode", "code", "The mode of this event declaration - whether application is sender or receiver.", 0, 1, mode); 6240 case -1014418093: /*definition*/ return new Property("definition", "canonical(MessageDefinition)", "Points to a message definition that identifies the messaging event, message structure, allowed responses, etc.", 0, 1, definition); 6241 default: return super.getNamedProperty(_hash, _name, _checkValid); 6242 } 6243 6244 } 6245 6246 @Override 6247 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 6248 switch (hash) { 6249 case 3357091: /*mode*/ return this.mode == null ? new Base[0] : new Base[] {this.mode}; // Enumeration<EventCapabilityMode> 6250 case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : new Base[] {this.definition}; // CanonicalType 6251 default: return super.getProperty(hash, name, checkValid); 6252 } 6253 6254 } 6255 6256 @Override 6257 public Base setProperty(int hash, String name, Base value) throws FHIRException { 6258 switch (hash) { 6259 case 3357091: // mode 6260 value = new EventCapabilityModeEnumFactory().fromType(TypeConvertor.castToCode(value)); 6261 this.mode = (Enumeration) value; // Enumeration<EventCapabilityMode> 6262 return value; 6263 case -1014418093: // definition 6264 this.definition = TypeConvertor.castToCanonical(value); // CanonicalType 6265 return value; 6266 default: return super.setProperty(hash, name, value); 6267 } 6268 6269 } 6270 6271 @Override 6272 public Base setProperty(String name, Base value) throws FHIRException { 6273 if (name.equals("mode")) { 6274 value = new EventCapabilityModeEnumFactory().fromType(TypeConvertor.castToCode(value)); 6275 this.mode = (Enumeration) value; // Enumeration<EventCapabilityMode> 6276 } else if (name.equals("definition")) { 6277 this.definition = TypeConvertor.castToCanonical(value); // CanonicalType 6278 } else 6279 return super.setProperty(name, value); 6280 return value; 6281 } 6282 6283 @Override 6284 public Base makeProperty(int hash, String name) throws FHIRException { 6285 switch (hash) { 6286 case 3357091: return getModeElement(); 6287 case -1014418093: return getDefinitionElement(); 6288 default: return super.makeProperty(hash, name); 6289 } 6290 6291 } 6292 6293 @Override 6294 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 6295 switch (hash) { 6296 case 3357091: /*mode*/ return new String[] {"code"}; 6297 case -1014418093: /*definition*/ return new String[] {"canonical"}; 6298 default: return super.getTypesForProperty(hash, name); 6299 } 6300 6301 } 6302 6303 @Override 6304 public Base addChild(String name) throws FHIRException { 6305 if (name.equals("mode")) { 6306 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.messaging.supportedMessage.mode"); 6307 } 6308 else if (name.equals("definition")) { 6309 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.messaging.supportedMessage.definition"); 6310 } 6311 else 6312 return super.addChild(name); 6313 } 6314 6315 public CapabilityStatementMessagingSupportedMessageComponent copy() { 6316 CapabilityStatementMessagingSupportedMessageComponent dst = new CapabilityStatementMessagingSupportedMessageComponent(); 6317 copyValues(dst); 6318 return dst; 6319 } 6320 6321 public void copyValues(CapabilityStatementMessagingSupportedMessageComponent dst) { 6322 super.copyValues(dst); 6323 dst.mode = mode == null ? null : mode.copy(); 6324 dst.definition = definition == null ? null : definition.copy(); 6325 } 6326 6327 @Override 6328 public boolean equalsDeep(Base other_) { 6329 if (!super.equalsDeep(other_)) 6330 return false; 6331 if (!(other_ instanceof CapabilityStatementMessagingSupportedMessageComponent)) 6332 return false; 6333 CapabilityStatementMessagingSupportedMessageComponent o = (CapabilityStatementMessagingSupportedMessageComponent) other_; 6334 return compareDeep(mode, o.mode, true) && compareDeep(definition, o.definition, true); 6335 } 6336 6337 @Override 6338 public boolean equalsShallow(Base other_) { 6339 if (!super.equalsShallow(other_)) 6340 return false; 6341 if (!(other_ instanceof CapabilityStatementMessagingSupportedMessageComponent)) 6342 return false; 6343 CapabilityStatementMessagingSupportedMessageComponent o = (CapabilityStatementMessagingSupportedMessageComponent) other_; 6344 return compareValues(mode, o.mode, true) && compareValues(definition, o.definition, true); 6345 } 6346 6347 public boolean isEmpty() { 6348 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(mode, definition); 6349 } 6350 6351 public String fhirType() { 6352 return "CapabilityStatement.messaging.supportedMessage"; 6353 6354 } 6355 6356 } 6357 6358 @Block() 6359 public static class CapabilityStatementDocumentComponent extends BackboneElement implements IBaseBackboneElement { 6360 /** 6361 * Mode of this document declaration - whether an application is a producer or consumer. 6362 */ 6363 @Child(name = "mode", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true) 6364 @Description(shortDefinition="producer | consumer", formalDefinition="Mode of this document declaration - whether an application is a producer or consumer." ) 6365 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/document-mode") 6366 protected Enumeration<DocumentMode> mode; 6367 6368 /** 6369 * A description of how the application supports or uses the specified document profile. For example, when documents are created, what action is taken with consumed documents, etc. 6370 */ 6371 @Child(name = "documentation", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=false) 6372 @Description(shortDefinition="Description of document support", formalDefinition="A description of how the application supports or uses the specified document profile. For example, when documents are created, what action is taken with consumed documents, etc." ) 6373 protected MarkdownType documentation; 6374 6375 /** 6376 * A profile on the document Bundle that constrains which resources are present, and their contents. 6377 */ 6378 @Child(name = "profile", type = {CanonicalType.class}, order=3, min=1, max=1, modifier=false, summary=true) 6379 @Description(shortDefinition="Constraint on the resources used in the document", formalDefinition="A profile on the document Bundle that constrains which resources are present, and their contents." ) 6380 protected CanonicalType profile; 6381 6382 private static final long serialVersionUID = 18026632L; 6383 6384 /** 6385 * Constructor 6386 */ 6387 public CapabilityStatementDocumentComponent() { 6388 super(); 6389 } 6390 6391 /** 6392 * Constructor 6393 */ 6394 public CapabilityStatementDocumentComponent(DocumentMode mode, String profile) { 6395 super(); 6396 this.setMode(mode); 6397 this.setProfile(profile); 6398 } 6399 6400 /** 6401 * @return {@link #mode} (Mode of this document declaration - whether an application is a producer or consumer.). This is the underlying object with id, value and extensions. The accessor "getMode" gives direct access to the value 6402 */ 6403 public Enumeration<DocumentMode> getModeElement() { 6404 if (this.mode == null) 6405 if (Configuration.errorOnAutoCreate()) 6406 throw new Error("Attempt to auto-create CapabilityStatementDocumentComponent.mode"); 6407 else if (Configuration.doAutoCreate()) 6408 this.mode = new Enumeration<DocumentMode>(new DocumentModeEnumFactory()); // bb 6409 return this.mode; 6410 } 6411 6412 public boolean hasModeElement() { 6413 return this.mode != null && !this.mode.isEmpty(); 6414 } 6415 6416 public boolean hasMode() { 6417 return this.mode != null && !this.mode.isEmpty(); 6418 } 6419 6420 /** 6421 * @param value {@link #mode} (Mode of this document declaration - whether an application is a producer or consumer.). This is the underlying object with id, value and extensions. The accessor "getMode" gives direct access to the value 6422 */ 6423 public CapabilityStatementDocumentComponent setModeElement(Enumeration<DocumentMode> value) { 6424 this.mode = value; 6425 return this; 6426 } 6427 6428 /** 6429 * @return Mode of this document declaration - whether an application is a producer or consumer. 6430 */ 6431 public DocumentMode getMode() { 6432 return this.mode == null ? null : this.mode.getValue(); 6433 } 6434 6435 /** 6436 * @param value Mode of this document declaration - whether an application is a producer or consumer. 6437 */ 6438 public CapabilityStatementDocumentComponent setMode(DocumentMode value) { 6439 if (this.mode == null) 6440 this.mode = new Enumeration<DocumentMode>(new DocumentModeEnumFactory()); 6441 this.mode.setValue(value); 6442 return this; 6443 } 6444 6445 /** 6446 * @return {@link #documentation} (A description of how the application supports or uses the specified document profile. For example, when documents are created, what action is taken with consumed documents, etc.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value 6447 */ 6448 public MarkdownType getDocumentationElement() { 6449 if (this.documentation == null) 6450 if (Configuration.errorOnAutoCreate()) 6451 throw new Error("Attempt to auto-create CapabilityStatementDocumentComponent.documentation"); 6452 else if (Configuration.doAutoCreate()) 6453 this.documentation = new MarkdownType(); // bb 6454 return this.documentation; 6455 } 6456 6457 public boolean hasDocumentationElement() { 6458 return this.documentation != null && !this.documentation.isEmpty(); 6459 } 6460 6461 public boolean hasDocumentation() { 6462 return this.documentation != null && !this.documentation.isEmpty(); 6463 } 6464 6465 /** 6466 * @param value {@link #documentation} (A description of how the application supports or uses the specified document profile. For example, when documents are created, what action is taken with consumed documents, etc.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value 6467 */ 6468 public CapabilityStatementDocumentComponent setDocumentationElement(MarkdownType value) { 6469 this.documentation = value; 6470 return this; 6471 } 6472 6473 /** 6474 * @return A description of how the application supports or uses the specified document profile. For example, when documents are created, what action is taken with consumed documents, etc. 6475 */ 6476 public String getDocumentation() { 6477 return this.documentation == null ? null : this.documentation.getValue(); 6478 } 6479 6480 /** 6481 * @param value A description of how the application supports or uses the specified document profile. For example, when documents are created, what action is taken with consumed documents, etc. 6482 */ 6483 public CapabilityStatementDocumentComponent setDocumentation(String value) { 6484 if (value == null) 6485 this.documentation = null; 6486 else { 6487 if (this.documentation == null) 6488 this.documentation = new MarkdownType(); 6489 this.documentation.setValue(value); 6490 } 6491 return this; 6492 } 6493 6494 /** 6495 * @return {@link #profile} (A profile on the document Bundle that constrains which resources are present, and their contents.). This is the underlying object with id, value and extensions. The accessor "getProfile" gives direct access to the value 6496 */ 6497 public CanonicalType getProfileElement() { 6498 if (this.profile == null) 6499 if (Configuration.errorOnAutoCreate()) 6500 throw new Error("Attempt to auto-create CapabilityStatementDocumentComponent.profile"); 6501 else if (Configuration.doAutoCreate()) 6502 this.profile = new CanonicalType(); // bb 6503 return this.profile; 6504 } 6505 6506 public boolean hasProfileElement() { 6507 return this.profile != null && !this.profile.isEmpty(); 6508 } 6509 6510 public boolean hasProfile() { 6511 return this.profile != null && !this.profile.isEmpty(); 6512 } 6513 6514 /** 6515 * @param value {@link #profile} (A profile on the document Bundle that constrains which resources are present, and their contents.). This is the underlying object with id, value and extensions. The accessor "getProfile" gives direct access to the value 6516 */ 6517 public CapabilityStatementDocumentComponent setProfileElement(CanonicalType value) { 6518 this.profile = value; 6519 return this; 6520 } 6521 6522 /** 6523 * @return A profile on the document Bundle that constrains which resources are present, and their contents. 6524 */ 6525 public String getProfile() { 6526 return this.profile == null ? null : this.profile.getValue(); 6527 } 6528 6529 /** 6530 * @param value A profile on the document Bundle that constrains which resources are present, and their contents. 6531 */ 6532 public CapabilityStatementDocumentComponent setProfile(String value) { 6533 if (this.profile == null) 6534 this.profile = new CanonicalType(); 6535 this.profile.setValue(value); 6536 return this; 6537 } 6538 6539 protected void listChildren(List<Property> children) { 6540 super.listChildren(children); 6541 children.add(new Property("mode", "code", "Mode of this document declaration - whether an application is a producer or consumer.", 0, 1, mode)); 6542 children.add(new Property("documentation", "markdown", "A description of how the application supports or uses the specified document profile. For example, when documents are created, what action is taken with consumed documents, etc.", 0, 1, documentation)); 6543 children.add(new Property("profile", "canonical(StructureDefinition)", "A profile on the document Bundle that constrains which resources are present, and their contents.", 0, 1, profile)); 6544 } 6545 6546 @Override 6547 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 6548 switch (_hash) { 6549 case 3357091: /*mode*/ return new Property("mode", "code", "Mode of this document declaration - whether an application is a producer or consumer.", 0, 1, mode); 6550 case 1587405498: /*documentation*/ return new Property("documentation", "markdown", "A description of how the application supports or uses the specified document profile. For example, when documents are created, what action is taken with consumed documents, etc.", 0, 1, documentation); 6551 case -309425751: /*profile*/ return new Property("profile", "canonical(StructureDefinition)", "A profile on the document Bundle that constrains which resources are present, and their contents.", 0, 1, profile); 6552 default: return super.getNamedProperty(_hash, _name, _checkValid); 6553 } 6554 6555 } 6556 6557 @Override 6558 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 6559 switch (hash) { 6560 case 3357091: /*mode*/ return this.mode == null ? new Base[0] : new Base[] {this.mode}; // Enumeration<DocumentMode> 6561 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 6562 case -309425751: /*profile*/ return this.profile == null ? new Base[0] : new Base[] {this.profile}; // CanonicalType 6563 default: return super.getProperty(hash, name, checkValid); 6564 } 6565 6566 } 6567 6568 @Override 6569 public Base setProperty(int hash, String name, Base value) throws FHIRException { 6570 switch (hash) { 6571 case 3357091: // mode 6572 value = new DocumentModeEnumFactory().fromType(TypeConvertor.castToCode(value)); 6573 this.mode = (Enumeration) value; // Enumeration<DocumentMode> 6574 return value; 6575 case 1587405498: // documentation 6576 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 6577 return value; 6578 case -309425751: // profile 6579 this.profile = TypeConvertor.castToCanonical(value); // CanonicalType 6580 return value; 6581 default: return super.setProperty(hash, name, value); 6582 } 6583 6584 } 6585 6586 @Override 6587 public Base setProperty(String name, Base value) throws FHIRException { 6588 if (name.equals("mode")) { 6589 value = new DocumentModeEnumFactory().fromType(TypeConvertor.castToCode(value)); 6590 this.mode = (Enumeration) value; // Enumeration<DocumentMode> 6591 } else if (name.equals("documentation")) { 6592 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 6593 } else if (name.equals("profile")) { 6594 this.profile = TypeConvertor.castToCanonical(value); // CanonicalType 6595 } else 6596 return super.setProperty(name, value); 6597 return value; 6598 } 6599 6600 @Override 6601 public Base makeProperty(int hash, String name) throws FHIRException { 6602 switch (hash) { 6603 case 3357091: return getModeElement(); 6604 case 1587405498: return getDocumentationElement(); 6605 case -309425751: return getProfileElement(); 6606 default: return super.makeProperty(hash, name); 6607 } 6608 6609 } 6610 6611 @Override 6612 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 6613 switch (hash) { 6614 case 3357091: /*mode*/ return new String[] {"code"}; 6615 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 6616 case -309425751: /*profile*/ return new String[] {"canonical"}; 6617 default: return super.getTypesForProperty(hash, name); 6618 } 6619 6620 } 6621 6622 @Override 6623 public Base addChild(String name) throws FHIRException { 6624 if (name.equals("mode")) { 6625 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.document.mode"); 6626 } 6627 else if (name.equals("documentation")) { 6628 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.document.documentation"); 6629 } 6630 else if (name.equals("profile")) { 6631 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.document.profile"); 6632 } 6633 else 6634 return super.addChild(name); 6635 } 6636 6637 public CapabilityStatementDocumentComponent copy() { 6638 CapabilityStatementDocumentComponent dst = new CapabilityStatementDocumentComponent(); 6639 copyValues(dst); 6640 return dst; 6641 } 6642 6643 public void copyValues(CapabilityStatementDocumentComponent dst) { 6644 super.copyValues(dst); 6645 dst.mode = mode == null ? null : mode.copy(); 6646 dst.documentation = documentation == null ? null : documentation.copy(); 6647 dst.profile = profile == null ? null : profile.copy(); 6648 } 6649 6650 @Override 6651 public boolean equalsDeep(Base other_) { 6652 if (!super.equalsDeep(other_)) 6653 return false; 6654 if (!(other_ instanceof CapabilityStatementDocumentComponent)) 6655 return false; 6656 CapabilityStatementDocumentComponent o = (CapabilityStatementDocumentComponent) other_; 6657 return compareDeep(mode, o.mode, true) && compareDeep(documentation, o.documentation, true) && compareDeep(profile, o.profile, true) 6658 ; 6659 } 6660 6661 @Override 6662 public boolean equalsShallow(Base other_) { 6663 if (!super.equalsShallow(other_)) 6664 return false; 6665 if (!(other_ instanceof CapabilityStatementDocumentComponent)) 6666 return false; 6667 CapabilityStatementDocumentComponent o = (CapabilityStatementDocumentComponent) other_; 6668 return compareValues(mode, o.mode, true) && compareValues(documentation, o.documentation, true) && compareValues(profile, o.profile, true) 6669 ; 6670 } 6671 6672 public boolean isEmpty() { 6673 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(mode, documentation, profile 6674 ); 6675 } 6676 6677 public String fhirType() { 6678 return "CapabilityStatement.document"; 6679 6680 } 6681 6682 } 6683 6684 /** 6685 * An absolute URI that is used to identify this capability statement when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this capability statement is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement is stored on different servers. 6686 */ 6687 @Child(name = "url", type = {UriType.class}, order=0, min=0, max=1, modifier=false, summary=true) 6688 @Description(shortDefinition="Canonical identifier for this capability statement, represented as a URI (globally unique)", formalDefinition="An absolute URI that is used to identify this capability statement when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this capability statement is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement is stored on different servers." ) 6689 protected UriType url; 6690 6691 /** 6692 * The identifier that is used to identify this version of the capability statement when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. 6693 */ 6694 @Child(name = "version", type = {StringType.class}, order=1, min=0, max=1, modifier=false, summary=true) 6695 @Description(shortDefinition="Business version of the capability statement", formalDefinition="The identifier that is used to identify this version of the capability statement when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence." ) 6696 protected StringType version; 6697 6698 /** 6699 * A natural language name identifying the capability statement. This name should be usable as an identifier for the module by machine processing applications such as code generation. 6700 */ 6701 @Child(name = "name", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true) 6702 @Description(shortDefinition="Name for this capability statement (computer friendly)", formalDefinition="A natural language name identifying the capability statement. This name should be usable as an identifier for the module by machine processing applications such as code generation." ) 6703 protected StringType name; 6704 6705 /** 6706 * A short, descriptive, user-friendly title for the capability statement. 6707 */ 6708 @Child(name = "title", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=true) 6709 @Description(shortDefinition="Name for this capability statement (human friendly)", formalDefinition="A short, descriptive, user-friendly title for the capability statement." ) 6710 protected StringType title; 6711 6712 /** 6713 * The status of this capability statement. Enables tracking the life-cycle of the content. 6714 */ 6715 @Child(name = "status", type = {CodeType.class}, order=4, min=1, max=1, modifier=true, summary=true) 6716 @Description(shortDefinition="draft | active | retired | unknown", formalDefinition="The status of this capability statement. Enables tracking the life-cycle of the content." ) 6717 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/publication-status") 6718 protected Enumeration<PublicationStatus> status; 6719 6720 /** 6721 * A Boolean value to indicate that this capability statement is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage. 6722 */ 6723 @Child(name = "experimental", type = {BooleanType.class}, order=5, min=0, max=1, modifier=false, summary=true) 6724 @Description(shortDefinition="For testing purposes, not real usage", formalDefinition="A Boolean value to indicate that this capability statement is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage." ) 6725 protected BooleanType experimental; 6726 6727 /** 6728 * The date (and optionally time) when the capability statement was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the capability statement changes. 6729 */ 6730 @Child(name = "date", type = {DateTimeType.class}, order=6, min=1, max=1, modifier=false, summary=true) 6731 @Description(shortDefinition="Date last changed", formalDefinition="The date (and optionally time) when the capability statement was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the capability statement changes." ) 6732 protected DateTimeType date; 6733 6734 /** 6735 * The name of the organization or individual that published the capability statement. 6736 */ 6737 @Child(name = "publisher", type = {StringType.class}, order=7, min=0, max=1, modifier=false, summary=true) 6738 @Description(shortDefinition="Name of the publisher (organization or individual)", formalDefinition="The name of the organization or individual that published the capability statement." ) 6739 protected StringType publisher; 6740 6741 /** 6742 * Contact details to assist a user in finding and communicating with the publisher. 6743 */ 6744 @Child(name = "contact", type = {ContactDetail.class}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6745 @Description(shortDefinition="Contact details for the publisher", formalDefinition="Contact details to assist a user in finding and communicating with the publisher." ) 6746 protected List<ContactDetail> contact; 6747 6748 /** 6749 * A free text natural language description of the capability statement from a consumer's perspective. Typically, this is used when the capability statement describes a desired rather than an actual solution, for example as a formal expression of requirements as part of an RFP. 6750 */ 6751 @Child(name = "description", type = {MarkdownType.class}, order=9, min=0, max=1, modifier=false, summary=false) 6752 @Description(shortDefinition="Natural language description of the capability statement", formalDefinition="A free text natural language description of the capability statement from a consumer's perspective. Typically, this is used when the capability statement describes a desired rather than an actual solution, for example as a formal expression of requirements as part of an RFP." ) 6753 protected MarkdownType description; 6754 6755 /** 6756 * The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate capability statement instances. 6757 */ 6758 @Child(name = "useContext", type = {UsageContext.class}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6759 @Description(shortDefinition="The context that the content is intended to support", formalDefinition="The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate capability statement instances." ) 6760 protected List<UsageContext> useContext; 6761 6762 /** 6763 * A legal or geographic region in which the capability statement is intended to be used. 6764 */ 6765 @Child(name = "jurisdiction", type = {CodeableConcept.class}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6766 @Description(shortDefinition="Intended jurisdiction for capability statement (if applicable)", formalDefinition="A legal or geographic region in which the capability statement is intended to be used." ) 6767 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/jurisdiction") 6768 protected List<CodeableConcept> jurisdiction; 6769 6770 /** 6771 * Explanation of why this capability statement is needed and why it has been designed as it has. 6772 */ 6773 @Child(name = "purpose", type = {MarkdownType.class}, order=12, min=0, max=1, modifier=false, summary=false) 6774 @Description(shortDefinition="Why this capability statement is defined", formalDefinition="Explanation of why this capability statement is needed and why it has been designed as it has." ) 6775 protected MarkdownType purpose; 6776 6777 /** 6778 * A copyright statement relating to the capability statement and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement. 6779 */ 6780 @Child(name = "copyright", type = {MarkdownType.class}, order=13, min=0, max=1, modifier=false, summary=false) 6781 @Description(shortDefinition="Use and/or publishing restrictions", formalDefinition="A copyright statement relating to the capability statement and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement." ) 6782 protected MarkdownType copyright; 6783 6784 /** 6785 * The way that this statement is intended to be used, to describe an actual running instance of software, a particular product (kind, not instance of software) or a class of implementation (e.g. a desired purchase). 6786 */ 6787 @Child(name = "kind", type = {CodeType.class}, order=14, min=1, max=1, modifier=false, summary=true) 6788 @Description(shortDefinition="instance | capability | requirements", formalDefinition="The way that this statement is intended to be used, to describe an actual running instance of software, a particular product (kind, not instance of software) or a class of implementation (e.g. a desired purchase)." ) 6789 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/capability-statement-kind") 6790 protected Enumeration<CapabilityStatementKind> kind; 6791 6792 /** 6793 * Reference to a canonical URL of another CapabilityStatement that this software implements. This capability statement is a published API description that corresponds to a business service. The server may actually implement a subset of the capability statement it claims to implement, so the capability statement must specify the full capability details. 6794 */ 6795 @Child(name = "instantiates", type = {CanonicalType.class}, order=15, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6796 @Description(shortDefinition="Canonical URL of another capability statement this implements", formalDefinition="Reference to a canonical URL of another CapabilityStatement that this software implements. This capability statement is a published API description that corresponds to a business service. The server may actually implement a subset of the capability statement it claims to implement, so the capability statement must specify the full capability details." ) 6797 protected List<CanonicalType> instantiates; 6798 6799 /** 6800 * Reference to a canonical URL of another CapabilityStatement that this software adds to. The capability statement automatically includes everything in the other statement, and it is not duplicated, though the server may repeat the same resources, interactions and operations to add additional details to them. 6801 */ 6802 @Child(name = "imports", type = {CanonicalType.class}, order=16, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6803 @Description(shortDefinition="Canonical URL of another capability statement this adds to", formalDefinition="Reference to a canonical URL of another CapabilityStatement that this software adds to. The capability statement automatically includes everything in the other statement, and it is not duplicated, though the server may repeat the same resources, interactions and operations to add additional details to them." ) 6804 protected List<CanonicalType> imports; 6805 6806 /** 6807 * Software that is covered by this capability statement. It is used when the capability statement describes the capabilities of a particular software version, independent of an installation. 6808 */ 6809 @Child(name = "software", type = {}, order=17, min=0, max=1, modifier=false, summary=true) 6810 @Description(shortDefinition="Software that is covered by this capability statement", formalDefinition="Software that is covered by this capability statement. It is used when the capability statement describes the capabilities of a particular software version, independent of an installation." ) 6811 protected CapabilityStatementSoftwareComponent software; 6812 6813 /** 6814 * Identifies a specific implementation instance that is described by the capability statement - i.e. a particular installation, rather than the capabilities of a software program. 6815 */ 6816 @Child(name = "implementation", type = {}, order=18, min=0, max=1, modifier=false, summary=true) 6817 @Description(shortDefinition="If this describes a specific instance", formalDefinition="Identifies a specific implementation instance that is described by the capability statement - i.e. a particular installation, rather than the capabilities of a software program." ) 6818 protected CapabilityStatementImplementationComponent implementation; 6819 6820 /** 6821 * The version of the FHIR specification that this CapabilityStatement describes (which SHALL be the same as the FHIR version of the CapabilityStatement itself). There is no default value. 6822 */ 6823 @Child(name = "fhirVersion", type = {CodeType.class}, order=19, min=1, max=1, modifier=false, summary=true) 6824 @Description(shortDefinition="FHIR Version the system supports", formalDefinition="The version of the FHIR specification that this CapabilityStatement describes (which SHALL be the same as the FHIR version of the CapabilityStatement itself). There is no default value." ) 6825 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/FHIR-version") 6826 protected Enumeration<FHIRVersion> fhirVersion; 6827 6828 /** 6829 * A list of the formats supported by this implementation using their content types. 6830 */ 6831 @Child(name = "format", type = {CodeType.class}, order=20, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6832 @Description(shortDefinition="formats supported (xml | json | ttl | mime type)", formalDefinition="A list of the formats supported by this implementation using their content types." ) 6833 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/mimetypes") 6834 protected List<CodeType> format; 6835 6836 /** 6837 * A list of the patch formats supported by this implementation using their content types. 6838 */ 6839 @Child(name = "patchFormat", type = {CodeType.class}, order=21, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6840 @Description(shortDefinition="Patch formats supported", formalDefinition="A list of the patch formats supported by this implementation using their content types." ) 6841 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/mimetypes") 6842 protected List<CodeType> patchFormat; 6843 6844 /** 6845 * A list of implementation guides that the server does (or should) support in their entirety. 6846 */ 6847 @Child(name = "implementationGuide", type = {CanonicalType.class}, order=22, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6848 @Description(shortDefinition="Implementation guides supported", formalDefinition="A list of implementation guides that the server does (or should) support in their entirety." ) 6849 protected List<CanonicalType> implementationGuide; 6850 6851 /** 6852 * A definition of the restful capabilities of the solution, if any. 6853 */ 6854 @Child(name = "rest", type = {}, order=23, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6855 @Description(shortDefinition="If the endpoint is a RESTful one", formalDefinition="A definition of the restful capabilities of the solution, if any." ) 6856 protected List<CapabilityStatementRestComponent> rest; 6857 6858 /** 6859 * A description of the messaging capabilities of the solution. 6860 */ 6861 @Child(name = "messaging", type = {}, order=24, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6862 @Description(shortDefinition="If messaging is supported", formalDefinition="A description of the messaging capabilities of the solution." ) 6863 protected List<CapabilityStatementMessagingComponent> messaging; 6864 6865 /** 6866 * A document definition. 6867 */ 6868 @Child(name = "document", type = {}, order=25, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6869 @Description(shortDefinition="Document definition", formalDefinition="A document definition." ) 6870 protected List<CapabilityStatementDocumentComponent> document; 6871 6872 private static final long serialVersionUID = 1554492069L; 6873 6874 /** 6875 * Constructor 6876 */ 6877 public CapabilityStatement() { 6878 super(); 6879 } 6880 6881 /** 6882 * Constructor 6883 */ 6884 public CapabilityStatement(PublicationStatus status, Date date, CapabilityStatementKind kind, FHIRVersion fhirVersion, String format) { 6885 super(); 6886 this.setStatus(status); 6887 this.setDate(date); 6888 this.setKind(kind); 6889 this.setFhirVersion(fhirVersion); 6890 this.addFormat(format); 6891 } 6892 6893 /** 6894 * @return {@link #url} (An absolute URI that is used to identify this capability statement when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this capability statement is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement is stored on different servers.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value 6895 */ 6896 public UriType getUrlElement() { 6897 if (this.url == null) 6898 if (Configuration.errorOnAutoCreate()) 6899 throw new Error("Attempt to auto-create CapabilityStatement.url"); 6900 else if (Configuration.doAutoCreate()) 6901 this.url = new UriType(); // bb 6902 return this.url; 6903 } 6904 6905 public boolean hasUrlElement() { 6906 return this.url != null && !this.url.isEmpty(); 6907 } 6908 6909 public boolean hasUrl() { 6910 return this.url != null && !this.url.isEmpty(); 6911 } 6912 6913 /** 6914 * @param value {@link #url} (An absolute URI that is used to identify this capability statement when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this capability statement is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement is stored on different servers.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value 6915 */ 6916 public CapabilityStatement setUrlElement(UriType value) { 6917 this.url = value; 6918 return this; 6919 } 6920 6921 /** 6922 * @return An absolute URI that is used to identify this capability statement when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this capability statement is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement is stored on different servers. 6923 */ 6924 public String getUrl() { 6925 return this.url == null ? null : this.url.getValue(); 6926 } 6927 6928 /** 6929 * @param value An absolute URI that is used to identify this capability statement when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this capability statement is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement is stored on different servers. 6930 */ 6931 public CapabilityStatement setUrl(String value) { 6932 if (Utilities.noString(value)) 6933 this.url = null; 6934 else { 6935 if (this.url == null) 6936 this.url = new UriType(); 6937 this.url.setValue(value); 6938 } 6939 return this; 6940 } 6941 6942 /** 6943 * @return {@link #version} (The identifier that is used to identify this version of the capability statement when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value 6944 */ 6945 public StringType getVersionElement() { 6946 if (this.version == null) 6947 if (Configuration.errorOnAutoCreate()) 6948 throw new Error("Attempt to auto-create CapabilityStatement.version"); 6949 else if (Configuration.doAutoCreate()) 6950 this.version = new StringType(); // bb 6951 return this.version; 6952 } 6953 6954 public boolean hasVersionElement() { 6955 return this.version != null && !this.version.isEmpty(); 6956 } 6957 6958 public boolean hasVersion() { 6959 return this.version != null && !this.version.isEmpty(); 6960 } 6961 6962 /** 6963 * @param value {@link #version} (The identifier that is used to identify this version of the capability statement when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value 6964 */ 6965 public CapabilityStatement setVersionElement(StringType value) { 6966 this.version = value; 6967 return this; 6968 } 6969 6970 /** 6971 * @return The identifier that is used to identify this version of the capability statement when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. 6972 */ 6973 public String getVersion() { 6974 return this.version == null ? null : this.version.getValue(); 6975 } 6976 6977 /** 6978 * @param value The identifier that is used to identify this version of the capability statement when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence. 6979 */ 6980 public CapabilityStatement setVersion(String value) { 6981 if (Utilities.noString(value)) 6982 this.version = null; 6983 else { 6984 if (this.version == null) 6985 this.version = new StringType(); 6986 this.version.setValue(value); 6987 } 6988 return this; 6989 } 6990 6991 /** 6992 * @return {@link #name} (A natural language name identifying the capability statement. This name should be usable as an identifier for the module by machine processing applications such as code generation.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value 6993 */ 6994 public StringType getNameElement() { 6995 if (this.name == null) 6996 if (Configuration.errorOnAutoCreate()) 6997 throw new Error("Attempt to auto-create CapabilityStatement.name"); 6998 else if (Configuration.doAutoCreate()) 6999 this.name = new StringType(); // bb 7000 return this.name; 7001 } 7002 7003 public boolean hasNameElement() { 7004 return this.name != null && !this.name.isEmpty(); 7005 } 7006 7007 public boolean hasName() { 7008 return this.name != null && !this.name.isEmpty(); 7009 } 7010 7011 /** 7012 * @param value {@link #name} (A natural language name identifying the capability statement. This name should be usable as an identifier for the module by machine processing applications such as code generation.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value 7013 */ 7014 public CapabilityStatement setNameElement(StringType value) { 7015 this.name = value; 7016 return this; 7017 } 7018 7019 /** 7020 * @return A natural language name identifying the capability statement. This name should be usable as an identifier for the module by machine processing applications such as code generation. 7021 */ 7022 public String getName() { 7023 return this.name == null ? null : this.name.getValue(); 7024 } 7025 7026 /** 7027 * @param value A natural language name identifying the capability statement. This name should be usable as an identifier for the module by machine processing applications such as code generation. 7028 */ 7029 public CapabilityStatement setName(String value) { 7030 if (Utilities.noString(value)) 7031 this.name = null; 7032 else { 7033 if (this.name == null) 7034 this.name = new StringType(); 7035 this.name.setValue(value); 7036 } 7037 return this; 7038 } 7039 7040 /** 7041 * @return {@link #title} (A short, descriptive, user-friendly title for the capability statement.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value 7042 */ 7043 public StringType getTitleElement() { 7044 if (this.title == null) 7045 if (Configuration.errorOnAutoCreate()) 7046 throw new Error("Attempt to auto-create CapabilityStatement.title"); 7047 else if (Configuration.doAutoCreate()) 7048 this.title = new StringType(); // bb 7049 return this.title; 7050 } 7051 7052 public boolean hasTitleElement() { 7053 return this.title != null && !this.title.isEmpty(); 7054 } 7055 7056 public boolean hasTitle() { 7057 return this.title != null && !this.title.isEmpty(); 7058 } 7059 7060 /** 7061 * @param value {@link #title} (A short, descriptive, user-friendly title for the capability statement.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value 7062 */ 7063 public CapabilityStatement setTitleElement(StringType value) { 7064 this.title = value; 7065 return this; 7066 } 7067 7068 /** 7069 * @return A short, descriptive, user-friendly title for the capability statement. 7070 */ 7071 public String getTitle() { 7072 return this.title == null ? null : this.title.getValue(); 7073 } 7074 7075 /** 7076 * @param value A short, descriptive, user-friendly title for the capability statement. 7077 */ 7078 public CapabilityStatement setTitle(String value) { 7079 if (Utilities.noString(value)) 7080 this.title = null; 7081 else { 7082 if (this.title == null) 7083 this.title = new StringType(); 7084 this.title.setValue(value); 7085 } 7086 return this; 7087 } 7088 7089 /** 7090 * @return {@link #status} (The status of this capability statement. Enables tracking the life-cycle of the content.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value 7091 */ 7092 public Enumeration<PublicationStatus> getStatusElement() { 7093 if (this.status == null) 7094 if (Configuration.errorOnAutoCreate()) 7095 throw new Error("Attempt to auto-create CapabilityStatement.status"); 7096 else if (Configuration.doAutoCreate()) 7097 this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb 7098 return this.status; 7099 } 7100 7101 public boolean hasStatusElement() { 7102 return this.status != null && !this.status.isEmpty(); 7103 } 7104 7105 public boolean hasStatus() { 7106 return this.status != null && !this.status.isEmpty(); 7107 } 7108 7109 /** 7110 * @param value {@link #status} (The status of this capability statement. Enables tracking the life-cycle of the content.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value 7111 */ 7112 public CapabilityStatement setStatusElement(Enumeration<PublicationStatus> value) { 7113 this.status = value; 7114 return this; 7115 } 7116 7117 /** 7118 * @return The status of this capability statement. Enables tracking the life-cycle of the content. 7119 */ 7120 public PublicationStatus getStatus() { 7121 return this.status == null ? null : this.status.getValue(); 7122 } 7123 7124 /** 7125 * @param value The status of this capability statement. Enables tracking the life-cycle of the content. 7126 */ 7127 public CapabilityStatement setStatus(PublicationStatus value) { 7128 if (this.status == null) 7129 this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); 7130 this.status.setValue(value); 7131 return this; 7132 } 7133 7134 /** 7135 * @return {@link #experimental} (A Boolean value to indicate that this capability statement is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.). This is the underlying object with id, value and extensions. The accessor "getExperimental" gives direct access to the value 7136 */ 7137 public BooleanType getExperimentalElement() { 7138 if (this.experimental == null) 7139 if (Configuration.errorOnAutoCreate()) 7140 throw new Error("Attempt to auto-create CapabilityStatement.experimental"); 7141 else if (Configuration.doAutoCreate()) 7142 this.experimental = new BooleanType(); // bb 7143 return this.experimental; 7144 } 7145 7146 public boolean hasExperimentalElement() { 7147 return this.experimental != null && !this.experimental.isEmpty(); 7148 } 7149 7150 public boolean hasExperimental() { 7151 return this.experimental != null && !this.experimental.isEmpty(); 7152 } 7153 7154 /** 7155 * @param value {@link #experimental} (A Boolean value to indicate that this capability statement is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.). This is the underlying object with id, value and extensions. The accessor "getExperimental" gives direct access to the value 7156 */ 7157 public CapabilityStatement setExperimentalElement(BooleanType value) { 7158 this.experimental = value; 7159 return this; 7160 } 7161 7162 /** 7163 * @return A Boolean value to indicate that this capability statement is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage. 7164 */ 7165 public boolean getExperimental() { 7166 return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue(); 7167 } 7168 7169 /** 7170 * @param value A Boolean value to indicate that this capability statement is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage. 7171 */ 7172 public CapabilityStatement setExperimental(boolean value) { 7173 if (this.experimental == null) 7174 this.experimental = new BooleanType(); 7175 this.experimental.setValue(value); 7176 return this; 7177 } 7178 7179 /** 7180 * @return {@link #date} (The date (and optionally time) when the capability statement was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the capability statement changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value 7181 */ 7182 public DateTimeType getDateElement() { 7183 if (this.date == null) 7184 if (Configuration.errorOnAutoCreate()) 7185 throw new Error("Attempt to auto-create CapabilityStatement.date"); 7186 else if (Configuration.doAutoCreate()) 7187 this.date = new DateTimeType(); // bb 7188 return this.date; 7189 } 7190 7191 public boolean hasDateElement() { 7192 return this.date != null && !this.date.isEmpty(); 7193 } 7194 7195 public boolean hasDate() { 7196 return this.date != null && !this.date.isEmpty(); 7197 } 7198 7199 /** 7200 * @param value {@link #date} (The date (and optionally time) when the capability statement was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the capability statement changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value 7201 */ 7202 public CapabilityStatement setDateElement(DateTimeType value) { 7203 this.date = value; 7204 return this; 7205 } 7206 7207 /** 7208 * @return The date (and optionally time) when the capability statement was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the capability statement changes. 7209 */ 7210 public Date getDate() { 7211 return this.date == null ? null : this.date.getValue(); 7212 } 7213 7214 /** 7215 * @param value The date (and optionally time) when the capability statement was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the capability statement changes. 7216 */ 7217 public CapabilityStatement setDate(Date value) { 7218 if (this.date == null) 7219 this.date = new DateTimeType(); 7220 this.date.setValue(value); 7221 return this; 7222 } 7223 7224 /** 7225 * @return {@link #publisher} (The name of the organization or individual that published the capability statement.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value 7226 */ 7227 public StringType getPublisherElement() { 7228 if (this.publisher == null) 7229 if (Configuration.errorOnAutoCreate()) 7230 throw new Error("Attempt to auto-create CapabilityStatement.publisher"); 7231 else if (Configuration.doAutoCreate()) 7232 this.publisher = new StringType(); // bb 7233 return this.publisher; 7234 } 7235 7236 public boolean hasPublisherElement() { 7237 return this.publisher != null && !this.publisher.isEmpty(); 7238 } 7239 7240 public boolean hasPublisher() { 7241 return this.publisher != null && !this.publisher.isEmpty(); 7242 } 7243 7244 /** 7245 * @param value {@link #publisher} (The name of the organization or individual that published the capability statement.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value 7246 */ 7247 public CapabilityStatement setPublisherElement(StringType value) { 7248 this.publisher = value; 7249 return this; 7250 } 7251 7252 /** 7253 * @return The name of the organization or individual that published the capability statement. 7254 */ 7255 public String getPublisher() { 7256 return this.publisher == null ? null : this.publisher.getValue(); 7257 } 7258 7259 /** 7260 * @param value The name of the organization or individual that published the capability statement. 7261 */ 7262 public CapabilityStatement setPublisher(String value) { 7263 if (Utilities.noString(value)) 7264 this.publisher = null; 7265 else { 7266 if (this.publisher == null) 7267 this.publisher = new StringType(); 7268 this.publisher.setValue(value); 7269 } 7270 return this; 7271 } 7272 7273 /** 7274 * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.) 7275 */ 7276 public List<ContactDetail> getContact() { 7277 if (this.contact == null) 7278 this.contact = new ArrayList<ContactDetail>(); 7279 return this.contact; 7280 } 7281 7282 /** 7283 * @return Returns a reference to <code>this</code> for easy method chaining 7284 */ 7285 public CapabilityStatement setContact(List<ContactDetail> theContact) { 7286 this.contact = theContact; 7287 return this; 7288 } 7289 7290 public boolean hasContact() { 7291 if (this.contact == null) 7292 return false; 7293 for (ContactDetail item : this.contact) 7294 if (!item.isEmpty()) 7295 return true; 7296 return false; 7297 } 7298 7299 public ContactDetail addContact() { //3 7300 ContactDetail t = new ContactDetail(); 7301 if (this.contact == null) 7302 this.contact = new ArrayList<ContactDetail>(); 7303 this.contact.add(t); 7304 return t; 7305 } 7306 7307 public CapabilityStatement addContact(ContactDetail t) { //3 7308 if (t == null) 7309 return this; 7310 if (this.contact == null) 7311 this.contact = new ArrayList<ContactDetail>(); 7312 this.contact.add(t); 7313 return this; 7314 } 7315 7316 /** 7317 * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist {3} 7318 */ 7319 public ContactDetail getContactFirstRep() { 7320 if (getContact().isEmpty()) { 7321 addContact(); 7322 } 7323 return getContact().get(0); 7324 } 7325 7326 /** 7327 * @return {@link #description} (A free text natural language description of the capability statement from a consumer's perspective. Typically, this is used when the capability statement describes a desired rather than an actual solution, for example as a formal expression of requirements as part of an RFP.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 7328 */ 7329 public MarkdownType getDescriptionElement() { 7330 if (this.description == null) 7331 if (Configuration.errorOnAutoCreate()) 7332 throw new Error("Attempt to auto-create CapabilityStatement.description"); 7333 else if (Configuration.doAutoCreate()) 7334 this.description = new MarkdownType(); // bb 7335 return this.description; 7336 } 7337 7338 public boolean hasDescriptionElement() { 7339 return this.description != null && !this.description.isEmpty(); 7340 } 7341 7342 public boolean hasDescription() { 7343 return this.description != null && !this.description.isEmpty(); 7344 } 7345 7346 /** 7347 * @param value {@link #description} (A free text natural language description of the capability statement from a consumer's perspective. Typically, this is used when the capability statement describes a desired rather than an actual solution, for example as a formal expression of requirements as part of an RFP.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value 7348 */ 7349 public CapabilityStatement setDescriptionElement(MarkdownType value) { 7350 this.description = value; 7351 return this; 7352 } 7353 7354 /** 7355 * @return A free text natural language description of the capability statement from a consumer's perspective. Typically, this is used when the capability statement describes a desired rather than an actual solution, for example as a formal expression of requirements as part of an RFP. 7356 */ 7357 public String getDescription() { 7358 return this.description == null ? null : this.description.getValue(); 7359 } 7360 7361 /** 7362 * @param value A free text natural language description of the capability statement from a consumer's perspective. Typically, this is used when the capability statement describes a desired rather than an actual solution, for example as a formal expression of requirements as part of an RFP. 7363 */ 7364 public CapabilityStatement setDescription(String value) { 7365 if (value == null) 7366 this.description = null; 7367 else { 7368 if (this.description == null) 7369 this.description = new MarkdownType(); 7370 this.description.setValue(value); 7371 } 7372 return this; 7373 } 7374 7375 /** 7376 * @return {@link #useContext} (The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate capability statement instances.) 7377 */ 7378 public List<UsageContext> getUseContext() { 7379 if (this.useContext == null) 7380 this.useContext = new ArrayList<UsageContext>(); 7381 return this.useContext; 7382 } 7383 7384 /** 7385 * @return Returns a reference to <code>this</code> for easy method chaining 7386 */ 7387 public CapabilityStatement setUseContext(List<UsageContext> theUseContext) { 7388 this.useContext = theUseContext; 7389 return this; 7390 } 7391 7392 public boolean hasUseContext() { 7393 if (this.useContext == null) 7394 return false; 7395 for (UsageContext item : this.useContext) 7396 if (!item.isEmpty()) 7397 return true; 7398 return false; 7399 } 7400 7401 public UsageContext addUseContext() { //3 7402 UsageContext t = new UsageContext(); 7403 if (this.useContext == null) 7404 this.useContext = new ArrayList<UsageContext>(); 7405 this.useContext.add(t); 7406 return t; 7407 } 7408 7409 public CapabilityStatement addUseContext(UsageContext t) { //3 7410 if (t == null) 7411 return this; 7412 if (this.useContext == null) 7413 this.useContext = new ArrayList<UsageContext>(); 7414 this.useContext.add(t); 7415 return this; 7416 } 7417 7418 /** 7419 * @return The first repetition of repeating field {@link #useContext}, creating it if it does not already exist {3} 7420 */ 7421 public UsageContext getUseContextFirstRep() { 7422 if (getUseContext().isEmpty()) { 7423 addUseContext(); 7424 } 7425 return getUseContext().get(0); 7426 } 7427 7428 /** 7429 * @return {@link #jurisdiction} (A legal or geographic region in which the capability statement is intended to be used.) 7430 */ 7431 public List<CodeableConcept> getJurisdiction() { 7432 if (this.jurisdiction == null) 7433 this.jurisdiction = new ArrayList<CodeableConcept>(); 7434 return this.jurisdiction; 7435 } 7436 7437 /** 7438 * @return Returns a reference to <code>this</code> for easy method chaining 7439 */ 7440 public CapabilityStatement setJurisdiction(List<CodeableConcept> theJurisdiction) { 7441 this.jurisdiction = theJurisdiction; 7442 return this; 7443 } 7444 7445 public boolean hasJurisdiction() { 7446 if (this.jurisdiction == null) 7447 return false; 7448 for (CodeableConcept item : this.jurisdiction) 7449 if (!item.isEmpty()) 7450 return true; 7451 return false; 7452 } 7453 7454 public CodeableConcept addJurisdiction() { //3 7455 CodeableConcept t = new CodeableConcept(); 7456 if (this.jurisdiction == null) 7457 this.jurisdiction = new ArrayList<CodeableConcept>(); 7458 this.jurisdiction.add(t); 7459 return t; 7460 } 7461 7462 public CapabilityStatement addJurisdiction(CodeableConcept t) { //3 7463 if (t == null) 7464 return this; 7465 if (this.jurisdiction == null) 7466 this.jurisdiction = new ArrayList<CodeableConcept>(); 7467 this.jurisdiction.add(t); 7468 return this; 7469 } 7470 7471 /** 7472 * @return The first repetition of repeating field {@link #jurisdiction}, creating it if it does not already exist {3} 7473 */ 7474 public CodeableConcept getJurisdictionFirstRep() { 7475 if (getJurisdiction().isEmpty()) { 7476 addJurisdiction(); 7477 } 7478 return getJurisdiction().get(0); 7479 } 7480 7481 /** 7482 * @return {@link #purpose} (Explanation of why this capability statement is needed and why it has been designed as it has.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value 7483 */ 7484 public MarkdownType getPurposeElement() { 7485 if (this.purpose == null) 7486 if (Configuration.errorOnAutoCreate()) 7487 throw new Error("Attempt to auto-create CapabilityStatement.purpose"); 7488 else if (Configuration.doAutoCreate()) 7489 this.purpose = new MarkdownType(); // bb 7490 return this.purpose; 7491 } 7492 7493 public boolean hasPurposeElement() { 7494 return this.purpose != null && !this.purpose.isEmpty(); 7495 } 7496 7497 public boolean hasPurpose() { 7498 return this.purpose != null && !this.purpose.isEmpty(); 7499 } 7500 7501 /** 7502 * @param value {@link #purpose} (Explanation of why this capability statement is needed and why it has been designed as it has.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value 7503 */ 7504 public CapabilityStatement setPurposeElement(MarkdownType value) { 7505 this.purpose = value; 7506 return this; 7507 } 7508 7509 /** 7510 * @return Explanation of why this capability statement is needed and why it has been designed as it has. 7511 */ 7512 public String getPurpose() { 7513 return this.purpose == null ? null : this.purpose.getValue(); 7514 } 7515 7516 /** 7517 * @param value Explanation of why this capability statement is needed and why it has been designed as it has. 7518 */ 7519 public CapabilityStatement setPurpose(String value) { 7520 if (value == null) 7521 this.purpose = null; 7522 else { 7523 if (this.purpose == null) 7524 this.purpose = new MarkdownType(); 7525 this.purpose.setValue(value); 7526 } 7527 return this; 7528 } 7529 7530 /** 7531 * @return {@link #copyright} (A copyright statement relating to the capability statement and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value 7532 */ 7533 public MarkdownType getCopyrightElement() { 7534 if (this.copyright == null) 7535 if (Configuration.errorOnAutoCreate()) 7536 throw new Error("Attempt to auto-create CapabilityStatement.copyright"); 7537 else if (Configuration.doAutoCreate()) 7538 this.copyright = new MarkdownType(); // bb 7539 return this.copyright; 7540 } 7541 7542 public boolean hasCopyrightElement() { 7543 return this.copyright != null && !this.copyright.isEmpty(); 7544 } 7545 7546 public boolean hasCopyright() { 7547 return this.copyright != null && !this.copyright.isEmpty(); 7548 } 7549 7550 /** 7551 * @param value {@link #copyright} (A copyright statement relating to the capability statement and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value 7552 */ 7553 public CapabilityStatement setCopyrightElement(MarkdownType value) { 7554 this.copyright = value; 7555 return this; 7556 } 7557 7558 /** 7559 * @return A copyright statement relating to the capability statement and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement. 7560 */ 7561 public String getCopyright() { 7562 return this.copyright == null ? null : this.copyright.getValue(); 7563 } 7564 7565 /** 7566 * @param value A copyright statement relating to the capability statement and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement. 7567 */ 7568 public CapabilityStatement setCopyright(String value) { 7569 if (value == null) 7570 this.copyright = null; 7571 else { 7572 if (this.copyright == null) 7573 this.copyright = new MarkdownType(); 7574 this.copyright.setValue(value); 7575 } 7576 return this; 7577 } 7578 7579 /** 7580 * @return {@link #kind} (The way that this statement is intended to be used, to describe an actual running instance of software, a particular product (kind, not instance of software) or a class of implementation (e.g. a desired purchase).). This is the underlying object with id, value and extensions. The accessor "getKind" gives direct access to the value 7581 */ 7582 public Enumeration<CapabilityStatementKind> getKindElement() { 7583 if (this.kind == null) 7584 if (Configuration.errorOnAutoCreate()) 7585 throw new Error("Attempt to auto-create CapabilityStatement.kind"); 7586 else if (Configuration.doAutoCreate()) 7587 this.kind = new Enumeration<CapabilityStatementKind>(new CapabilityStatementKindEnumFactory()); // bb 7588 return this.kind; 7589 } 7590 7591 public boolean hasKindElement() { 7592 return this.kind != null && !this.kind.isEmpty(); 7593 } 7594 7595 public boolean hasKind() { 7596 return this.kind != null && !this.kind.isEmpty(); 7597 } 7598 7599 /** 7600 * @param value {@link #kind} (The way that this statement is intended to be used, to describe an actual running instance of software, a particular product (kind, not instance of software) or a class of implementation (e.g. a desired purchase).). This is the underlying object with id, value and extensions. The accessor "getKind" gives direct access to the value 7601 */ 7602 public CapabilityStatement setKindElement(Enumeration<CapabilityStatementKind> value) { 7603 this.kind = value; 7604 return this; 7605 } 7606 7607 /** 7608 * @return The way that this statement is intended to be used, to describe an actual running instance of software, a particular product (kind, not instance of software) or a class of implementation (e.g. a desired purchase). 7609 */ 7610 public CapabilityStatementKind getKind() { 7611 return this.kind == null ? null : this.kind.getValue(); 7612 } 7613 7614 /** 7615 * @param value The way that this statement is intended to be used, to describe an actual running instance of software, a particular product (kind, not instance of software) or a class of implementation (e.g. a desired purchase). 7616 */ 7617 public CapabilityStatement setKind(CapabilityStatementKind value) { 7618 if (this.kind == null) 7619 this.kind = new Enumeration<CapabilityStatementKind>(new CapabilityStatementKindEnumFactory()); 7620 this.kind.setValue(value); 7621 return this; 7622 } 7623 7624 /** 7625 * @return {@link #instantiates} (Reference to a canonical URL of another CapabilityStatement that this software implements. This capability statement is a published API description that corresponds to a business service. The server may actually implement a subset of the capability statement it claims to implement, so the capability statement must specify the full capability details.) 7626 */ 7627 public List<CanonicalType> getInstantiates() { 7628 if (this.instantiates == null) 7629 this.instantiates = new ArrayList<CanonicalType>(); 7630 return this.instantiates; 7631 } 7632 7633 /** 7634 * @return Returns a reference to <code>this</code> for easy method chaining 7635 */ 7636 public CapabilityStatement setInstantiates(List<CanonicalType> theInstantiates) { 7637 this.instantiates = theInstantiates; 7638 return this; 7639 } 7640 7641 public boolean hasInstantiates() { 7642 if (this.instantiates == null) 7643 return false; 7644 for (CanonicalType item : this.instantiates) 7645 if (!item.isEmpty()) 7646 return true; 7647 return false; 7648 } 7649 7650 /** 7651 * @return {@link #instantiates} (Reference to a canonical URL of another CapabilityStatement that this software implements. This capability statement is a published API description that corresponds to a business service. The server may actually implement a subset of the capability statement it claims to implement, so the capability statement must specify the full capability details.) 7652 */ 7653 public CanonicalType addInstantiatesElement() {//2 7654 CanonicalType t = new CanonicalType(); 7655 if (this.instantiates == null) 7656 this.instantiates = new ArrayList<CanonicalType>(); 7657 this.instantiates.add(t); 7658 return t; 7659 } 7660 7661 /** 7662 * @param value {@link #instantiates} (Reference to a canonical URL of another CapabilityStatement that this software implements. This capability statement is a published API description that corresponds to a business service. The server may actually implement a subset of the capability statement it claims to implement, so the capability statement must specify the full capability details.) 7663 */ 7664 public CapabilityStatement addInstantiates(String value) { //1 7665 CanonicalType t = new CanonicalType(); 7666 t.setValue(value); 7667 if (this.instantiates == null) 7668 this.instantiates = new ArrayList<CanonicalType>(); 7669 this.instantiates.add(t); 7670 return this; 7671 } 7672 7673 /** 7674 * @param value {@link #instantiates} (Reference to a canonical URL of another CapabilityStatement that this software implements. This capability statement is a published API description that corresponds to a business service. The server may actually implement a subset of the capability statement it claims to implement, so the capability statement must specify the full capability details.) 7675 */ 7676 public boolean hasInstantiates(String value) { 7677 if (this.instantiates == null) 7678 return false; 7679 for (CanonicalType v : this.instantiates) 7680 if (v.getValue().equals(value)) // canonical 7681 return true; 7682 return false; 7683 } 7684 7685 /** 7686 * @return {@link #imports} (Reference to a canonical URL of another CapabilityStatement that this software adds to. The capability statement automatically includes everything in the other statement, and it is not duplicated, though the server may repeat the same resources, interactions and operations to add additional details to them.) 7687 */ 7688 public List<CanonicalType> getImports() { 7689 if (this.imports == null) 7690 this.imports = new ArrayList<CanonicalType>(); 7691 return this.imports; 7692 } 7693 7694 /** 7695 * @return Returns a reference to <code>this</code> for easy method chaining 7696 */ 7697 public CapabilityStatement setImports(List<CanonicalType> theImports) { 7698 this.imports = theImports; 7699 return this; 7700 } 7701 7702 public boolean hasImports() { 7703 if (this.imports == null) 7704 return false; 7705 for (CanonicalType item : this.imports) 7706 if (!item.isEmpty()) 7707 return true; 7708 return false; 7709 } 7710 7711 /** 7712 * @return {@link #imports} (Reference to a canonical URL of another CapabilityStatement that this software adds to. The capability statement automatically includes everything in the other statement, and it is not duplicated, though the server may repeat the same resources, interactions and operations to add additional details to them.) 7713 */ 7714 public CanonicalType addImportsElement() {//2 7715 CanonicalType t = new CanonicalType(); 7716 if (this.imports == null) 7717 this.imports = new ArrayList<CanonicalType>(); 7718 this.imports.add(t); 7719 return t; 7720 } 7721 7722 /** 7723 * @param value {@link #imports} (Reference to a canonical URL of another CapabilityStatement that this software adds to. The capability statement automatically includes everything in the other statement, and it is not duplicated, though the server may repeat the same resources, interactions and operations to add additional details to them.) 7724 */ 7725 public CapabilityStatement addImports(String value) { //1 7726 CanonicalType t = new CanonicalType(); 7727 t.setValue(value); 7728 if (this.imports == null) 7729 this.imports = new ArrayList<CanonicalType>(); 7730 this.imports.add(t); 7731 return this; 7732 } 7733 7734 /** 7735 * @param value {@link #imports} (Reference to a canonical URL of another CapabilityStatement that this software adds to. The capability statement automatically includes everything in the other statement, and it is not duplicated, though the server may repeat the same resources, interactions and operations to add additional details to them.) 7736 */ 7737 public boolean hasImports(String value) { 7738 if (this.imports == null) 7739 return false; 7740 for (CanonicalType v : this.imports) 7741 if (v.getValue().equals(value)) // canonical 7742 return true; 7743 return false; 7744 } 7745 7746 /** 7747 * @return {@link #software} (Software that is covered by this capability statement. It is used when the capability statement describes the capabilities of a particular software version, independent of an installation.) 7748 */ 7749 public CapabilityStatementSoftwareComponent getSoftware() { 7750 if (this.software == null) 7751 if (Configuration.errorOnAutoCreate()) 7752 throw new Error("Attempt to auto-create CapabilityStatement.software"); 7753 else if (Configuration.doAutoCreate()) 7754 this.software = new CapabilityStatementSoftwareComponent(); // cc 7755 return this.software; 7756 } 7757 7758 public boolean hasSoftware() { 7759 return this.software != null && !this.software.isEmpty(); 7760 } 7761 7762 /** 7763 * @param value {@link #software} (Software that is covered by this capability statement. It is used when the capability statement describes the capabilities of a particular software version, independent of an installation.) 7764 */ 7765 public CapabilityStatement setSoftware(CapabilityStatementSoftwareComponent value) { 7766 this.software = value; 7767 return this; 7768 } 7769 7770 /** 7771 * @return {@link #implementation} (Identifies a specific implementation instance that is described by the capability statement - i.e. a particular installation, rather than the capabilities of a software program.) 7772 */ 7773 public CapabilityStatementImplementationComponent getImplementation() { 7774 if (this.implementation == null) 7775 if (Configuration.errorOnAutoCreate()) 7776 throw new Error("Attempt to auto-create CapabilityStatement.implementation"); 7777 else if (Configuration.doAutoCreate()) 7778 this.implementation = new CapabilityStatementImplementationComponent(); // cc 7779 return this.implementation; 7780 } 7781 7782 public boolean hasImplementation() { 7783 return this.implementation != null && !this.implementation.isEmpty(); 7784 } 7785 7786 /** 7787 * @param value {@link #implementation} (Identifies a specific implementation instance that is described by the capability statement - i.e. a particular installation, rather than the capabilities of a software program.) 7788 */ 7789 public CapabilityStatement setImplementation(CapabilityStatementImplementationComponent value) { 7790 this.implementation = value; 7791 return this; 7792 } 7793 7794 /** 7795 * @return {@link #fhirVersion} (The version of the FHIR specification that this CapabilityStatement describes (which SHALL be the same as the FHIR version of the CapabilityStatement itself). There is no default value.). This is the underlying object with id, value and extensions. The accessor "getFhirVersion" gives direct access to the value 7796 */ 7797 public Enumeration<FHIRVersion> getFhirVersionElement() { 7798 if (this.fhirVersion == null) 7799 if (Configuration.errorOnAutoCreate()) 7800 throw new Error("Attempt to auto-create CapabilityStatement.fhirVersion"); 7801 else if (Configuration.doAutoCreate()) 7802 this.fhirVersion = new Enumeration<FHIRVersion>(new FHIRVersionEnumFactory()); // bb 7803 return this.fhirVersion; 7804 } 7805 7806 public boolean hasFhirVersionElement() { 7807 return this.fhirVersion != null && !this.fhirVersion.isEmpty(); 7808 } 7809 7810 public boolean hasFhirVersion() { 7811 return this.fhirVersion != null && !this.fhirVersion.isEmpty(); 7812 } 7813 7814 /** 7815 * @param value {@link #fhirVersion} (The version of the FHIR specification that this CapabilityStatement describes (which SHALL be the same as the FHIR version of the CapabilityStatement itself). There is no default value.). This is the underlying object with id, value and extensions. The accessor "getFhirVersion" gives direct access to the value 7816 */ 7817 public CapabilityStatement setFhirVersionElement(Enumeration<FHIRVersion> value) { 7818 this.fhirVersion = value; 7819 return this; 7820 } 7821 7822 /** 7823 * @return The version of the FHIR specification that this CapabilityStatement describes (which SHALL be the same as the FHIR version of the CapabilityStatement itself). There is no default value. 7824 */ 7825 public FHIRVersion getFhirVersion() { 7826 return this.fhirVersion == null ? null : this.fhirVersion.getValue(); 7827 } 7828 7829 /** 7830 * @param value The version of the FHIR specification that this CapabilityStatement describes (which SHALL be the same as the FHIR version of the CapabilityStatement itself). There is no default value. 7831 */ 7832 public CapabilityStatement setFhirVersion(FHIRVersion value) { 7833 if (this.fhirVersion == null) 7834 this.fhirVersion = new Enumeration<FHIRVersion>(new FHIRVersionEnumFactory()); 7835 this.fhirVersion.setValue(value); 7836 return this; 7837 } 7838 7839 /** 7840 * @return {@link #format} (A list of the formats supported by this implementation using their content types.) 7841 */ 7842 public List<CodeType> getFormat() { 7843 if (this.format == null) 7844 this.format = new ArrayList<CodeType>(); 7845 return this.format; 7846 } 7847 7848 /** 7849 * @return Returns a reference to <code>this</code> for easy method chaining 7850 */ 7851 public CapabilityStatement setFormat(List<CodeType> theFormat) { 7852 this.format = theFormat; 7853 return this; 7854 } 7855 7856 public boolean hasFormat() { 7857 if (this.format == null) 7858 return false; 7859 for (CodeType item : this.format) 7860 if (!item.isEmpty()) 7861 return true; 7862 return false; 7863 } 7864 7865 /** 7866 * @return {@link #format} (A list of the formats supported by this implementation using their content types.) 7867 */ 7868 public CodeType addFormatElement() {//2 7869 CodeType t = new CodeType(); 7870 if (this.format == null) 7871 this.format = new ArrayList<CodeType>(); 7872 this.format.add(t); 7873 return t; 7874 } 7875 7876 /** 7877 * @param value {@link #format} (A list of the formats supported by this implementation using their content types.) 7878 */ 7879 public CapabilityStatement addFormat(String value) { //1 7880 CodeType t = new CodeType(); 7881 t.setValue(value); 7882 if (this.format == null) 7883 this.format = new ArrayList<CodeType>(); 7884 this.format.add(t); 7885 return this; 7886 } 7887 7888 /** 7889 * @param value {@link #format} (A list of the formats supported by this implementation using their content types.) 7890 */ 7891 public boolean hasFormat(String value) { 7892 if (this.format == null) 7893 return false; 7894 for (CodeType v : this.format) 7895 if (v.getValue().equals(value)) // code 7896 return true; 7897 return false; 7898 } 7899 7900 /** 7901 * @return {@link #patchFormat} (A list of the patch formats supported by this implementation using their content types.) 7902 */ 7903 public List<CodeType> getPatchFormat() { 7904 if (this.patchFormat == null) 7905 this.patchFormat = new ArrayList<CodeType>(); 7906 return this.patchFormat; 7907 } 7908 7909 /** 7910 * @return Returns a reference to <code>this</code> for easy method chaining 7911 */ 7912 public CapabilityStatement setPatchFormat(List<CodeType> thePatchFormat) { 7913 this.patchFormat = thePatchFormat; 7914 return this; 7915 } 7916 7917 public boolean hasPatchFormat() { 7918 if (this.patchFormat == null) 7919 return false; 7920 for (CodeType item : this.patchFormat) 7921 if (!item.isEmpty()) 7922 return true; 7923 return false; 7924 } 7925 7926 /** 7927 * @return {@link #patchFormat} (A list of the patch formats supported by this implementation using their content types.) 7928 */ 7929 public CodeType addPatchFormatElement() {//2 7930 CodeType t = new CodeType(); 7931 if (this.patchFormat == null) 7932 this.patchFormat = new ArrayList<CodeType>(); 7933 this.patchFormat.add(t); 7934 return t; 7935 } 7936 7937 /** 7938 * @param value {@link #patchFormat} (A list of the patch formats supported by this implementation using their content types.) 7939 */ 7940 public CapabilityStatement addPatchFormat(String value) { //1 7941 CodeType t = new CodeType(); 7942 t.setValue(value); 7943 if (this.patchFormat == null) 7944 this.patchFormat = new ArrayList<CodeType>(); 7945 this.patchFormat.add(t); 7946 return this; 7947 } 7948 7949 /** 7950 * @param value {@link #patchFormat} (A list of the patch formats supported by this implementation using their content types.) 7951 */ 7952 public boolean hasPatchFormat(String value) { 7953 if (this.patchFormat == null) 7954 return false; 7955 for (CodeType v : this.patchFormat) 7956 if (v.getValue().equals(value)) // code 7957 return true; 7958 return false; 7959 } 7960 7961 /** 7962 * @return {@link #implementationGuide} (A list of implementation guides that the server does (or should) support in their entirety.) 7963 */ 7964 public List<CanonicalType> getImplementationGuide() { 7965 if (this.implementationGuide == null) 7966 this.implementationGuide = new ArrayList<CanonicalType>(); 7967 return this.implementationGuide; 7968 } 7969 7970 /** 7971 * @return Returns a reference to <code>this</code> for easy method chaining 7972 */ 7973 public CapabilityStatement setImplementationGuide(List<CanonicalType> theImplementationGuide) { 7974 this.implementationGuide = theImplementationGuide; 7975 return this; 7976 } 7977 7978 public boolean hasImplementationGuide() { 7979 if (this.implementationGuide == null) 7980 return false; 7981 for (CanonicalType item : this.implementationGuide) 7982 if (!item.isEmpty()) 7983 return true; 7984 return false; 7985 } 7986 7987 /** 7988 * @return {@link #implementationGuide} (A list of implementation guides that the server does (or should) support in their entirety.) 7989 */ 7990 public CanonicalType addImplementationGuideElement() {//2 7991 CanonicalType t = new CanonicalType(); 7992 if (this.implementationGuide == null) 7993 this.implementationGuide = new ArrayList<CanonicalType>(); 7994 this.implementationGuide.add(t); 7995 return t; 7996 } 7997 7998 /** 7999 * @param value {@link #implementationGuide} (A list of implementation guides that the server does (or should) support in their entirety.) 8000 */ 8001 public CapabilityStatement addImplementationGuide(String value) { //1 8002 CanonicalType t = new CanonicalType(); 8003 t.setValue(value); 8004 if (this.implementationGuide == null) 8005 this.implementationGuide = new ArrayList<CanonicalType>(); 8006 this.implementationGuide.add(t); 8007 return this; 8008 } 8009 8010 /** 8011 * @param value {@link #implementationGuide} (A list of implementation guides that the server does (or should) support in their entirety.) 8012 */ 8013 public boolean hasImplementationGuide(String value) { 8014 if (this.implementationGuide == null) 8015 return false; 8016 for (CanonicalType v : this.implementationGuide) 8017 if (v.getValue().equals(value)) // canonical 8018 return true; 8019 return false; 8020 } 8021 8022 /** 8023 * @return {@link #rest} (A definition of the restful capabilities of the solution, if any.) 8024 */ 8025 public List<CapabilityStatementRestComponent> getRest() { 8026 if (this.rest == null) 8027 this.rest = new ArrayList<CapabilityStatementRestComponent>(); 8028 return this.rest; 8029 } 8030 8031 /** 8032 * @return Returns a reference to <code>this</code> for easy method chaining 8033 */ 8034 public CapabilityStatement setRest(List<CapabilityStatementRestComponent> theRest) { 8035 this.rest = theRest; 8036 return this; 8037 } 8038 8039 public boolean hasRest() { 8040 if (this.rest == null) 8041 return false; 8042 for (CapabilityStatementRestComponent item : this.rest) 8043 if (!item.isEmpty()) 8044 return true; 8045 return false; 8046 } 8047 8048 public CapabilityStatementRestComponent addRest() { //3 8049 CapabilityStatementRestComponent t = new CapabilityStatementRestComponent(); 8050 if (this.rest == null) 8051 this.rest = new ArrayList<CapabilityStatementRestComponent>(); 8052 this.rest.add(t); 8053 return t; 8054 } 8055 8056 public CapabilityStatement addRest(CapabilityStatementRestComponent t) { //3 8057 if (t == null) 8058 return this; 8059 if (this.rest == null) 8060 this.rest = new ArrayList<CapabilityStatementRestComponent>(); 8061 this.rest.add(t); 8062 return this; 8063 } 8064 8065 /** 8066 * @return The first repetition of repeating field {@link #rest}, creating it if it does not already exist {3} 8067 */ 8068 public CapabilityStatementRestComponent getRestFirstRep() { 8069 if (getRest().isEmpty()) { 8070 addRest(); 8071 } 8072 return getRest().get(0); 8073 } 8074 8075 /** 8076 * @return {@link #messaging} (A description of the messaging capabilities of the solution.) 8077 */ 8078 public List<CapabilityStatementMessagingComponent> getMessaging() { 8079 if (this.messaging == null) 8080 this.messaging = new ArrayList<CapabilityStatementMessagingComponent>(); 8081 return this.messaging; 8082 } 8083 8084 /** 8085 * @return Returns a reference to <code>this</code> for easy method chaining 8086 */ 8087 public CapabilityStatement setMessaging(List<CapabilityStatementMessagingComponent> theMessaging) { 8088 this.messaging = theMessaging; 8089 return this; 8090 } 8091 8092 public boolean hasMessaging() { 8093 if (this.messaging == null) 8094 return false; 8095 for (CapabilityStatementMessagingComponent item : this.messaging) 8096 if (!item.isEmpty()) 8097 return true; 8098 return false; 8099 } 8100 8101 public CapabilityStatementMessagingComponent addMessaging() { //3 8102 CapabilityStatementMessagingComponent t = new CapabilityStatementMessagingComponent(); 8103 if (this.messaging == null) 8104 this.messaging = new ArrayList<CapabilityStatementMessagingComponent>(); 8105 this.messaging.add(t); 8106 return t; 8107 } 8108 8109 public CapabilityStatement addMessaging(CapabilityStatementMessagingComponent t) { //3 8110 if (t == null) 8111 return this; 8112 if (this.messaging == null) 8113 this.messaging = new ArrayList<CapabilityStatementMessagingComponent>(); 8114 this.messaging.add(t); 8115 return this; 8116 } 8117 8118 /** 8119 * @return The first repetition of repeating field {@link #messaging}, creating it if it does not already exist {3} 8120 */ 8121 public CapabilityStatementMessagingComponent getMessagingFirstRep() { 8122 if (getMessaging().isEmpty()) { 8123 addMessaging(); 8124 } 8125 return getMessaging().get(0); 8126 } 8127 8128 /** 8129 * @return {@link #document} (A document definition.) 8130 */ 8131 public List<CapabilityStatementDocumentComponent> getDocument() { 8132 if (this.document == null) 8133 this.document = new ArrayList<CapabilityStatementDocumentComponent>(); 8134 return this.document; 8135 } 8136 8137 /** 8138 * @return Returns a reference to <code>this</code> for easy method chaining 8139 */ 8140 public CapabilityStatement setDocument(List<CapabilityStatementDocumentComponent> theDocument) { 8141 this.document = theDocument; 8142 return this; 8143 } 8144 8145 public boolean hasDocument() { 8146 if (this.document == null) 8147 return false; 8148 for (CapabilityStatementDocumentComponent item : this.document) 8149 if (!item.isEmpty()) 8150 return true; 8151 return false; 8152 } 8153 8154 public CapabilityStatementDocumentComponent addDocument() { //3 8155 CapabilityStatementDocumentComponent t = new CapabilityStatementDocumentComponent(); 8156 if (this.document == null) 8157 this.document = new ArrayList<CapabilityStatementDocumentComponent>(); 8158 this.document.add(t); 8159 return t; 8160 } 8161 8162 public CapabilityStatement addDocument(CapabilityStatementDocumentComponent t) { //3 8163 if (t == null) 8164 return this; 8165 if (this.document == null) 8166 this.document = new ArrayList<CapabilityStatementDocumentComponent>(); 8167 this.document.add(t); 8168 return this; 8169 } 8170 8171 /** 8172 * @return The first repetition of repeating field {@link #document}, creating it if it does not already exist {3} 8173 */ 8174 public CapabilityStatementDocumentComponent getDocumentFirstRep() { 8175 if (getDocument().isEmpty()) { 8176 addDocument(); 8177 } 8178 return getDocument().get(0); 8179 } 8180 8181 protected void listChildren(List<Property> children) { 8182 super.listChildren(children); 8183 children.add(new Property("url", "uri", "An absolute URI that is used to identify this capability statement when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this capability statement is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement is stored on different servers.", 0, 1, url)); 8184 children.add(new Property("version", "string", "The identifier that is used to identify this version of the capability statement when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.", 0, 1, version)); 8185 children.add(new Property("name", "string", "A natural language name identifying the capability statement. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name)); 8186 children.add(new Property("title", "string", "A short, descriptive, user-friendly title for the capability statement.", 0, 1, title)); 8187 children.add(new Property("status", "code", "The status of this capability statement. Enables tracking the life-cycle of the content.", 0, 1, status)); 8188 children.add(new Property("experimental", "boolean", "A Boolean value to indicate that this capability statement is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.", 0, 1, experimental)); 8189 children.add(new Property("date", "dateTime", "The date (and optionally time) when the capability statement was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the capability statement changes.", 0, 1, date)); 8190 children.add(new Property("publisher", "string", "The name of the organization or individual that published the capability statement.", 0, 1, publisher)); 8191 children.add(new Property("contact", "ContactDetail", "Contact details to assist a user in finding and communicating with the publisher.", 0, java.lang.Integer.MAX_VALUE, contact)); 8192 children.add(new Property("description", "markdown", "A free text natural language description of the capability statement from a consumer's perspective. Typically, this is used when the capability statement describes a desired rather than an actual solution, for example as a formal expression of requirements as part of an RFP.", 0, 1, description)); 8193 children.add(new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate capability statement instances.", 0, java.lang.Integer.MAX_VALUE, useContext)); 8194 children.add(new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the capability statement is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction)); 8195 children.add(new Property("purpose", "markdown", "Explanation of why this capability statement is needed and why it has been designed as it has.", 0, 1, purpose)); 8196 children.add(new Property("copyright", "markdown", "A copyright statement relating to the capability statement and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement.", 0, 1, copyright)); 8197 children.add(new Property("kind", "code", "The way that this statement is intended to be used, to describe an actual running instance of software, a particular product (kind, not instance of software) or a class of implementation (e.g. a desired purchase).", 0, 1, kind)); 8198 children.add(new Property("instantiates", "canonical(CapabilityStatement)", "Reference to a canonical URL of another CapabilityStatement that this software implements. This capability statement is a published API description that corresponds to a business service. The server may actually implement a subset of the capability statement it claims to implement, so the capability statement must specify the full capability details.", 0, java.lang.Integer.MAX_VALUE, instantiates)); 8199 children.add(new Property("imports", "canonical(CapabilityStatement)", "Reference to a canonical URL of another CapabilityStatement that this software adds to. The capability statement automatically includes everything in the other statement, and it is not duplicated, though the server may repeat the same resources, interactions and operations to add additional details to them.", 0, java.lang.Integer.MAX_VALUE, imports)); 8200 children.add(new Property("software", "", "Software that is covered by this capability statement. It is used when the capability statement describes the capabilities of a particular software version, independent of an installation.", 0, 1, software)); 8201 children.add(new Property("implementation", "", "Identifies a specific implementation instance that is described by the capability statement - i.e. a particular installation, rather than the capabilities of a software program.", 0, 1, implementation)); 8202 children.add(new Property("fhirVersion", "code", "The version of the FHIR specification that this CapabilityStatement describes (which SHALL be the same as the FHIR version of the CapabilityStatement itself). There is no default value.", 0, 1, fhirVersion)); 8203 children.add(new Property("format", "code", "A list of the formats supported by this implementation using their content types.", 0, java.lang.Integer.MAX_VALUE, format)); 8204 children.add(new Property("patchFormat", "code", "A list of the patch formats supported by this implementation using their content types.", 0, java.lang.Integer.MAX_VALUE, patchFormat)); 8205 children.add(new Property("implementationGuide", "canonical(ImplementationGuide)", "A list of implementation guides that the server does (or should) support in their entirety.", 0, java.lang.Integer.MAX_VALUE, implementationGuide)); 8206 children.add(new Property("rest", "", "A definition of the restful capabilities of the solution, if any.", 0, java.lang.Integer.MAX_VALUE, rest)); 8207 children.add(new Property("messaging", "", "A description of the messaging capabilities of the solution.", 0, java.lang.Integer.MAX_VALUE, messaging)); 8208 children.add(new Property("document", "", "A document definition.", 0, java.lang.Integer.MAX_VALUE, document)); 8209 } 8210 8211 @Override 8212 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 8213 switch (_hash) { 8214 case 116079: /*url*/ return new Property("url", "uri", "An absolute URI that is used to identify this capability statement when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this capability statement is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement is stored on different servers.", 0, 1, url); 8215 case 351608024: /*version*/ return new Property("version", "string", "The identifier that is used to identify this version of the capability statement when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.", 0, 1, version); 8216 case 3373707: /*name*/ return new Property("name", "string", "A natural language name identifying the capability statement. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name); 8217 case 110371416: /*title*/ return new Property("title", "string", "A short, descriptive, user-friendly title for the capability statement.", 0, 1, title); 8218 case -892481550: /*status*/ return new Property("status", "code", "The status of this capability statement. Enables tracking the life-cycle of the content.", 0, 1, status); 8219 case -404562712: /*experimental*/ return new Property("experimental", "boolean", "A Boolean value to indicate that this capability statement is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.", 0, 1, experimental); 8220 case 3076014: /*date*/ return new Property("date", "dateTime", "The date (and optionally time) when the capability statement was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the capability statement changes.", 0, 1, date); 8221 case 1447404028: /*publisher*/ return new Property("publisher", "string", "The name of the organization or individual that published the capability statement.", 0, 1, publisher); 8222 case 951526432: /*contact*/ return new Property("contact", "ContactDetail", "Contact details to assist a user in finding and communicating with the publisher.", 0, java.lang.Integer.MAX_VALUE, contact); 8223 case -1724546052: /*description*/ return new Property("description", "markdown", "A free text natural language description of the capability statement from a consumer's perspective. Typically, this is used when the capability statement describes a desired rather than an actual solution, for example as a formal expression of requirements as part of an RFP.", 0, 1, description); 8224 case -669707736: /*useContext*/ return new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate capability statement instances.", 0, java.lang.Integer.MAX_VALUE, useContext); 8225 case -507075711: /*jurisdiction*/ return new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the capability statement is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction); 8226 case -220463842: /*purpose*/ return new Property("purpose", "markdown", "Explanation of why this capability statement is needed and why it has been designed as it has.", 0, 1, purpose); 8227 case 1522889671: /*copyright*/ return new Property("copyright", "markdown", "A copyright statement relating to the capability statement and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement.", 0, 1, copyright); 8228 case 3292052: /*kind*/ return new Property("kind", "code", "The way that this statement is intended to be used, to describe an actual running instance of software, a particular product (kind, not instance of software) or a class of implementation (e.g. a desired purchase).", 0, 1, kind); 8229 case -246883639: /*instantiates*/ return new Property("instantiates", "canonical(CapabilityStatement)", "Reference to a canonical URL of another CapabilityStatement that this software implements. This capability statement is a published API description that corresponds to a business service. The server may actually implement a subset of the capability statement it claims to implement, so the capability statement must specify the full capability details.", 0, java.lang.Integer.MAX_VALUE, instantiates); 8230 case 1926037870: /*imports*/ return new Property("imports", "canonical(CapabilityStatement)", "Reference to a canonical URL of another CapabilityStatement that this software adds to. The capability statement automatically includes everything in the other statement, and it is not duplicated, though the server may repeat the same resources, interactions and operations to add additional details to them.", 0, java.lang.Integer.MAX_VALUE, imports); 8231 case 1319330215: /*software*/ return new Property("software", "", "Software that is covered by this capability statement. It is used when the capability statement describes the capabilities of a particular software version, independent of an installation.", 0, 1, software); 8232 case 1683336114: /*implementation*/ return new Property("implementation", "", "Identifies a specific implementation instance that is described by the capability statement - i.e. a particular installation, rather than the capabilities of a software program.", 0, 1, implementation); 8233 case 461006061: /*fhirVersion*/ return new Property("fhirVersion", "code", "The version of the FHIR specification that this CapabilityStatement describes (which SHALL be the same as the FHIR version of the CapabilityStatement itself). There is no default value.", 0, 1, fhirVersion); 8234 case -1268779017: /*format*/ return new Property("format", "code", "A list of the formats supported by this implementation using their content types.", 0, java.lang.Integer.MAX_VALUE, format); 8235 case 172338783: /*patchFormat*/ return new Property("patchFormat", "code", "A list of the patch formats supported by this implementation using their content types.", 0, java.lang.Integer.MAX_VALUE, patchFormat); 8236 case 156966506: /*implementationGuide*/ return new Property("implementationGuide", "canonical(ImplementationGuide)", "A list of implementation guides that the server does (or should) support in their entirety.", 0, java.lang.Integer.MAX_VALUE, implementationGuide); 8237 case 3496916: /*rest*/ return new Property("rest", "", "A definition of the restful capabilities of the solution, if any.", 0, java.lang.Integer.MAX_VALUE, rest); 8238 case -1440008444: /*messaging*/ return new Property("messaging", "", "A description of the messaging capabilities of the solution.", 0, java.lang.Integer.MAX_VALUE, messaging); 8239 case 861720859: /*document*/ return new Property("document", "", "A document definition.", 0, java.lang.Integer.MAX_VALUE, document); 8240 default: return super.getNamedProperty(_hash, _name, _checkValid); 8241 } 8242 8243 } 8244 8245 @Override 8246 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 8247 switch (hash) { 8248 case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType 8249 case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType 8250 case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType 8251 case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType 8252 case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<PublicationStatus> 8253 case -404562712: /*experimental*/ return this.experimental == null ? new Base[0] : new Base[] {this.experimental}; // BooleanType 8254 case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType 8255 case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType 8256 case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail 8257 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType 8258 case -669707736: /*useContext*/ return this.useContext == null ? new Base[0] : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext 8259 case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept 8260 case -220463842: /*purpose*/ return this.purpose == null ? new Base[0] : new Base[] {this.purpose}; // MarkdownType 8261 case 1522889671: /*copyright*/ return this.copyright == null ? new Base[0] : new Base[] {this.copyright}; // MarkdownType 8262 case 3292052: /*kind*/ return this.kind == null ? new Base[0] : new Base[] {this.kind}; // Enumeration<CapabilityStatementKind> 8263 case -246883639: /*instantiates*/ return this.instantiates == null ? new Base[0] : this.instantiates.toArray(new Base[this.instantiates.size()]); // CanonicalType 8264 case 1926037870: /*imports*/ return this.imports == null ? new Base[0] : this.imports.toArray(new Base[this.imports.size()]); // CanonicalType 8265 case 1319330215: /*software*/ return this.software == null ? new Base[0] : new Base[] {this.software}; // CapabilityStatementSoftwareComponent 8266 case 1683336114: /*implementation*/ return this.implementation == null ? new Base[0] : new Base[] {this.implementation}; // CapabilityStatementImplementationComponent 8267 case 461006061: /*fhirVersion*/ return this.fhirVersion == null ? new Base[0] : new Base[] {this.fhirVersion}; // Enumeration<FHIRVersion> 8268 case -1268779017: /*format*/ return this.format == null ? new Base[0] : this.format.toArray(new Base[this.format.size()]); // CodeType 8269 case 172338783: /*patchFormat*/ return this.patchFormat == null ? new Base[0] : this.patchFormat.toArray(new Base[this.patchFormat.size()]); // CodeType 8270 case 156966506: /*implementationGuide*/ return this.implementationGuide == null ? new Base[0] : this.implementationGuide.toArray(new Base[this.implementationGuide.size()]); // CanonicalType 8271 case 3496916: /*rest*/ return this.rest == null ? new Base[0] : this.rest.toArray(new Base[this.rest.size()]); // CapabilityStatementRestComponent 8272 case -1440008444: /*messaging*/ return this.messaging == null ? new Base[0] : this.messaging.toArray(new Base[this.messaging.size()]); // CapabilityStatementMessagingComponent 8273 case 861720859: /*document*/ return this.document == null ? new Base[0] : this.document.toArray(new Base[this.document.size()]); // CapabilityStatementDocumentComponent 8274 default: return super.getProperty(hash, name, checkValid); 8275 } 8276 8277 } 8278 8279 @Override 8280 public Base setProperty(int hash, String name, Base value) throws FHIRException { 8281 switch (hash) { 8282 case 116079: // url 8283 this.url = TypeConvertor.castToUri(value); // UriType 8284 return value; 8285 case 351608024: // version 8286 this.version = TypeConvertor.castToString(value); // StringType 8287 return value; 8288 case 3373707: // name 8289 this.name = TypeConvertor.castToString(value); // StringType 8290 return value; 8291 case 110371416: // title 8292 this.title = TypeConvertor.castToString(value); // StringType 8293 return value; 8294 case -892481550: // status 8295 value = new PublicationStatusEnumFactory().fromType(TypeConvertor.castToCode(value)); 8296 this.status = (Enumeration) value; // Enumeration<PublicationStatus> 8297 return value; 8298 case -404562712: // experimental 8299 this.experimental = TypeConvertor.castToBoolean(value); // BooleanType 8300 return value; 8301 case 3076014: // date 8302 this.date = TypeConvertor.castToDateTime(value); // DateTimeType 8303 return value; 8304 case 1447404028: // publisher 8305 this.publisher = TypeConvertor.castToString(value); // StringType 8306 return value; 8307 case 951526432: // contact 8308 this.getContact().add(TypeConvertor.castToContactDetail(value)); // ContactDetail 8309 return value; 8310 case -1724546052: // description 8311 this.description = TypeConvertor.castToMarkdown(value); // MarkdownType 8312 return value; 8313 case -669707736: // useContext 8314 this.getUseContext().add(TypeConvertor.castToUsageContext(value)); // UsageContext 8315 return value; 8316 case -507075711: // jurisdiction 8317 this.getJurisdiction().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept 8318 return value; 8319 case -220463842: // purpose 8320 this.purpose = TypeConvertor.castToMarkdown(value); // MarkdownType 8321 return value; 8322 case 1522889671: // copyright 8323 this.copyright = TypeConvertor.castToMarkdown(value); // MarkdownType 8324 return value; 8325 case 3292052: // kind 8326 value = new CapabilityStatementKindEnumFactory().fromType(TypeConvertor.castToCode(value)); 8327 this.kind = (Enumeration) value; // Enumeration<CapabilityStatementKind> 8328 return value; 8329 case -246883639: // instantiates 8330 this.getInstantiates().add(TypeConvertor.castToCanonical(value)); // CanonicalType 8331 return value; 8332 case 1926037870: // imports 8333 this.getImports().add(TypeConvertor.castToCanonical(value)); // CanonicalType 8334 return value; 8335 case 1319330215: // software 8336 this.software = (CapabilityStatementSoftwareComponent) value; // CapabilityStatementSoftwareComponent 8337 return value; 8338 case 1683336114: // implementation 8339 this.implementation = (CapabilityStatementImplementationComponent) value; // CapabilityStatementImplementationComponent 8340 return value; 8341 case 461006061: // fhirVersion 8342 value = new FHIRVersionEnumFactory().fromType(TypeConvertor.castToCode(value)); 8343 this.fhirVersion = (Enumeration) value; // Enumeration<FHIRVersion> 8344 return value; 8345 case -1268779017: // format 8346 this.getFormat().add(TypeConvertor.castToCode(value)); // CodeType 8347 return value; 8348 case 172338783: // patchFormat 8349 this.getPatchFormat().add(TypeConvertor.castToCode(value)); // CodeType 8350 return value; 8351 case 156966506: // implementationGuide 8352 this.getImplementationGuide().add(TypeConvertor.castToCanonical(value)); // CanonicalType 8353 return value; 8354 case 3496916: // rest 8355 this.getRest().add((CapabilityStatementRestComponent) value); // CapabilityStatementRestComponent 8356 return value; 8357 case -1440008444: // messaging 8358 this.getMessaging().add((CapabilityStatementMessagingComponent) value); // CapabilityStatementMessagingComponent 8359 return value; 8360 case 861720859: // document 8361 this.getDocument().add((CapabilityStatementDocumentComponent) value); // CapabilityStatementDocumentComponent 8362 return value; 8363 default: return super.setProperty(hash, name, value); 8364 } 8365 8366 } 8367 8368 @Override 8369 public Base setProperty(String name, Base value) throws FHIRException { 8370 if (name.equals("url")) { 8371 this.url = TypeConvertor.castToUri(value); // UriType 8372 } else if (name.equals("version")) { 8373 this.version = TypeConvertor.castToString(value); // StringType 8374 } else if (name.equals("name")) { 8375 this.name = TypeConvertor.castToString(value); // StringType 8376 } else if (name.equals("title")) { 8377 this.title = TypeConvertor.castToString(value); // StringType 8378 } else if (name.equals("status")) { 8379 value = new PublicationStatusEnumFactory().fromType(TypeConvertor.castToCode(value)); 8380 this.status = (Enumeration) value; // Enumeration<PublicationStatus> 8381 } else if (name.equals("experimental")) { 8382 this.experimental = TypeConvertor.castToBoolean(value); // BooleanType 8383 } else if (name.equals("date")) { 8384 this.date = TypeConvertor.castToDateTime(value); // DateTimeType 8385 } else if (name.equals("publisher")) { 8386 this.publisher = TypeConvertor.castToString(value); // StringType 8387 } else if (name.equals("contact")) { 8388 this.getContact().add(TypeConvertor.castToContactDetail(value)); 8389 } else if (name.equals("description")) { 8390 this.description = TypeConvertor.castToMarkdown(value); // MarkdownType 8391 } else if (name.equals("useContext")) { 8392 this.getUseContext().add(TypeConvertor.castToUsageContext(value)); 8393 } else if (name.equals("jurisdiction")) { 8394 this.getJurisdiction().add(TypeConvertor.castToCodeableConcept(value)); 8395 } else if (name.equals("purpose")) { 8396 this.purpose = TypeConvertor.castToMarkdown(value); // MarkdownType 8397 } else if (name.equals("copyright")) { 8398 this.copyright = TypeConvertor.castToMarkdown(value); // MarkdownType 8399 } else if (name.equals("kind")) { 8400 value = new CapabilityStatementKindEnumFactory().fromType(TypeConvertor.castToCode(value)); 8401 this.kind = (Enumeration) value; // Enumeration<CapabilityStatementKind> 8402 } else if (name.equals("instantiates")) { 8403 this.getInstantiates().add(TypeConvertor.castToCanonical(value)); 8404 } else if (name.equals("imports")) { 8405 this.getImports().add(TypeConvertor.castToCanonical(value)); 8406 } else if (name.equals("software")) { 8407 this.software = (CapabilityStatementSoftwareComponent) value; // CapabilityStatementSoftwareComponent 8408 } else if (name.equals("implementation")) { 8409 this.implementation = (CapabilityStatementImplementationComponent) value; // CapabilityStatementImplementationComponent 8410 } else if (name.equals("fhirVersion")) { 8411 value = new FHIRVersionEnumFactory().fromType(TypeConvertor.castToCode(value)); 8412 this.fhirVersion = (Enumeration) value; // Enumeration<FHIRVersion> 8413 } else if (name.equals("format")) { 8414 this.getFormat().add(TypeConvertor.castToCode(value)); 8415 } else if (name.equals("patchFormat")) { 8416 this.getPatchFormat().add(TypeConvertor.castToCode(value)); 8417 } else if (name.equals("implementationGuide")) { 8418 this.getImplementationGuide().add(TypeConvertor.castToCanonical(value)); 8419 } else if (name.equals("rest")) { 8420 this.getRest().add((CapabilityStatementRestComponent) value); 8421 } else if (name.equals("messaging")) { 8422 this.getMessaging().add((CapabilityStatementMessagingComponent) value); 8423 } else if (name.equals("document")) { 8424 this.getDocument().add((CapabilityStatementDocumentComponent) value); 8425 } else 8426 return super.setProperty(name, value); 8427 return value; 8428 } 8429 8430 @Override 8431 public Base makeProperty(int hash, String name) throws FHIRException { 8432 switch (hash) { 8433 case 116079: return getUrlElement(); 8434 case 351608024: return getVersionElement(); 8435 case 3373707: return getNameElement(); 8436 case 110371416: return getTitleElement(); 8437 case -892481550: return getStatusElement(); 8438 case -404562712: return getExperimentalElement(); 8439 case 3076014: return getDateElement(); 8440 case 1447404028: return getPublisherElement(); 8441 case 951526432: return addContact(); 8442 case -1724546052: return getDescriptionElement(); 8443 case -669707736: return addUseContext(); 8444 case -507075711: return addJurisdiction(); 8445 case -220463842: return getPurposeElement(); 8446 case 1522889671: return getCopyrightElement(); 8447 case 3292052: return getKindElement(); 8448 case -246883639: return addInstantiatesElement(); 8449 case 1926037870: return addImportsElement(); 8450 case 1319330215: return getSoftware(); 8451 case 1683336114: return getImplementation(); 8452 case 461006061: return getFhirVersionElement(); 8453 case -1268779017: return addFormatElement(); 8454 case 172338783: return addPatchFormatElement(); 8455 case 156966506: return addImplementationGuideElement(); 8456 case 3496916: return addRest(); 8457 case -1440008444: return addMessaging(); 8458 case 861720859: return addDocument(); 8459 default: return super.makeProperty(hash, name); 8460 } 8461 8462 } 8463 8464 @Override 8465 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 8466 switch (hash) { 8467 case 116079: /*url*/ return new String[] {"uri"}; 8468 case 351608024: /*version*/ return new String[] {"string"}; 8469 case 3373707: /*name*/ return new String[] {"string"}; 8470 case 110371416: /*title*/ return new String[] {"string"}; 8471 case -892481550: /*status*/ return new String[] {"code"}; 8472 case -404562712: /*experimental*/ return new String[] {"boolean"}; 8473 case 3076014: /*date*/ return new String[] {"dateTime"}; 8474 case 1447404028: /*publisher*/ return new String[] {"string"}; 8475 case 951526432: /*contact*/ return new String[] {"ContactDetail"}; 8476 case -1724546052: /*description*/ return new String[] {"markdown"}; 8477 case -669707736: /*useContext*/ return new String[] {"UsageContext"}; 8478 case -507075711: /*jurisdiction*/ return new String[] {"CodeableConcept"}; 8479 case -220463842: /*purpose*/ return new String[] {"markdown"}; 8480 case 1522889671: /*copyright*/ return new String[] {"markdown"}; 8481 case 3292052: /*kind*/ return new String[] {"code"}; 8482 case -246883639: /*instantiates*/ return new String[] {"canonical"}; 8483 case 1926037870: /*imports*/ return new String[] {"canonical"}; 8484 case 1319330215: /*software*/ return new String[] {}; 8485 case 1683336114: /*implementation*/ return new String[] {}; 8486 case 461006061: /*fhirVersion*/ return new String[] {"code"}; 8487 case -1268779017: /*format*/ return new String[] {"code"}; 8488 case 172338783: /*patchFormat*/ return new String[] {"code"}; 8489 case 156966506: /*implementationGuide*/ return new String[] {"canonical"}; 8490 case 3496916: /*rest*/ return new String[] {}; 8491 case -1440008444: /*messaging*/ return new String[] {}; 8492 case 861720859: /*document*/ return new String[] {}; 8493 default: return super.getTypesForProperty(hash, name); 8494 } 8495 8496 } 8497 8498 @Override 8499 public Base addChild(String name) throws FHIRException { 8500 if (name.equals("url")) { 8501 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.url"); 8502 } 8503 else if (name.equals("version")) { 8504 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.version"); 8505 } 8506 else if (name.equals("name")) { 8507 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.name"); 8508 } 8509 else if (name.equals("title")) { 8510 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.title"); 8511 } 8512 else if (name.equals("status")) { 8513 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.status"); 8514 } 8515 else if (name.equals("experimental")) { 8516 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.experimental"); 8517 } 8518 else if (name.equals("date")) { 8519 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.date"); 8520 } 8521 else if (name.equals("publisher")) { 8522 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.publisher"); 8523 } 8524 else if (name.equals("contact")) { 8525 return addContact(); 8526 } 8527 else if (name.equals("description")) { 8528 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.description"); 8529 } 8530 else if (name.equals("useContext")) { 8531 return addUseContext(); 8532 } 8533 else if (name.equals("jurisdiction")) { 8534 return addJurisdiction(); 8535 } 8536 else if (name.equals("purpose")) { 8537 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.purpose"); 8538 } 8539 else if (name.equals("copyright")) { 8540 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.copyright"); 8541 } 8542 else if (name.equals("kind")) { 8543 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.kind"); 8544 } 8545 else if (name.equals("instantiates")) { 8546 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.instantiates"); 8547 } 8548 else if (name.equals("imports")) { 8549 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.imports"); 8550 } 8551 else if (name.equals("software")) { 8552 this.software = new CapabilityStatementSoftwareComponent(); 8553 return this.software; 8554 } 8555 else if (name.equals("implementation")) { 8556 this.implementation = new CapabilityStatementImplementationComponent(); 8557 return this.implementation; 8558 } 8559 else if (name.equals("fhirVersion")) { 8560 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.fhirVersion"); 8561 } 8562 else if (name.equals("format")) { 8563 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.format"); 8564 } 8565 else if (name.equals("patchFormat")) { 8566 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.patchFormat"); 8567 } 8568 else if (name.equals("implementationGuide")) { 8569 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.implementationGuide"); 8570 } 8571 else if (name.equals("rest")) { 8572 return addRest(); 8573 } 8574 else if (name.equals("messaging")) { 8575 return addMessaging(); 8576 } 8577 else if (name.equals("document")) { 8578 return addDocument(); 8579 } 8580 else 8581 return super.addChild(name); 8582 } 8583 8584 public String fhirType() { 8585 return "CapabilityStatement"; 8586 8587 } 8588 8589 public CapabilityStatement copy() { 8590 CapabilityStatement dst = new CapabilityStatement(); 8591 copyValues(dst); 8592 return dst; 8593 } 8594 8595 public void copyValues(CapabilityStatement dst) { 8596 super.copyValues(dst); 8597 dst.url = url == null ? null : url.copy(); 8598 dst.version = version == null ? null : version.copy(); 8599 dst.name = name == null ? null : name.copy(); 8600 dst.title = title == null ? null : title.copy(); 8601 dst.status = status == null ? null : status.copy(); 8602 dst.experimental = experimental == null ? null : experimental.copy(); 8603 dst.date = date == null ? null : date.copy(); 8604 dst.publisher = publisher == null ? null : publisher.copy(); 8605 if (contact != null) { 8606 dst.contact = new ArrayList<ContactDetail>(); 8607 for (ContactDetail i : contact) 8608 dst.contact.add(i.copy()); 8609 }; 8610 dst.description = description == null ? null : description.copy(); 8611 if (useContext != null) { 8612 dst.useContext = new ArrayList<UsageContext>(); 8613 for (UsageContext i : useContext) 8614 dst.useContext.add(i.copy()); 8615 }; 8616 if (jurisdiction != null) { 8617 dst.jurisdiction = new ArrayList<CodeableConcept>(); 8618 for (CodeableConcept i : jurisdiction) 8619 dst.jurisdiction.add(i.copy()); 8620 }; 8621 dst.purpose = purpose == null ? null : purpose.copy(); 8622 dst.copyright = copyright == null ? null : copyright.copy(); 8623 dst.kind = kind == null ? null : kind.copy(); 8624 if (instantiates != null) { 8625 dst.instantiates = new ArrayList<CanonicalType>(); 8626 for (CanonicalType i : instantiates) 8627 dst.instantiates.add(i.copy()); 8628 }; 8629 if (imports != null) { 8630 dst.imports = new ArrayList<CanonicalType>(); 8631 for (CanonicalType i : imports) 8632 dst.imports.add(i.copy()); 8633 }; 8634 dst.software = software == null ? null : software.copy(); 8635 dst.implementation = implementation == null ? null : implementation.copy(); 8636 dst.fhirVersion = fhirVersion == null ? null : fhirVersion.copy(); 8637 if (format != null) { 8638 dst.format = new ArrayList<CodeType>(); 8639 for (CodeType i : format) 8640 dst.format.add(i.copy()); 8641 }; 8642 if (patchFormat != null) { 8643 dst.patchFormat = new ArrayList<CodeType>(); 8644 for (CodeType i : patchFormat) 8645 dst.patchFormat.add(i.copy()); 8646 }; 8647 if (implementationGuide != null) { 8648 dst.implementationGuide = new ArrayList<CanonicalType>(); 8649 for (CanonicalType i : implementationGuide) 8650 dst.implementationGuide.add(i.copy()); 8651 }; 8652 if (rest != null) { 8653 dst.rest = new ArrayList<CapabilityStatementRestComponent>(); 8654 for (CapabilityStatementRestComponent i : rest) 8655 dst.rest.add(i.copy()); 8656 }; 8657 if (messaging != null) { 8658 dst.messaging = new ArrayList<CapabilityStatementMessagingComponent>(); 8659 for (CapabilityStatementMessagingComponent i : messaging) 8660 dst.messaging.add(i.copy()); 8661 }; 8662 if (document != null) { 8663 dst.document = new ArrayList<CapabilityStatementDocumentComponent>(); 8664 for (CapabilityStatementDocumentComponent i : document) 8665 dst.document.add(i.copy()); 8666 }; 8667 } 8668 8669 protected CapabilityStatement typedCopy() { 8670 return copy(); 8671 } 8672 8673 @Override 8674 public boolean equalsDeep(Base other_) { 8675 if (!super.equalsDeep(other_)) 8676 return false; 8677 if (!(other_ instanceof CapabilityStatement)) 8678 return false; 8679 CapabilityStatement o = (CapabilityStatement) other_; 8680 return compareDeep(url, o.url, true) && compareDeep(version, o.version, true) && compareDeep(name, o.name, true) 8681 && compareDeep(title, o.title, true) && compareDeep(status, o.status, true) && compareDeep(experimental, o.experimental, true) 8682 && compareDeep(date, o.date, true) && compareDeep(publisher, o.publisher, true) && compareDeep(contact, o.contact, true) 8683 && compareDeep(description, o.description, true) && compareDeep(useContext, o.useContext, true) 8684 && compareDeep(jurisdiction, o.jurisdiction, true) && compareDeep(purpose, o.purpose, true) && compareDeep(copyright, o.copyright, true) 8685 && compareDeep(kind, o.kind, true) && compareDeep(instantiates, o.instantiates, true) && compareDeep(imports, o.imports, true) 8686 && compareDeep(software, o.software, true) && compareDeep(implementation, o.implementation, true) 8687 && compareDeep(fhirVersion, o.fhirVersion, true) && compareDeep(format, o.format, true) && compareDeep(patchFormat, o.patchFormat, true) 8688 && compareDeep(implementationGuide, o.implementationGuide, true) && compareDeep(rest, o.rest, true) 8689 && compareDeep(messaging, o.messaging, true) && compareDeep(document, o.document, true); 8690 } 8691 8692 @Override 8693 public boolean equalsShallow(Base other_) { 8694 if (!super.equalsShallow(other_)) 8695 return false; 8696 if (!(other_ instanceof CapabilityStatement)) 8697 return false; 8698 CapabilityStatement o = (CapabilityStatement) other_; 8699 return compareValues(url, o.url, true) && compareValues(version, o.version, true) && compareValues(name, o.name, true) 8700 && compareValues(title, o.title, true) && compareValues(status, o.status, true) && compareValues(experimental, o.experimental, true) 8701 && compareValues(date, o.date, true) && compareValues(publisher, o.publisher, true) && compareValues(description, o.description, true) 8702 && compareValues(purpose, o.purpose, true) && compareValues(copyright, o.copyright, true) && compareValues(kind, o.kind, true) 8703 && compareValues(instantiates, o.instantiates, true) && compareValues(imports, o.imports, true) && compareValues(fhirVersion, o.fhirVersion, true) 8704 && compareValues(format, o.format, true) && compareValues(patchFormat, o.patchFormat, true) && compareValues(implementationGuide, o.implementationGuide, true) 8705 ; 8706 } 8707 8708 public boolean isEmpty() { 8709 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(url, version, name, title 8710 , status, experimental, date, publisher, contact, description, useContext, jurisdiction 8711 , purpose, copyright, kind, instantiates, imports, software, implementation, fhirVersion 8712 , format, patchFormat, implementationGuide, rest, messaging, document); 8713 } 8714 8715 @Override 8716 public ResourceType getResourceType() { 8717 return ResourceType.CapabilityStatement; 8718 } 8719 8720 @Override 8721 public List<Identifier> getIdentifier() { 8722 return new ArrayList<>(); 8723 } 8724 8725 @Override 8726 public CanonicalResource setIdentifier(List<Identifier> theIdentifier) { 8727 return this; 8728 } 8729 8730 @Override 8731 public boolean hasIdentifier() { 8732 return false; 8733 } 8734 8735 @Override 8736 public Identifier addIdentifier() { 8737 return null; 8738 } 8739 8740 @Override 8741 public CanonicalResource addIdentifier(Identifier t) { 8742 return null; 8743 } 8744 8745 @Override 8746 public Identifier getIdentifierFirstRep() { 8747 return null; 8748 } 8749 8750// Manual code (from Configuration.txt): 8751 8752// end addition 8753 /** 8754 * Search parameter: <b>fhirversion</b> 8755 * <p> 8756 * Description: <b>The version of FHIR</b><br> 8757 * Type: <b>token</b><br> 8758 * Path: <b>CapabilityStatement.version</b><br> 8759 * </p> 8760 */ 8761 @SearchParamDefinition(name="fhirversion", path="CapabilityStatement.version", description="The version of FHIR", type="token" ) 8762 public static final String SP_FHIRVERSION = "fhirversion"; 8763 /** 8764 * <b>Fluent Client</b> search parameter constant for <b>fhirversion</b> 8765 * <p> 8766 * Description: <b>The version of FHIR</b><br> 8767 * Type: <b>token</b><br> 8768 * Path: <b>CapabilityStatement.version</b><br> 8769 * </p> 8770 */ 8771 public static final ca.uhn.fhir.rest.gclient.TokenClientParam FHIRVERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_FHIRVERSION); 8772 8773 /** 8774 * Search parameter: <b>format</b> 8775 * <p> 8776 * Description: <b>formats supported (xml | json | ttl | mime type)</b><br> 8777 * Type: <b>token</b><br> 8778 * Path: <b>CapabilityStatement.format</b><br> 8779 * </p> 8780 */ 8781 @SearchParamDefinition(name="format", path="CapabilityStatement.format", description="formats supported (xml | json | ttl | mime type)", type="token" ) 8782 public static final String SP_FORMAT = "format"; 8783 /** 8784 * <b>Fluent Client</b> search parameter constant for <b>format</b> 8785 * <p> 8786 * Description: <b>formats supported (xml | json | ttl | mime type)</b><br> 8787 * Type: <b>token</b><br> 8788 * Path: <b>CapabilityStatement.format</b><br> 8789 * </p> 8790 */ 8791 public static final ca.uhn.fhir.rest.gclient.TokenClientParam FORMAT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_FORMAT); 8792 8793 /** 8794 * Search parameter: <b>guide</b> 8795 * <p> 8796 * Description: <b>Implementation guides supported</b><br> 8797 * Type: <b>reference</b><br> 8798 * Path: <b>CapabilityStatement.implementationGuide</b><br> 8799 * </p> 8800 */ 8801 @SearchParamDefinition(name="guide", path="CapabilityStatement.implementationGuide", description="Implementation guides supported", type="reference", target={ImplementationGuide.class } ) 8802 public static final String SP_GUIDE = "guide"; 8803 /** 8804 * <b>Fluent Client</b> search parameter constant for <b>guide</b> 8805 * <p> 8806 * Description: <b>Implementation guides supported</b><br> 8807 * Type: <b>reference</b><br> 8808 * Path: <b>CapabilityStatement.implementationGuide</b><br> 8809 * </p> 8810 */ 8811 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam GUIDE = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_GUIDE); 8812 8813/** 8814 * Constant for fluent queries to be used to add include statements. Specifies 8815 * the path value of "<b>CapabilityStatement:guide</b>". 8816 */ 8817 public static final ca.uhn.fhir.model.api.Include INCLUDE_GUIDE = new ca.uhn.fhir.model.api.Include("CapabilityStatement:guide").toLocked(); 8818 8819 /** 8820 * Search parameter: <b>mode</b> 8821 * <p> 8822 * Description: <b>Mode - restful (server/client) or messaging (sender/receiver)</b><br> 8823 * Type: <b>token</b><br> 8824 * Path: <b>CapabilityStatement.rest.mode</b><br> 8825 * </p> 8826 */ 8827 @SearchParamDefinition(name="mode", path="CapabilityStatement.rest.mode", description="Mode - restful (server/client) or messaging (sender/receiver)", type="token" ) 8828 public static final String SP_MODE = "mode"; 8829 /** 8830 * <b>Fluent Client</b> search parameter constant for <b>mode</b> 8831 * <p> 8832 * Description: <b>Mode - restful (server/client) or messaging (sender/receiver)</b><br> 8833 * Type: <b>token</b><br> 8834 * Path: <b>CapabilityStatement.rest.mode</b><br> 8835 * </p> 8836 */ 8837 public static final ca.uhn.fhir.rest.gclient.TokenClientParam MODE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_MODE); 8838 8839 /** 8840 * Search parameter: <b>resource-profile</b> 8841 * <p> 8842 * Description: <b>A profile id invoked in a capability statement</b><br> 8843 * Type: <b>reference</b><br> 8844 * Path: <b>CapabilityStatement.rest.resource.profile</b><br> 8845 * </p> 8846 */ 8847 @SearchParamDefinition(name="resource-profile", path="CapabilityStatement.rest.resource.profile", description="A profile id invoked in a capability statement", type="reference", target={StructureDefinition.class } ) 8848 public static final String SP_RESOURCE_PROFILE = "resource-profile"; 8849 /** 8850 * <b>Fluent Client</b> search parameter constant for <b>resource-profile</b> 8851 * <p> 8852 * Description: <b>A profile id invoked in a capability statement</b><br> 8853 * Type: <b>reference</b><br> 8854 * Path: <b>CapabilityStatement.rest.resource.profile</b><br> 8855 * </p> 8856 */ 8857 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam RESOURCE_PROFILE = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_RESOURCE_PROFILE); 8858 8859/** 8860 * Constant for fluent queries to be used to add include statements. Specifies 8861 * the path value of "<b>CapabilityStatement:resource-profile</b>". 8862 */ 8863 public static final ca.uhn.fhir.model.api.Include INCLUDE_RESOURCE_PROFILE = new ca.uhn.fhir.model.api.Include("CapabilityStatement:resource-profile").toLocked(); 8864 8865 /** 8866 * Search parameter: <b>resource</b> 8867 * <p> 8868 * Description: <b>Name of a resource mentioned in a capability statement</b><br> 8869 * Type: <b>token</b><br> 8870 * Path: <b>CapabilityStatement.rest.resource.type</b><br> 8871 * </p> 8872 */ 8873 @SearchParamDefinition(name="resource", path="CapabilityStatement.rest.resource.type", description="Name of a resource mentioned in a capability statement", type="token" ) 8874 public static final String SP_RESOURCE = "resource"; 8875 /** 8876 * <b>Fluent Client</b> search parameter constant for <b>resource</b> 8877 * <p> 8878 * Description: <b>Name of a resource mentioned in a capability statement</b><br> 8879 * Type: <b>token</b><br> 8880 * Path: <b>CapabilityStatement.rest.resource.type</b><br> 8881 * </p> 8882 */ 8883 public static final ca.uhn.fhir.rest.gclient.TokenClientParam RESOURCE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_RESOURCE); 8884 8885 /** 8886 * Search parameter: <b>security-service</b> 8887 * <p> 8888 * Description: <b>OAuth | SMART-on-FHIR | NTLM | Basic | Kerberos | Certificates</b><br> 8889 * Type: <b>token</b><br> 8890 * Path: <b>CapabilityStatement.rest.security.service</b><br> 8891 * </p> 8892 */ 8893 @SearchParamDefinition(name="security-service", path="CapabilityStatement.rest.security.service", description="OAuth | SMART-on-FHIR | NTLM | Basic | Kerberos | Certificates", type="token" ) 8894 public static final String SP_SECURITY_SERVICE = "security-service"; 8895 /** 8896 * <b>Fluent Client</b> search parameter constant for <b>security-service</b> 8897 * <p> 8898 * Description: <b>OAuth | SMART-on-FHIR | NTLM | Basic | Kerberos | Certificates</b><br> 8899 * Type: <b>token</b><br> 8900 * Path: <b>CapabilityStatement.rest.security.service</b><br> 8901 * </p> 8902 */ 8903 public static final ca.uhn.fhir.rest.gclient.TokenClientParam SECURITY_SERVICE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_SECURITY_SERVICE); 8904 8905 /** 8906 * Search parameter: <b>software</b> 8907 * <p> 8908 * Description: <b>Part of the name of a software application</b><br> 8909 * Type: <b>string</b><br> 8910 * Path: <b>CapabilityStatement.software.name</b><br> 8911 * </p> 8912 */ 8913 @SearchParamDefinition(name="software", path="CapabilityStatement.software.name", description="Part of the name of a software application", type="string" ) 8914 public static final String SP_SOFTWARE = "software"; 8915 /** 8916 * <b>Fluent Client</b> search parameter constant for <b>software</b> 8917 * <p> 8918 * Description: <b>Part of the name of a software application</b><br> 8919 * Type: <b>string</b><br> 8920 * Path: <b>CapabilityStatement.software.name</b><br> 8921 * </p> 8922 */ 8923 public static final ca.uhn.fhir.rest.gclient.StringClientParam SOFTWARE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_SOFTWARE); 8924 8925 /** 8926 * Search parameter: <b>supported-profile</b> 8927 * <p> 8928 * Description: <b>Profiles for use cases supported</b><br> 8929 * Type: <b>reference</b><br> 8930 * Path: <b>CapabilityStatement.rest.resource.supportedProfile</b><br> 8931 * </p> 8932 */ 8933 @SearchParamDefinition(name="supported-profile", path="CapabilityStatement.rest.resource.supportedProfile", description="Profiles for use cases supported", type="reference", target={StructureDefinition.class } ) 8934 public static final String SP_SUPPORTED_PROFILE = "supported-profile"; 8935 /** 8936 * <b>Fluent Client</b> search parameter constant for <b>supported-profile</b> 8937 * <p> 8938 * Description: <b>Profiles for use cases supported</b><br> 8939 * Type: <b>reference</b><br> 8940 * Path: <b>CapabilityStatement.rest.resource.supportedProfile</b><br> 8941 * </p> 8942 */ 8943 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SUPPORTED_PROFILE = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_SUPPORTED_PROFILE); 8944 8945/** 8946 * Constant for fluent queries to be used to add include statements. Specifies 8947 * the path value of "<b>CapabilityStatement:supported-profile</b>". 8948 */ 8949 public static final ca.uhn.fhir.model.api.Include INCLUDE_SUPPORTED_PROFILE = new ca.uhn.fhir.model.api.Include("CapabilityStatement:supported-profile").toLocked(); 8950 8951 /** 8952 * Search parameter: <b>context-quantity</b> 8953 * <p> 8954 * Description: <b>Multiple Resources: 8955 8956* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement 8957* [CodeSystem](codesystem.html): A quantity- or range-valued use context assigned to the code system 8958* [CompartmentDefinition](compartmentdefinition.html): A quantity- or range-valued use context assigned to the compartment definition 8959* [ConceptMap](conceptmap.html): A quantity- or range-valued use context assigned to the concept map 8960* [GraphDefinition](graphdefinition.html): A quantity- or range-valued use context assigned to the graph definition 8961* [ImplementationGuide](implementationguide.html): A quantity- or range-valued use context assigned to the implementation guide 8962* [MessageDefinition](messagedefinition.html): A quantity- or range-valued use context assigned to the message definition 8963* [NamingSystem](namingsystem.html): A quantity- or range-valued use context assigned to the naming system 8964* [OperationDefinition](operationdefinition.html): A quantity- or range-valued use context assigned to the operation definition 8965* [SearchParameter](searchparameter.html): A quantity- or range-valued use context assigned to the search parameter 8966* [StructureDefinition](structuredefinition.html): A quantity- or range-valued use context assigned to the structure definition 8967* [StructureMap](structuremap.html): A quantity- or range-valued use context assigned to the structure map 8968* [TerminologyCapabilities](terminologycapabilities.html): A quantity- or range-valued use context assigned to the terminology capabilities 8969* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set 8970</b><br> 8971 * Type: <b>quantity</b><br> 8972 * Path: <b>(CapabilityStatement.useContext.value as Quantity) | (CapabilityStatement.useContext.value as Range) | (CodeSystem.useContext.value as Quantity) | (CodeSystem.useContext.value as Range) | (CompartmentDefinition.useContext.value as Quantity) | (CompartmentDefinition.useContext.value as Range) | (ConceptMap.useContext.value as Quantity) | (ConceptMap.useContext.value as Range) | (GraphDefinition.useContext.value as Quantity) | (GraphDefinition.useContext.value as Range) | (ImplementationGuide.useContext.value as Quantity) | (ImplementationGuide.useContext.value as Range) | (MessageDefinition.useContext.value as Quantity) | (MessageDefinition.useContext.value as Range) | (NamingSystem.useContext.value as Quantity) | (NamingSystem.useContext.value as Range) | (OperationDefinition.useContext.value as Quantity) | (OperationDefinition.useContext.value as Range) | (SearchParameter.useContext.value as Quantity) | (SearchParameter.useContext.value as Range) | (StructureDefinition.useContext.value as Quantity) | (StructureDefinition.useContext.value as Range) | (StructureMap.useContext.value as Quantity) | (StructureMap.useContext.value as Range) | (TerminologyCapabilities.useContext.value as Quantity) | (TerminologyCapabilities.useContext.value as Range) | (ValueSet.useContext.value as Quantity) | (ValueSet.useContext.value as Range)</b><br> 8973 * </p> 8974 */ 8975 @SearchParamDefinition(name="context-quantity", path="(CapabilityStatement.useContext.value as Quantity) | (CapabilityStatement.useContext.value as Range) | (CodeSystem.useContext.value as Quantity) | (CodeSystem.useContext.value as Range) | (CompartmentDefinition.useContext.value as Quantity) | (CompartmentDefinition.useContext.value as Range) | (ConceptMap.useContext.value as Quantity) | (ConceptMap.useContext.value as Range) | (GraphDefinition.useContext.value as Quantity) | (GraphDefinition.useContext.value as Range) | (ImplementationGuide.useContext.value as Quantity) | (ImplementationGuide.useContext.value as Range) | (MessageDefinition.useContext.value as Quantity) | (MessageDefinition.useContext.value as Range) | (NamingSystem.useContext.value as Quantity) | (NamingSystem.useContext.value as Range) | (OperationDefinition.useContext.value as Quantity) | (OperationDefinition.useContext.value as Range) | (SearchParameter.useContext.value as Quantity) | (SearchParameter.useContext.value as Range) | (StructureDefinition.useContext.value as Quantity) | (StructureDefinition.useContext.value as Range) | (StructureMap.useContext.value as Quantity) | (StructureMap.useContext.value as Range) | (TerminologyCapabilities.useContext.value as Quantity) | (TerminologyCapabilities.useContext.value as Range) | (ValueSet.useContext.value as Quantity) | (ValueSet.useContext.value as Range)", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement\r\n* [CodeSystem](codesystem.html): A quantity- or range-valued use context assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A quantity- or range-valued use context assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A quantity- or range-valued use context assigned to the concept map\r\n* [GraphDefinition](graphdefinition.html): A quantity- or range-valued use context assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A quantity- or range-valued use context assigned to the implementation guide\r\n* [MessageDefinition](messagedefinition.html): A quantity- or range-valued use context assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A quantity- or range-valued use context assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A quantity- or range-valued use context assigned to the operation definition\r\n* [SearchParameter](searchparameter.html): A quantity- or range-valued use context assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A quantity- or range-valued use context assigned to the structure definition\r\n* [StructureMap](structuremap.html): A quantity- or range-valued use context assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A quantity- or range-valued use context assigned to the terminology capabilities\r\n* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set\r\n", type="quantity" ) 8976 public static final String SP_CONTEXT_QUANTITY = "context-quantity"; 8977 /** 8978 * <b>Fluent Client</b> search parameter constant for <b>context-quantity</b> 8979 * <p> 8980 * Description: <b>Multiple Resources: 8981 8982* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement 8983* [CodeSystem](codesystem.html): A quantity- or range-valued use context assigned to the code system 8984* [CompartmentDefinition](compartmentdefinition.html): A quantity- or range-valued use context assigned to the compartment definition 8985* [ConceptMap](conceptmap.html): A quantity- or range-valued use context assigned to the concept map 8986* [GraphDefinition](graphdefinition.html): A quantity- or range-valued use context assigned to the graph definition 8987* [ImplementationGuide](implementationguide.html): A quantity- or range-valued use context assigned to the implementation guide 8988* [MessageDefinition](messagedefinition.html): A quantity- or range-valued use context assigned to the message definition 8989* [NamingSystem](namingsystem.html): A quantity- or range-valued use context assigned to the naming system 8990* [OperationDefinition](operationdefinition.html): A quantity- or range-valued use context assigned to the operation definition 8991* [SearchParameter](searchparameter.html): A quantity- or range-valued use context assigned to the search parameter 8992* [StructureDefinition](structuredefinition.html): A quantity- or range-valued use context assigned to the structure definition 8993* [StructureMap](structuremap.html): A quantity- or range-valued use context assigned to the structure map 8994* [TerminologyCapabilities](terminologycapabilities.html): A quantity- or range-valued use context assigned to the terminology capabilities 8995* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set 8996</b><br> 8997 * Type: <b>quantity</b><br> 8998 * Path: <b>(CapabilityStatement.useContext.value as Quantity) | (CapabilityStatement.useContext.value as Range) | (CodeSystem.useContext.value as Quantity) | (CodeSystem.useContext.value as Range) | (CompartmentDefinition.useContext.value as Quantity) | (CompartmentDefinition.useContext.value as Range) | (ConceptMap.useContext.value as Quantity) | (ConceptMap.useContext.value as Range) | (GraphDefinition.useContext.value as Quantity) | (GraphDefinition.useContext.value as Range) | (ImplementationGuide.useContext.value as Quantity) | (ImplementationGuide.useContext.value as Range) | (MessageDefinition.useContext.value as Quantity) | (MessageDefinition.useContext.value as Range) | (NamingSystem.useContext.value as Quantity) | (NamingSystem.useContext.value as Range) | (OperationDefinition.useContext.value as Quantity) | (OperationDefinition.useContext.value as Range) | (SearchParameter.useContext.value as Quantity) | (SearchParameter.useContext.value as Range) | (StructureDefinition.useContext.value as Quantity) | (StructureDefinition.useContext.value as Range) | (StructureMap.useContext.value as Quantity) | (StructureMap.useContext.value as Range) | (TerminologyCapabilities.useContext.value as Quantity) | (TerminologyCapabilities.useContext.value as Range) | (ValueSet.useContext.value as Quantity) | (ValueSet.useContext.value as Range)</b><br> 8999 * </p> 9000 */ 9001 public static final ca.uhn.fhir.rest.gclient.QuantityClientParam CONTEXT_QUANTITY = new ca.uhn.fhir.rest.gclient.QuantityClientParam(SP_CONTEXT_QUANTITY); 9002 9003 /** 9004 * Search parameter: <b>context-type-quantity</b> 9005 * <p> 9006 * Description: <b>Multiple Resources: 9007 9008* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement 9009* [CodeSystem](codesystem.html): A use context type and quantity- or range-based value assigned to the code system 9010* [CompartmentDefinition](compartmentdefinition.html): A use context type and quantity- or range-based value assigned to the compartment definition 9011* [ConceptMap](conceptmap.html): A use context type and quantity- or range-based value assigned to the concept map 9012* [GraphDefinition](graphdefinition.html): A use context type and quantity- or range-based value assigned to the graph definition 9013* [ImplementationGuide](implementationguide.html): A use context type and quantity- or range-based value assigned to the implementation guide 9014* [MessageDefinition](messagedefinition.html): A use context type and quantity- or range-based value assigned to the message definition 9015* [NamingSystem](namingsystem.html): A use context type and quantity- or range-based value assigned to the naming system 9016* [OperationDefinition](operationdefinition.html): A use context type and quantity- or range-based value assigned to the operation definition 9017* [SearchParameter](searchparameter.html): A use context type and quantity- or range-based value assigned to the search parameter 9018* [StructureDefinition](structuredefinition.html): A use context type and quantity- or range-based value assigned to the structure definition 9019* [StructureMap](structuremap.html): A use context type and quantity- or range-based value assigned to the structure map 9020* [TerminologyCapabilities](terminologycapabilities.html): A use context type and quantity- or range-based value assigned to the terminology capabilities 9021* [ValueSet](valueset.html): A use context type and quantity- or range-based value assigned to the value set 9022</b><br> 9023 * Type: <b>composite</b><br> 9024 * Path: <b>CapabilityStatement.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | ValueSet.useContext</b><br> 9025 * </p> 9026 */ 9027 @SearchParamDefinition(name="context-type-quantity", path="CapabilityStatement.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | ValueSet.useContext", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement\r\n* [CodeSystem](codesystem.html): A use context type and quantity- or range-based value assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A use context type and quantity- or range-based value assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A use context type and quantity- or range-based value assigned to the concept map\r\n* [GraphDefinition](graphdefinition.html): A use context type and quantity- or range-based value assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A use context type and quantity- or range-based value assigned to the implementation guide\r\n* [MessageDefinition](messagedefinition.html): A use context type and quantity- or range-based value assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A use context type and quantity- or range-based value assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A use context type and quantity- or range-based value assigned to the operation definition\r\n* [SearchParameter](searchparameter.html): A use context type and quantity- or range-based value assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A use context type and quantity- or range-based value assigned to the structure definition\r\n* [StructureMap](structuremap.html): A use context type and quantity- or range-based value assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A use context type and quantity- or range-based value assigned to the terminology capabilities\r\n* [ValueSet](valueset.html): A use context type and quantity- or range-based value assigned to the value set\r\n", type="composite", compositeOf={"context-type", "context-quantity"} ) 9028 public static final String SP_CONTEXT_TYPE_QUANTITY = "context-type-quantity"; 9029 /** 9030 * <b>Fluent Client</b> search parameter constant for <b>context-type-quantity</b> 9031 * <p> 9032 * Description: <b>Multiple Resources: 9033 9034* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement 9035* [CodeSystem](codesystem.html): A use context type and quantity- or range-based value assigned to the code system 9036* [CompartmentDefinition](compartmentdefinition.html): A use context type and quantity- or range-based value assigned to the compartment definition 9037* [ConceptMap](conceptmap.html): A use context type and quantity- or range-based value assigned to the concept map 9038* [GraphDefinition](graphdefinition.html): A use context type and quantity- or range-based value assigned to the graph definition 9039* [ImplementationGuide](implementationguide.html): A use context type and quantity- or range-based value assigned to the implementation guide 9040* [MessageDefinition](messagedefinition.html): A use context type and quantity- or range-based value assigned to the message definition 9041* [NamingSystem](namingsystem.html): A use context type and quantity- or range-based value assigned to the naming system 9042* [OperationDefinition](operationdefinition.html): A use context type and quantity- or range-based value assigned to the operation definition 9043* [SearchParameter](searchparameter.html): A use context type and quantity- or range-based value assigned to the search parameter 9044* [StructureDefinition](structuredefinition.html): A use context type and quantity- or range-based value assigned to the structure definition 9045* [StructureMap](structuremap.html): A use context type and quantity- or range-based value assigned to the structure map 9046* [TerminologyCapabilities](terminologycapabilities.html): A use context type and quantity- or range-based value assigned to the terminology capabilities 9047* [ValueSet](valueset.html): A use context type and quantity- or range-based value assigned to the value set 9048</b><br> 9049 * Type: <b>composite</b><br> 9050 * Path: <b>CapabilityStatement.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | ValueSet.useContext</b><br> 9051 * </p> 9052 */ 9053 public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.QuantityClientParam> CONTEXT_TYPE_QUANTITY = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.QuantityClientParam>(SP_CONTEXT_TYPE_QUANTITY); 9054 9055 /** 9056 * Search parameter: <b>context-type-value</b> 9057 * <p> 9058 * Description: <b>Multiple Resources: 9059 9060* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement 9061* [CodeSystem](codesystem.html): A use context type and value assigned to the code system 9062* [CompartmentDefinition](compartmentdefinition.html): A use context type and value assigned to the compartment definition 9063* [ConceptMap](conceptmap.html): A use context type and value assigned to the concept map 9064* [GraphDefinition](graphdefinition.html): A use context type and value assigned to the graph definition 9065* [ImplementationGuide](implementationguide.html): A use context type and value assigned to the implementation guide 9066* [MessageDefinition](messagedefinition.html): A use context type and value assigned to the message definition 9067* [NamingSystem](namingsystem.html): A use context type and value assigned to the naming system 9068* [OperationDefinition](operationdefinition.html): A use context type and value assigned to the operation definition 9069* [SearchParameter](searchparameter.html): A use context type and value assigned to the search parameter 9070* [StructureDefinition](structuredefinition.html): A use context type and value assigned to the structure definition 9071* [StructureMap](structuremap.html): A use context type and value assigned to the structure map 9072* [TerminologyCapabilities](terminologycapabilities.html): A use context type and value assigned to the terminology capabilities 9073* [ValueSet](valueset.html): A use context type and value assigned to the value set 9074</b><br> 9075 * Type: <b>composite</b><br> 9076 * Path: <b>CapabilityStatement.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | ValueSet.useContext</b><br> 9077 * </p> 9078 */ 9079 @SearchParamDefinition(name="context-type-value", path="CapabilityStatement.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | ValueSet.useContext", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement\r\n* [CodeSystem](codesystem.html): A use context type and value assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A use context type and value assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A use context type and value assigned to the concept map\r\n* [GraphDefinition](graphdefinition.html): A use context type and value assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A use context type and value assigned to the implementation guide\r\n* [MessageDefinition](messagedefinition.html): A use context type and value assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A use context type and value assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A use context type and value assigned to the operation definition\r\n* [SearchParameter](searchparameter.html): A use context type and value assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A use context type and value assigned to the structure definition\r\n* [StructureMap](structuremap.html): A use context type and value assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A use context type and value assigned to the terminology capabilities\r\n* [ValueSet](valueset.html): A use context type and value assigned to the value set\r\n", type="composite", compositeOf={"context-type", "context"} ) 9080 public static final String SP_CONTEXT_TYPE_VALUE = "context-type-value"; 9081 /** 9082 * <b>Fluent Client</b> search parameter constant for <b>context-type-value</b> 9083 * <p> 9084 * Description: <b>Multiple Resources: 9085 9086* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement 9087* [CodeSystem](codesystem.html): A use context type and value assigned to the code system 9088* [CompartmentDefinition](compartmentdefinition.html): A use context type and value assigned to the compartment definition 9089* [ConceptMap](conceptmap.html): A use context type and value assigned to the concept map 9090* [GraphDefinition](graphdefinition.html): A use context type and value assigned to the graph definition 9091* [ImplementationGuide](implementationguide.html): A use context type and value assigned to the implementation guide 9092* [MessageDefinition](messagedefinition.html): A use context type and value assigned to the message definition 9093* [NamingSystem](namingsystem.html): A use context type and value assigned to the naming system 9094* [OperationDefinition](operationdefinition.html): A use context type and value assigned to the operation definition 9095* [SearchParameter](searchparameter.html): A use context type and value assigned to the search parameter 9096* [StructureDefinition](structuredefinition.html): A use context type and value assigned to the structure definition 9097* [StructureMap](structuremap.html): A use context type and value assigned to the structure map 9098* [TerminologyCapabilities](terminologycapabilities.html): A use context type and value assigned to the terminology capabilities 9099* [ValueSet](valueset.html): A use context type and value assigned to the value set 9100</b><br> 9101 * Type: <b>composite</b><br> 9102 * Path: <b>CapabilityStatement.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | ValueSet.useContext</b><br> 9103 * </p> 9104 */ 9105 public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.TokenClientParam> CONTEXT_TYPE_VALUE = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.TokenClientParam>(SP_CONTEXT_TYPE_VALUE); 9106 9107 /** 9108 * Search parameter: <b>context-type</b> 9109 * <p> 9110 * Description: <b>Multiple Resources: 9111 9112* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement 9113* [CodeSystem](codesystem.html): A type of use context assigned to the code system 9114* [CompartmentDefinition](compartmentdefinition.html): A type of use context assigned to the compartment definition 9115* [ConceptMap](conceptmap.html): A type of use context assigned to the concept map 9116* [GraphDefinition](graphdefinition.html): A type of use context assigned to the graph definition 9117* [ImplementationGuide](implementationguide.html): A type of use context assigned to the implementation guide 9118* [MessageDefinition](messagedefinition.html): A type of use context assigned to the message definition 9119* [NamingSystem](namingsystem.html): A type of use context assigned to the naming system 9120* [OperationDefinition](operationdefinition.html): A type of use context assigned to the operation definition 9121* [SearchParameter](searchparameter.html): A type of use context assigned to the search parameter 9122* [StructureDefinition](structuredefinition.html): A type of use context assigned to the structure definition 9123* [StructureMap](structuremap.html): A type of use context assigned to the structure map 9124* [TerminologyCapabilities](terminologycapabilities.html): A type of use context assigned to the terminology capabilities 9125* [ValueSet](valueset.html): A type of use context assigned to the value set 9126</b><br> 9127 * Type: <b>token</b><br> 9128 * Path: <b>CapabilityStatement.useContext.code | CodeSystem.useContext.code | CompartmentDefinition.useContext.code | ConceptMap.useContext.code | GraphDefinition.useContext.code | ImplementationGuide.useContext.code | MessageDefinition.useContext.code | NamingSystem.useContext.code | OperationDefinition.useContext.code | SearchParameter.useContext.code | StructureDefinition.useContext.code | StructureMap.useContext.code | TerminologyCapabilities.useContext.code | ValueSet.useContext.code</b><br> 9129 * </p> 9130 */ 9131 @SearchParamDefinition(name="context-type", path="CapabilityStatement.useContext.code | CodeSystem.useContext.code | CompartmentDefinition.useContext.code | ConceptMap.useContext.code | GraphDefinition.useContext.code | ImplementationGuide.useContext.code | MessageDefinition.useContext.code | NamingSystem.useContext.code | OperationDefinition.useContext.code | SearchParameter.useContext.code | StructureDefinition.useContext.code | StructureMap.useContext.code | TerminologyCapabilities.useContext.code | ValueSet.useContext.code", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement\r\n* [CodeSystem](codesystem.html): A type of use context assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A type of use context assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A type of use context assigned to the concept map\r\n* [GraphDefinition](graphdefinition.html): A type of use context assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A type of use context assigned to the implementation guide\r\n* [MessageDefinition](messagedefinition.html): A type of use context assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A type of use context assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A type of use context assigned to the operation definition\r\n* [SearchParameter](searchparameter.html): A type of use context assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A type of use context assigned to the structure definition\r\n* [StructureMap](structuremap.html): A type of use context assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A type of use context assigned to the terminology capabilities\r\n* [ValueSet](valueset.html): A type of use context assigned to the value set\r\n", type="token" ) 9132 public static final String SP_CONTEXT_TYPE = "context-type"; 9133 /** 9134 * <b>Fluent Client</b> search parameter constant for <b>context-type</b> 9135 * <p> 9136 * Description: <b>Multiple Resources: 9137 9138* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement 9139* [CodeSystem](codesystem.html): A type of use context assigned to the code system 9140* [CompartmentDefinition](compartmentdefinition.html): A type of use context assigned to the compartment definition 9141* [ConceptMap](conceptmap.html): A type of use context assigned to the concept map 9142* [GraphDefinition](graphdefinition.html): A type of use context assigned to the graph definition 9143* [ImplementationGuide](implementationguide.html): A type of use context assigned to the implementation guide 9144* [MessageDefinition](messagedefinition.html): A type of use context assigned to the message definition 9145* [NamingSystem](namingsystem.html): A type of use context assigned to the naming system 9146* [OperationDefinition](operationdefinition.html): A type of use context assigned to the operation definition 9147* [SearchParameter](searchparameter.html): A type of use context assigned to the search parameter 9148* [StructureDefinition](structuredefinition.html): A type of use context assigned to the structure definition 9149* [StructureMap](structuremap.html): A type of use context assigned to the structure map 9150* [TerminologyCapabilities](terminologycapabilities.html): A type of use context assigned to the terminology capabilities 9151* [ValueSet](valueset.html): A type of use context assigned to the value set 9152</b><br> 9153 * Type: <b>token</b><br> 9154 * Path: <b>CapabilityStatement.useContext.code | CodeSystem.useContext.code | CompartmentDefinition.useContext.code | ConceptMap.useContext.code | GraphDefinition.useContext.code | ImplementationGuide.useContext.code | MessageDefinition.useContext.code | NamingSystem.useContext.code | OperationDefinition.useContext.code | SearchParameter.useContext.code | StructureDefinition.useContext.code | StructureMap.useContext.code | TerminologyCapabilities.useContext.code | ValueSet.useContext.code</b><br> 9155 * </p> 9156 */ 9157 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT_TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT_TYPE); 9158 9159 /** 9160 * Search parameter: <b>context</b> 9161 * <p> 9162 * Description: <b>Multiple Resources: 9163 9164* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement 9165* [CodeSystem](codesystem.html): A use context assigned to the code system 9166* [CompartmentDefinition](compartmentdefinition.html): A use context assigned to the compartment definition 9167* [ConceptMap](conceptmap.html): A use context assigned to the concept map 9168* [GraphDefinition](graphdefinition.html): A use context assigned to the graph definition 9169* [ImplementationGuide](implementationguide.html): A use context assigned to the implementation guide 9170* [MessageDefinition](messagedefinition.html): A use context assigned to the message definition 9171* [NamingSystem](namingsystem.html): A use context assigned to the naming system 9172* [OperationDefinition](operationdefinition.html): A use context assigned to the operation definition 9173* [SearchParameter](searchparameter.html): A use context assigned to the search parameter 9174* [StructureDefinition](structuredefinition.html): A use context assigned to the structure definition 9175* [StructureMap](structuremap.html): A use context assigned to the structure map 9176* [TerminologyCapabilities](terminologycapabilities.html): A use context assigned to the terminology capabilities 9177* [ValueSet](valueset.html): A use context assigned to the value set 9178</b><br> 9179 * Type: <b>token</b><br> 9180 * Path: <b>(CapabilityStatement.useContext.value as CodeableConcept) | (CodeSystem.useContext.value as CodeableConcept) | (CompartmentDefinition.useContext.value as CodeableConcept) | (ConceptMap.useContext.value as CodeableConcept) | (GraphDefinition.useContext.value as CodeableConcept) | (ImplementationGuide.useContext.value as CodeableConcept) | (MessageDefinition.useContext.value as CodeableConcept) | (NamingSystem.useContext.value as CodeableConcept) | (OperationDefinition.useContext.value as CodeableConcept) | (SearchParameter.useContext.value as CodeableConcept) | (StructureDefinition.useContext.value as CodeableConcept) | (StructureMap.useContext.value as CodeableConcept) | (TerminologyCapabilities.useContext.value as CodeableConcept) | (ValueSet.useContext.value as CodeableConcept)</b><br> 9181 * </p> 9182 */ 9183 @SearchParamDefinition(name="context", path="(CapabilityStatement.useContext.value as CodeableConcept) | (CodeSystem.useContext.value as CodeableConcept) | (CompartmentDefinition.useContext.value as CodeableConcept) | (ConceptMap.useContext.value as CodeableConcept) | (GraphDefinition.useContext.value as CodeableConcept) | (ImplementationGuide.useContext.value as CodeableConcept) | (MessageDefinition.useContext.value as CodeableConcept) | (NamingSystem.useContext.value as CodeableConcept) | (OperationDefinition.useContext.value as CodeableConcept) | (SearchParameter.useContext.value as CodeableConcept) | (StructureDefinition.useContext.value as CodeableConcept) | (StructureMap.useContext.value as CodeableConcept) | (TerminologyCapabilities.useContext.value as CodeableConcept) | (ValueSet.useContext.value as CodeableConcept)", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement\r\n* [CodeSystem](codesystem.html): A use context assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A use context assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A use context assigned to the concept map\r\n* [GraphDefinition](graphdefinition.html): A use context assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A use context assigned to the implementation guide\r\n* [MessageDefinition](messagedefinition.html): A use context assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A use context assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A use context assigned to the operation definition\r\n* [SearchParameter](searchparameter.html): A use context assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A use context assigned to the structure definition\r\n* [StructureMap](structuremap.html): A use context assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A use context assigned to the terminology capabilities\r\n* [ValueSet](valueset.html): A use context assigned to the value set\r\n", type="token" ) 9184 public static final String SP_CONTEXT = "context"; 9185 /** 9186 * <b>Fluent Client</b> search parameter constant for <b>context</b> 9187 * <p> 9188 * Description: <b>Multiple Resources: 9189 9190* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement 9191* [CodeSystem](codesystem.html): A use context assigned to the code system 9192* [CompartmentDefinition](compartmentdefinition.html): A use context assigned to the compartment definition 9193* [ConceptMap](conceptmap.html): A use context assigned to the concept map 9194* [GraphDefinition](graphdefinition.html): A use context assigned to the graph definition 9195* [ImplementationGuide](implementationguide.html): A use context assigned to the implementation guide 9196* [MessageDefinition](messagedefinition.html): A use context assigned to the message definition 9197* [NamingSystem](namingsystem.html): A use context assigned to the naming system 9198* [OperationDefinition](operationdefinition.html): A use context assigned to the operation definition 9199* [SearchParameter](searchparameter.html): A use context assigned to the search parameter 9200* [StructureDefinition](structuredefinition.html): A use context assigned to the structure definition 9201* [StructureMap](structuremap.html): A use context assigned to the structure map 9202* [TerminologyCapabilities](terminologycapabilities.html): A use context assigned to the terminology capabilities 9203* [ValueSet](valueset.html): A use context assigned to the value set 9204</b><br> 9205 * Type: <b>token</b><br> 9206 * Path: <b>(CapabilityStatement.useContext.value as CodeableConcept) | (CodeSystem.useContext.value as CodeableConcept) | (CompartmentDefinition.useContext.value as CodeableConcept) | (ConceptMap.useContext.value as CodeableConcept) | (GraphDefinition.useContext.value as CodeableConcept) | (ImplementationGuide.useContext.value as CodeableConcept) | (MessageDefinition.useContext.value as CodeableConcept) | (NamingSystem.useContext.value as CodeableConcept) | (OperationDefinition.useContext.value as CodeableConcept) | (SearchParameter.useContext.value as CodeableConcept) | (StructureDefinition.useContext.value as CodeableConcept) | (StructureMap.useContext.value as CodeableConcept) | (TerminologyCapabilities.useContext.value as CodeableConcept) | (ValueSet.useContext.value as CodeableConcept)</b><br> 9207 * </p> 9208 */ 9209 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT); 9210 9211 /** 9212 * Search parameter: <b>date</b> 9213 * <p> 9214 * Description: <b>Multiple Resources: 9215 9216* [CapabilityStatement](capabilitystatement.html): The capability statement publication date 9217* [CodeSystem](codesystem.html): The code system publication date 9218* [CompartmentDefinition](compartmentdefinition.html): The compartment definition publication date 9219* [ConceptMap](conceptmap.html): The concept map publication date 9220* [GraphDefinition](graphdefinition.html): The graph definition publication date 9221* [ImplementationGuide](implementationguide.html): The implementation guide publication date 9222* [MessageDefinition](messagedefinition.html): The message definition publication date 9223* [NamingSystem](namingsystem.html): The naming system publication date 9224* [OperationDefinition](operationdefinition.html): The operation definition publication date 9225* [SearchParameter](searchparameter.html): The search parameter publication date 9226* [StructureDefinition](structuredefinition.html): The structure definition publication date 9227* [StructureMap](structuremap.html): The structure map publication date 9228* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date 9229* [ValueSet](valueset.html): The value set publication date 9230</b><br> 9231 * Type: <b>date</b><br> 9232 * Path: <b>CapabilityStatement.date | CodeSystem.date | CompartmentDefinition.date | ConceptMap.date | GraphDefinition.date | ImplementationGuide.date | MessageDefinition.date | NamingSystem.date | OperationDefinition.date | SearchParameter.date | StructureDefinition.date | StructureMap.date | TerminologyCapabilities.date | ValueSet.date</b><br> 9233 * </p> 9234 */ 9235 @SearchParamDefinition(name="date", path="CapabilityStatement.date | CodeSystem.date | CompartmentDefinition.date | ConceptMap.date | GraphDefinition.date | ImplementationGuide.date | MessageDefinition.date | NamingSystem.date | OperationDefinition.date | SearchParameter.date | StructureDefinition.date | StructureMap.date | TerminologyCapabilities.date | ValueSet.date", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): The capability statement publication date\r\n* [CodeSystem](codesystem.html): The code system publication date\r\n* [CompartmentDefinition](compartmentdefinition.html): The compartment definition publication date\r\n* [ConceptMap](conceptmap.html): The concept map publication date\r\n* [GraphDefinition](graphdefinition.html): The graph definition publication date\r\n* [ImplementationGuide](implementationguide.html): The implementation guide publication date\r\n* [MessageDefinition](messagedefinition.html): The message definition publication date\r\n* [NamingSystem](namingsystem.html): The naming system publication date\r\n* [OperationDefinition](operationdefinition.html): The operation definition publication date\r\n* [SearchParameter](searchparameter.html): The search parameter publication date\r\n* [StructureDefinition](structuredefinition.html): The structure definition publication date\r\n* [StructureMap](structuremap.html): The structure map publication date\r\n* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date\r\n* [ValueSet](valueset.html): The value set publication date\r\n", type="date" ) 9236 public static final String SP_DATE = "date"; 9237 /** 9238 * <b>Fluent Client</b> search parameter constant for <b>date</b> 9239 * <p> 9240 * Description: <b>Multiple Resources: 9241 9242* [CapabilityStatement](capabilitystatement.html): The capability statement publication date 9243* [CodeSystem](codesystem.html): The code system publication date 9244* [CompartmentDefinition](compartmentdefinition.html): The compartment definition publication date 9245* [ConceptMap](conceptmap.html): The concept map publication date 9246* [GraphDefinition](graphdefinition.html): The graph definition publication date 9247* [ImplementationGuide](implementationguide.html): The implementation guide publication date 9248* [MessageDefinition](messagedefinition.html): The message definition publication date 9249* [NamingSystem](namingsystem.html): The naming system publication date 9250* [OperationDefinition](operationdefinition.html): The operation definition publication date 9251* [SearchParameter](searchparameter.html): The search parameter publication date 9252* [StructureDefinition](structuredefinition.html): The structure definition publication date 9253* [StructureMap](structuremap.html): The structure map publication date 9254* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date 9255* [ValueSet](valueset.html): The value set publication date 9256</b><br> 9257 * Type: <b>date</b><br> 9258 * Path: <b>CapabilityStatement.date | CodeSystem.date | CompartmentDefinition.date | ConceptMap.date | GraphDefinition.date | ImplementationGuide.date | MessageDefinition.date | NamingSystem.date | OperationDefinition.date | SearchParameter.date | StructureDefinition.date | StructureMap.date | TerminologyCapabilities.date | ValueSet.date</b><br> 9259 * </p> 9260 */ 9261 public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE); 9262 9263 /** 9264 * Search parameter: <b>description</b> 9265 * <p> 9266 * Description: <b>Multiple Resources: 9267 9268* [CapabilityStatement](capabilitystatement.html): The description of the capability statement 9269* [CodeSystem](codesystem.html): The description of the code system 9270* [CompartmentDefinition](compartmentdefinition.html): The description of the compartment definition 9271* [ConceptMap](conceptmap.html): The description of the concept map 9272* [GraphDefinition](graphdefinition.html): The description of the graph definition 9273* [ImplementationGuide](implementationguide.html): The description of the implementation guide 9274* [MessageDefinition](messagedefinition.html): The description of the message definition 9275* [NamingSystem](namingsystem.html): The description of the naming system 9276* [OperationDefinition](operationdefinition.html): The description of the operation definition 9277* [SearchParameter](searchparameter.html): The description of the search parameter 9278* [StructureDefinition](structuredefinition.html): The description of the structure definition 9279* [StructureMap](structuremap.html): The description of the structure map 9280* [TerminologyCapabilities](terminologycapabilities.html): The description of the terminology capabilities 9281* [ValueSet](valueset.html): The description of the value set 9282</b><br> 9283 * Type: <b>string</b><br> 9284 * Path: <b>CapabilityStatement.description | CodeSystem.description | CompartmentDefinition.description | ConceptMap.description | GraphDefinition.description | ImplementationGuide.description | MessageDefinition.description | NamingSystem.description | OperationDefinition.description | SearchParameter.description | StructureDefinition.description | StructureMap.description | TerminologyCapabilities.description | ValueSet.description</b><br> 9285 * </p> 9286 */ 9287 @SearchParamDefinition(name="description", path="CapabilityStatement.description | CodeSystem.description | CompartmentDefinition.description | ConceptMap.description | GraphDefinition.description | ImplementationGuide.description | MessageDefinition.description | NamingSystem.description | OperationDefinition.description | SearchParameter.description | StructureDefinition.description | StructureMap.description | TerminologyCapabilities.description | ValueSet.description", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): The description of the capability statement\r\n* [CodeSystem](codesystem.html): The description of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): The description of the compartment definition\r\n* [ConceptMap](conceptmap.html): The description of the concept map\r\n* [GraphDefinition](graphdefinition.html): The description of the graph definition\r\n* [ImplementationGuide](implementationguide.html): The description of the implementation guide\r\n* [MessageDefinition](messagedefinition.html): The description of the message definition\r\n* [NamingSystem](namingsystem.html): The description of the naming system\r\n* [OperationDefinition](operationdefinition.html): The description of the operation definition\r\n* [SearchParameter](searchparameter.html): The description of the search parameter\r\n* [StructureDefinition](structuredefinition.html): The description of the structure definition\r\n* [StructureMap](structuremap.html): The description of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): The description of the terminology capabilities\r\n* [ValueSet](valueset.html): The description of the value set\r\n", type="string" ) 9288 public static final String SP_DESCRIPTION = "description"; 9289 /** 9290 * <b>Fluent Client</b> search parameter constant for <b>description</b> 9291 * <p> 9292 * Description: <b>Multiple Resources: 9293 9294* [CapabilityStatement](capabilitystatement.html): The description of the capability statement 9295* [CodeSystem](codesystem.html): The description of the code system 9296* [CompartmentDefinition](compartmentdefinition.html): The description of the compartment definition 9297* [ConceptMap](conceptmap.html): The description of the concept map 9298* [GraphDefinition](graphdefinition.html): The description of the graph definition 9299* [ImplementationGuide](implementationguide.html): The description of the implementation guide 9300* [MessageDefinition](messagedefinition.html): The description of the message definition 9301* [NamingSystem](namingsystem.html): The description of the naming system 9302* [OperationDefinition](operationdefinition.html): The description of the operation definition 9303* [SearchParameter](searchparameter.html): The description of the search parameter 9304* [StructureDefinition](structuredefinition.html): The description of the structure definition 9305* [StructureMap](structuremap.html): The description of the structure map 9306* [TerminologyCapabilities](terminologycapabilities.html): The description of the terminology capabilities 9307* [ValueSet](valueset.html): The description of the value set 9308</b><br> 9309 * Type: <b>string</b><br> 9310 * Path: <b>CapabilityStatement.description | CodeSystem.description | CompartmentDefinition.description | ConceptMap.description | GraphDefinition.description | ImplementationGuide.description | MessageDefinition.description | NamingSystem.description | OperationDefinition.description | SearchParameter.description | StructureDefinition.description | StructureMap.description | TerminologyCapabilities.description | ValueSet.description</b><br> 9311 * </p> 9312 */ 9313 public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION); 9314 9315 /** 9316 * Search parameter: <b>jurisdiction</b> 9317 * <p> 9318 * Description: <b>Multiple Resources: 9319 9320* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement 9321* [CodeSystem](codesystem.html): Intended jurisdiction for the code system 9322* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map 9323* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition 9324* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide 9325* [MessageDefinition](messagedefinition.html): Intended jurisdiction for the message definition 9326* [NamingSystem](namingsystem.html): Intended jurisdiction for the naming system 9327* [OperationDefinition](operationdefinition.html): Intended jurisdiction for the operation definition 9328* [SearchParameter](searchparameter.html): Intended jurisdiction for the search parameter 9329* [StructureDefinition](structuredefinition.html): Intended jurisdiction for the structure definition 9330* [StructureMap](structuremap.html): Intended jurisdiction for the structure map 9331* [TerminologyCapabilities](terminologycapabilities.html): Intended jurisdiction for the terminology capabilities 9332* [ValueSet](valueset.html): Intended jurisdiction for the value set 9333</b><br> 9334 * Type: <b>token</b><br> 9335 * Path: <b>CapabilityStatement.jurisdiction | CodeSystem.jurisdiction | ConceptMap.jurisdiction | GraphDefinition.jurisdiction | ImplementationGuide.jurisdiction | MessageDefinition.jurisdiction | NamingSystem.jurisdiction | OperationDefinition.jurisdiction | SearchParameter.jurisdiction | StructureDefinition.jurisdiction | StructureMap.jurisdiction | TerminologyCapabilities.jurisdiction | ValueSet.jurisdiction</b><br> 9336 * </p> 9337 */ 9338 @SearchParamDefinition(name="jurisdiction", path="CapabilityStatement.jurisdiction | CodeSystem.jurisdiction | ConceptMap.jurisdiction | GraphDefinition.jurisdiction | ImplementationGuide.jurisdiction | MessageDefinition.jurisdiction | NamingSystem.jurisdiction | OperationDefinition.jurisdiction | SearchParameter.jurisdiction | StructureDefinition.jurisdiction | StructureMap.jurisdiction | TerminologyCapabilities.jurisdiction | ValueSet.jurisdiction", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement\r\n* [CodeSystem](codesystem.html): Intended jurisdiction for the code system\r\n* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map\r\n* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition\r\n* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide\r\n* [MessageDefinition](messagedefinition.html): Intended jurisdiction for the message definition\r\n* [NamingSystem](namingsystem.html): Intended jurisdiction for the naming system\r\n* [OperationDefinition](operationdefinition.html): Intended jurisdiction for the operation definition\r\n* [SearchParameter](searchparameter.html): Intended jurisdiction for the search parameter\r\n* [StructureDefinition](structuredefinition.html): Intended jurisdiction for the structure definition\r\n* [StructureMap](structuremap.html): Intended jurisdiction for the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): Intended jurisdiction for the terminology capabilities\r\n* [ValueSet](valueset.html): Intended jurisdiction for the value set\r\n", type="token" ) 9339 public static final String SP_JURISDICTION = "jurisdiction"; 9340 /** 9341 * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b> 9342 * <p> 9343 * Description: <b>Multiple Resources: 9344 9345* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement 9346* [CodeSystem](codesystem.html): Intended jurisdiction for the code system 9347* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map 9348* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition 9349* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide 9350* [MessageDefinition](messagedefinition.html): Intended jurisdiction for the message definition 9351* [NamingSystem](namingsystem.html): Intended jurisdiction for the naming system 9352* [OperationDefinition](operationdefinition.html): Intended jurisdiction for the operation definition 9353* [SearchParameter](searchparameter.html): Intended jurisdiction for the search parameter 9354* [StructureDefinition](structuredefinition.html): Intended jurisdiction for the structure definition 9355* [StructureMap](structuremap.html): Intended jurisdiction for the structure map 9356* [TerminologyCapabilities](terminologycapabilities.html): Intended jurisdiction for the terminology capabilities 9357* [ValueSet](valueset.html): Intended jurisdiction for the value set 9358</b><br> 9359 * Type: <b>token</b><br> 9360 * Path: <b>CapabilityStatement.jurisdiction | CodeSystem.jurisdiction | ConceptMap.jurisdiction | GraphDefinition.jurisdiction | ImplementationGuide.jurisdiction | MessageDefinition.jurisdiction | NamingSystem.jurisdiction | OperationDefinition.jurisdiction | SearchParameter.jurisdiction | StructureDefinition.jurisdiction | StructureMap.jurisdiction | TerminologyCapabilities.jurisdiction | ValueSet.jurisdiction</b><br> 9361 * </p> 9362 */ 9363 public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_JURISDICTION); 9364 9365 /** 9366 * Search parameter: <b>name</b> 9367 * <p> 9368 * Description: <b>Multiple Resources: 9369 9370* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement 9371* [CodeSystem](codesystem.html): Computationally friendly name of the code system 9372* [CompartmentDefinition](compartmentdefinition.html): Computationally friendly name of the compartment definition 9373* [ConceptMap](conceptmap.html): Computationally friendly name of the concept map 9374* [GraphDefinition](graphdefinition.html): Computationally friendly name of the graph definition 9375* [ImplementationGuide](implementationguide.html): Computationally friendly name of the implementation guide 9376* [MessageDefinition](messagedefinition.html): Computationally friendly name of the message definition 9377* [NamingSystem](namingsystem.html): Computationally friendly name of the naming system 9378* [OperationDefinition](operationdefinition.html): Computationally friendly name of the operation definition 9379* [SearchParameter](searchparameter.html): Computationally friendly name of the search parameter 9380* [StructureDefinition](structuredefinition.html): Computationally friendly name of the structure definition 9381* [StructureMap](structuremap.html): Computationally friendly name of the structure map 9382* [TerminologyCapabilities](terminologycapabilities.html): Computationally friendly name of the terminology capabilities 9383* [ValueSet](valueset.html): Computationally friendly name of the value set 9384</b><br> 9385 * Type: <b>string</b><br> 9386 * Path: <b>CapabilityStatement.name | CodeSystem.name | CompartmentDefinition.name | ConceptMap.name | GraphDefinition.name | ImplementationGuide.name | MessageDefinition.name | NamingSystem.name | OperationDefinition.name | SearchParameter.name | StructureDefinition.name | StructureMap.name | TerminologyCapabilities.name | ValueSet.name</b><br> 9387 * </p> 9388 */ 9389 @SearchParamDefinition(name="name", path="CapabilityStatement.name | CodeSystem.name | CompartmentDefinition.name | ConceptMap.name | GraphDefinition.name | ImplementationGuide.name | MessageDefinition.name | NamingSystem.name | OperationDefinition.name | SearchParameter.name | StructureDefinition.name | StructureMap.name | TerminologyCapabilities.name | ValueSet.name", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement\r\n* [CodeSystem](codesystem.html): Computationally friendly name of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): Computationally friendly name of the compartment definition\r\n* [ConceptMap](conceptmap.html): Computationally friendly name of the concept map\r\n* [GraphDefinition](graphdefinition.html): Computationally friendly name of the graph definition\r\n* [ImplementationGuide](implementationguide.html): Computationally friendly name of the implementation guide\r\n* [MessageDefinition](messagedefinition.html): Computationally friendly name of the message definition\r\n* [NamingSystem](namingsystem.html): Computationally friendly name of the naming system\r\n* [OperationDefinition](operationdefinition.html): Computationally friendly name of the operation definition\r\n* [SearchParameter](searchparameter.html): Computationally friendly name of the search parameter\r\n* [StructureDefinition](structuredefinition.html): Computationally friendly name of the structure definition\r\n* [StructureMap](structuremap.html): Computationally friendly name of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): Computationally friendly name of the terminology capabilities\r\n* [ValueSet](valueset.html): Computationally friendly name of the value set\r\n", type="string" ) 9390 public static final String SP_NAME = "name"; 9391 /** 9392 * <b>Fluent Client</b> search parameter constant for <b>name</b> 9393 * <p> 9394 * Description: <b>Multiple Resources: 9395 9396* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement 9397* [CodeSystem](codesystem.html): Computationally friendly name of the code system 9398* [CompartmentDefinition](compartmentdefinition.html): Computationally friendly name of the compartment definition 9399* [ConceptMap](conceptmap.html): Computationally friendly name of the concept map 9400* [GraphDefinition](graphdefinition.html): Computationally friendly name of the graph definition 9401* [ImplementationGuide](implementationguide.html): Computationally friendly name of the implementation guide 9402* [MessageDefinition](messagedefinition.html): Computationally friendly name of the message definition 9403* [NamingSystem](namingsystem.html): Computationally friendly name of the naming system 9404* [OperationDefinition](operationdefinition.html): Computationally friendly name of the operation definition 9405* [SearchParameter](searchparameter.html): Computationally friendly name of the search parameter 9406* [StructureDefinition](structuredefinition.html): Computationally friendly name of the structure definition 9407* [StructureMap](structuremap.html): Computationally friendly name of the structure map 9408* [TerminologyCapabilities](terminologycapabilities.html): Computationally friendly name of the terminology capabilities 9409* [ValueSet](valueset.html): Computationally friendly name of the value set 9410</b><br> 9411 * Type: <b>string</b><br> 9412 * Path: <b>CapabilityStatement.name | CodeSystem.name | CompartmentDefinition.name | ConceptMap.name | GraphDefinition.name | ImplementationGuide.name | MessageDefinition.name | NamingSystem.name | OperationDefinition.name | SearchParameter.name | StructureDefinition.name | StructureMap.name | TerminologyCapabilities.name | ValueSet.name</b><br> 9413 * </p> 9414 */ 9415 public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME); 9416 9417 /** 9418 * Search parameter: <b>publisher</b> 9419 * <p> 9420 * Description: <b>Multiple Resources: 9421 9422* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement 9423* [CodeSystem](codesystem.html): Name of the publisher of the code system 9424* [CompartmentDefinition](compartmentdefinition.html): Name of the publisher of the compartment definition 9425* [ConceptMap](conceptmap.html): Name of the publisher of the concept map 9426* [GraphDefinition](graphdefinition.html): Name of the publisher of the graph definition 9427* [ImplementationGuide](implementationguide.html): Name of the publisher of the implementation guide 9428* [MessageDefinition](messagedefinition.html): Name of the publisher of the message definition 9429* [NamingSystem](namingsystem.html): Name of the publisher of the naming system 9430* [OperationDefinition](operationdefinition.html): Name of the publisher of the operation definition 9431* [SearchParameter](searchparameter.html): Name of the publisher of the search parameter 9432* [StructureDefinition](structuredefinition.html): Name of the publisher of the structure definition 9433* [StructureMap](structuremap.html): Name of the publisher of the structure map 9434* [TerminologyCapabilities](terminologycapabilities.html): Name of the publisher of the terminology capabilities 9435* [ValueSet](valueset.html): Name of the publisher of the value set 9436</b><br> 9437 * Type: <b>string</b><br> 9438 * Path: <b>CapabilityStatement.publisher | CodeSystem.publisher | CompartmentDefinition.publisher | ConceptMap.publisher | GraphDefinition.publisher | ImplementationGuide.publisher | MessageDefinition.publisher | NamingSystem.publisher | OperationDefinition.publisher | SearchParameter.publisher | StructureDefinition.publisher | StructureMap.publisher | TerminologyCapabilities.publisher | ValueSet.publisher</b><br> 9439 * </p> 9440 */ 9441 @SearchParamDefinition(name="publisher", path="CapabilityStatement.publisher | CodeSystem.publisher | CompartmentDefinition.publisher | ConceptMap.publisher | GraphDefinition.publisher | ImplementationGuide.publisher | MessageDefinition.publisher | NamingSystem.publisher | OperationDefinition.publisher | SearchParameter.publisher | StructureDefinition.publisher | StructureMap.publisher | TerminologyCapabilities.publisher | ValueSet.publisher", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement\r\n* [CodeSystem](codesystem.html): Name of the publisher of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): Name of the publisher of the compartment definition\r\n* [ConceptMap](conceptmap.html): Name of the publisher of the concept map\r\n* [GraphDefinition](graphdefinition.html): Name of the publisher of the graph definition\r\n* [ImplementationGuide](implementationguide.html): Name of the publisher of the implementation guide\r\n* [MessageDefinition](messagedefinition.html): Name of the publisher of the message definition\r\n* [NamingSystem](namingsystem.html): Name of the publisher of the naming system\r\n* [OperationDefinition](operationdefinition.html): Name of the publisher of the operation definition\r\n* [SearchParameter](searchparameter.html): Name of the publisher of the search parameter\r\n* [StructureDefinition](structuredefinition.html): Name of the publisher of the structure definition\r\n* [StructureMap](structuremap.html): Name of the publisher of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): Name of the publisher of the terminology capabilities\r\n* [ValueSet](valueset.html): Name of the publisher of the value set\r\n", type="string" ) 9442 public static final String SP_PUBLISHER = "publisher"; 9443 /** 9444 * <b>Fluent Client</b> search parameter constant for <b>publisher</b> 9445 * <p> 9446 * Description: <b>Multiple Resources: 9447 9448* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement 9449* [CodeSystem](codesystem.html): Name of the publisher of the code system 9450* [CompartmentDefinition](compartmentdefinition.html): Name of the publisher of the compartment definition 9451* [ConceptMap](conceptmap.html): Name of the publisher of the concept map 9452* [GraphDefinition](graphdefinition.html): Name of the publisher of the graph definition 9453* [ImplementationGuide](implementationguide.html): Name of the publisher of the implementation guide 9454* [MessageDefinition](messagedefinition.html): Name of the publisher of the message definition 9455* [NamingSystem](namingsystem.html): Name of the publisher of the naming system 9456* [OperationDefinition](operationdefinition.html): Name of the publisher of the operation definition 9457* [SearchParameter](searchparameter.html): Name of the publisher of the search parameter 9458* [StructureDefinition](structuredefinition.html): Name of the publisher of the structure definition 9459* [StructureMap](structuremap.html): Name of the publisher of the structure map 9460* [TerminologyCapabilities](terminologycapabilities.html): Name of the publisher of the terminology capabilities 9461* [ValueSet](valueset.html): Name of the publisher of the value set 9462</b><br> 9463 * Type: <b>string</b><br> 9464 * Path: <b>CapabilityStatement.publisher | CodeSystem.publisher | CompartmentDefinition.publisher | ConceptMap.publisher | GraphDefinition.publisher | ImplementationGuide.publisher | MessageDefinition.publisher | NamingSystem.publisher | OperationDefinition.publisher | SearchParameter.publisher | StructureDefinition.publisher | StructureMap.publisher | TerminologyCapabilities.publisher | ValueSet.publisher</b><br> 9465 * </p> 9466 */ 9467 public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_PUBLISHER); 9468 9469 /** 9470 * Search parameter: <b>status</b> 9471 * <p> 9472 * Description: <b>Multiple Resources: 9473 9474* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement 9475* [CodeSystem](codesystem.html): The current status of the code system 9476* [CompartmentDefinition](compartmentdefinition.html): The current status of the compartment definition 9477* [ConceptMap](conceptmap.html): The current status of the concept map 9478* [GraphDefinition](graphdefinition.html): The current status of the graph definition 9479* [ImplementationGuide](implementationguide.html): The current status of the implementation guide 9480* [MessageDefinition](messagedefinition.html): The current status of the message definition 9481* [NamingSystem](namingsystem.html): The current status of the naming system 9482* [OperationDefinition](operationdefinition.html): The current status of the operation definition 9483* [SearchParameter](searchparameter.html): The current status of the search parameter 9484* [StructureDefinition](structuredefinition.html): The current status of the structure definition 9485* [StructureMap](structuremap.html): The current status of the structure map 9486* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities 9487* [ValueSet](valueset.html): The current status of the value set 9488</b><br> 9489 * Type: <b>token</b><br> 9490 * Path: <b>CapabilityStatement.status | CodeSystem.status | CompartmentDefinition.status | ConceptMap.status | GraphDefinition.status | ImplementationGuide.status | MessageDefinition.status | NamingSystem.status | OperationDefinition.status | SearchParameter.status | StructureDefinition.status | StructureMap.status | TerminologyCapabilities.status | ValueSet.status</b><br> 9491 * </p> 9492 */ 9493 @SearchParamDefinition(name="status", path="CapabilityStatement.status | CodeSystem.status | CompartmentDefinition.status | ConceptMap.status | GraphDefinition.status | ImplementationGuide.status | MessageDefinition.status | NamingSystem.status | OperationDefinition.status | SearchParameter.status | StructureDefinition.status | StructureMap.status | TerminologyCapabilities.status | ValueSet.status", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement\r\n* [CodeSystem](codesystem.html): The current status of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): The current status of the compartment definition\r\n* [ConceptMap](conceptmap.html): The current status of the concept map\r\n* [GraphDefinition](graphdefinition.html): The current status of the graph definition\r\n* [ImplementationGuide](implementationguide.html): The current status of the implementation guide\r\n* [MessageDefinition](messagedefinition.html): The current status of the message definition\r\n* [NamingSystem](namingsystem.html): The current status of the naming system\r\n* [OperationDefinition](operationdefinition.html): The current status of the operation definition\r\n* [SearchParameter](searchparameter.html): The current status of the search parameter\r\n* [StructureDefinition](structuredefinition.html): The current status of the structure definition\r\n* [StructureMap](structuremap.html): The current status of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities\r\n* [ValueSet](valueset.html): The current status of the value set\r\n", type="token" ) 9494 public static final String SP_STATUS = "status"; 9495 /** 9496 * <b>Fluent Client</b> search parameter constant for <b>status</b> 9497 * <p> 9498 * Description: <b>Multiple Resources: 9499 9500* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement 9501* [CodeSystem](codesystem.html): The current status of the code system 9502* [CompartmentDefinition](compartmentdefinition.html): The current status of the compartment definition 9503* [ConceptMap](conceptmap.html): The current status of the concept map 9504* [GraphDefinition](graphdefinition.html): The current status of the graph definition 9505* [ImplementationGuide](implementationguide.html): The current status of the implementation guide 9506* [MessageDefinition](messagedefinition.html): The current status of the message definition 9507* [NamingSystem](namingsystem.html): The current status of the naming system 9508* [OperationDefinition](operationdefinition.html): The current status of the operation definition 9509* [SearchParameter](searchparameter.html): The current status of the search parameter 9510* [StructureDefinition](structuredefinition.html): The current status of the structure definition 9511* [StructureMap](structuremap.html): The current status of the structure map 9512* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities 9513* [ValueSet](valueset.html): The current status of the value set 9514</b><br> 9515 * Type: <b>token</b><br> 9516 * Path: <b>CapabilityStatement.status | CodeSystem.status | CompartmentDefinition.status | ConceptMap.status | GraphDefinition.status | ImplementationGuide.status | MessageDefinition.status | NamingSystem.status | OperationDefinition.status | SearchParameter.status | StructureDefinition.status | StructureMap.status | TerminologyCapabilities.status | ValueSet.status</b><br> 9517 * </p> 9518 */ 9519 public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS); 9520 9521 /** 9522 * Search parameter: <b>title</b> 9523 * <p> 9524 * Description: <b>Multiple Resources: 9525 9526* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement 9527* [CodeSystem](codesystem.html): The human-friendly name of the code system 9528* [ConceptMap](conceptmap.html): The human-friendly name of the concept map 9529* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide 9530* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition 9531* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition 9532* [StructureDefinition](structuredefinition.html): The human-friendly name of the structure definition 9533* [StructureMap](structuremap.html): The human-friendly name of the structure map 9534* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities 9535* [ValueSet](valueset.html): The human-friendly name of the value set 9536</b><br> 9537 * Type: <b>string</b><br> 9538 * Path: <b>CapabilityStatement.title | CodeSystem.title | ConceptMap.title | ImplementationGuide.title | MessageDefinition.title | OperationDefinition.title | StructureDefinition.title | StructureMap.title | TerminologyCapabilities.title | ValueSet.title</b><br> 9539 * </p> 9540 */ 9541 @SearchParamDefinition(name="title", path="CapabilityStatement.title | CodeSystem.title | ConceptMap.title | ImplementationGuide.title | MessageDefinition.title | OperationDefinition.title | StructureDefinition.title | StructureMap.title | TerminologyCapabilities.title | ValueSet.title", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement\r\n* [CodeSystem](codesystem.html): The human-friendly name of the code system\r\n* [ConceptMap](conceptmap.html): The human-friendly name of the concept map\r\n* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide\r\n* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition\r\n* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition\r\n* [StructureDefinition](structuredefinition.html): The human-friendly name of the structure definition\r\n* [StructureMap](structuremap.html): The human-friendly name of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities\r\n* [ValueSet](valueset.html): The human-friendly name of the value set\r\n", type="string" ) 9542 public static final String SP_TITLE = "title"; 9543 /** 9544 * <b>Fluent Client</b> search parameter constant for <b>title</b> 9545 * <p> 9546 * Description: <b>Multiple Resources: 9547 9548* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement 9549* [CodeSystem](codesystem.html): The human-friendly name of the code system 9550* [ConceptMap](conceptmap.html): The human-friendly name of the concept map 9551* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide 9552* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition 9553* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition 9554* [StructureDefinition](structuredefinition.html): The human-friendly name of the structure definition 9555* [StructureMap](structuremap.html): The human-friendly name of the structure map 9556* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities 9557* [ValueSet](valueset.html): The human-friendly name of the value set 9558</b><br> 9559 * Type: <b>string</b><br> 9560 * Path: <b>CapabilityStatement.title | CodeSystem.title | ConceptMap.title | ImplementationGuide.title | MessageDefinition.title | OperationDefinition.title | StructureDefinition.title | StructureMap.title | TerminologyCapabilities.title | ValueSet.title</b><br> 9561 * </p> 9562 */ 9563 public static final ca.uhn.fhir.rest.gclient.StringClientParam TITLE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_TITLE); 9564 9565 /** 9566 * Search parameter: <b>url</b> 9567 * <p> 9568 * Description: <b>Multiple Resources: 9569 9570* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement 9571* [CodeSystem](codesystem.html): The uri that identifies the code system 9572* [CompartmentDefinition](compartmentdefinition.html): The uri that identifies the compartment definition 9573* [ConceptMap](conceptmap.html): The uri that identifies the concept map 9574* [GraphDefinition](graphdefinition.html): The uri that identifies the graph definition 9575* [ImplementationGuide](implementationguide.html): The uri that identifies the implementation guide 9576* [MessageDefinition](messagedefinition.html): The uri that identifies the message definition 9577* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition 9578* [SearchParameter](searchparameter.html): The uri that identifies the search parameter 9579* [StructureDefinition](structuredefinition.html): The uri that identifies the structure definition 9580* [StructureMap](structuremap.html): The uri that identifies the structure map 9581* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities 9582* [ValueSet](valueset.html): The uri that identifies the value set 9583</b><br> 9584 * Type: <b>uri</b><br> 9585 * Path: <b>CapabilityStatement.url | CodeSystem.url | CompartmentDefinition.url | ConceptMap.url | GraphDefinition.url | ImplementationGuide.url | MessageDefinition.url | OperationDefinition.url | SearchParameter.url | StructureDefinition.url | StructureMap.url | TerminologyCapabilities.url | ValueSet.url</b><br> 9586 * </p> 9587 */ 9588 @SearchParamDefinition(name="url", path="CapabilityStatement.url | CodeSystem.url | CompartmentDefinition.url | ConceptMap.url | GraphDefinition.url | ImplementationGuide.url | MessageDefinition.url | OperationDefinition.url | SearchParameter.url | StructureDefinition.url | StructureMap.url | TerminologyCapabilities.url | ValueSet.url", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement\r\n* [CodeSystem](codesystem.html): The uri that identifies the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): The uri that identifies the compartment definition\r\n* [ConceptMap](conceptmap.html): The uri that identifies the concept map\r\n* [GraphDefinition](graphdefinition.html): The uri that identifies the graph definition\r\n* [ImplementationGuide](implementationguide.html): The uri that identifies the implementation guide\r\n* [MessageDefinition](messagedefinition.html): The uri that identifies the message definition\r\n* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition\r\n* [SearchParameter](searchparameter.html): The uri that identifies the search parameter\r\n* [StructureDefinition](structuredefinition.html): The uri that identifies the structure definition\r\n* [StructureMap](structuremap.html): The uri that identifies the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities\r\n* [ValueSet](valueset.html): The uri that identifies the value set\r\n", type="uri" ) 9589 public static final String SP_URL = "url"; 9590 /** 9591 * <b>Fluent Client</b> search parameter constant for <b>url</b> 9592 * <p> 9593 * Description: <b>Multiple Resources: 9594 9595* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement 9596* [CodeSystem](codesystem.html): The uri that identifies the code system 9597* [CompartmentDefinition](compartmentdefinition.html): The uri that identifies the compartment definition 9598* [ConceptMap](conceptmap.html): The uri that identifies the concept map 9599* [GraphDefinition](graphdefinition.html): The uri that identifies the graph definition 9600* [ImplementationGuide](implementationguide.html): The uri that identifies the implementation guide 9601* [MessageDefinition](messagedefinition.html): The uri that identifies the message definition 9602* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition 9603* [SearchParameter](searchparameter.html): The uri that identifies the search parameter 9604* [StructureDefinition](structuredefinition.html): The uri that identifies the structure definition 9605* [StructureMap](structuremap.html): The uri that identifies the structure map 9606* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities 9607* [ValueSet](valueset.html): The uri that identifies the value set 9608</b><br> 9609 * Type: <b>uri</b><br> 9610 * Path: <b>CapabilityStatement.url | CodeSystem.url | CompartmentDefinition.url | ConceptMap.url | GraphDefinition.url | ImplementationGuide.url | MessageDefinition.url | OperationDefinition.url | SearchParameter.url | StructureDefinition.url | StructureMap.url | TerminologyCapabilities.url | ValueSet.url</b><br> 9611 * </p> 9612 */ 9613 public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL); 9614 9615 /** 9616 * Search parameter: <b>version</b> 9617 * <p> 9618 * Description: <b>Multiple Resources: 9619 9620* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement 9621* [CodeSystem](codesystem.html): The business version of the code system 9622* [CompartmentDefinition](compartmentdefinition.html): The business version of the compartment definition 9623* [ConceptMap](conceptmap.html): The business version of the concept map 9624* [GraphDefinition](graphdefinition.html): The business version of the graph definition 9625* [ImplementationGuide](implementationguide.html): The business version of the implementation guide 9626* [MessageDefinition](messagedefinition.html): The business version of the message definition 9627* [OperationDefinition](operationdefinition.html): The business version of the operation definition 9628* [SearchParameter](searchparameter.html): The business version of the search parameter 9629* [StructureDefinition](structuredefinition.html): The business version of the structure definition 9630* [StructureMap](structuremap.html): The business version of the structure map 9631* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities 9632* [ValueSet](valueset.html): The business version of the value set 9633</b><br> 9634 * Type: <b>token</b><br> 9635 * Path: <b>CapabilityStatement.version | CodeSystem.version | CompartmentDefinition.version | ConceptMap.version | GraphDefinition.version | ImplementationGuide.version | MessageDefinition.version | OperationDefinition.version | SearchParameter.version | StructureDefinition.version | StructureMap.version | TerminologyCapabilities.version | ValueSet.version</b><br> 9636 * </p> 9637 */ 9638 @SearchParamDefinition(name="version", path="CapabilityStatement.version | CodeSystem.version | CompartmentDefinition.version | ConceptMap.version | GraphDefinition.version | ImplementationGuide.version | MessageDefinition.version | OperationDefinition.version | SearchParameter.version | StructureDefinition.version | StructureMap.version | TerminologyCapabilities.version | ValueSet.version", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement\r\n* [CodeSystem](codesystem.html): The business version of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): The business version of the compartment definition\r\n* [ConceptMap](conceptmap.html): The business version of the concept map\r\n* [GraphDefinition](graphdefinition.html): The business version of the graph definition\r\n* [ImplementationGuide](implementationguide.html): The business version of the implementation guide\r\n* [MessageDefinition](messagedefinition.html): The business version of the message definition\r\n* [OperationDefinition](operationdefinition.html): The business version of the operation definition\r\n* [SearchParameter](searchparameter.html): The business version of the search parameter\r\n* [StructureDefinition](structuredefinition.html): The business version of the structure definition\r\n* [StructureMap](structuremap.html): The business version of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities\r\n* [ValueSet](valueset.html): The business version of the value set\r\n", type="token" ) 9639 public static final String SP_VERSION = "version"; 9640 /** 9641 * <b>Fluent Client</b> search parameter constant for <b>version</b> 9642 * <p> 9643 * Description: <b>Multiple Resources: 9644 9645* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement 9646* [CodeSystem](codesystem.html): The business version of the code system 9647* [CompartmentDefinition](compartmentdefinition.html): The business version of the compartment definition 9648* [ConceptMap](conceptmap.html): The business version of the concept map 9649* [GraphDefinition](graphdefinition.html): The business version of the graph definition 9650* [ImplementationGuide](implementationguide.html): The business version of the implementation guide 9651* [MessageDefinition](messagedefinition.html): The business version of the message definition 9652* [OperationDefinition](operationdefinition.html): The business version of the operation definition 9653* [SearchParameter](searchparameter.html): The business version of the search parameter 9654* [StructureDefinition](structuredefinition.html): The business version of the structure definition 9655* [StructureMap](structuremap.html): The business version of the structure map 9656* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities 9657* [ValueSet](valueset.html): The business version of the value set 9658</b><br> 9659 * Type: <b>token</b><br> 9660 * Path: <b>CapabilityStatement.version | CodeSystem.version | CompartmentDefinition.version | ConceptMap.version | GraphDefinition.version | ImplementationGuide.version | MessageDefinition.version | OperationDefinition.version | SearchParameter.version | StructureDefinition.version | StructureMap.version | TerminologyCapabilities.version | ValueSet.version</b><br> 9661 * </p> 9662 */ 9663 public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VERSION); 9664 9665} 9666