001package org.hl7.fhir.r4.model; 002 003 004 005/* 006 Copyright (c) 2011+, HL7, Inc. 007 All rights reserved. 008 009 Redistribution and use in source and binary forms, with or without modification, 010 are permitted provided that the following conditions are met: 011 012 * Redistributions of source code must retain the above copyright notice, this 013 list of conditions and the following disclaimer. 014 * Redistributions in binary form must reproduce the above copyright notice, 015 this list of conditions and the following disclaimer in the documentation 016 and/or other materials provided with the distribution. 017 * Neither the name of HL7 nor the names of its contributors may be used to 018 endorse or promote products derived from this software without specific 019 prior written permission. 020 021 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 022 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 023 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 024 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 025 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 026 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 027 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 028 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 029 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 030 POSSIBILITY OF SUCH DAMAGE. 031 032*/ 033 034 035// Generated on Tue, May 12, 2020 07:26+1000 for FHIR v4.0.1 036 037import java.util.*; 038 039import org.hl7.fhir.utilities.Utilities; 040import org.hl7.fhir.r4.model.Enumerations.*; 041import ca.uhn.fhir.model.api.annotation.ResourceDef; 042import ca.uhn.fhir.model.api.annotation.SearchParamDefinition; 043import ca.uhn.fhir.model.api.annotation.Child; 044import ca.uhn.fhir.model.api.annotation.ChildOrder; 045import ca.uhn.fhir.model.api.annotation.Description; 046import ca.uhn.fhir.model.api.annotation.Block; 047import org.hl7.fhir.instance.model.api.*; 048import org.hl7.fhir.exceptions.FHIRException; 049/** 050 * 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. 051 */ 052@ResourceDef(name="CapabilityStatement", profile="http://hl7.org/fhir/StructureDefinition/CapabilityStatement") 053@ChildOrder(names={"url", "version", "name", "title", "status", "experimental", "date", "publisher", "contact", "description", "useContext", "jurisdiction", "purpose", "copyright", "kind", "instantiates", "imports", "software", "implementation", "fhirVersion", "format", "patchFormat", "implementationGuide", "rest", "messaging", "document"}) 054public class CapabilityStatement extends MetadataResource implements IBaseConformance { 055 056 public enum CapabilityStatementKind { 057 /** 058 * The CapabilityStatement instance represents the present capabilities of a specific system instance. This is the kind returned by /metadata for a FHIR server end-point. 059 */ 060 INSTANCE, 061 /** 062 * The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation. 063 */ 064 CAPABILITY, 065 /** 066 * The CapabilityStatement instance represents a set of requirements for other systems to meet; e.g. as part of an implementation guide or 'request for proposal'. 067 */ 068 REQUIREMENTS, 069 /** 070 * added to help the parsers with the generic types 071 */ 072 NULL; 073 public static CapabilityStatementKind fromCode(String codeString) throws FHIRException { 074 if (codeString == null || "".equals(codeString)) 075 return null; 076 if ("instance".equals(codeString)) 077 return INSTANCE; 078 if ("capability".equals(codeString)) 079 return CAPABILITY; 080 if ("requirements".equals(codeString)) 081 return REQUIREMENTS; 082 if (Configuration.isAcceptInvalidEnums()) 083 return null; 084 else 085 throw new FHIRException("Unknown CapabilityStatementKind code '"+codeString+"'"); 086 } 087 public String toCode() { 088 switch (this) { 089 case INSTANCE: return "instance"; 090 case CAPABILITY: return "capability"; 091 case REQUIREMENTS: return "requirements"; 092 default: return "?"; 093 } 094 } 095 public String getSystem() { 096 switch (this) { 097 case INSTANCE: return "http://hl7.org/fhir/capability-statement-kind"; 098 case CAPABILITY: return "http://hl7.org/fhir/capability-statement-kind"; 099 case REQUIREMENTS: return "http://hl7.org/fhir/capability-statement-kind"; 100 default: return "?"; 101 } 102 } 103 public String getDefinition() { 104 switch (this) { 105 case INSTANCE: return "The CapabilityStatement instance represents the present capabilities of a specific system instance. This is the kind returned by /metadata for a FHIR server end-point."; 106 case CAPABILITY: return "The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation."; 107 case REQUIREMENTS: return "The CapabilityStatement instance represents a set of requirements for other systems to meet; e.g. as part of an implementation guide or 'request for proposal'."; 108 default: return "?"; 109 } 110 } 111 public String getDisplay() { 112 switch (this) { 113 case INSTANCE: return "Instance"; 114 case CAPABILITY: return "Capability"; 115 case REQUIREMENTS: return "Requirements"; 116 default: return "?"; 117 } 118 } 119 } 120 121 public static class CapabilityStatementKindEnumFactory implements EnumFactory<CapabilityStatementKind> { 122 public CapabilityStatementKind fromCode(String codeString) throws IllegalArgumentException { 123 if (codeString == null || "".equals(codeString)) 124 if (codeString == null || "".equals(codeString)) 125 return null; 126 if ("instance".equals(codeString)) 127 return CapabilityStatementKind.INSTANCE; 128 if ("capability".equals(codeString)) 129 return CapabilityStatementKind.CAPABILITY; 130 if ("requirements".equals(codeString)) 131 return CapabilityStatementKind.REQUIREMENTS; 132 throw new IllegalArgumentException("Unknown CapabilityStatementKind code '"+codeString+"'"); 133 } 134 public Enumeration<CapabilityStatementKind> fromType(Base code) throws FHIRException { 135 if (code == null) 136 return null; 137 if (code.isEmpty()) 138 return new Enumeration<CapabilityStatementKind>(this); 139 String codeString = ((PrimitiveType) code).asStringValue(); 140 if (codeString == null || "".equals(codeString)) 141 return null; 142 if ("instance".equals(codeString)) 143 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.INSTANCE); 144 if ("capability".equals(codeString)) 145 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.CAPABILITY); 146 if ("requirements".equals(codeString)) 147 return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.REQUIREMENTS); 148 throw new FHIRException("Unknown CapabilityStatementKind code '"+codeString+"'"); 149 } 150 public String toCode(CapabilityStatementKind code) { 151 if (code == CapabilityStatementKind.INSTANCE) 152 return "instance"; 153 if (code == CapabilityStatementKind.CAPABILITY) 154 return "capability"; 155 if (code == CapabilityStatementKind.REQUIREMENTS) 156 return "requirements"; 157 return "?"; 158 } 159 public String toSystem(CapabilityStatementKind code) { 160 return code.getSystem(); 161 } 162 } 163 164 public enum RestfulCapabilityMode { 165 /** 166 * The application acts as a client for this resource. 167 */ 168 CLIENT, 169 /** 170 * The application acts as a server for this resource. 171 */ 172 SERVER, 173 /** 174 * added to help the parsers with the generic types 175 */ 176 NULL; 177 public static RestfulCapabilityMode fromCode(String codeString) throws FHIRException { 178 if (codeString == null || "".equals(codeString)) 179 return null; 180 if ("client".equals(codeString)) 181 return CLIENT; 182 if ("server".equals(codeString)) 183 return SERVER; 184 if (Configuration.isAcceptInvalidEnums()) 185 return null; 186 else 187 throw new FHIRException("Unknown RestfulCapabilityMode code '"+codeString+"'"); 188 } 189 public String toCode() { 190 switch (this) { 191 case CLIENT: return "client"; 192 case SERVER: return "server"; 193 default: return "?"; 194 } 195 } 196 public String getSystem() { 197 switch (this) { 198 case CLIENT: return "http://hl7.org/fhir/restful-capability-mode"; 199 case SERVER: return "http://hl7.org/fhir/restful-capability-mode"; 200 default: return "?"; 201 } 202 } 203 public String getDefinition() { 204 switch (this) { 205 case CLIENT: return "The application acts as a client for this resource."; 206 case SERVER: return "The application acts as a server for this resource."; 207 default: return "?"; 208 } 209 } 210 public String getDisplay() { 211 switch (this) { 212 case CLIENT: return "Client"; 213 case SERVER: return "Server"; 214 default: return "?"; 215 } 216 } 217 } 218 219 public static class RestfulCapabilityModeEnumFactory implements EnumFactory<RestfulCapabilityMode> { 220 public RestfulCapabilityMode fromCode(String codeString) throws IllegalArgumentException { 221 if (codeString == null || "".equals(codeString)) 222 if (codeString == null || "".equals(codeString)) 223 return null; 224 if ("client".equals(codeString)) 225 return RestfulCapabilityMode.CLIENT; 226 if ("server".equals(codeString)) 227 return RestfulCapabilityMode.SERVER; 228 throw new IllegalArgumentException("Unknown RestfulCapabilityMode code '"+codeString+"'"); 229 } 230 public Enumeration<RestfulCapabilityMode> fromType(Base code) throws FHIRException { 231 if (code == null) 232 return null; 233 if (code.isEmpty()) 234 return new Enumeration<RestfulCapabilityMode>(this); 235 String codeString = ((PrimitiveType) code).asStringValue(); 236 if (codeString == null || "".equals(codeString)) 237 return null; 238 if ("client".equals(codeString)) 239 return new Enumeration<RestfulCapabilityMode>(this, RestfulCapabilityMode.CLIENT); 240 if ("server".equals(codeString)) 241 return new Enumeration<RestfulCapabilityMode>(this, RestfulCapabilityMode.SERVER); 242 throw new FHIRException("Unknown RestfulCapabilityMode code '"+codeString+"'"); 243 } 244 public String toCode(RestfulCapabilityMode code) { 245 if (code == RestfulCapabilityMode.CLIENT) 246 return "client"; 247 if (code == RestfulCapabilityMode.SERVER) 248 return "server"; 249 return "?"; 250 } 251 public String toSystem(RestfulCapabilityMode code) { 252 return code.getSystem(); 253 } 254 } 255 256 public enum TypeRestfulInteraction { 257 /** 258 * null 259 */ 260 READ, 261 /** 262 * null 263 */ 264 VREAD, 265 /** 266 * null 267 */ 268 UPDATE, 269 /** 270 * null 271 */ 272 PATCH, 273 /** 274 * null 275 */ 276 DELETE, 277 /** 278 * null 279 */ 280 HISTORYINSTANCE, 281 /** 282 * null 283 */ 284 HISTORYTYPE, 285 /** 286 * null 287 */ 288 CREATE, 289 /** 290 * null 291 */ 292 SEARCHTYPE, 293 /** 294 * added to help the parsers with the generic types 295 */ 296 NULL; 297 public static TypeRestfulInteraction fromCode(String codeString) throws FHIRException { 298 if (codeString == null || "".equals(codeString)) 299 return null; 300 if ("read".equals(codeString)) 301 return READ; 302 if ("vread".equals(codeString)) 303 return VREAD; 304 if ("update".equals(codeString)) 305 return UPDATE; 306 if ("patch".equals(codeString)) 307 return PATCH; 308 if ("delete".equals(codeString)) 309 return DELETE; 310 if ("history-instance".equals(codeString)) 311 return HISTORYINSTANCE; 312 if ("history-type".equals(codeString)) 313 return HISTORYTYPE; 314 if ("create".equals(codeString)) 315 return CREATE; 316 if ("search-type".equals(codeString)) 317 return SEARCHTYPE; 318 if (Configuration.isAcceptInvalidEnums()) 319 return null; 320 else 321 throw new FHIRException("Unknown TypeRestfulInteraction code '"+codeString+"'"); 322 } 323 public String toCode() { 324 switch (this) { 325 case READ: return "read"; 326 case VREAD: return "vread"; 327 case UPDATE: return "update"; 328 case PATCH: return "patch"; 329 case DELETE: return "delete"; 330 case HISTORYINSTANCE: return "history-instance"; 331 case HISTORYTYPE: return "history-type"; 332 case CREATE: return "create"; 333 case SEARCHTYPE: return "search-type"; 334 default: return "?"; 335 } 336 } 337 public String getSystem() { 338 switch (this) { 339 case READ: return "http://hl7.org/fhir/restful-interaction"; 340 case VREAD: return "http://hl7.org/fhir/restful-interaction"; 341 case UPDATE: return "http://hl7.org/fhir/restful-interaction"; 342 case PATCH: return "http://hl7.org/fhir/restful-interaction"; 343 case DELETE: return "http://hl7.org/fhir/restful-interaction"; 344 case HISTORYINSTANCE: return "http://hl7.org/fhir/restful-interaction"; 345 case HISTORYTYPE: return "http://hl7.org/fhir/restful-interaction"; 346 case CREATE: return "http://hl7.org/fhir/restful-interaction"; 347 case SEARCHTYPE: return "http://hl7.org/fhir/restful-interaction"; 348 default: return "?"; 349 } 350 } 351 public String getDefinition() { 352 switch (this) { 353 case READ: return ""; 354 case VREAD: return ""; 355 case UPDATE: return ""; 356 case PATCH: return ""; 357 case DELETE: return ""; 358 case HISTORYINSTANCE: return ""; 359 case HISTORYTYPE: return ""; 360 case CREATE: return ""; 361 case SEARCHTYPE: return ""; 362 default: return "?"; 363 } 364 } 365 public String getDisplay() { 366 switch (this) { 367 case READ: return "read"; 368 case VREAD: return "vread"; 369 case UPDATE: return "update"; 370 case PATCH: return "patch"; 371 case DELETE: return "delete"; 372 case HISTORYINSTANCE: return "history-instance"; 373 case HISTORYTYPE: return "history-type"; 374 case CREATE: return "create"; 375 case SEARCHTYPE: return "search-type"; 376 default: return "?"; 377 } 378 } 379 } 380 381 public static class TypeRestfulInteractionEnumFactory implements EnumFactory<TypeRestfulInteraction> { 382 public TypeRestfulInteraction fromCode(String codeString) throws IllegalArgumentException { 383 if (codeString == null || "".equals(codeString)) 384 if (codeString == null || "".equals(codeString)) 385 return null; 386 if ("read".equals(codeString)) 387 return TypeRestfulInteraction.READ; 388 if ("vread".equals(codeString)) 389 return TypeRestfulInteraction.VREAD; 390 if ("update".equals(codeString)) 391 return TypeRestfulInteraction.UPDATE; 392 if ("patch".equals(codeString)) 393 return TypeRestfulInteraction.PATCH; 394 if ("delete".equals(codeString)) 395 return TypeRestfulInteraction.DELETE; 396 if ("history-instance".equals(codeString)) 397 return TypeRestfulInteraction.HISTORYINSTANCE; 398 if ("history-type".equals(codeString)) 399 return TypeRestfulInteraction.HISTORYTYPE; 400 if ("create".equals(codeString)) 401 return TypeRestfulInteraction.CREATE; 402 if ("search-type".equals(codeString)) 403 return TypeRestfulInteraction.SEARCHTYPE; 404 throw new IllegalArgumentException("Unknown TypeRestfulInteraction code '"+codeString+"'"); 405 } 406 public Enumeration<TypeRestfulInteraction> fromType(Base code) throws FHIRException { 407 if (code == null) 408 return null; 409 if (code.isEmpty()) 410 return new Enumeration<TypeRestfulInteraction>(this); 411 String codeString = ((PrimitiveType) code).asStringValue(); 412 if (codeString == null || "".equals(codeString)) 413 return null; 414 if ("read".equals(codeString)) 415 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.READ); 416 if ("vread".equals(codeString)) 417 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.VREAD); 418 if ("update".equals(codeString)) 419 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.UPDATE); 420 if ("patch".equals(codeString)) 421 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.PATCH); 422 if ("delete".equals(codeString)) 423 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.DELETE); 424 if ("history-instance".equals(codeString)) 425 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.HISTORYINSTANCE); 426 if ("history-type".equals(codeString)) 427 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.HISTORYTYPE); 428 if ("create".equals(codeString)) 429 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.CREATE); 430 if ("search-type".equals(codeString)) 431 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.SEARCHTYPE); 432 throw new FHIRException("Unknown TypeRestfulInteraction code '"+codeString+"'"); 433 } 434 public String toCode(TypeRestfulInteraction code) { 435 if (code == TypeRestfulInteraction.READ) 436 return "read"; 437 if (code == TypeRestfulInteraction.VREAD) 438 return "vread"; 439 if (code == TypeRestfulInteraction.UPDATE) 440 return "update"; 441 if (code == TypeRestfulInteraction.PATCH) 442 return "patch"; 443 if (code == TypeRestfulInteraction.DELETE) 444 return "delete"; 445 if (code == TypeRestfulInteraction.HISTORYINSTANCE) 446 return "history-instance"; 447 if (code == TypeRestfulInteraction.HISTORYTYPE) 448 return "history-type"; 449 if (code == TypeRestfulInteraction.CREATE) 450 return "create"; 451 if (code == TypeRestfulInteraction.SEARCHTYPE) 452 return "search-type"; 453 return "?"; 454 } 455 public String toSystem(TypeRestfulInteraction code) { 456 return code.getSystem(); 457 } 458 } 459 460 public enum ResourceVersionPolicy { 461 /** 462 * VersionId meta-property is not supported (server) or used (client). 463 */ 464 NOVERSION, 465 /** 466 * VersionId meta-property is supported (server) or used (client). 467 */ 468 VERSIONED, 469 /** 470 * VersionId must be correct for updates (server) or will be specified (If-match header) for updates (client). 471 */ 472 VERSIONEDUPDATE, 473 /** 474 * added to help the parsers with the generic types 475 */ 476 NULL; 477 public static ResourceVersionPolicy fromCode(String codeString) throws FHIRException { 478 if (codeString == null || "".equals(codeString)) 479 return null; 480 if ("no-version".equals(codeString)) 481 return NOVERSION; 482 if ("versioned".equals(codeString)) 483 return VERSIONED; 484 if ("versioned-update".equals(codeString)) 485 return VERSIONEDUPDATE; 486 if (Configuration.isAcceptInvalidEnums()) 487 return null; 488 else 489 throw new FHIRException("Unknown ResourceVersionPolicy code '"+codeString+"'"); 490 } 491 public String toCode() { 492 switch (this) { 493 case NOVERSION: return "no-version"; 494 case VERSIONED: return "versioned"; 495 case VERSIONEDUPDATE: return "versioned-update"; 496 default: return "?"; 497 } 498 } 499 public String getSystem() { 500 switch (this) { 501 case NOVERSION: return "http://hl7.org/fhir/versioning-policy"; 502 case VERSIONED: return "http://hl7.org/fhir/versioning-policy"; 503 case VERSIONEDUPDATE: return "http://hl7.org/fhir/versioning-policy"; 504 default: return "?"; 505 } 506 } 507 public String getDefinition() { 508 switch (this) { 509 case NOVERSION: return "VersionId meta-property is not supported (server) or used (client)."; 510 case VERSIONED: return "VersionId meta-property is supported (server) or used (client)."; 511 case VERSIONEDUPDATE: return "VersionId must be correct for updates (server) or will be specified (If-match header) for updates (client)."; 512 default: return "?"; 513 } 514 } 515 public String getDisplay() { 516 switch (this) { 517 case NOVERSION: return "No VersionId Support"; 518 case VERSIONED: return "Versioned"; 519 case VERSIONEDUPDATE: return "VersionId tracked fully"; 520 default: return "?"; 521 } 522 } 523 } 524 525 public static class ResourceVersionPolicyEnumFactory implements EnumFactory<ResourceVersionPolicy> { 526 public ResourceVersionPolicy fromCode(String codeString) throws IllegalArgumentException { 527 if (codeString == null || "".equals(codeString)) 528 if (codeString == null || "".equals(codeString)) 529 return null; 530 if ("no-version".equals(codeString)) 531 return ResourceVersionPolicy.NOVERSION; 532 if ("versioned".equals(codeString)) 533 return ResourceVersionPolicy.VERSIONED; 534 if ("versioned-update".equals(codeString)) 535 return ResourceVersionPolicy.VERSIONEDUPDATE; 536 throw new IllegalArgumentException("Unknown ResourceVersionPolicy code '"+codeString+"'"); 537 } 538 public Enumeration<ResourceVersionPolicy> fromType(Base code) throws FHIRException { 539 if (code == null) 540 return null; 541 if (code.isEmpty()) 542 return new Enumeration<ResourceVersionPolicy>(this); 543 String codeString = ((PrimitiveType) code).asStringValue(); 544 if (codeString == null || "".equals(codeString)) 545 return null; 546 if ("no-version".equals(codeString)) 547 return new Enumeration<ResourceVersionPolicy>(this, ResourceVersionPolicy.NOVERSION); 548 if ("versioned".equals(codeString)) 549 return new Enumeration<ResourceVersionPolicy>(this, ResourceVersionPolicy.VERSIONED); 550 if ("versioned-update".equals(codeString)) 551 return new Enumeration<ResourceVersionPolicy>(this, ResourceVersionPolicy.VERSIONEDUPDATE); 552 throw new FHIRException("Unknown ResourceVersionPolicy code '"+codeString+"'"); 553 } 554 public String toCode(ResourceVersionPolicy code) { 555 if (code == ResourceVersionPolicy.NOVERSION) 556 return "no-version"; 557 if (code == ResourceVersionPolicy.VERSIONED) 558 return "versioned"; 559 if (code == ResourceVersionPolicy.VERSIONEDUPDATE) 560 return "versioned-update"; 561 return "?"; 562 } 563 public String toSystem(ResourceVersionPolicy code) { 564 return code.getSystem(); 565 } 566 } 567 568 public enum ConditionalReadStatus { 569 /** 570 * No support for conditional reads. 571 */ 572 NOTSUPPORTED, 573 /** 574 * Conditional reads are supported, but only with the If-Modified-Since HTTP Header. 575 */ 576 MODIFIEDSINCE, 577 /** 578 * Conditional reads are supported, but only with the If-None-Match HTTP Header. 579 */ 580 NOTMATCH, 581 /** 582 * Conditional reads are supported, with both If-Modified-Since and If-None-Match HTTP Headers. 583 */ 584 FULLSUPPORT, 585 /** 586 * added to help the parsers with the generic types 587 */ 588 NULL; 589 public static ConditionalReadStatus fromCode(String codeString) throws FHIRException { 590 if (codeString == null || "".equals(codeString)) 591 return null; 592 if ("not-supported".equals(codeString)) 593 return NOTSUPPORTED; 594 if ("modified-since".equals(codeString)) 595 return MODIFIEDSINCE; 596 if ("not-match".equals(codeString)) 597 return NOTMATCH; 598 if ("full-support".equals(codeString)) 599 return FULLSUPPORT; 600 if (Configuration.isAcceptInvalidEnums()) 601 return null; 602 else 603 throw new FHIRException("Unknown ConditionalReadStatus code '"+codeString+"'"); 604 } 605 public String toCode() { 606 switch (this) { 607 case NOTSUPPORTED: return "not-supported"; 608 case MODIFIEDSINCE: return "modified-since"; 609 case NOTMATCH: return "not-match"; 610 case FULLSUPPORT: return "full-support"; 611 default: return "?"; 612 } 613 } 614 public String getSystem() { 615 switch (this) { 616 case NOTSUPPORTED: return "http://hl7.org/fhir/conditional-read-status"; 617 case MODIFIEDSINCE: return "http://hl7.org/fhir/conditional-read-status"; 618 case NOTMATCH: return "http://hl7.org/fhir/conditional-read-status"; 619 case FULLSUPPORT: return "http://hl7.org/fhir/conditional-read-status"; 620 default: return "?"; 621 } 622 } 623 public String getDefinition() { 624 switch (this) { 625 case NOTSUPPORTED: return "No support for conditional reads."; 626 case MODIFIEDSINCE: return "Conditional reads are supported, but only with the If-Modified-Since HTTP Header."; 627 case NOTMATCH: return "Conditional reads are supported, but only with the If-None-Match HTTP Header."; 628 case FULLSUPPORT: return "Conditional reads are supported, with both If-Modified-Since and If-None-Match HTTP Headers."; 629 default: return "?"; 630 } 631 } 632 public String getDisplay() { 633 switch (this) { 634 case NOTSUPPORTED: return "Not Supported"; 635 case MODIFIEDSINCE: return "If-Modified-Since"; 636 case NOTMATCH: return "If-None-Match"; 637 case FULLSUPPORT: return "Full Support"; 638 default: return "?"; 639 } 640 } 641 } 642 643 public static class ConditionalReadStatusEnumFactory implements EnumFactory<ConditionalReadStatus> { 644 public ConditionalReadStatus fromCode(String codeString) throws IllegalArgumentException { 645 if (codeString == null || "".equals(codeString)) 646 if (codeString == null || "".equals(codeString)) 647 return null; 648 if ("not-supported".equals(codeString)) 649 return ConditionalReadStatus.NOTSUPPORTED; 650 if ("modified-since".equals(codeString)) 651 return ConditionalReadStatus.MODIFIEDSINCE; 652 if ("not-match".equals(codeString)) 653 return ConditionalReadStatus.NOTMATCH; 654 if ("full-support".equals(codeString)) 655 return ConditionalReadStatus.FULLSUPPORT; 656 throw new IllegalArgumentException("Unknown ConditionalReadStatus code '"+codeString+"'"); 657 } 658 public Enumeration<ConditionalReadStatus> fromType(Base code) throws FHIRException { 659 if (code == null) 660 return null; 661 if (code.isEmpty()) 662 return new Enumeration<ConditionalReadStatus>(this); 663 String codeString = ((PrimitiveType) code).asStringValue(); 664 if (codeString == null || "".equals(codeString)) 665 return null; 666 if ("not-supported".equals(codeString)) 667 return new Enumeration<ConditionalReadStatus>(this, ConditionalReadStatus.NOTSUPPORTED); 668 if ("modified-since".equals(codeString)) 669 return new Enumeration<ConditionalReadStatus>(this, ConditionalReadStatus.MODIFIEDSINCE); 670 if ("not-match".equals(codeString)) 671 return new Enumeration<ConditionalReadStatus>(this, ConditionalReadStatus.NOTMATCH); 672 if ("full-support".equals(codeString)) 673 return new Enumeration<ConditionalReadStatus>(this, ConditionalReadStatus.FULLSUPPORT); 674 throw new FHIRException("Unknown ConditionalReadStatus code '"+codeString+"'"); 675 } 676 public String toCode(ConditionalReadStatus code) { 677 if (code == ConditionalReadStatus.NOTSUPPORTED) 678 return "not-supported"; 679 if (code == ConditionalReadStatus.MODIFIEDSINCE) 680 return "modified-since"; 681 if (code == ConditionalReadStatus.NOTMATCH) 682 return "not-match"; 683 if (code == ConditionalReadStatus.FULLSUPPORT) 684 return "full-support"; 685 return "?"; 686 } 687 public String toSystem(ConditionalReadStatus code) { 688 return code.getSystem(); 689 } 690 } 691 692 public enum ConditionalDeleteStatus { 693 /** 694 * No support for conditional deletes. 695 */ 696 NOTSUPPORTED, 697 /** 698 * Conditional deletes are supported, but only single resources at a time. 699 */ 700 SINGLE, 701 /** 702 * Conditional deletes are supported, and multiple resources can be deleted in a single interaction. 703 */ 704 MULTIPLE, 705 /** 706 * added to help the parsers with the generic types 707 */ 708 NULL; 709 public static ConditionalDeleteStatus fromCode(String codeString) throws FHIRException { 710 if (codeString == null || "".equals(codeString)) 711 return null; 712 if ("not-supported".equals(codeString)) 713 return NOTSUPPORTED; 714 if ("single".equals(codeString)) 715 return SINGLE; 716 if ("multiple".equals(codeString)) 717 return MULTIPLE; 718 if (Configuration.isAcceptInvalidEnums()) 719 return null; 720 else 721 throw new FHIRException("Unknown ConditionalDeleteStatus code '"+codeString+"'"); 722 } 723 public String toCode() { 724 switch (this) { 725 case NOTSUPPORTED: return "not-supported"; 726 case SINGLE: return "single"; 727 case MULTIPLE: return "multiple"; 728 default: return "?"; 729 } 730 } 731 public String getSystem() { 732 switch (this) { 733 case NOTSUPPORTED: return "http://hl7.org/fhir/conditional-delete-status"; 734 case SINGLE: return "http://hl7.org/fhir/conditional-delete-status"; 735 case MULTIPLE: return "http://hl7.org/fhir/conditional-delete-status"; 736 default: return "?"; 737 } 738 } 739 public String getDefinition() { 740 switch (this) { 741 case NOTSUPPORTED: return "No support for conditional deletes."; 742 case SINGLE: return "Conditional deletes are supported, but only single resources at a time."; 743 case MULTIPLE: return "Conditional deletes are supported, and multiple resources can be deleted in a single interaction."; 744 default: return "?"; 745 } 746 } 747 public String getDisplay() { 748 switch (this) { 749 case NOTSUPPORTED: return "Not Supported"; 750 case SINGLE: return "Single Deletes Supported"; 751 case MULTIPLE: return "Multiple Deletes Supported"; 752 default: return "?"; 753 } 754 } 755 } 756 757 public static class ConditionalDeleteStatusEnumFactory implements EnumFactory<ConditionalDeleteStatus> { 758 public ConditionalDeleteStatus fromCode(String codeString) throws IllegalArgumentException { 759 if (codeString == null || "".equals(codeString)) 760 if (codeString == null || "".equals(codeString)) 761 return null; 762 if ("not-supported".equals(codeString)) 763 return ConditionalDeleteStatus.NOTSUPPORTED; 764 if ("single".equals(codeString)) 765 return ConditionalDeleteStatus.SINGLE; 766 if ("multiple".equals(codeString)) 767 return ConditionalDeleteStatus.MULTIPLE; 768 throw new IllegalArgumentException("Unknown ConditionalDeleteStatus code '"+codeString+"'"); 769 } 770 public Enumeration<ConditionalDeleteStatus> fromType(Base code) throws FHIRException { 771 if (code == null) 772 return null; 773 if (code.isEmpty()) 774 return new Enumeration<ConditionalDeleteStatus>(this); 775 String codeString = ((PrimitiveType) code).asStringValue(); 776 if (codeString == null || "".equals(codeString)) 777 return null; 778 if ("not-supported".equals(codeString)) 779 return new Enumeration<ConditionalDeleteStatus>(this, ConditionalDeleteStatus.NOTSUPPORTED); 780 if ("single".equals(codeString)) 781 return new Enumeration<ConditionalDeleteStatus>(this, ConditionalDeleteStatus.SINGLE); 782 if ("multiple".equals(codeString)) 783 return new Enumeration<ConditionalDeleteStatus>(this, ConditionalDeleteStatus.MULTIPLE); 784 throw new FHIRException("Unknown ConditionalDeleteStatus code '"+codeString+"'"); 785 } 786 public String toCode(ConditionalDeleteStatus code) { 787 if (code == ConditionalDeleteStatus.NOTSUPPORTED) 788 return "not-supported"; 789 if (code == ConditionalDeleteStatus.SINGLE) 790 return "single"; 791 if (code == ConditionalDeleteStatus.MULTIPLE) 792 return "multiple"; 793 return "?"; 794 } 795 public String toSystem(ConditionalDeleteStatus code) { 796 return code.getSystem(); 797 } 798 } 799 800 public enum ReferenceHandlingPolicy { 801 /** 802 * 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'). 803 */ 804 LITERAL, 805 /** 806 * The server allows logical references (i.e. using Reference.identifier). 807 */ 808 LOGICAL, 809 /** 810 * 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). 811 */ 812 RESOLVES, 813 /** 814 * 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. 815 */ 816 ENFORCED, 817 /** 818 * The server does not support references that point to other servers. 819 */ 820 LOCAL, 821 /** 822 * added to help the parsers with the generic types 823 */ 824 NULL; 825 public static ReferenceHandlingPolicy fromCode(String codeString) throws FHIRException { 826 if (codeString == null || "".equals(codeString)) 827 return null; 828 if ("literal".equals(codeString)) 829 return LITERAL; 830 if ("logical".equals(codeString)) 831 return LOGICAL; 832 if ("resolves".equals(codeString)) 833 return RESOLVES; 834 if ("enforced".equals(codeString)) 835 return ENFORCED; 836 if ("local".equals(codeString)) 837 return LOCAL; 838 if (Configuration.isAcceptInvalidEnums()) 839 return null; 840 else 841 throw new FHIRException("Unknown ReferenceHandlingPolicy code '"+codeString+"'"); 842 } 843 public String toCode() { 844 switch (this) { 845 case LITERAL: return "literal"; 846 case LOGICAL: return "logical"; 847 case RESOLVES: return "resolves"; 848 case ENFORCED: return "enforced"; 849 case LOCAL: return "local"; 850 default: return "?"; 851 } 852 } 853 public String getSystem() { 854 switch (this) { 855 case LITERAL: return "http://hl7.org/fhir/reference-handling-policy"; 856 case LOGICAL: return "http://hl7.org/fhir/reference-handling-policy"; 857 case RESOLVES: return "http://hl7.org/fhir/reference-handling-policy"; 858 case ENFORCED: return "http://hl7.org/fhir/reference-handling-policy"; 859 case LOCAL: return "http://hl7.org/fhir/reference-handling-policy"; 860 default: return "?"; 861 } 862 } 863 public String getDefinition() { 864 switch (this) { 865 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')."; 866 case LOGICAL: return "The server allows logical references (i.e. using Reference.identifier)."; 867 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)."; 868 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."; 869 case LOCAL: return "The server does not support references that point to other servers."; 870 default: return "?"; 871 } 872 } 873 public String getDisplay() { 874 switch (this) { 875 case LITERAL: return "Literal References"; 876 case LOGICAL: return "Logical References"; 877 case RESOLVES: return "Resolves References"; 878 case ENFORCED: return "Reference Integrity Enforced"; 879 case LOCAL: return "Local References Only"; 880 default: return "?"; 881 } 882 } 883 } 884 885 public static class ReferenceHandlingPolicyEnumFactory implements EnumFactory<ReferenceHandlingPolicy> { 886 public ReferenceHandlingPolicy fromCode(String codeString) throws IllegalArgumentException { 887 if (codeString == null || "".equals(codeString)) 888 if (codeString == null || "".equals(codeString)) 889 return null; 890 if ("literal".equals(codeString)) 891 return ReferenceHandlingPolicy.LITERAL; 892 if ("logical".equals(codeString)) 893 return ReferenceHandlingPolicy.LOGICAL; 894 if ("resolves".equals(codeString)) 895 return ReferenceHandlingPolicy.RESOLVES; 896 if ("enforced".equals(codeString)) 897 return ReferenceHandlingPolicy.ENFORCED; 898 if ("local".equals(codeString)) 899 return ReferenceHandlingPolicy.LOCAL; 900 throw new IllegalArgumentException("Unknown ReferenceHandlingPolicy code '"+codeString+"'"); 901 } 902 public Enumeration<ReferenceHandlingPolicy> fromType(Base code) throws FHIRException { 903 if (code == null) 904 return null; 905 if (code.isEmpty()) 906 return new Enumeration<ReferenceHandlingPolicy>(this); 907 String codeString = ((PrimitiveType) code).asStringValue(); 908 if (codeString == null || "".equals(codeString)) 909 return null; 910 if ("literal".equals(codeString)) 911 return new Enumeration<ReferenceHandlingPolicy>(this, ReferenceHandlingPolicy.LITERAL); 912 if ("logical".equals(codeString)) 913 return new Enumeration<ReferenceHandlingPolicy>(this, ReferenceHandlingPolicy.LOGICAL); 914 if ("resolves".equals(codeString)) 915 return new Enumeration<ReferenceHandlingPolicy>(this, ReferenceHandlingPolicy.RESOLVES); 916 if ("enforced".equals(codeString)) 917 return new Enumeration<ReferenceHandlingPolicy>(this, ReferenceHandlingPolicy.ENFORCED); 918 if ("local".equals(codeString)) 919 return new Enumeration<ReferenceHandlingPolicy>(this, ReferenceHandlingPolicy.LOCAL); 920 throw new FHIRException("Unknown ReferenceHandlingPolicy code '"+codeString+"'"); 921 } 922 public String toCode(ReferenceHandlingPolicy code) { 923 if (code == ReferenceHandlingPolicy.LITERAL) 924 return "literal"; 925 if (code == ReferenceHandlingPolicy.LOGICAL) 926 return "logical"; 927 if (code == ReferenceHandlingPolicy.RESOLVES) 928 return "resolves"; 929 if (code == ReferenceHandlingPolicy.ENFORCED) 930 return "enforced"; 931 if (code == ReferenceHandlingPolicy.LOCAL) 932 return "local"; 933 return "?"; 934 } 935 public String toSystem(ReferenceHandlingPolicy code) { 936 return code.getSystem(); 937 } 938 } 939 940 public enum SystemRestfulInteraction { 941 /** 942 * null 943 */ 944 TRANSACTION, 945 /** 946 * null 947 */ 948 BATCH, 949 /** 950 * null 951 */ 952 SEARCHSYSTEM, 953 /** 954 * null 955 */ 956 HISTORYSYSTEM, 957 /** 958 * added to help the parsers with the generic types 959 */ 960 NULL; 961 public static SystemRestfulInteraction fromCode(String codeString) throws FHIRException { 962 if (codeString == null || "".equals(codeString)) 963 return null; 964 if ("transaction".equals(codeString)) 965 return TRANSACTION; 966 if ("batch".equals(codeString)) 967 return BATCH; 968 if ("search-system".equals(codeString)) 969 return SEARCHSYSTEM; 970 if ("history-system".equals(codeString)) 971 return HISTORYSYSTEM; 972 if (Configuration.isAcceptInvalidEnums()) 973 return null; 974 else 975 throw new FHIRException("Unknown SystemRestfulInteraction code '"+codeString+"'"); 976 } 977 public String toCode() { 978 switch (this) { 979 case TRANSACTION: return "transaction"; 980 case BATCH: return "batch"; 981 case SEARCHSYSTEM: return "search-system"; 982 case HISTORYSYSTEM: return "history-system"; 983 default: return "?"; 984 } 985 } 986 public String getSystem() { 987 switch (this) { 988 case TRANSACTION: return "http://hl7.org/fhir/restful-interaction"; 989 case BATCH: return "http://hl7.org/fhir/restful-interaction"; 990 case SEARCHSYSTEM: return "http://hl7.org/fhir/restful-interaction"; 991 case HISTORYSYSTEM: return "http://hl7.org/fhir/restful-interaction"; 992 default: return "?"; 993 } 994 } 995 public String getDefinition() { 996 switch (this) { 997 case TRANSACTION: return ""; 998 case BATCH: return ""; 999 case SEARCHSYSTEM: return ""; 1000 case HISTORYSYSTEM: return ""; 1001 default: return "?"; 1002 } 1003 } 1004 public String getDisplay() { 1005 switch (this) { 1006 case TRANSACTION: return "transaction"; 1007 case BATCH: return "batch"; 1008 case SEARCHSYSTEM: return "search-system"; 1009 case HISTORYSYSTEM: return "history-system"; 1010 default: return "?"; 1011 } 1012 } 1013 } 1014 1015 public static class SystemRestfulInteractionEnumFactory implements EnumFactory<SystemRestfulInteraction> { 1016 public SystemRestfulInteraction fromCode(String codeString) throws IllegalArgumentException { 1017 if (codeString == null || "".equals(codeString)) 1018 if (codeString == null || "".equals(codeString)) 1019 return null; 1020 if ("transaction".equals(codeString)) 1021 return SystemRestfulInteraction.TRANSACTION; 1022 if ("batch".equals(codeString)) 1023 return SystemRestfulInteraction.BATCH; 1024 if ("search-system".equals(codeString)) 1025 return SystemRestfulInteraction.SEARCHSYSTEM; 1026 if ("history-system".equals(codeString)) 1027 return SystemRestfulInteraction.HISTORYSYSTEM; 1028 throw new IllegalArgumentException("Unknown SystemRestfulInteraction code '"+codeString+"'"); 1029 } 1030 public Enumeration<SystemRestfulInteraction> fromType(Base code) throws FHIRException { 1031 if (code == null) 1032 return null; 1033 if (code.isEmpty()) 1034 return new Enumeration<SystemRestfulInteraction>(this); 1035 String codeString = ((PrimitiveType) code).asStringValue(); 1036 if (codeString == null || "".equals(codeString)) 1037 return null; 1038 if ("transaction".equals(codeString)) 1039 return new Enumeration<SystemRestfulInteraction>(this, SystemRestfulInteraction.TRANSACTION); 1040 if ("batch".equals(codeString)) 1041 return new Enumeration<SystemRestfulInteraction>(this, SystemRestfulInteraction.BATCH); 1042 if ("search-system".equals(codeString)) 1043 return new Enumeration<SystemRestfulInteraction>(this, SystemRestfulInteraction.SEARCHSYSTEM); 1044 if ("history-system".equals(codeString)) 1045 return new Enumeration<SystemRestfulInteraction>(this, SystemRestfulInteraction.HISTORYSYSTEM); 1046 throw new FHIRException("Unknown SystemRestfulInteraction code '"+codeString+"'"); 1047 } 1048 public String toCode(SystemRestfulInteraction code) { 1049 if (code == SystemRestfulInteraction.TRANSACTION) 1050 return "transaction"; 1051 if (code == SystemRestfulInteraction.BATCH) 1052 return "batch"; 1053 if (code == SystemRestfulInteraction.SEARCHSYSTEM) 1054 return "search-system"; 1055 if (code == SystemRestfulInteraction.HISTORYSYSTEM) 1056 return "history-system"; 1057 return "?"; 1058 } 1059 public String toSystem(SystemRestfulInteraction code) { 1060 return code.getSystem(); 1061 } 1062 } 1063 1064 public enum EventCapabilityMode { 1065 /** 1066 * The application sends requests and receives responses. 1067 */ 1068 SENDER, 1069 /** 1070 * The application receives requests and sends responses. 1071 */ 1072 RECEIVER, 1073 /** 1074 * added to help the parsers with the generic types 1075 */ 1076 NULL; 1077 public static EventCapabilityMode fromCode(String codeString) throws FHIRException { 1078 if (codeString == null || "".equals(codeString)) 1079 return null; 1080 if ("sender".equals(codeString)) 1081 return SENDER; 1082 if ("receiver".equals(codeString)) 1083 return RECEIVER; 1084 if (Configuration.isAcceptInvalidEnums()) 1085 return null; 1086 else 1087 throw new FHIRException("Unknown EventCapabilityMode code '"+codeString+"'"); 1088 } 1089 public String toCode() { 1090 switch (this) { 1091 case SENDER: return "sender"; 1092 case RECEIVER: return "receiver"; 1093 default: return "?"; 1094 } 1095 } 1096 public String getSystem() { 1097 switch (this) { 1098 case SENDER: return "http://hl7.org/fhir/event-capability-mode"; 1099 case RECEIVER: return "http://hl7.org/fhir/event-capability-mode"; 1100 default: return "?"; 1101 } 1102 } 1103 public String getDefinition() { 1104 switch (this) { 1105 case SENDER: return "The application sends requests and receives responses."; 1106 case RECEIVER: return "The application receives requests and sends responses."; 1107 default: return "?"; 1108 } 1109 } 1110 public String getDisplay() { 1111 switch (this) { 1112 case SENDER: return "Sender"; 1113 case RECEIVER: return "Receiver"; 1114 default: return "?"; 1115 } 1116 } 1117 } 1118 1119 public static class EventCapabilityModeEnumFactory implements EnumFactory<EventCapabilityMode> { 1120 public EventCapabilityMode fromCode(String codeString) throws IllegalArgumentException { 1121 if (codeString == null || "".equals(codeString)) 1122 if (codeString == null || "".equals(codeString)) 1123 return null; 1124 if ("sender".equals(codeString)) 1125 return EventCapabilityMode.SENDER; 1126 if ("receiver".equals(codeString)) 1127 return EventCapabilityMode.RECEIVER; 1128 throw new IllegalArgumentException("Unknown EventCapabilityMode code '"+codeString+"'"); 1129 } 1130 public Enumeration<EventCapabilityMode> fromType(Base code) throws FHIRException { 1131 if (code == null) 1132 return null; 1133 if (code.isEmpty()) 1134 return new Enumeration<EventCapabilityMode>(this); 1135 String codeString = ((PrimitiveType) code).asStringValue(); 1136 if (codeString == null || "".equals(codeString)) 1137 return null; 1138 if ("sender".equals(codeString)) 1139 return new Enumeration<EventCapabilityMode>(this, EventCapabilityMode.SENDER); 1140 if ("receiver".equals(codeString)) 1141 return new Enumeration<EventCapabilityMode>(this, EventCapabilityMode.RECEIVER); 1142 throw new FHIRException("Unknown EventCapabilityMode code '"+codeString+"'"); 1143 } 1144 public String toCode(EventCapabilityMode code) { 1145 if (code == EventCapabilityMode.SENDER) 1146 return "sender"; 1147 if (code == EventCapabilityMode.RECEIVER) 1148 return "receiver"; 1149 return "?"; 1150 } 1151 public String toSystem(EventCapabilityMode code) { 1152 return code.getSystem(); 1153 } 1154 } 1155 1156 public enum DocumentMode { 1157 /** 1158 * The application produces documents of the specified type. 1159 */ 1160 PRODUCER, 1161 /** 1162 * The application consumes documents of the specified type. 1163 */ 1164 CONSUMER, 1165 /** 1166 * added to help the parsers with the generic types 1167 */ 1168 NULL; 1169 public static DocumentMode fromCode(String codeString) throws FHIRException { 1170 if (codeString == null || "".equals(codeString)) 1171 return null; 1172 if ("producer".equals(codeString)) 1173 return PRODUCER; 1174 if ("consumer".equals(codeString)) 1175 return CONSUMER; 1176 if (Configuration.isAcceptInvalidEnums()) 1177 return null; 1178 else 1179 throw new FHIRException("Unknown DocumentMode code '"+codeString+"'"); 1180 } 1181 public String toCode() { 1182 switch (this) { 1183 case PRODUCER: return "producer"; 1184 case CONSUMER: return "consumer"; 1185 default: return "?"; 1186 } 1187 } 1188 public String getSystem() { 1189 switch (this) { 1190 case PRODUCER: return "http://hl7.org/fhir/document-mode"; 1191 case CONSUMER: return "http://hl7.org/fhir/document-mode"; 1192 default: return "?"; 1193 } 1194 } 1195 public String getDefinition() { 1196 switch (this) { 1197 case PRODUCER: return "The application produces documents of the specified type."; 1198 case CONSUMER: return "The application consumes documents of the specified type."; 1199 default: return "?"; 1200 } 1201 } 1202 public String getDisplay() { 1203 switch (this) { 1204 case PRODUCER: return "Producer"; 1205 case CONSUMER: return "Consumer"; 1206 default: return "?"; 1207 } 1208 } 1209 } 1210 1211 public static class DocumentModeEnumFactory implements EnumFactory<DocumentMode> { 1212 public DocumentMode fromCode(String codeString) throws IllegalArgumentException { 1213 if (codeString == null || "".equals(codeString)) 1214 if (codeString == null || "".equals(codeString)) 1215 return null; 1216 if ("producer".equals(codeString)) 1217 return DocumentMode.PRODUCER; 1218 if ("consumer".equals(codeString)) 1219 return DocumentMode.CONSUMER; 1220 throw new IllegalArgumentException("Unknown DocumentMode code '"+codeString+"'"); 1221 } 1222 public Enumeration<DocumentMode> fromType(Base code) throws FHIRException { 1223 if (code == null) 1224 return null; 1225 if (code.isEmpty()) 1226 return new Enumeration<DocumentMode>(this); 1227 String codeString = ((PrimitiveType) code).asStringValue(); 1228 if (codeString == null || "".equals(codeString)) 1229 return null; 1230 if ("producer".equals(codeString)) 1231 return new Enumeration<DocumentMode>(this, DocumentMode.PRODUCER); 1232 if ("consumer".equals(codeString)) 1233 return new Enumeration<DocumentMode>(this, DocumentMode.CONSUMER); 1234 throw new FHIRException("Unknown DocumentMode code '"+codeString+"'"); 1235 } 1236 public String toCode(DocumentMode code) { 1237 if (code == DocumentMode.PRODUCER) 1238 return "producer"; 1239 if (code == DocumentMode.CONSUMER) 1240 return "consumer"; 1241 return "?"; 1242 } 1243 public String toSystem(DocumentMode code) { 1244 return code.getSystem(); 1245 } 1246 } 1247 1248 @Block() 1249 public static class CapabilityStatementSoftwareComponent extends BackboneElement implements IBaseBackboneElement { 1250 /** 1251 * Name the software is known by. 1252 */ 1253 @Child(name = "name", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true) 1254 @Description(shortDefinition="A name the software is known by", formalDefinition="Name the software is known by." ) 1255 protected StringType name; 1256 1257 /** 1258 * The version identifier for the software covered by this statement. 1259 */ 1260 @Child(name = "version", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true) 1261 @Description(shortDefinition="Version covered by this statement", formalDefinition="The version identifier for the software covered by this statement." ) 1262 protected StringType version; 1263 1264 /** 1265 * Date this version of the software was released. 1266 */ 1267 @Child(name = "releaseDate", type = {DateTimeType.class}, order=3, min=0, max=1, modifier=false, summary=true) 1268 @Description(shortDefinition="Date this version was released", formalDefinition="Date this version of the software was released." ) 1269 protected DateTimeType releaseDate; 1270 1271 private static final long serialVersionUID = 1819769027L; 1272 1273 /** 1274 * Constructor 1275 */ 1276 public CapabilityStatementSoftwareComponent() { 1277 super(); 1278 } 1279 1280 /** 1281 * Constructor 1282 */ 1283 public CapabilityStatementSoftwareComponent(StringType name) { 1284 super(); 1285 this.name = name; 1286 } 1287 1288 /** 1289 * @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 1290 */ 1291 public StringType getNameElement() { 1292 if (this.name == null) 1293 if (Configuration.errorOnAutoCreate()) 1294 throw new Error("Attempt to auto-create CapabilityStatementSoftwareComponent.name"); 1295 else if (Configuration.doAutoCreate()) 1296 this.name = new StringType(); // bb 1297 return this.name; 1298 } 1299 1300 public boolean hasNameElement() { 1301 return this.name != null && !this.name.isEmpty(); 1302 } 1303 1304 public boolean hasName() { 1305 return this.name != null && !this.name.isEmpty(); 1306 } 1307 1308 /** 1309 * @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 1310 */ 1311 public CapabilityStatementSoftwareComponent setNameElement(StringType value) { 1312 this.name = value; 1313 return this; 1314 } 1315 1316 /** 1317 * @return Name the software is known by. 1318 */ 1319 public String getName() { 1320 return this.name == null ? null : this.name.getValue(); 1321 } 1322 1323 /** 1324 * @param value Name the software is known by. 1325 */ 1326 public CapabilityStatementSoftwareComponent setName(String value) { 1327 if (this.name == null) 1328 this.name = new StringType(); 1329 this.name.setValue(value); 1330 return this; 1331 } 1332 1333 /** 1334 * @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 1335 */ 1336 public StringType getVersionElement() { 1337 if (this.version == null) 1338 if (Configuration.errorOnAutoCreate()) 1339 throw new Error("Attempt to auto-create CapabilityStatementSoftwareComponent.version"); 1340 else if (Configuration.doAutoCreate()) 1341 this.version = new StringType(); // bb 1342 return this.version; 1343 } 1344 1345 public boolean hasVersionElement() { 1346 return this.version != null && !this.version.isEmpty(); 1347 } 1348 1349 public boolean hasVersion() { 1350 return this.version != null && !this.version.isEmpty(); 1351 } 1352 1353 /** 1354 * @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 1355 */ 1356 public CapabilityStatementSoftwareComponent setVersionElement(StringType value) { 1357 this.version = value; 1358 return this; 1359 } 1360 1361 /** 1362 * @return The version identifier for the software covered by this statement. 1363 */ 1364 public String getVersion() { 1365 return this.version == null ? null : this.version.getValue(); 1366 } 1367 1368 /** 1369 * @param value The version identifier for the software covered by this statement. 1370 */ 1371 public CapabilityStatementSoftwareComponent setVersion(String value) { 1372 if (Utilities.noString(value)) 1373 this.version = null; 1374 else { 1375 if (this.version == null) 1376 this.version = new StringType(); 1377 this.version.setValue(value); 1378 } 1379 return this; 1380 } 1381 1382 /** 1383 * @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 1384 */ 1385 public DateTimeType getReleaseDateElement() { 1386 if (this.releaseDate == null) 1387 if (Configuration.errorOnAutoCreate()) 1388 throw new Error("Attempt to auto-create CapabilityStatementSoftwareComponent.releaseDate"); 1389 else if (Configuration.doAutoCreate()) 1390 this.releaseDate = new DateTimeType(); // bb 1391 return this.releaseDate; 1392 } 1393 1394 public boolean hasReleaseDateElement() { 1395 return this.releaseDate != null && !this.releaseDate.isEmpty(); 1396 } 1397 1398 public boolean hasReleaseDate() { 1399 return this.releaseDate != null && !this.releaseDate.isEmpty(); 1400 } 1401 1402 /** 1403 * @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 1404 */ 1405 public CapabilityStatementSoftwareComponent setReleaseDateElement(DateTimeType value) { 1406 this.releaseDate = value; 1407 return this; 1408 } 1409 1410 /** 1411 * @return Date this version of the software was released. 1412 */ 1413 public Date getReleaseDate() { 1414 return this.releaseDate == null ? null : this.releaseDate.getValue(); 1415 } 1416 1417 /** 1418 * @param value Date this version of the software was released. 1419 */ 1420 public CapabilityStatementSoftwareComponent setReleaseDate(Date value) { 1421 if (value == null) 1422 this.releaseDate = null; 1423 else { 1424 if (this.releaseDate == null) 1425 this.releaseDate = new DateTimeType(); 1426 this.releaseDate.setValue(value); 1427 } 1428 return this; 1429 } 1430 1431 protected void listChildren(List<Property> children) { 1432 super.listChildren(children); 1433 children.add(new Property("name", "string", "Name the software is known by.", 0, 1, name)); 1434 children.add(new Property("version", "string", "The version identifier for the software covered by this statement.", 0, 1, version)); 1435 children.add(new Property("releaseDate", "dateTime", "Date this version of the software was released.", 0, 1, releaseDate)); 1436 } 1437 1438 @Override 1439 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1440 switch (_hash) { 1441 case 3373707: /*name*/ return new Property("name", "string", "Name the software is known by.", 0, 1, name); 1442 case 351608024: /*version*/ return new Property("version", "string", "The version identifier for the software covered by this statement.", 0, 1, version); 1443 case 212873301: /*releaseDate*/ return new Property("releaseDate", "dateTime", "Date this version of the software was released.", 0, 1, releaseDate); 1444 default: return super.getNamedProperty(_hash, _name, _checkValid); 1445 } 1446 1447 } 1448 1449 @Override 1450 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1451 switch (hash) { 1452 case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType 1453 case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType 1454 case 212873301: /*releaseDate*/ return this.releaseDate == null ? new Base[0] : new Base[] {this.releaseDate}; // DateTimeType 1455 default: return super.getProperty(hash, name, checkValid); 1456 } 1457 1458 } 1459 1460 @Override 1461 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1462 switch (hash) { 1463 case 3373707: // name 1464 this.name = castToString(value); // StringType 1465 return value; 1466 case 351608024: // version 1467 this.version = castToString(value); // StringType 1468 return value; 1469 case 212873301: // releaseDate 1470 this.releaseDate = castToDateTime(value); // DateTimeType 1471 return value; 1472 default: return super.setProperty(hash, name, value); 1473 } 1474 1475 } 1476 1477 @Override 1478 public Base setProperty(String name, Base value) throws FHIRException { 1479 if (name.equals("name")) { 1480 this.name = castToString(value); // StringType 1481 } else if (name.equals("version")) { 1482 this.version = castToString(value); // StringType 1483 } else if (name.equals("releaseDate")) { 1484 this.releaseDate = castToDateTime(value); // DateTimeType 1485 } else 1486 return super.setProperty(name, value); 1487 return value; 1488 } 1489 1490 @Override 1491 public Base makeProperty(int hash, String name) throws FHIRException { 1492 switch (hash) { 1493 case 3373707: return getNameElement(); 1494 case 351608024: return getVersionElement(); 1495 case 212873301: return getReleaseDateElement(); 1496 default: return super.makeProperty(hash, name); 1497 } 1498 1499 } 1500 1501 @Override 1502 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1503 switch (hash) { 1504 case 3373707: /*name*/ return new String[] {"string"}; 1505 case 351608024: /*version*/ return new String[] {"string"}; 1506 case 212873301: /*releaseDate*/ return new String[] {"dateTime"}; 1507 default: return super.getTypesForProperty(hash, name); 1508 } 1509 1510 } 1511 1512 @Override 1513 public Base addChild(String name) throws FHIRException { 1514 if (name.equals("name")) { 1515 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.name"); 1516 } 1517 else if (name.equals("version")) { 1518 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.version"); 1519 } 1520 else if (name.equals("releaseDate")) { 1521 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.releaseDate"); 1522 } 1523 else 1524 return super.addChild(name); 1525 } 1526 1527 public CapabilityStatementSoftwareComponent copy() { 1528 CapabilityStatementSoftwareComponent dst = new CapabilityStatementSoftwareComponent(); 1529 copyValues(dst); 1530 return dst; 1531 } 1532 1533 public void copyValues(CapabilityStatementSoftwareComponent dst) { 1534 super.copyValues(dst); 1535 dst.name = name == null ? null : name.copy(); 1536 dst.version = version == null ? null : version.copy(); 1537 dst.releaseDate = releaseDate == null ? null : releaseDate.copy(); 1538 } 1539 1540 @Override 1541 public boolean equalsDeep(Base other_) { 1542 if (!super.equalsDeep(other_)) 1543 return false; 1544 if (!(other_ instanceof CapabilityStatementSoftwareComponent)) 1545 return false; 1546 CapabilityStatementSoftwareComponent o = (CapabilityStatementSoftwareComponent) other_; 1547 return compareDeep(name, o.name, true) && compareDeep(version, o.version, true) && compareDeep(releaseDate, o.releaseDate, true) 1548 ; 1549 } 1550 1551 @Override 1552 public boolean equalsShallow(Base other_) { 1553 if (!super.equalsShallow(other_)) 1554 return false; 1555 if (!(other_ instanceof CapabilityStatementSoftwareComponent)) 1556 return false; 1557 CapabilityStatementSoftwareComponent o = (CapabilityStatementSoftwareComponent) other_; 1558 return compareValues(name, o.name, true) && compareValues(version, o.version, true) && compareValues(releaseDate, o.releaseDate, true) 1559 ; 1560 } 1561 1562 public boolean isEmpty() { 1563 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, version, releaseDate 1564 ); 1565 } 1566 1567 public String fhirType() { 1568 return "CapabilityStatement.software"; 1569 1570 } 1571 1572 } 1573 1574 @Block() 1575 public static class CapabilityStatementImplementationComponent extends BackboneElement implements IBaseBackboneElement { 1576 /** 1577 * Information about the specific installation that this capability statement relates to. 1578 */ 1579 @Child(name = "description", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true) 1580 @Description(shortDefinition="Describes this specific instance", formalDefinition="Information about the specific installation that this capability statement relates to." ) 1581 protected StringType description; 1582 1583 /** 1584 * An absolute base URL for the implementation. This forms the base for REST interfaces as well as the mailbox and document interfaces. 1585 */ 1586 @Child(name = "url", type = {UrlType.class}, order=2, min=0, max=1, modifier=false, summary=true) 1587 @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." ) 1588 protected UrlType url; 1589 1590 /** 1591 * The organization responsible for the management of the instance and oversight of the data on the server at the specified URL. 1592 */ 1593 @Child(name = "custodian", type = {Organization.class}, order=3, min=0, max=1, modifier=false, summary=true) 1594 @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." ) 1595 protected Reference custodian; 1596 1597 /** 1598 * The actual object that is the target of the reference (The organization responsible for the management of the instance and oversight of the data on the server at the specified URL.) 1599 */ 1600 protected Organization custodianTarget; 1601 1602 private static final long serialVersionUID = -1705695694L; 1603 1604 /** 1605 * Constructor 1606 */ 1607 public CapabilityStatementImplementationComponent() { 1608 super(); 1609 } 1610 1611 /** 1612 * Constructor 1613 */ 1614 public CapabilityStatementImplementationComponent(StringType description) { 1615 super(); 1616 this.description = description; 1617 } 1618 1619 /** 1620 * @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 1621 */ 1622 public StringType getDescriptionElement() { 1623 if (this.description == null) 1624 if (Configuration.errorOnAutoCreate()) 1625 throw new Error("Attempt to auto-create CapabilityStatementImplementationComponent.description"); 1626 else if (Configuration.doAutoCreate()) 1627 this.description = new StringType(); // bb 1628 return this.description; 1629 } 1630 1631 public boolean hasDescriptionElement() { 1632 return this.description != null && !this.description.isEmpty(); 1633 } 1634 1635 public boolean hasDescription() { 1636 return this.description != null && !this.description.isEmpty(); 1637 } 1638 1639 /** 1640 * @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 1641 */ 1642 public CapabilityStatementImplementationComponent setDescriptionElement(StringType value) { 1643 this.description = value; 1644 return this; 1645 } 1646 1647 /** 1648 * @return Information about the specific installation that this capability statement relates to. 1649 */ 1650 public String getDescription() { 1651 return this.description == null ? null : this.description.getValue(); 1652 } 1653 1654 /** 1655 * @param value Information about the specific installation that this capability statement relates to. 1656 */ 1657 public CapabilityStatementImplementationComponent setDescription(String value) { 1658 if (this.description == null) 1659 this.description = new StringType(); 1660 this.description.setValue(value); 1661 return this; 1662 } 1663 1664 /** 1665 * @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 1666 */ 1667 public UrlType getUrlElement() { 1668 if (this.url == null) 1669 if (Configuration.errorOnAutoCreate()) 1670 throw new Error("Attempt to auto-create CapabilityStatementImplementationComponent.url"); 1671 else if (Configuration.doAutoCreate()) 1672 this.url = new UrlType(); // bb 1673 return this.url; 1674 } 1675 1676 public boolean hasUrlElement() { 1677 return this.url != null && !this.url.isEmpty(); 1678 } 1679 1680 public boolean hasUrl() { 1681 return this.url != null && !this.url.isEmpty(); 1682 } 1683 1684 /** 1685 * @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 1686 */ 1687 public CapabilityStatementImplementationComponent setUrlElement(UrlType value) { 1688 this.url = value; 1689 return this; 1690 } 1691 1692 /** 1693 * @return An absolute base URL for the implementation. This forms the base for REST interfaces as well as the mailbox and document interfaces. 1694 */ 1695 public String getUrl() { 1696 return this.url == null ? null : this.url.getValue(); 1697 } 1698 1699 /** 1700 * @param value An absolute base URL for the implementation. This forms the base for REST interfaces as well as the mailbox and document interfaces. 1701 */ 1702 public CapabilityStatementImplementationComponent setUrl(String value) { 1703 if (Utilities.noString(value)) 1704 this.url = null; 1705 else { 1706 if (this.url == null) 1707 this.url = new UrlType(); 1708 this.url.setValue(value); 1709 } 1710 return this; 1711 } 1712 1713 /** 1714 * @return {@link #custodian} (The organization responsible for the management of the instance and oversight of the data on the server at the specified URL.) 1715 */ 1716 public Reference getCustodian() { 1717 if (this.custodian == null) 1718 if (Configuration.errorOnAutoCreate()) 1719 throw new Error("Attempt to auto-create CapabilityStatementImplementationComponent.custodian"); 1720 else if (Configuration.doAutoCreate()) 1721 this.custodian = new Reference(); // cc 1722 return this.custodian; 1723 } 1724 1725 public boolean hasCustodian() { 1726 return this.custodian != null && !this.custodian.isEmpty(); 1727 } 1728 1729 /** 1730 * @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.) 1731 */ 1732 public CapabilityStatementImplementationComponent setCustodian(Reference value) { 1733 this.custodian = value; 1734 return this; 1735 } 1736 1737 /** 1738 * @return {@link #custodian} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The organization responsible for the management of the instance and oversight of the data on the server at the specified URL.) 1739 */ 1740 public Organization getCustodianTarget() { 1741 if (this.custodianTarget == null) 1742 if (Configuration.errorOnAutoCreate()) 1743 throw new Error("Attempt to auto-create CapabilityStatementImplementationComponent.custodian"); 1744 else if (Configuration.doAutoCreate()) 1745 this.custodianTarget = new Organization(); // aa 1746 return this.custodianTarget; 1747 } 1748 1749 /** 1750 * @param value {@link #custodian} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The organization responsible for the management of the instance and oversight of the data on the server at the specified URL.) 1751 */ 1752 public CapabilityStatementImplementationComponent setCustodianTarget(Organization value) { 1753 this.custodianTarget = value; 1754 return this; 1755 } 1756 1757 protected void listChildren(List<Property> children) { 1758 super.listChildren(children); 1759 children.add(new Property("description", "string", "Information about the specific installation that this capability statement relates to.", 0, 1, description)); 1760 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)); 1761 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)); 1762 } 1763 1764 @Override 1765 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1766 switch (_hash) { 1767 case -1724546052: /*description*/ return new Property("description", "string", "Information about the specific installation that this capability statement relates to.", 0, 1, description); 1768 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); 1769 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); 1770 default: return super.getNamedProperty(_hash, _name, _checkValid); 1771 } 1772 1773 } 1774 1775 @Override 1776 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1777 switch (hash) { 1778 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType 1779 case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UrlType 1780 case 1611297262: /*custodian*/ return this.custodian == null ? new Base[0] : new Base[] {this.custodian}; // Reference 1781 default: return super.getProperty(hash, name, checkValid); 1782 } 1783 1784 } 1785 1786 @Override 1787 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1788 switch (hash) { 1789 case -1724546052: // description 1790 this.description = castToString(value); // StringType 1791 return value; 1792 case 116079: // url 1793 this.url = castToUrl(value); // UrlType 1794 return value; 1795 case 1611297262: // custodian 1796 this.custodian = castToReference(value); // Reference 1797 return value; 1798 default: return super.setProperty(hash, name, value); 1799 } 1800 1801 } 1802 1803 @Override 1804 public Base setProperty(String name, Base value) throws FHIRException { 1805 if (name.equals("description")) { 1806 this.description = castToString(value); // StringType 1807 } else if (name.equals("url")) { 1808 this.url = castToUrl(value); // UrlType 1809 } else if (name.equals("custodian")) { 1810 this.custodian = castToReference(value); // Reference 1811 } else 1812 return super.setProperty(name, value); 1813 return value; 1814 } 1815 1816 @Override 1817 public Base makeProperty(int hash, String name) throws FHIRException { 1818 switch (hash) { 1819 case -1724546052: return getDescriptionElement(); 1820 case 116079: return getUrlElement(); 1821 case 1611297262: return getCustodian(); 1822 default: return super.makeProperty(hash, name); 1823 } 1824 1825 } 1826 1827 @Override 1828 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1829 switch (hash) { 1830 case -1724546052: /*description*/ return new String[] {"string"}; 1831 case 116079: /*url*/ return new String[] {"url"}; 1832 case 1611297262: /*custodian*/ return new String[] {"Reference"}; 1833 default: return super.getTypesForProperty(hash, name); 1834 } 1835 1836 } 1837 1838 @Override 1839 public Base addChild(String name) throws FHIRException { 1840 if (name.equals("description")) { 1841 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.description"); 1842 } 1843 else if (name.equals("url")) { 1844 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.url"); 1845 } 1846 else if (name.equals("custodian")) { 1847 this.custodian = new Reference(); 1848 return this.custodian; 1849 } 1850 else 1851 return super.addChild(name); 1852 } 1853 1854 public CapabilityStatementImplementationComponent copy() { 1855 CapabilityStatementImplementationComponent dst = new CapabilityStatementImplementationComponent(); 1856 copyValues(dst); 1857 return dst; 1858 } 1859 1860 public void copyValues(CapabilityStatementImplementationComponent dst) { 1861 super.copyValues(dst); 1862 dst.description = description == null ? null : description.copy(); 1863 dst.url = url == null ? null : url.copy(); 1864 dst.custodian = custodian == null ? null : custodian.copy(); 1865 } 1866 1867 @Override 1868 public boolean equalsDeep(Base other_) { 1869 if (!super.equalsDeep(other_)) 1870 return false; 1871 if (!(other_ instanceof CapabilityStatementImplementationComponent)) 1872 return false; 1873 CapabilityStatementImplementationComponent o = (CapabilityStatementImplementationComponent) other_; 1874 return compareDeep(description, o.description, true) && compareDeep(url, o.url, true) && compareDeep(custodian, o.custodian, true) 1875 ; 1876 } 1877 1878 @Override 1879 public boolean equalsShallow(Base other_) { 1880 if (!super.equalsShallow(other_)) 1881 return false; 1882 if (!(other_ instanceof CapabilityStatementImplementationComponent)) 1883 return false; 1884 CapabilityStatementImplementationComponent o = (CapabilityStatementImplementationComponent) other_; 1885 return compareValues(description, o.description, true) && compareValues(url, o.url, true); 1886 } 1887 1888 public boolean isEmpty() { 1889 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(description, url, custodian 1890 ); 1891 } 1892 1893 public String fhirType() { 1894 return "CapabilityStatement.implementation"; 1895 1896 } 1897 1898 } 1899 1900 @Block() 1901 public static class CapabilityStatementRestComponent extends BackboneElement implements IBaseBackboneElement { 1902 /** 1903 * Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations. 1904 */ 1905 @Child(name = "mode", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true) 1906 @Description(shortDefinition="client | server", formalDefinition="Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations." ) 1907 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/restful-capability-mode") 1908 protected Enumeration<RestfulCapabilityMode> mode; 1909 1910 /** 1911 * Information about the system's restful capabilities that apply across all applications, such as security. 1912 */ 1913 @Child(name = "documentation", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=false) 1914 @Description(shortDefinition="General description of implementation", formalDefinition="Information about the system's restful capabilities that apply across all applications, such as security." ) 1915 protected MarkdownType documentation; 1916 1917 /** 1918 * Information about security implementation from an interface perspective - what a client needs to know. 1919 */ 1920 @Child(name = "security", type = {}, order=3, min=0, max=1, modifier=false, summary=true) 1921 @Description(shortDefinition="Information about security of implementation", formalDefinition="Information about security implementation from an interface perspective - what a client needs to know." ) 1922 protected CapabilityStatementRestSecurityComponent security; 1923 1924 /** 1925 * A specification of the restful capabilities of the solution for a specific resource type. 1926 */ 1927 @Child(name = "resource", type = {}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 1928 @Description(shortDefinition="Resource served on the REST interface", formalDefinition="A specification of the restful capabilities of the solution for a specific resource type." ) 1929 protected List<CapabilityStatementRestResourceComponent> resource; 1930 1931 /** 1932 * A specification of restful operations supported by the system. 1933 */ 1934 @Child(name = "interaction", type = {}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1935 @Description(shortDefinition="What operations are supported?", formalDefinition="A specification of restful operations supported by the system." ) 1936 protected List<SystemInteractionComponent> interaction; 1937 1938 /** 1939 * 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. 1940 */ 1941 @Child(name = "searchParam", type = {CapabilityStatementRestResourceSearchParamComponent.class}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1942 @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." ) 1943 protected List<CapabilityStatementRestResourceSearchParamComponent> searchParam; 1944 1945 /** 1946 * Definition of an operation or a named query together with its parameters and their meaning and type. 1947 */ 1948 @Child(name = "operation", type = {CapabilityStatementRestResourceOperationComponent.class}, order=7, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 1949 @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." ) 1950 protected List<CapabilityStatementRestResourceOperationComponent> operation; 1951 1952 /** 1953 * 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 . 1954 */ 1955 @Child(name = "compartment", type = {CanonicalType.class}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1956 @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 ." ) 1957 protected List<CanonicalType> compartment; 1958 1959 private static final long serialVersionUID = -1442029817L; 1960 1961 /** 1962 * Constructor 1963 */ 1964 public CapabilityStatementRestComponent() { 1965 super(); 1966 } 1967 1968 /** 1969 * Constructor 1970 */ 1971 public CapabilityStatementRestComponent(Enumeration<RestfulCapabilityMode> mode) { 1972 super(); 1973 this.mode = mode; 1974 } 1975 1976 /** 1977 * @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 1978 */ 1979 public Enumeration<RestfulCapabilityMode> getModeElement() { 1980 if (this.mode == null) 1981 if (Configuration.errorOnAutoCreate()) 1982 throw new Error("Attempt to auto-create CapabilityStatementRestComponent.mode"); 1983 else if (Configuration.doAutoCreate()) 1984 this.mode = new Enumeration<RestfulCapabilityMode>(new RestfulCapabilityModeEnumFactory()); // bb 1985 return this.mode; 1986 } 1987 1988 public boolean hasModeElement() { 1989 return this.mode != null && !this.mode.isEmpty(); 1990 } 1991 1992 public boolean hasMode() { 1993 return this.mode != null && !this.mode.isEmpty(); 1994 } 1995 1996 /** 1997 * @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 1998 */ 1999 public CapabilityStatementRestComponent setModeElement(Enumeration<RestfulCapabilityMode> value) { 2000 this.mode = value; 2001 return this; 2002 } 2003 2004 /** 2005 * @return Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations. 2006 */ 2007 public RestfulCapabilityMode getMode() { 2008 return this.mode == null ? null : this.mode.getValue(); 2009 } 2010 2011 /** 2012 * @param value Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations. 2013 */ 2014 public CapabilityStatementRestComponent setMode(RestfulCapabilityMode value) { 2015 if (this.mode == null) 2016 this.mode = new Enumeration<RestfulCapabilityMode>(new RestfulCapabilityModeEnumFactory()); 2017 this.mode.setValue(value); 2018 return this; 2019 } 2020 2021 /** 2022 * @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 2023 */ 2024 public MarkdownType getDocumentationElement() { 2025 if (this.documentation == null) 2026 if (Configuration.errorOnAutoCreate()) 2027 throw new Error("Attempt to auto-create CapabilityStatementRestComponent.documentation"); 2028 else if (Configuration.doAutoCreate()) 2029 this.documentation = new MarkdownType(); // bb 2030 return this.documentation; 2031 } 2032 2033 public boolean hasDocumentationElement() { 2034 return this.documentation != null && !this.documentation.isEmpty(); 2035 } 2036 2037 public boolean hasDocumentation() { 2038 return this.documentation != null && !this.documentation.isEmpty(); 2039 } 2040 2041 /** 2042 * @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 2043 */ 2044 public CapabilityStatementRestComponent setDocumentationElement(MarkdownType value) { 2045 this.documentation = value; 2046 return this; 2047 } 2048 2049 /** 2050 * @return Information about the system's restful capabilities that apply across all applications, such as security. 2051 */ 2052 public String getDocumentation() { 2053 return this.documentation == null ? null : this.documentation.getValue(); 2054 } 2055 2056 /** 2057 * @param value Information about the system's restful capabilities that apply across all applications, such as security. 2058 */ 2059 public CapabilityStatementRestComponent setDocumentation(String value) { 2060 if (value == null) 2061 this.documentation = null; 2062 else { 2063 if (this.documentation == null) 2064 this.documentation = new MarkdownType(); 2065 this.documentation.setValue(value); 2066 } 2067 return this; 2068 } 2069 2070 /** 2071 * @return {@link #security} (Information about security implementation from an interface perspective - what a client needs to know.) 2072 */ 2073 public CapabilityStatementRestSecurityComponent getSecurity() { 2074 if (this.security == null) 2075 if (Configuration.errorOnAutoCreate()) 2076 throw new Error("Attempt to auto-create CapabilityStatementRestComponent.security"); 2077 else if (Configuration.doAutoCreate()) 2078 this.security = new CapabilityStatementRestSecurityComponent(); // cc 2079 return this.security; 2080 } 2081 2082 public boolean hasSecurity() { 2083 return this.security != null && !this.security.isEmpty(); 2084 } 2085 2086 /** 2087 * @param value {@link #security} (Information about security implementation from an interface perspective - what a client needs to know.) 2088 */ 2089 public CapabilityStatementRestComponent setSecurity(CapabilityStatementRestSecurityComponent value) { 2090 this.security = value; 2091 return this; 2092 } 2093 2094 /** 2095 * @return {@link #resource} (A specification of the restful capabilities of the solution for a specific resource type.) 2096 */ 2097 public List<CapabilityStatementRestResourceComponent> getResource() { 2098 if (this.resource == null) 2099 this.resource = new ArrayList<CapabilityStatementRestResourceComponent>(); 2100 return this.resource; 2101 } 2102 2103 /** 2104 * @return Returns a reference to <code>this</code> for easy method chaining 2105 */ 2106 public CapabilityStatementRestComponent setResource(List<CapabilityStatementRestResourceComponent> theResource) { 2107 this.resource = theResource; 2108 return this; 2109 } 2110 2111 public boolean hasResource() { 2112 if (this.resource == null) 2113 return false; 2114 for (CapabilityStatementRestResourceComponent item : this.resource) 2115 if (!item.isEmpty()) 2116 return true; 2117 return false; 2118 } 2119 2120 public CapabilityStatementRestResourceComponent addResource() { //3 2121 CapabilityStatementRestResourceComponent t = new CapabilityStatementRestResourceComponent(); 2122 if (this.resource == null) 2123 this.resource = new ArrayList<CapabilityStatementRestResourceComponent>(); 2124 this.resource.add(t); 2125 return t; 2126 } 2127 2128 public CapabilityStatementRestComponent addResource(CapabilityStatementRestResourceComponent t) { //3 2129 if (t == null) 2130 return this; 2131 if (this.resource == null) 2132 this.resource = new ArrayList<CapabilityStatementRestResourceComponent>(); 2133 this.resource.add(t); 2134 return this; 2135 } 2136 2137 /** 2138 * @return The first repetition of repeating field {@link #resource}, creating it if it does not already exist 2139 */ 2140 public CapabilityStatementRestResourceComponent getResourceFirstRep() { 2141 if (getResource().isEmpty()) { 2142 addResource(); 2143 } 2144 return getResource().get(0); 2145 } 2146 2147 /** 2148 * @return {@link #interaction} (A specification of restful operations supported by the system.) 2149 */ 2150 public List<SystemInteractionComponent> getInteraction() { 2151 if (this.interaction == null) 2152 this.interaction = new ArrayList<SystemInteractionComponent>(); 2153 return this.interaction; 2154 } 2155 2156 /** 2157 * @return Returns a reference to <code>this</code> for easy method chaining 2158 */ 2159 public CapabilityStatementRestComponent setInteraction(List<SystemInteractionComponent> theInteraction) { 2160 this.interaction = theInteraction; 2161 return this; 2162 } 2163 2164 public boolean hasInteraction() { 2165 if (this.interaction == null) 2166 return false; 2167 for (SystemInteractionComponent item : this.interaction) 2168 if (!item.isEmpty()) 2169 return true; 2170 return false; 2171 } 2172 2173 public SystemInteractionComponent addInteraction() { //3 2174 SystemInteractionComponent t = new SystemInteractionComponent(); 2175 if (this.interaction == null) 2176 this.interaction = new ArrayList<SystemInteractionComponent>(); 2177 this.interaction.add(t); 2178 return t; 2179 } 2180 2181 public CapabilityStatementRestComponent addInteraction(SystemInteractionComponent t) { //3 2182 if (t == null) 2183 return this; 2184 if (this.interaction == null) 2185 this.interaction = new ArrayList<SystemInteractionComponent>(); 2186 this.interaction.add(t); 2187 return this; 2188 } 2189 2190 /** 2191 * @return The first repetition of repeating field {@link #interaction}, creating it if it does not already exist 2192 */ 2193 public SystemInteractionComponent getInteractionFirstRep() { 2194 if (getInteraction().isEmpty()) { 2195 addInteraction(); 2196 } 2197 return getInteraction().get(0); 2198 } 2199 2200 /** 2201 * @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.) 2202 */ 2203 public List<CapabilityStatementRestResourceSearchParamComponent> getSearchParam() { 2204 if (this.searchParam == null) 2205 this.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>(); 2206 return this.searchParam; 2207 } 2208 2209 /** 2210 * @return Returns a reference to <code>this</code> for easy method chaining 2211 */ 2212 public CapabilityStatementRestComponent setSearchParam(List<CapabilityStatementRestResourceSearchParamComponent> theSearchParam) { 2213 this.searchParam = theSearchParam; 2214 return this; 2215 } 2216 2217 public boolean hasSearchParam() { 2218 if (this.searchParam == null) 2219 return false; 2220 for (CapabilityStatementRestResourceSearchParamComponent item : this.searchParam) 2221 if (!item.isEmpty()) 2222 return true; 2223 return false; 2224 } 2225 2226 public CapabilityStatementRestResourceSearchParamComponent addSearchParam() { //3 2227 CapabilityStatementRestResourceSearchParamComponent t = new CapabilityStatementRestResourceSearchParamComponent(); 2228 if (this.searchParam == null) 2229 this.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>(); 2230 this.searchParam.add(t); 2231 return t; 2232 } 2233 2234 public CapabilityStatementRestComponent addSearchParam(CapabilityStatementRestResourceSearchParamComponent t) { //3 2235 if (t == null) 2236 return this; 2237 if (this.searchParam == null) 2238 this.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>(); 2239 this.searchParam.add(t); 2240 return this; 2241 } 2242 2243 /** 2244 * @return The first repetition of repeating field {@link #searchParam}, creating it if it does not already exist 2245 */ 2246 public CapabilityStatementRestResourceSearchParamComponent getSearchParamFirstRep() { 2247 if (getSearchParam().isEmpty()) { 2248 addSearchParam(); 2249 } 2250 return getSearchParam().get(0); 2251 } 2252 2253 /** 2254 * @return {@link #operation} (Definition of an operation or a named query together with its parameters and their meaning and type.) 2255 */ 2256 public List<CapabilityStatementRestResourceOperationComponent> getOperation() { 2257 if (this.operation == null) 2258 this.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>(); 2259 return this.operation; 2260 } 2261 2262 /** 2263 * @return Returns a reference to <code>this</code> for easy method chaining 2264 */ 2265 public CapabilityStatementRestComponent setOperation(List<CapabilityStatementRestResourceOperationComponent> theOperation) { 2266 this.operation = theOperation; 2267 return this; 2268 } 2269 2270 public boolean hasOperation() { 2271 if (this.operation == null) 2272 return false; 2273 for (CapabilityStatementRestResourceOperationComponent item : this.operation) 2274 if (!item.isEmpty()) 2275 return true; 2276 return false; 2277 } 2278 2279 public CapabilityStatementRestResourceOperationComponent addOperation() { //3 2280 CapabilityStatementRestResourceOperationComponent t = new CapabilityStatementRestResourceOperationComponent(); 2281 if (this.operation == null) 2282 this.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>(); 2283 this.operation.add(t); 2284 return t; 2285 } 2286 2287 public CapabilityStatementRestComponent addOperation(CapabilityStatementRestResourceOperationComponent t) { //3 2288 if (t == null) 2289 return this; 2290 if (this.operation == null) 2291 this.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>(); 2292 this.operation.add(t); 2293 return this; 2294 } 2295 2296 /** 2297 * @return The first repetition of repeating field {@link #operation}, creating it if it does not already exist 2298 */ 2299 public CapabilityStatementRestResourceOperationComponent getOperationFirstRep() { 2300 if (getOperation().isEmpty()) { 2301 addOperation(); 2302 } 2303 return getOperation().get(0); 2304 } 2305 2306 /** 2307 * @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 .) 2308 */ 2309 public List<CanonicalType> getCompartment() { 2310 if (this.compartment == null) 2311 this.compartment = new ArrayList<CanonicalType>(); 2312 return this.compartment; 2313 } 2314 2315 /** 2316 * @return Returns a reference to <code>this</code> for easy method chaining 2317 */ 2318 public CapabilityStatementRestComponent setCompartment(List<CanonicalType> theCompartment) { 2319 this.compartment = theCompartment; 2320 return this; 2321 } 2322 2323 public boolean hasCompartment() { 2324 if (this.compartment == null) 2325 return false; 2326 for (CanonicalType item : this.compartment) 2327 if (!item.isEmpty()) 2328 return true; 2329 return false; 2330 } 2331 2332 /** 2333 * @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 .) 2334 */ 2335 public CanonicalType addCompartmentElement() {//2 2336 CanonicalType t = new CanonicalType(); 2337 if (this.compartment == null) 2338 this.compartment = new ArrayList<CanonicalType>(); 2339 this.compartment.add(t); 2340 return t; 2341 } 2342 2343 /** 2344 * @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 .) 2345 */ 2346 public CapabilityStatementRestComponent addCompartment(String value) { //1 2347 CanonicalType t = new CanonicalType(); 2348 t.setValue(value); 2349 if (this.compartment == null) 2350 this.compartment = new ArrayList<CanonicalType>(); 2351 this.compartment.add(t); 2352 return this; 2353 } 2354 2355 /** 2356 * @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 .) 2357 */ 2358 public boolean hasCompartment(String value) { 2359 if (this.compartment == null) 2360 return false; 2361 for (CanonicalType v : this.compartment) 2362 if (v.getValue().equals(value)) // canonical(CompartmentDefinition) 2363 return true; 2364 return false; 2365 } 2366 2367 protected void listChildren(List<Property> children) { 2368 super.listChildren(children); 2369 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)); 2370 children.add(new Property("documentation", "markdown", "Information about the system's restful capabilities that apply across all applications, such as security.", 0, 1, documentation)); 2371 children.add(new Property("security", "", "Information about security implementation from an interface perspective - what a client needs to know.", 0, 1, security)); 2372 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)); 2373 children.add(new Property("interaction", "", "A specification of restful operations supported by the system.", 0, java.lang.Integer.MAX_VALUE, interaction)); 2374 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)); 2375 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)); 2376 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)); 2377 } 2378 2379 @Override 2380 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 2381 switch (_hash) { 2382 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); 2383 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); 2384 case 949122880: /*security*/ return new Property("security", "", "Information about security implementation from an interface perspective - what a client needs to know.", 0, 1, security); 2385 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); 2386 case 1844104722: /*interaction*/ return new Property("interaction", "", "A specification of restful operations supported by the system.", 0, java.lang.Integer.MAX_VALUE, interaction); 2387 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); 2388 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); 2389 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); 2390 default: return super.getNamedProperty(_hash, _name, _checkValid); 2391 } 2392 2393 } 2394 2395 @Override 2396 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 2397 switch (hash) { 2398 case 3357091: /*mode*/ return this.mode == null ? new Base[0] : new Base[] {this.mode}; // Enumeration<RestfulCapabilityMode> 2399 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 2400 case 949122880: /*security*/ return this.security == null ? new Base[0] : new Base[] {this.security}; // CapabilityStatementRestSecurityComponent 2401 case -341064690: /*resource*/ return this.resource == null ? new Base[0] : this.resource.toArray(new Base[this.resource.size()]); // CapabilityStatementRestResourceComponent 2402 case 1844104722: /*interaction*/ return this.interaction == null ? new Base[0] : this.interaction.toArray(new Base[this.interaction.size()]); // SystemInteractionComponent 2403 case -553645115: /*searchParam*/ return this.searchParam == null ? new Base[0] : this.searchParam.toArray(new Base[this.searchParam.size()]); // CapabilityStatementRestResourceSearchParamComponent 2404 case 1662702951: /*operation*/ return this.operation == null ? new Base[0] : this.operation.toArray(new Base[this.operation.size()]); // CapabilityStatementRestResourceOperationComponent 2405 case -397756334: /*compartment*/ return this.compartment == null ? new Base[0] : this.compartment.toArray(new Base[this.compartment.size()]); // CanonicalType 2406 default: return super.getProperty(hash, name, checkValid); 2407 } 2408 2409 } 2410 2411 @Override 2412 public Base setProperty(int hash, String name, Base value) throws FHIRException { 2413 switch (hash) { 2414 case 3357091: // mode 2415 value = new RestfulCapabilityModeEnumFactory().fromType(castToCode(value)); 2416 this.mode = (Enumeration) value; // Enumeration<RestfulCapabilityMode> 2417 return value; 2418 case 1587405498: // documentation 2419 this.documentation = castToMarkdown(value); // MarkdownType 2420 return value; 2421 case 949122880: // security 2422 this.security = (CapabilityStatementRestSecurityComponent) value; // CapabilityStatementRestSecurityComponent 2423 return value; 2424 case -341064690: // resource 2425 this.getResource().add((CapabilityStatementRestResourceComponent) value); // CapabilityStatementRestResourceComponent 2426 return value; 2427 case 1844104722: // interaction 2428 this.getInteraction().add((SystemInteractionComponent) value); // SystemInteractionComponent 2429 return value; 2430 case -553645115: // searchParam 2431 this.getSearchParam().add((CapabilityStatementRestResourceSearchParamComponent) value); // CapabilityStatementRestResourceSearchParamComponent 2432 return value; 2433 case 1662702951: // operation 2434 this.getOperation().add((CapabilityStatementRestResourceOperationComponent) value); // CapabilityStatementRestResourceOperationComponent 2435 return value; 2436 case -397756334: // compartment 2437 this.getCompartment().add(castToCanonical(value)); // CanonicalType 2438 return value; 2439 default: return super.setProperty(hash, name, value); 2440 } 2441 2442 } 2443 2444 @Override 2445 public Base setProperty(String name, Base value) throws FHIRException { 2446 if (name.equals("mode")) { 2447 value = new RestfulCapabilityModeEnumFactory().fromType(castToCode(value)); 2448 this.mode = (Enumeration) value; // Enumeration<RestfulCapabilityMode> 2449 } else if (name.equals("documentation")) { 2450 this.documentation = castToMarkdown(value); // MarkdownType 2451 } else if (name.equals("security")) { 2452 this.security = (CapabilityStatementRestSecurityComponent) value; // CapabilityStatementRestSecurityComponent 2453 } else if (name.equals("resource")) { 2454 this.getResource().add((CapabilityStatementRestResourceComponent) value); 2455 } else if (name.equals("interaction")) { 2456 this.getInteraction().add((SystemInteractionComponent) value); 2457 } else if (name.equals("searchParam")) { 2458 this.getSearchParam().add((CapabilityStatementRestResourceSearchParamComponent) value); 2459 } else if (name.equals("operation")) { 2460 this.getOperation().add((CapabilityStatementRestResourceOperationComponent) value); 2461 } else if (name.equals("compartment")) { 2462 this.getCompartment().add(castToCanonical(value)); 2463 } else 2464 return super.setProperty(name, value); 2465 return value; 2466 } 2467 2468 @Override 2469 public Base makeProperty(int hash, String name) throws FHIRException { 2470 switch (hash) { 2471 case 3357091: return getModeElement(); 2472 case 1587405498: return getDocumentationElement(); 2473 case 949122880: return getSecurity(); 2474 case -341064690: return addResource(); 2475 case 1844104722: return addInteraction(); 2476 case -553645115: return addSearchParam(); 2477 case 1662702951: return addOperation(); 2478 case -397756334: return addCompartmentElement(); 2479 default: return super.makeProperty(hash, name); 2480 } 2481 2482 } 2483 2484 @Override 2485 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 2486 switch (hash) { 2487 case 3357091: /*mode*/ return new String[] {"code"}; 2488 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 2489 case 949122880: /*security*/ return new String[] {}; 2490 case -341064690: /*resource*/ return new String[] {}; 2491 case 1844104722: /*interaction*/ return new String[] {}; 2492 case -553645115: /*searchParam*/ return new String[] {"@CapabilityStatement.rest.resource.searchParam"}; 2493 case 1662702951: /*operation*/ return new String[] {"@CapabilityStatement.rest.resource.operation"}; 2494 case -397756334: /*compartment*/ return new String[] {"canonical"}; 2495 default: return super.getTypesForProperty(hash, name); 2496 } 2497 2498 } 2499 2500 @Override 2501 public Base addChild(String name) throws FHIRException { 2502 if (name.equals("mode")) { 2503 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.mode"); 2504 } 2505 else if (name.equals("documentation")) { 2506 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.documentation"); 2507 } 2508 else if (name.equals("security")) { 2509 this.security = new CapabilityStatementRestSecurityComponent(); 2510 return this.security; 2511 } 2512 else if (name.equals("resource")) { 2513 return addResource(); 2514 } 2515 else if (name.equals("interaction")) { 2516 return addInteraction(); 2517 } 2518 else if (name.equals("searchParam")) { 2519 return addSearchParam(); 2520 } 2521 else if (name.equals("operation")) { 2522 return addOperation(); 2523 } 2524 else if (name.equals("compartment")) { 2525 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.compartment"); 2526 } 2527 else 2528 return super.addChild(name); 2529 } 2530 2531 public CapabilityStatementRestComponent copy() { 2532 CapabilityStatementRestComponent dst = new CapabilityStatementRestComponent(); 2533 copyValues(dst); 2534 return dst; 2535 } 2536 2537 public void copyValues(CapabilityStatementRestComponent dst) { 2538 super.copyValues(dst); 2539 dst.mode = mode == null ? null : mode.copy(); 2540 dst.documentation = documentation == null ? null : documentation.copy(); 2541 dst.security = security == null ? null : security.copy(); 2542 if (resource != null) { 2543 dst.resource = new ArrayList<CapabilityStatementRestResourceComponent>(); 2544 for (CapabilityStatementRestResourceComponent i : resource) 2545 dst.resource.add(i.copy()); 2546 }; 2547 if (interaction != null) { 2548 dst.interaction = new ArrayList<SystemInteractionComponent>(); 2549 for (SystemInteractionComponent i : interaction) 2550 dst.interaction.add(i.copy()); 2551 }; 2552 if (searchParam != null) { 2553 dst.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>(); 2554 for (CapabilityStatementRestResourceSearchParamComponent i : searchParam) 2555 dst.searchParam.add(i.copy()); 2556 }; 2557 if (operation != null) { 2558 dst.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>(); 2559 for (CapabilityStatementRestResourceOperationComponent i : operation) 2560 dst.operation.add(i.copy()); 2561 }; 2562 if (compartment != null) { 2563 dst.compartment = new ArrayList<CanonicalType>(); 2564 for (CanonicalType i : compartment) 2565 dst.compartment.add(i.copy()); 2566 }; 2567 } 2568 2569 @Override 2570 public boolean equalsDeep(Base other_) { 2571 if (!super.equalsDeep(other_)) 2572 return false; 2573 if (!(other_ instanceof CapabilityStatementRestComponent)) 2574 return false; 2575 CapabilityStatementRestComponent o = (CapabilityStatementRestComponent) other_; 2576 return compareDeep(mode, o.mode, true) && compareDeep(documentation, o.documentation, true) && compareDeep(security, o.security, true) 2577 && compareDeep(resource, o.resource, true) && compareDeep(interaction, o.interaction, true) && compareDeep(searchParam, o.searchParam, true) 2578 && compareDeep(operation, o.operation, true) && compareDeep(compartment, o.compartment, true); 2579 } 2580 2581 @Override 2582 public boolean equalsShallow(Base other_) { 2583 if (!super.equalsShallow(other_)) 2584 return false; 2585 if (!(other_ instanceof CapabilityStatementRestComponent)) 2586 return false; 2587 CapabilityStatementRestComponent o = (CapabilityStatementRestComponent) other_; 2588 return compareValues(mode, o.mode, true) && compareValues(documentation, o.documentation, true); 2589 } 2590 2591 public boolean isEmpty() { 2592 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(mode, documentation, security 2593 , resource, interaction, searchParam, operation, compartment); 2594 } 2595 2596 public String fhirType() { 2597 return "CapabilityStatement.rest"; 2598 2599 } 2600 2601 } 2602 2603 @Block() 2604 public static class CapabilityStatementRestSecurityComponent extends BackboneElement implements IBaseBackboneElement { 2605 /** 2606 * Server adds CORS headers when responding to requests - this enables Javascript applications to use the server. 2607 */ 2608 @Child(name = "cors", type = {BooleanType.class}, order=1, min=0, max=1, modifier=false, summary=true) 2609 @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." ) 2610 protected BooleanType cors; 2611 2612 /** 2613 * Types of security services that are supported/required by the system. 2614 */ 2615 @Child(name = "service", type = {CodeableConcept.class}, order=2, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 2616 @Description(shortDefinition="OAuth | SMART-on-FHIR | NTLM | Basic | Kerberos | Certificates", formalDefinition="Types of security services that are supported/required by the system." ) 2617 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/restful-security-service") 2618 protected List<CodeableConcept> service; 2619 2620 /** 2621 * General description of how security works. 2622 */ 2623 @Child(name = "description", type = {MarkdownType.class}, order=3, min=0, max=1, modifier=false, summary=false) 2624 @Description(shortDefinition="General description of how security works", formalDefinition="General description of how security works." ) 2625 protected MarkdownType description; 2626 2627 private static final long serialVersionUID = -1348900500L; 2628 2629 /** 2630 * Constructor 2631 */ 2632 public CapabilityStatementRestSecurityComponent() { 2633 super(); 2634 } 2635 2636 /** 2637 * @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 2638 */ 2639 public BooleanType getCorsElement() { 2640 if (this.cors == null) 2641 if (Configuration.errorOnAutoCreate()) 2642 throw new Error("Attempt to auto-create CapabilityStatementRestSecurityComponent.cors"); 2643 else if (Configuration.doAutoCreate()) 2644 this.cors = new BooleanType(); // bb 2645 return this.cors; 2646 } 2647 2648 public boolean hasCorsElement() { 2649 return this.cors != null && !this.cors.isEmpty(); 2650 } 2651 2652 public boolean hasCors() { 2653 return this.cors != null && !this.cors.isEmpty(); 2654 } 2655 2656 /** 2657 * @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 2658 */ 2659 public CapabilityStatementRestSecurityComponent setCorsElement(BooleanType value) { 2660 this.cors = value; 2661 return this; 2662 } 2663 2664 /** 2665 * @return Server adds CORS headers when responding to requests - this enables Javascript applications to use the server. 2666 */ 2667 public boolean getCors() { 2668 return this.cors == null || this.cors.isEmpty() ? false : this.cors.getValue(); 2669 } 2670 2671 /** 2672 * @param value Server adds CORS headers when responding to requests - this enables Javascript applications to use the server. 2673 */ 2674 public CapabilityStatementRestSecurityComponent setCors(boolean value) { 2675 if (this.cors == null) 2676 this.cors = new BooleanType(); 2677 this.cors.setValue(value); 2678 return this; 2679 } 2680 2681 /** 2682 * @return {@link #service} (Types of security services that are supported/required by the system.) 2683 */ 2684 public List<CodeableConcept> getService() { 2685 if (this.service == null) 2686 this.service = new ArrayList<CodeableConcept>(); 2687 return this.service; 2688 } 2689 2690 /** 2691 * @return Returns a reference to <code>this</code> for easy method chaining 2692 */ 2693 public CapabilityStatementRestSecurityComponent setService(List<CodeableConcept> theService) { 2694 this.service = theService; 2695 return this; 2696 } 2697 2698 public boolean hasService() { 2699 if (this.service == null) 2700 return false; 2701 for (CodeableConcept item : this.service) 2702 if (!item.isEmpty()) 2703 return true; 2704 return false; 2705 } 2706 2707 public CodeableConcept addService() { //3 2708 CodeableConcept t = new CodeableConcept(); 2709 if (this.service == null) 2710 this.service = new ArrayList<CodeableConcept>(); 2711 this.service.add(t); 2712 return t; 2713 } 2714 2715 public CapabilityStatementRestSecurityComponent addService(CodeableConcept t) { //3 2716 if (t == null) 2717 return this; 2718 if (this.service == null) 2719 this.service = new ArrayList<CodeableConcept>(); 2720 this.service.add(t); 2721 return this; 2722 } 2723 2724 /** 2725 * @return The first repetition of repeating field {@link #service}, creating it if it does not already exist 2726 */ 2727 public CodeableConcept getServiceFirstRep() { 2728 if (getService().isEmpty()) { 2729 addService(); 2730 } 2731 return getService().get(0); 2732 } 2733 2734 /** 2735 * @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 2736 */ 2737 public MarkdownType getDescriptionElement() { 2738 if (this.description == null) 2739 if (Configuration.errorOnAutoCreate()) 2740 throw new Error("Attempt to auto-create CapabilityStatementRestSecurityComponent.description"); 2741 else if (Configuration.doAutoCreate()) 2742 this.description = new MarkdownType(); // bb 2743 return this.description; 2744 } 2745 2746 public boolean hasDescriptionElement() { 2747 return this.description != null && !this.description.isEmpty(); 2748 } 2749 2750 public boolean hasDescription() { 2751 return this.description != null && !this.description.isEmpty(); 2752 } 2753 2754 /** 2755 * @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 2756 */ 2757 public CapabilityStatementRestSecurityComponent setDescriptionElement(MarkdownType value) { 2758 this.description = value; 2759 return this; 2760 } 2761 2762 /** 2763 * @return General description of how security works. 2764 */ 2765 public String getDescription() { 2766 return this.description == null ? null : this.description.getValue(); 2767 } 2768 2769 /** 2770 * @param value General description of how security works. 2771 */ 2772 public CapabilityStatementRestSecurityComponent setDescription(String value) { 2773 if (value == null) 2774 this.description = null; 2775 else { 2776 if (this.description == null) 2777 this.description = new MarkdownType(); 2778 this.description.setValue(value); 2779 } 2780 return this; 2781 } 2782 2783 protected void listChildren(List<Property> children) { 2784 super.listChildren(children); 2785 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)); 2786 children.add(new Property("service", "CodeableConcept", "Types of security services that are supported/required by the system.", 0, java.lang.Integer.MAX_VALUE, service)); 2787 children.add(new Property("description", "markdown", "General description of how security works.", 0, 1, description)); 2788 } 2789 2790 @Override 2791 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 2792 switch (_hash) { 2793 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); 2794 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); 2795 case -1724546052: /*description*/ return new Property("description", "markdown", "General description of how security works.", 0, 1, description); 2796 default: return super.getNamedProperty(_hash, _name, _checkValid); 2797 } 2798 2799 } 2800 2801 @Override 2802 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 2803 switch (hash) { 2804 case 3059629: /*cors*/ return this.cors == null ? new Base[0] : new Base[] {this.cors}; // BooleanType 2805 case 1984153269: /*service*/ return this.service == null ? new Base[0] : this.service.toArray(new Base[this.service.size()]); // CodeableConcept 2806 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType 2807 default: return super.getProperty(hash, name, checkValid); 2808 } 2809 2810 } 2811 2812 @Override 2813 public Base setProperty(int hash, String name, Base value) throws FHIRException { 2814 switch (hash) { 2815 case 3059629: // cors 2816 this.cors = castToBoolean(value); // BooleanType 2817 return value; 2818 case 1984153269: // service 2819 this.getService().add(castToCodeableConcept(value)); // CodeableConcept 2820 return value; 2821 case -1724546052: // description 2822 this.description = castToMarkdown(value); // MarkdownType 2823 return value; 2824 default: return super.setProperty(hash, name, value); 2825 } 2826 2827 } 2828 2829 @Override 2830 public Base setProperty(String name, Base value) throws FHIRException { 2831 if (name.equals("cors")) { 2832 this.cors = castToBoolean(value); // BooleanType 2833 } else if (name.equals("service")) { 2834 this.getService().add(castToCodeableConcept(value)); 2835 } else if (name.equals("description")) { 2836 this.description = castToMarkdown(value); // MarkdownType 2837 } else 2838 return super.setProperty(name, value); 2839 return value; 2840 } 2841 2842 @Override 2843 public Base makeProperty(int hash, String name) throws FHIRException { 2844 switch (hash) { 2845 case 3059629: return getCorsElement(); 2846 case 1984153269: return addService(); 2847 case -1724546052: return getDescriptionElement(); 2848 default: return super.makeProperty(hash, name); 2849 } 2850 2851 } 2852 2853 @Override 2854 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 2855 switch (hash) { 2856 case 3059629: /*cors*/ return new String[] {"boolean"}; 2857 case 1984153269: /*service*/ return new String[] {"CodeableConcept"}; 2858 case -1724546052: /*description*/ return new String[] {"markdown"}; 2859 default: return super.getTypesForProperty(hash, name); 2860 } 2861 2862 } 2863 2864 @Override 2865 public Base addChild(String name) throws FHIRException { 2866 if (name.equals("cors")) { 2867 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.cors"); 2868 } 2869 else if (name.equals("service")) { 2870 return addService(); 2871 } 2872 else if (name.equals("description")) { 2873 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.description"); 2874 } 2875 else 2876 return super.addChild(name); 2877 } 2878 2879 public CapabilityStatementRestSecurityComponent copy() { 2880 CapabilityStatementRestSecurityComponent dst = new CapabilityStatementRestSecurityComponent(); 2881 copyValues(dst); 2882 return dst; 2883 } 2884 2885 public void copyValues(CapabilityStatementRestSecurityComponent dst) { 2886 super.copyValues(dst); 2887 dst.cors = cors == null ? null : cors.copy(); 2888 if (service != null) { 2889 dst.service = new ArrayList<CodeableConcept>(); 2890 for (CodeableConcept i : service) 2891 dst.service.add(i.copy()); 2892 }; 2893 dst.description = description == null ? null : description.copy(); 2894 } 2895 2896 @Override 2897 public boolean equalsDeep(Base other_) { 2898 if (!super.equalsDeep(other_)) 2899 return false; 2900 if (!(other_ instanceof CapabilityStatementRestSecurityComponent)) 2901 return false; 2902 CapabilityStatementRestSecurityComponent o = (CapabilityStatementRestSecurityComponent) other_; 2903 return compareDeep(cors, o.cors, true) && compareDeep(service, o.service, true) && compareDeep(description, o.description, true) 2904 ; 2905 } 2906 2907 @Override 2908 public boolean equalsShallow(Base other_) { 2909 if (!super.equalsShallow(other_)) 2910 return false; 2911 if (!(other_ instanceof CapabilityStatementRestSecurityComponent)) 2912 return false; 2913 CapabilityStatementRestSecurityComponent o = (CapabilityStatementRestSecurityComponent) other_; 2914 return compareValues(cors, o.cors, true) && compareValues(description, o.description, true); 2915 } 2916 2917 public boolean isEmpty() { 2918 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(cors, service, description 2919 ); 2920 } 2921 2922 public String fhirType() { 2923 return "CapabilityStatement.rest.security"; 2924 2925 } 2926 2927 } 2928 2929 @Block() 2930 public static class CapabilityStatementRestResourceComponent extends BackboneElement implements IBaseBackboneElement { 2931 /** 2932 * A type of resource exposed via the restful interface. 2933 */ 2934 @Child(name = "type", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true) 2935 @Description(shortDefinition="A resource type that is supported", formalDefinition="A type of resource exposed via the restful interface." ) 2936 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/resource-types") 2937 protected CodeType type; 2938 2939 /** 2940 * 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). 2941 */ 2942 @Child(name = "profile", type = {CanonicalType.class}, order=2, min=0, max=1, modifier=false, summary=true) 2943 @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)." ) 2944 protected CanonicalType profile; 2945 2946 /** 2947 * 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). 2948 */ 2949 @Child(name = "supportedProfile", type = {CanonicalType.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 2950 @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)." ) 2951 protected List<CanonicalType> supportedProfile; 2952 2953 /** 2954 * Additional information about the resource type used by the system. 2955 */ 2956 @Child(name = "documentation", type = {MarkdownType.class}, order=4, min=0, max=1, modifier=false, summary=false) 2957 @Description(shortDefinition="Additional information about the use of the resource type", formalDefinition="Additional information about the resource type used by the system." ) 2958 protected MarkdownType documentation; 2959 2960 /** 2961 * Identifies a restful operation supported by the solution. 2962 */ 2963 @Child(name = "interaction", type = {}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 2964 @Description(shortDefinition="What operations are supported?", formalDefinition="Identifies a restful operation supported by the solution." ) 2965 protected List<ResourceInteractionComponent> interaction; 2966 2967 /** 2968 * 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. 2969 */ 2970 @Child(name = "versioning", type = {CodeType.class}, order=6, min=0, max=1, modifier=false, summary=false) 2971 @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." ) 2972 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/versioning-policy") 2973 protected Enumeration<ResourceVersionPolicy> versioning; 2974 2975 /** 2976 * A flag for whether the server is able to return past versions as part of the vRead operation. 2977 */ 2978 @Child(name = "readHistory", type = {BooleanType.class}, order=7, min=0, max=1, modifier=false, summary=false) 2979 @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." ) 2980 protected BooleanType readHistory; 2981 2982 /** 2983 * 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. 2984 */ 2985 @Child(name = "updateCreate", type = {BooleanType.class}, order=8, min=0, max=1, modifier=false, summary=false) 2986 @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." ) 2987 protected BooleanType updateCreate; 2988 2989 /** 2990 * A flag that indicates that the server supports conditional create. 2991 */ 2992 @Child(name = "conditionalCreate", type = {BooleanType.class}, order=9, min=0, max=1, modifier=false, summary=false) 2993 @Description(shortDefinition="If allows/uses conditional create", formalDefinition="A flag that indicates that the server supports conditional create." ) 2994 protected BooleanType conditionalCreate; 2995 2996 /** 2997 * A code that indicates how the server supports conditional read. 2998 */ 2999 @Child(name = "conditionalRead", type = {CodeType.class}, order=10, min=0, max=1, modifier=false, summary=false) 3000 @Description(shortDefinition="not-supported | modified-since | not-match | full-support", formalDefinition="A code that indicates how the server supports conditional read." ) 3001 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/conditional-read-status") 3002 protected Enumeration<ConditionalReadStatus> conditionalRead; 3003 3004 /** 3005 * A flag that indicates that the server supports conditional update. 3006 */ 3007 @Child(name = "conditionalUpdate", type = {BooleanType.class}, order=11, min=0, max=1, modifier=false, summary=false) 3008 @Description(shortDefinition="If allows/uses conditional update", formalDefinition="A flag that indicates that the server supports conditional update." ) 3009 protected BooleanType conditionalUpdate; 3010 3011 /** 3012 * A code that indicates how the server supports conditional delete. 3013 */ 3014 @Child(name = "conditionalDelete", type = {CodeType.class}, order=12, min=0, max=1, modifier=false, summary=false) 3015 @Description(shortDefinition="not-supported | single | multiple - how conditional delete is supported", formalDefinition="A code that indicates how the server supports conditional delete." ) 3016 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/conditional-delete-status") 3017 protected Enumeration<ConditionalDeleteStatus> conditionalDelete; 3018 3019 /** 3020 * A set of flags that defines how references are supported. 3021 */ 3022 @Child(name = "referencePolicy", type = {CodeType.class}, order=13, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 3023 @Description(shortDefinition="literal | logical | resolves | enforced | local", formalDefinition="A set of flags that defines how references are supported." ) 3024 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/reference-handling-policy") 3025 protected List<Enumeration<ReferenceHandlingPolicy>> referencePolicy; 3026 3027 /** 3028 * A list of _include values supported by the server. 3029 */ 3030 @Child(name = "searchInclude", type = {StringType.class}, order=14, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 3031 @Description(shortDefinition="_include values supported by the server", formalDefinition="A list of _include values supported by the server." ) 3032 protected List<StringType> searchInclude; 3033 3034 /** 3035 * A list of _revinclude (reverse include) values supported by the server. 3036 */ 3037 @Child(name = "searchRevInclude", type = {StringType.class}, order=15, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 3038 @Description(shortDefinition="_revinclude values supported by the server", formalDefinition="A list of _revinclude (reverse include) values supported by the server." ) 3039 protected List<StringType> searchRevInclude; 3040 3041 /** 3042 * 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. 3043 */ 3044 @Child(name = "searchParam", type = {}, order=16, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 3045 @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." ) 3046 protected List<CapabilityStatementRestResourceSearchParamComponent> searchParam; 3047 3048 /** 3049 * 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. 3050 */ 3051 @Child(name = "operation", type = {}, order=17, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 3052 @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." ) 3053 protected List<CapabilityStatementRestResourceOperationComponent> operation; 3054 3055 private static final long serialVersionUID = -1843372337L; 3056 3057 /** 3058 * Constructor 3059 */ 3060 public CapabilityStatementRestResourceComponent() { 3061 super(); 3062 } 3063 3064 /** 3065 * Constructor 3066 */ 3067 public CapabilityStatementRestResourceComponent(CodeType type) { 3068 super(); 3069 this.type = type; 3070 } 3071 3072 /** 3073 * @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 3074 */ 3075 public CodeType getTypeElement() { 3076 if (this.type == null) 3077 if (Configuration.errorOnAutoCreate()) 3078 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.type"); 3079 else if (Configuration.doAutoCreate()) 3080 this.type = new CodeType(); // bb 3081 return this.type; 3082 } 3083 3084 public boolean hasTypeElement() { 3085 return this.type != null && !this.type.isEmpty(); 3086 } 3087 3088 public boolean hasType() { 3089 return this.type != null && !this.type.isEmpty(); 3090 } 3091 3092 /** 3093 * @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 3094 */ 3095 public CapabilityStatementRestResourceComponent setTypeElement(CodeType value) { 3096 this.type = value; 3097 return this; 3098 } 3099 3100 /** 3101 * @return A type of resource exposed via the restful interface. 3102 */ 3103 public String getType() { 3104 return this.type == null ? null : this.type.getValue(); 3105 } 3106 3107 /** 3108 * @param value A type of resource exposed via the restful interface. 3109 */ 3110 public CapabilityStatementRestResourceComponent setType(String value) { 3111 if (this.type == null) 3112 this.type = new CodeType(); 3113 this.type.setValue(value); 3114 return this; 3115 } 3116 3117 /** 3118 * @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 3119 */ 3120 public CanonicalType getProfileElement() { 3121 if (this.profile == null) 3122 if (Configuration.errorOnAutoCreate()) 3123 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.profile"); 3124 else if (Configuration.doAutoCreate()) 3125 this.profile = new CanonicalType(); // bb 3126 return this.profile; 3127 } 3128 3129 public boolean hasProfileElement() { 3130 return this.profile != null && !this.profile.isEmpty(); 3131 } 3132 3133 public boolean hasProfile() { 3134 return this.profile != null && !this.profile.isEmpty(); 3135 } 3136 3137 /** 3138 * @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 3139 */ 3140 public CapabilityStatementRestResourceComponent setProfileElement(CanonicalType value) { 3141 this.profile = value; 3142 return this; 3143 } 3144 3145 /** 3146 * @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). 3147 */ 3148 public String getProfile() { 3149 return this.profile == null ? null : this.profile.getValue(); 3150 } 3151 3152 /** 3153 * @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). 3154 */ 3155 public CapabilityStatementRestResourceComponent setProfile(String value) { 3156 if (Utilities.noString(value)) 3157 this.profile = null; 3158 else { 3159 if (this.profile == null) 3160 this.profile = new CanonicalType(); 3161 this.profile.setValue(value); 3162 } 3163 return this; 3164 } 3165 3166 /** 3167 * @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).) 3168 */ 3169 public List<CanonicalType> getSupportedProfile() { 3170 if (this.supportedProfile == null) 3171 this.supportedProfile = new ArrayList<CanonicalType>(); 3172 return this.supportedProfile; 3173 } 3174 3175 /** 3176 * @return Returns a reference to <code>this</code> for easy method chaining 3177 */ 3178 public CapabilityStatementRestResourceComponent setSupportedProfile(List<CanonicalType> theSupportedProfile) { 3179 this.supportedProfile = theSupportedProfile; 3180 return this; 3181 } 3182 3183 public boolean hasSupportedProfile() { 3184 if (this.supportedProfile == null) 3185 return false; 3186 for (CanonicalType item : this.supportedProfile) 3187 if (!item.isEmpty()) 3188 return true; 3189 return false; 3190 } 3191 3192 /** 3193 * @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).) 3194 */ 3195 public CanonicalType addSupportedProfileElement() {//2 3196 CanonicalType t = new CanonicalType(); 3197 if (this.supportedProfile == null) 3198 this.supportedProfile = new ArrayList<CanonicalType>(); 3199 this.supportedProfile.add(t); 3200 return t; 3201 } 3202 3203 /** 3204 * @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).) 3205 */ 3206 public CapabilityStatementRestResourceComponent addSupportedProfile(String value) { //1 3207 CanonicalType t = new CanonicalType(); 3208 t.setValue(value); 3209 if (this.supportedProfile == null) 3210 this.supportedProfile = new ArrayList<CanonicalType>(); 3211 this.supportedProfile.add(t); 3212 return this; 3213 } 3214 3215 /** 3216 * @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).) 3217 */ 3218 public boolean hasSupportedProfile(String value) { 3219 if (this.supportedProfile == null) 3220 return false; 3221 for (CanonicalType v : this.supportedProfile) 3222 if (v.getValue().equals(value)) // canonical(StructureDefinition) 3223 return true; 3224 return false; 3225 } 3226 3227 /** 3228 * @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 3229 */ 3230 public MarkdownType getDocumentationElement() { 3231 if (this.documentation == null) 3232 if (Configuration.errorOnAutoCreate()) 3233 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.documentation"); 3234 else if (Configuration.doAutoCreate()) 3235 this.documentation = new MarkdownType(); // bb 3236 return this.documentation; 3237 } 3238 3239 public boolean hasDocumentationElement() { 3240 return this.documentation != null && !this.documentation.isEmpty(); 3241 } 3242 3243 public boolean hasDocumentation() { 3244 return this.documentation != null && !this.documentation.isEmpty(); 3245 } 3246 3247 /** 3248 * @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 3249 */ 3250 public CapabilityStatementRestResourceComponent setDocumentationElement(MarkdownType value) { 3251 this.documentation = value; 3252 return this; 3253 } 3254 3255 /** 3256 * @return Additional information about the resource type used by the system. 3257 */ 3258 public String getDocumentation() { 3259 return this.documentation == null ? null : this.documentation.getValue(); 3260 } 3261 3262 /** 3263 * @param value Additional information about the resource type used by the system. 3264 */ 3265 public CapabilityStatementRestResourceComponent setDocumentation(String value) { 3266 if (value == null) 3267 this.documentation = null; 3268 else { 3269 if (this.documentation == null) 3270 this.documentation = new MarkdownType(); 3271 this.documentation.setValue(value); 3272 } 3273 return this; 3274 } 3275 3276 /** 3277 * @return {@link #interaction} (Identifies a restful operation supported by the solution.) 3278 */ 3279 public List<ResourceInteractionComponent> getInteraction() { 3280 if (this.interaction == null) 3281 this.interaction = new ArrayList<ResourceInteractionComponent>(); 3282 return this.interaction; 3283 } 3284 3285 /** 3286 * @return Returns a reference to <code>this</code> for easy method chaining 3287 */ 3288 public CapabilityStatementRestResourceComponent setInteraction(List<ResourceInteractionComponent> theInteraction) { 3289 this.interaction = theInteraction; 3290 return this; 3291 } 3292 3293 public boolean hasInteraction() { 3294 if (this.interaction == null) 3295 return false; 3296 for (ResourceInteractionComponent item : this.interaction) 3297 if (!item.isEmpty()) 3298 return true; 3299 return false; 3300 } 3301 3302 public ResourceInteractionComponent addInteraction() { //3 3303 ResourceInteractionComponent t = new ResourceInteractionComponent(); 3304 if (this.interaction == null) 3305 this.interaction = new ArrayList<ResourceInteractionComponent>(); 3306 this.interaction.add(t); 3307 return t; 3308 } 3309 3310 public CapabilityStatementRestResourceComponent addInteraction(ResourceInteractionComponent t) { //3 3311 if (t == null) 3312 return this; 3313 if (this.interaction == null) 3314 this.interaction = new ArrayList<ResourceInteractionComponent>(); 3315 this.interaction.add(t); 3316 return this; 3317 } 3318 3319 /** 3320 * @return The first repetition of repeating field {@link #interaction}, creating it if it does not already exist 3321 */ 3322 public ResourceInteractionComponent getInteractionFirstRep() { 3323 if (getInteraction().isEmpty()) { 3324 addInteraction(); 3325 } 3326 return getInteraction().get(0); 3327 } 3328 3329 /** 3330 * @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 3331 */ 3332 public Enumeration<ResourceVersionPolicy> getVersioningElement() { 3333 if (this.versioning == null) 3334 if (Configuration.errorOnAutoCreate()) 3335 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.versioning"); 3336 else if (Configuration.doAutoCreate()) 3337 this.versioning = new Enumeration<ResourceVersionPolicy>(new ResourceVersionPolicyEnumFactory()); // bb 3338 return this.versioning; 3339 } 3340 3341 public boolean hasVersioningElement() { 3342 return this.versioning != null && !this.versioning.isEmpty(); 3343 } 3344 3345 public boolean hasVersioning() { 3346 return this.versioning != null && !this.versioning.isEmpty(); 3347 } 3348 3349 /** 3350 * @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 3351 */ 3352 public CapabilityStatementRestResourceComponent setVersioningElement(Enumeration<ResourceVersionPolicy> value) { 3353 this.versioning = value; 3354 return this; 3355 } 3356 3357 /** 3358 * @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. 3359 */ 3360 public ResourceVersionPolicy getVersioning() { 3361 return this.versioning == null ? null : this.versioning.getValue(); 3362 } 3363 3364 /** 3365 * @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. 3366 */ 3367 public CapabilityStatementRestResourceComponent setVersioning(ResourceVersionPolicy value) { 3368 if (value == null) 3369 this.versioning = null; 3370 else { 3371 if (this.versioning == null) 3372 this.versioning = new Enumeration<ResourceVersionPolicy>(new ResourceVersionPolicyEnumFactory()); 3373 this.versioning.setValue(value); 3374 } 3375 return this; 3376 } 3377 3378 /** 3379 * @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 3380 */ 3381 public BooleanType getReadHistoryElement() { 3382 if (this.readHistory == null) 3383 if (Configuration.errorOnAutoCreate()) 3384 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.readHistory"); 3385 else if (Configuration.doAutoCreate()) 3386 this.readHistory = new BooleanType(); // bb 3387 return this.readHistory; 3388 } 3389 3390 public boolean hasReadHistoryElement() { 3391 return this.readHistory != null && !this.readHistory.isEmpty(); 3392 } 3393 3394 public boolean hasReadHistory() { 3395 return this.readHistory != null && !this.readHistory.isEmpty(); 3396 } 3397 3398 /** 3399 * @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 3400 */ 3401 public CapabilityStatementRestResourceComponent setReadHistoryElement(BooleanType value) { 3402 this.readHistory = value; 3403 return this; 3404 } 3405 3406 /** 3407 * @return A flag for whether the server is able to return past versions as part of the vRead operation. 3408 */ 3409 public boolean getReadHistory() { 3410 return this.readHistory == null || this.readHistory.isEmpty() ? false : this.readHistory.getValue(); 3411 } 3412 3413 /** 3414 * @param value A flag for whether the server is able to return past versions as part of the vRead operation. 3415 */ 3416 public CapabilityStatementRestResourceComponent setReadHistory(boolean value) { 3417 if (this.readHistory == null) 3418 this.readHistory = new BooleanType(); 3419 this.readHistory.setValue(value); 3420 return this; 3421 } 3422 3423 /** 3424 * @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 3425 */ 3426 public BooleanType getUpdateCreateElement() { 3427 if (this.updateCreate == null) 3428 if (Configuration.errorOnAutoCreate()) 3429 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.updateCreate"); 3430 else if (Configuration.doAutoCreate()) 3431 this.updateCreate = new BooleanType(); // bb 3432 return this.updateCreate; 3433 } 3434 3435 public boolean hasUpdateCreateElement() { 3436 return this.updateCreate != null && !this.updateCreate.isEmpty(); 3437 } 3438 3439 public boolean hasUpdateCreate() { 3440 return this.updateCreate != null && !this.updateCreate.isEmpty(); 3441 } 3442 3443 /** 3444 * @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 3445 */ 3446 public CapabilityStatementRestResourceComponent setUpdateCreateElement(BooleanType value) { 3447 this.updateCreate = value; 3448 return this; 3449 } 3450 3451 /** 3452 * @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. 3453 */ 3454 public boolean getUpdateCreate() { 3455 return this.updateCreate == null || this.updateCreate.isEmpty() ? false : this.updateCreate.getValue(); 3456 } 3457 3458 /** 3459 * @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. 3460 */ 3461 public CapabilityStatementRestResourceComponent setUpdateCreate(boolean value) { 3462 if (this.updateCreate == null) 3463 this.updateCreate = new BooleanType(); 3464 this.updateCreate.setValue(value); 3465 return this; 3466 } 3467 3468 /** 3469 * @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 3470 */ 3471 public BooleanType getConditionalCreateElement() { 3472 if (this.conditionalCreate == null) 3473 if (Configuration.errorOnAutoCreate()) 3474 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.conditionalCreate"); 3475 else if (Configuration.doAutoCreate()) 3476 this.conditionalCreate = new BooleanType(); // bb 3477 return this.conditionalCreate; 3478 } 3479 3480 public boolean hasConditionalCreateElement() { 3481 return this.conditionalCreate != null && !this.conditionalCreate.isEmpty(); 3482 } 3483 3484 public boolean hasConditionalCreate() { 3485 return this.conditionalCreate != null && !this.conditionalCreate.isEmpty(); 3486 } 3487 3488 /** 3489 * @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 3490 */ 3491 public CapabilityStatementRestResourceComponent setConditionalCreateElement(BooleanType value) { 3492 this.conditionalCreate = value; 3493 return this; 3494 } 3495 3496 /** 3497 * @return A flag that indicates that the server supports conditional create. 3498 */ 3499 public boolean getConditionalCreate() { 3500 return this.conditionalCreate == null || this.conditionalCreate.isEmpty() ? false : this.conditionalCreate.getValue(); 3501 } 3502 3503 /** 3504 * @param value A flag that indicates that the server supports conditional create. 3505 */ 3506 public CapabilityStatementRestResourceComponent setConditionalCreate(boolean value) { 3507 if (this.conditionalCreate == null) 3508 this.conditionalCreate = new BooleanType(); 3509 this.conditionalCreate.setValue(value); 3510 return this; 3511 } 3512 3513 /** 3514 * @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 3515 */ 3516 public Enumeration<ConditionalReadStatus> getConditionalReadElement() { 3517 if (this.conditionalRead == null) 3518 if (Configuration.errorOnAutoCreate()) 3519 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.conditionalRead"); 3520 else if (Configuration.doAutoCreate()) 3521 this.conditionalRead = new Enumeration<ConditionalReadStatus>(new ConditionalReadStatusEnumFactory()); // bb 3522 return this.conditionalRead; 3523 } 3524 3525 public boolean hasConditionalReadElement() { 3526 return this.conditionalRead != null && !this.conditionalRead.isEmpty(); 3527 } 3528 3529 public boolean hasConditionalRead() { 3530 return this.conditionalRead != null && !this.conditionalRead.isEmpty(); 3531 } 3532 3533 /** 3534 * @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 3535 */ 3536 public CapabilityStatementRestResourceComponent setConditionalReadElement(Enumeration<ConditionalReadStatus> value) { 3537 this.conditionalRead = value; 3538 return this; 3539 } 3540 3541 /** 3542 * @return A code that indicates how the server supports conditional read. 3543 */ 3544 public ConditionalReadStatus getConditionalRead() { 3545 return this.conditionalRead == null ? null : this.conditionalRead.getValue(); 3546 } 3547 3548 /** 3549 * @param value A code that indicates how the server supports conditional read. 3550 */ 3551 public CapabilityStatementRestResourceComponent setConditionalRead(ConditionalReadStatus value) { 3552 if (value == null) 3553 this.conditionalRead = null; 3554 else { 3555 if (this.conditionalRead == null) 3556 this.conditionalRead = new Enumeration<ConditionalReadStatus>(new ConditionalReadStatusEnumFactory()); 3557 this.conditionalRead.setValue(value); 3558 } 3559 return this; 3560 } 3561 3562 /** 3563 * @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 3564 */ 3565 public BooleanType getConditionalUpdateElement() { 3566 if (this.conditionalUpdate == null) 3567 if (Configuration.errorOnAutoCreate()) 3568 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.conditionalUpdate"); 3569 else if (Configuration.doAutoCreate()) 3570 this.conditionalUpdate = new BooleanType(); // bb 3571 return this.conditionalUpdate; 3572 } 3573 3574 public boolean hasConditionalUpdateElement() { 3575 return this.conditionalUpdate != null && !this.conditionalUpdate.isEmpty(); 3576 } 3577 3578 public boolean hasConditionalUpdate() { 3579 return this.conditionalUpdate != null && !this.conditionalUpdate.isEmpty(); 3580 } 3581 3582 /** 3583 * @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 3584 */ 3585 public CapabilityStatementRestResourceComponent setConditionalUpdateElement(BooleanType value) { 3586 this.conditionalUpdate = value; 3587 return this; 3588 } 3589 3590 /** 3591 * @return A flag that indicates that the server supports conditional update. 3592 */ 3593 public boolean getConditionalUpdate() { 3594 return this.conditionalUpdate == null || this.conditionalUpdate.isEmpty() ? false : this.conditionalUpdate.getValue(); 3595 } 3596 3597 /** 3598 * @param value A flag that indicates that the server supports conditional update. 3599 */ 3600 public CapabilityStatementRestResourceComponent setConditionalUpdate(boolean value) { 3601 if (this.conditionalUpdate == null) 3602 this.conditionalUpdate = new BooleanType(); 3603 this.conditionalUpdate.setValue(value); 3604 return this; 3605 } 3606 3607 /** 3608 * @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 3609 */ 3610 public Enumeration<ConditionalDeleteStatus> getConditionalDeleteElement() { 3611 if (this.conditionalDelete == null) 3612 if (Configuration.errorOnAutoCreate()) 3613 throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.conditionalDelete"); 3614 else if (Configuration.doAutoCreate()) 3615 this.conditionalDelete = new Enumeration<ConditionalDeleteStatus>(new ConditionalDeleteStatusEnumFactory()); // bb 3616 return this.conditionalDelete; 3617 } 3618 3619 public boolean hasConditionalDeleteElement() { 3620 return this.conditionalDelete != null && !this.conditionalDelete.isEmpty(); 3621 } 3622 3623 public boolean hasConditionalDelete() { 3624 return this.conditionalDelete != null && !this.conditionalDelete.isEmpty(); 3625 } 3626 3627 /** 3628 * @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 3629 */ 3630 public CapabilityStatementRestResourceComponent setConditionalDeleteElement(Enumeration<ConditionalDeleteStatus> value) { 3631 this.conditionalDelete = value; 3632 return this; 3633 } 3634 3635 /** 3636 * @return A code that indicates how the server supports conditional delete. 3637 */ 3638 public ConditionalDeleteStatus getConditionalDelete() { 3639 return this.conditionalDelete == null ? null : this.conditionalDelete.getValue(); 3640 } 3641 3642 /** 3643 * @param value A code that indicates how the server supports conditional delete. 3644 */ 3645 public CapabilityStatementRestResourceComponent setConditionalDelete(ConditionalDeleteStatus value) { 3646 if (value == null) 3647 this.conditionalDelete = null; 3648 else { 3649 if (this.conditionalDelete == null) 3650 this.conditionalDelete = new Enumeration<ConditionalDeleteStatus>(new ConditionalDeleteStatusEnumFactory()); 3651 this.conditionalDelete.setValue(value); 3652 } 3653 return this; 3654 } 3655 3656 /** 3657 * @return {@link #referencePolicy} (A set of flags that defines how references are supported.) 3658 */ 3659 public List<Enumeration<ReferenceHandlingPolicy>> getReferencePolicy() { 3660 if (this.referencePolicy == null) 3661 this.referencePolicy = new ArrayList<Enumeration<ReferenceHandlingPolicy>>(); 3662 return this.referencePolicy; 3663 } 3664 3665 /** 3666 * @return Returns a reference to <code>this</code> for easy method chaining 3667 */ 3668 public CapabilityStatementRestResourceComponent setReferencePolicy(List<Enumeration<ReferenceHandlingPolicy>> theReferencePolicy) { 3669 this.referencePolicy = theReferencePolicy; 3670 return this; 3671 } 3672 3673 public boolean hasReferencePolicy() { 3674 if (this.referencePolicy == null) 3675 return false; 3676 for (Enumeration<ReferenceHandlingPolicy> item : this.referencePolicy) 3677 if (!item.isEmpty()) 3678 return true; 3679 return false; 3680 } 3681 3682 /** 3683 * @return {@link #referencePolicy} (A set of flags that defines how references are supported.) 3684 */ 3685 public Enumeration<ReferenceHandlingPolicy> addReferencePolicyElement() {//2 3686 Enumeration<ReferenceHandlingPolicy> t = new Enumeration<ReferenceHandlingPolicy>(new ReferenceHandlingPolicyEnumFactory()); 3687 if (this.referencePolicy == null) 3688 this.referencePolicy = new ArrayList<Enumeration<ReferenceHandlingPolicy>>(); 3689 this.referencePolicy.add(t); 3690 return t; 3691 } 3692 3693 /** 3694 * @param value {@link #referencePolicy} (A set of flags that defines how references are supported.) 3695 */ 3696 public CapabilityStatementRestResourceComponent addReferencePolicy(ReferenceHandlingPolicy value) { //1 3697 Enumeration<ReferenceHandlingPolicy> t = new Enumeration<ReferenceHandlingPolicy>(new ReferenceHandlingPolicyEnumFactory()); 3698 t.setValue(value); 3699 if (this.referencePolicy == null) 3700 this.referencePolicy = new ArrayList<Enumeration<ReferenceHandlingPolicy>>(); 3701 this.referencePolicy.add(t); 3702 return this; 3703 } 3704 3705 /** 3706 * @param value {@link #referencePolicy} (A set of flags that defines how references are supported.) 3707 */ 3708 public boolean hasReferencePolicy(ReferenceHandlingPolicy value) { 3709 if (this.referencePolicy == null) 3710 return false; 3711 for (Enumeration<ReferenceHandlingPolicy> v : this.referencePolicy) 3712 if (v.getValue().equals(value)) // code 3713 return true; 3714 return false; 3715 } 3716 3717 /** 3718 * @return {@link #searchInclude} (A list of _include values supported by the server.) 3719 */ 3720 public List<StringType> getSearchInclude() { 3721 if (this.searchInclude == null) 3722 this.searchInclude = new ArrayList<StringType>(); 3723 return this.searchInclude; 3724 } 3725 3726 /** 3727 * @return Returns a reference to <code>this</code> for easy method chaining 3728 */ 3729 public CapabilityStatementRestResourceComponent setSearchInclude(List<StringType> theSearchInclude) { 3730 this.searchInclude = theSearchInclude; 3731 return this; 3732 } 3733 3734 public boolean hasSearchInclude() { 3735 if (this.searchInclude == null) 3736 return false; 3737 for (StringType item : this.searchInclude) 3738 if (!item.isEmpty()) 3739 return true; 3740 return false; 3741 } 3742 3743 /** 3744 * @return {@link #searchInclude} (A list of _include values supported by the server.) 3745 */ 3746 public StringType addSearchIncludeElement() {//2 3747 StringType t = new StringType(); 3748 if (this.searchInclude == null) 3749 this.searchInclude = new ArrayList<StringType>(); 3750 this.searchInclude.add(t); 3751 return t; 3752 } 3753 3754 /** 3755 * @param value {@link #searchInclude} (A list of _include values supported by the server.) 3756 */ 3757 public CapabilityStatementRestResourceComponent addSearchInclude(String value) { //1 3758 StringType t = new StringType(); 3759 t.setValue(value); 3760 if (this.searchInclude == null) 3761 this.searchInclude = new ArrayList<StringType>(); 3762 this.searchInclude.add(t); 3763 return this; 3764 } 3765 3766 /** 3767 * @param value {@link #searchInclude} (A list of _include values supported by the server.) 3768 */ 3769 public boolean hasSearchInclude(String value) { 3770 if (this.searchInclude == null) 3771 return false; 3772 for (StringType v : this.searchInclude) 3773 if (v.getValue().equals(value)) // string 3774 return true; 3775 return false; 3776 } 3777 3778 /** 3779 * @return {@link #searchRevInclude} (A list of _revinclude (reverse include) values supported by the server.) 3780 */ 3781 public List<StringType> getSearchRevInclude() { 3782 if (this.searchRevInclude == null) 3783 this.searchRevInclude = new ArrayList<StringType>(); 3784 return this.searchRevInclude; 3785 } 3786 3787 /** 3788 * @return Returns a reference to <code>this</code> for easy method chaining 3789 */ 3790 public CapabilityStatementRestResourceComponent setSearchRevInclude(List<StringType> theSearchRevInclude) { 3791 this.searchRevInclude = theSearchRevInclude; 3792 return this; 3793 } 3794 3795 public boolean hasSearchRevInclude() { 3796 if (this.searchRevInclude == null) 3797 return false; 3798 for (StringType item : this.searchRevInclude) 3799 if (!item.isEmpty()) 3800 return true; 3801 return false; 3802 } 3803 3804 /** 3805 * @return {@link #searchRevInclude} (A list of _revinclude (reverse include) values supported by the server.) 3806 */ 3807 public StringType addSearchRevIncludeElement() {//2 3808 StringType t = new StringType(); 3809 if (this.searchRevInclude == null) 3810 this.searchRevInclude = new ArrayList<StringType>(); 3811 this.searchRevInclude.add(t); 3812 return t; 3813 } 3814 3815 /** 3816 * @param value {@link #searchRevInclude} (A list of _revinclude (reverse include) values supported by the server.) 3817 */ 3818 public CapabilityStatementRestResourceComponent addSearchRevInclude(String value) { //1 3819 StringType t = new StringType(); 3820 t.setValue(value); 3821 if (this.searchRevInclude == null) 3822 this.searchRevInclude = new ArrayList<StringType>(); 3823 this.searchRevInclude.add(t); 3824 return this; 3825 } 3826 3827 /** 3828 * @param value {@link #searchRevInclude} (A list of _revinclude (reverse include) values supported by the server.) 3829 */ 3830 public boolean hasSearchRevInclude(String value) { 3831 if (this.searchRevInclude == null) 3832 return false; 3833 for (StringType v : this.searchRevInclude) 3834 if (v.getValue().equals(value)) // string 3835 return true; 3836 return false; 3837 } 3838 3839 /** 3840 * @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.) 3841 */ 3842 public List<CapabilityStatementRestResourceSearchParamComponent> getSearchParam() { 3843 if (this.searchParam == null) 3844 this.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>(); 3845 return this.searchParam; 3846 } 3847 3848 /** 3849 * @return Returns a reference to <code>this</code> for easy method chaining 3850 */ 3851 public CapabilityStatementRestResourceComponent setSearchParam(List<CapabilityStatementRestResourceSearchParamComponent> theSearchParam) { 3852 this.searchParam = theSearchParam; 3853 return this; 3854 } 3855 3856 public boolean hasSearchParam() { 3857 if (this.searchParam == null) 3858 return false; 3859 for (CapabilityStatementRestResourceSearchParamComponent item : this.searchParam) 3860 if (!item.isEmpty()) 3861 return true; 3862 return false; 3863 } 3864 3865 public CapabilityStatementRestResourceSearchParamComponent addSearchParam() { //3 3866 CapabilityStatementRestResourceSearchParamComponent t = new CapabilityStatementRestResourceSearchParamComponent(); 3867 if (this.searchParam == null) 3868 this.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>(); 3869 this.searchParam.add(t); 3870 return t; 3871 } 3872 3873 public CapabilityStatementRestResourceComponent addSearchParam(CapabilityStatementRestResourceSearchParamComponent t) { //3 3874 if (t == null) 3875 return this; 3876 if (this.searchParam == null) 3877 this.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>(); 3878 this.searchParam.add(t); 3879 return this; 3880 } 3881 3882 /** 3883 * @return The first repetition of repeating field {@link #searchParam}, creating it if it does not already exist 3884 */ 3885 public CapabilityStatementRestResourceSearchParamComponent getSearchParamFirstRep() { 3886 if (getSearchParam().isEmpty()) { 3887 addSearchParam(); 3888 } 3889 return getSearchParam().get(0); 3890 } 3891 3892 /** 3893 * @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.) 3894 */ 3895 public List<CapabilityStatementRestResourceOperationComponent> getOperation() { 3896 if (this.operation == null) 3897 this.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>(); 3898 return this.operation; 3899 } 3900 3901 /** 3902 * @return Returns a reference to <code>this</code> for easy method chaining 3903 */ 3904 public CapabilityStatementRestResourceComponent setOperation(List<CapabilityStatementRestResourceOperationComponent> theOperation) { 3905 this.operation = theOperation; 3906 return this; 3907 } 3908 3909 public boolean hasOperation() { 3910 if (this.operation == null) 3911 return false; 3912 for (CapabilityStatementRestResourceOperationComponent item : this.operation) 3913 if (!item.isEmpty()) 3914 return true; 3915 return false; 3916 } 3917 3918 public CapabilityStatementRestResourceOperationComponent addOperation() { //3 3919 CapabilityStatementRestResourceOperationComponent t = new CapabilityStatementRestResourceOperationComponent(); 3920 if (this.operation == null) 3921 this.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>(); 3922 this.operation.add(t); 3923 return t; 3924 } 3925 3926 public CapabilityStatementRestResourceComponent addOperation(CapabilityStatementRestResourceOperationComponent t) { //3 3927 if (t == null) 3928 return this; 3929 if (this.operation == null) 3930 this.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>(); 3931 this.operation.add(t); 3932 return this; 3933 } 3934 3935 /** 3936 * @return The first repetition of repeating field {@link #operation}, creating it if it does not already exist 3937 */ 3938 public CapabilityStatementRestResourceOperationComponent getOperationFirstRep() { 3939 if (getOperation().isEmpty()) { 3940 addOperation(); 3941 } 3942 return getOperation().get(0); 3943 } 3944 3945 protected void listChildren(List<Property> children) { 3946 super.listChildren(children); 3947 children.add(new Property("type", "code", "A type of resource exposed via the restful interface.", 0, 1, type)); 3948 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)); 3949 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)); 3950 children.add(new Property("documentation", "markdown", "Additional information about the resource type used by the system.", 0, 1, documentation)); 3951 children.add(new Property("interaction", "", "Identifies a restful operation supported by the solution.", 0, java.lang.Integer.MAX_VALUE, interaction)); 3952 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)); 3953 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)); 3954 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)); 3955 children.add(new Property("conditionalCreate", "boolean", "A flag that indicates that the server supports conditional create.", 0, 1, conditionalCreate)); 3956 children.add(new Property("conditionalRead", "code", "A code that indicates how the server supports conditional read.", 0, 1, conditionalRead)); 3957 children.add(new Property("conditionalUpdate", "boolean", "A flag that indicates that the server supports conditional update.", 0, 1, conditionalUpdate)); 3958 children.add(new Property("conditionalDelete", "code", "A code that indicates how the server supports conditional delete.", 0, 1, conditionalDelete)); 3959 children.add(new Property("referencePolicy", "code", "A set of flags that defines how references are supported.", 0, java.lang.Integer.MAX_VALUE, referencePolicy)); 3960 children.add(new Property("searchInclude", "string", "A list of _include values supported by the server.", 0, java.lang.Integer.MAX_VALUE, searchInclude)); 3961 children.add(new Property("searchRevInclude", "string", "A list of _revinclude (reverse include) values supported by the server.", 0, java.lang.Integer.MAX_VALUE, searchRevInclude)); 3962 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)); 3963 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)); 3964 } 3965 3966 @Override 3967 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 3968 switch (_hash) { 3969 case 3575610: /*type*/ return new Property("type", "code", "A type of resource exposed via the restful interface.", 0, 1, type); 3970 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); 3971 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); 3972 case 1587405498: /*documentation*/ return new Property("documentation", "markdown", "Additional information about the resource type used by the system.", 0, 1, documentation); 3973 case 1844104722: /*interaction*/ return new Property("interaction", "", "Identifies a restful operation supported by the solution.", 0, java.lang.Integer.MAX_VALUE, interaction); 3974 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); 3975 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); 3976 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); 3977 case 6401826: /*conditionalCreate*/ return new Property("conditionalCreate", "boolean", "A flag that indicates that the server supports conditional create.", 0, 1, conditionalCreate); 3978 case 822786364: /*conditionalRead*/ return new Property("conditionalRead", "code", "A code that indicates how the server supports conditional read.", 0, 1, conditionalRead); 3979 case 519849711: /*conditionalUpdate*/ return new Property("conditionalUpdate", "boolean", "A flag that indicates that the server supports conditional update.", 0, 1, conditionalUpdate); 3980 case 23237585: /*conditionalDelete*/ return new Property("conditionalDelete", "code", "A code that indicates how the server supports conditional delete.", 0, 1, conditionalDelete); 3981 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); 3982 case -1035904544: /*searchInclude*/ return new Property("searchInclude", "string", "A list of _include values supported by the server.", 0, java.lang.Integer.MAX_VALUE, searchInclude); 3983 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); 3984 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); 3985 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); 3986 default: return super.getNamedProperty(_hash, _name, _checkValid); 3987 } 3988 3989 } 3990 3991 @Override 3992 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 3993 switch (hash) { 3994 case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // CodeType 3995 case -309425751: /*profile*/ return this.profile == null ? new Base[0] : new Base[] {this.profile}; // CanonicalType 3996 case 1225477403: /*supportedProfile*/ return this.supportedProfile == null ? new Base[0] : this.supportedProfile.toArray(new Base[this.supportedProfile.size()]); // CanonicalType 3997 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 3998 case 1844104722: /*interaction*/ return this.interaction == null ? new Base[0] : this.interaction.toArray(new Base[this.interaction.size()]); // ResourceInteractionComponent 3999 case -670487542: /*versioning*/ return this.versioning == null ? new Base[0] : new Base[] {this.versioning}; // Enumeration<ResourceVersionPolicy> 4000 case 187518494: /*readHistory*/ return this.readHistory == null ? new Base[0] : new Base[] {this.readHistory}; // BooleanType 4001 case -1400550619: /*updateCreate*/ return this.updateCreate == null ? new Base[0] : new Base[] {this.updateCreate}; // BooleanType 4002 case 6401826: /*conditionalCreate*/ return this.conditionalCreate == null ? new Base[0] : new Base[] {this.conditionalCreate}; // BooleanType 4003 case 822786364: /*conditionalRead*/ return this.conditionalRead == null ? new Base[0] : new Base[] {this.conditionalRead}; // Enumeration<ConditionalReadStatus> 4004 case 519849711: /*conditionalUpdate*/ return this.conditionalUpdate == null ? new Base[0] : new Base[] {this.conditionalUpdate}; // BooleanType 4005 case 23237585: /*conditionalDelete*/ return this.conditionalDelete == null ? new Base[0] : new Base[] {this.conditionalDelete}; // Enumeration<ConditionalDeleteStatus> 4006 case 796257373: /*referencePolicy*/ return this.referencePolicy == null ? new Base[0] : this.referencePolicy.toArray(new Base[this.referencePolicy.size()]); // Enumeration<ReferenceHandlingPolicy> 4007 case -1035904544: /*searchInclude*/ return this.searchInclude == null ? new Base[0] : this.searchInclude.toArray(new Base[this.searchInclude.size()]); // StringType 4008 case -2123884979: /*searchRevInclude*/ return this.searchRevInclude == null ? new Base[0] : this.searchRevInclude.toArray(new Base[this.searchRevInclude.size()]); // StringType 4009 case -553645115: /*searchParam*/ return this.searchParam == null ? new Base[0] : this.searchParam.toArray(new Base[this.searchParam.size()]); // CapabilityStatementRestResourceSearchParamComponent 4010 case 1662702951: /*operation*/ return this.operation == null ? new Base[0] : this.operation.toArray(new Base[this.operation.size()]); // CapabilityStatementRestResourceOperationComponent 4011 default: return super.getProperty(hash, name, checkValid); 4012 } 4013 4014 } 4015 4016 @Override 4017 public Base setProperty(int hash, String name, Base value) throws FHIRException { 4018 switch (hash) { 4019 case 3575610: // type 4020 this.type = castToCode(value); // CodeType 4021 return value; 4022 case -309425751: // profile 4023 this.profile = castToCanonical(value); // CanonicalType 4024 return value; 4025 case 1225477403: // supportedProfile 4026 this.getSupportedProfile().add(castToCanonical(value)); // CanonicalType 4027 return value; 4028 case 1587405498: // documentation 4029 this.documentation = castToMarkdown(value); // MarkdownType 4030 return value; 4031 case 1844104722: // interaction 4032 this.getInteraction().add((ResourceInteractionComponent) value); // ResourceInteractionComponent 4033 return value; 4034 case -670487542: // versioning 4035 value = new ResourceVersionPolicyEnumFactory().fromType(castToCode(value)); 4036 this.versioning = (Enumeration) value; // Enumeration<ResourceVersionPolicy> 4037 return value; 4038 case 187518494: // readHistory 4039 this.readHistory = castToBoolean(value); // BooleanType 4040 return value; 4041 case -1400550619: // updateCreate 4042 this.updateCreate = castToBoolean(value); // BooleanType 4043 return value; 4044 case 6401826: // conditionalCreate 4045 this.conditionalCreate = castToBoolean(value); // BooleanType 4046 return value; 4047 case 822786364: // conditionalRead 4048 value = new ConditionalReadStatusEnumFactory().fromType(castToCode(value)); 4049 this.conditionalRead = (Enumeration) value; // Enumeration<ConditionalReadStatus> 4050 return value; 4051 case 519849711: // conditionalUpdate 4052 this.conditionalUpdate = castToBoolean(value); // BooleanType 4053 return value; 4054 case 23237585: // conditionalDelete 4055 value = new ConditionalDeleteStatusEnumFactory().fromType(castToCode(value)); 4056 this.conditionalDelete = (Enumeration) value; // Enumeration<ConditionalDeleteStatus> 4057 return value; 4058 case 796257373: // referencePolicy 4059 value = new ReferenceHandlingPolicyEnumFactory().fromType(castToCode(value)); 4060 this.getReferencePolicy().add((Enumeration) value); // Enumeration<ReferenceHandlingPolicy> 4061 return value; 4062 case -1035904544: // searchInclude 4063 this.getSearchInclude().add(castToString(value)); // StringType 4064 return value; 4065 case -2123884979: // searchRevInclude 4066 this.getSearchRevInclude().add(castToString(value)); // StringType 4067 return value; 4068 case -553645115: // searchParam 4069 this.getSearchParam().add((CapabilityStatementRestResourceSearchParamComponent) value); // CapabilityStatementRestResourceSearchParamComponent 4070 return value; 4071 case 1662702951: // operation 4072 this.getOperation().add((CapabilityStatementRestResourceOperationComponent) value); // CapabilityStatementRestResourceOperationComponent 4073 return value; 4074 default: return super.setProperty(hash, name, value); 4075 } 4076 4077 } 4078 4079 @Override 4080 public Base setProperty(String name, Base value) throws FHIRException { 4081 if (name.equals("type")) { 4082 this.type = castToCode(value); // CodeType 4083 } else if (name.equals("profile")) { 4084 this.profile = castToCanonical(value); // CanonicalType 4085 } else if (name.equals("supportedProfile")) { 4086 this.getSupportedProfile().add(castToCanonical(value)); 4087 } else if (name.equals("documentation")) { 4088 this.documentation = castToMarkdown(value); // MarkdownType 4089 } else if (name.equals("interaction")) { 4090 this.getInteraction().add((ResourceInteractionComponent) value); 4091 } else if (name.equals("versioning")) { 4092 value = new ResourceVersionPolicyEnumFactory().fromType(castToCode(value)); 4093 this.versioning = (Enumeration) value; // Enumeration<ResourceVersionPolicy> 4094 } else if (name.equals("readHistory")) { 4095 this.readHistory = castToBoolean(value); // BooleanType 4096 } else if (name.equals("updateCreate")) { 4097 this.updateCreate = castToBoolean(value); // BooleanType 4098 } else if (name.equals("conditionalCreate")) { 4099 this.conditionalCreate = castToBoolean(value); // BooleanType 4100 } else if (name.equals("conditionalRead")) { 4101 value = new ConditionalReadStatusEnumFactory().fromType(castToCode(value)); 4102 this.conditionalRead = (Enumeration) value; // Enumeration<ConditionalReadStatus> 4103 } else if (name.equals("conditionalUpdate")) { 4104 this.conditionalUpdate = castToBoolean(value); // BooleanType 4105 } else if (name.equals("conditionalDelete")) { 4106 value = new ConditionalDeleteStatusEnumFactory().fromType(castToCode(value)); 4107 this.conditionalDelete = (Enumeration) value; // Enumeration<ConditionalDeleteStatus> 4108 } else if (name.equals("referencePolicy")) { 4109 value = new ReferenceHandlingPolicyEnumFactory().fromType(castToCode(value)); 4110 this.getReferencePolicy().add((Enumeration) value); 4111 } else if (name.equals("searchInclude")) { 4112 this.getSearchInclude().add(castToString(value)); 4113 } else if (name.equals("searchRevInclude")) { 4114 this.getSearchRevInclude().add(castToString(value)); 4115 } else if (name.equals("searchParam")) { 4116 this.getSearchParam().add((CapabilityStatementRestResourceSearchParamComponent) value); 4117 } else if (name.equals("operation")) { 4118 this.getOperation().add((CapabilityStatementRestResourceOperationComponent) value); 4119 } else 4120 return super.setProperty(name, value); 4121 return value; 4122 } 4123 4124 @Override 4125 public Base makeProperty(int hash, String name) throws FHIRException { 4126 switch (hash) { 4127 case 3575610: return getTypeElement(); 4128 case -309425751: return getProfileElement(); 4129 case 1225477403: return addSupportedProfileElement(); 4130 case 1587405498: return getDocumentationElement(); 4131 case 1844104722: return addInteraction(); 4132 case -670487542: return getVersioningElement(); 4133 case 187518494: return getReadHistoryElement(); 4134 case -1400550619: return getUpdateCreateElement(); 4135 case 6401826: return getConditionalCreateElement(); 4136 case 822786364: return getConditionalReadElement(); 4137 case 519849711: return getConditionalUpdateElement(); 4138 case 23237585: return getConditionalDeleteElement(); 4139 case 796257373: return addReferencePolicyElement(); 4140 case -1035904544: return addSearchIncludeElement(); 4141 case -2123884979: return addSearchRevIncludeElement(); 4142 case -553645115: return addSearchParam(); 4143 case 1662702951: return addOperation(); 4144 default: return super.makeProperty(hash, name); 4145 } 4146 4147 } 4148 4149 @Override 4150 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 4151 switch (hash) { 4152 case 3575610: /*type*/ return new String[] {"code"}; 4153 case -309425751: /*profile*/ return new String[] {"canonical"}; 4154 case 1225477403: /*supportedProfile*/ return new String[] {"canonical"}; 4155 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 4156 case 1844104722: /*interaction*/ return new String[] {}; 4157 case -670487542: /*versioning*/ return new String[] {"code"}; 4158 case 187518494: /*readHistory*/ return new String[] {"boolean"}; 4159 case -1400550619: /*updateCreate*/ return new String[] {"boolean"}; 4160 case 6401826: /*conditionalCreate*/ return new String[] {"boolean"}; 4161 case 822786364: /*conditionalRead*/ return new String[] {"code"}; 4162 case 519849711: /*conditionalUpdate*/ return new String[] {"boolean"}; 4163 case 23237585: /*conditionalDelete*/ return new String[] {"code"}; 4164 case 796257373: /*referencePolicy*/ return new String[] {"code"}; 4165 case -1035904544: /*searchInclude*/ return new String[] {"string"}; 4166 case -2123884979: /*searchRevInclude*/ return new String[] {"string"}; 4167 case -553645115: /*searchParam*/ return new String[] {}; 4168 case 1662702951: /*operation*/ return new String[] {}; 4169 default: return super.getTypesForProperty(hash, name); 4170 } 4171 4172 } 4173 4174 @Override 4175 public Base addChild(String name) throws FHIRException { 4176 if (name.equals("type")) { 4177 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.type"); 4178 } 4179 else if (name.equals("profile")) { 4180 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.profile"); 4181 } 4182 else if (name.equals("supportedProfile")) { 4183 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.supportedProfile"); 4184 } 4185 else if (name.equals("documentation")) { 4186 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.documentation"); 4187 } 4188 else if (name.equals("interaction")) { 4189 return addInteraction(); 4190 } 4191 else if (name.equals("versioning")) { 4192 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.versioning"); 4193 } 4194 else if (name.equals("readHistory")) { 4195 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.readHistory"); 4196 } 4197 else if (name.equals("updateCreate")) { 4198 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.updateCreate"); 4199 } 4200 else if (name.equals("conditionalCreate")) { 4201 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.conditionalCreate"); 4202 } 4203 else if (name.equals("conditionalRead")) { 4204 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.conditionalRead"); 4205 } 4206 else if (name.equals("conditionalUpdate")) { 4207 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.conditionalUpdate"); 4208 } 4209 else if (name.equals("conditionalDelete")) { 4210 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.conditionalDelete"); 4211 } 4212 else if (name.equals("referencePolicy")) { 4213 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.referencePolicy"); 4214 } 4215 else if (name.equals("searchInclude")) { 4216 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.searchInclude"); 4217 } 4218 else if (name.equals("searchRevInclude")) { 4219 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.searchRevInclude"); 4220 } 4221 else if (name.equals("searchParam")) { 4222 return addSearchParam(); 4223 } 4224 else if (name.equals("operation")) { 4225 return addOperation(); 4226 } 4227 else 4228 return super.addChild(name); 4229 } 4230 4231 public CapabilityStatementRestResourceComponent copy() { 4232 CapabilityStatementRestResourceComponent dst = new CapabilityStatementRestResourceComponent(); 4233 copyValues(dst); 4234 return dst; 4235 } 4236 4237 public void copyValues(CapabilityStatementRestResourceComponent dst) { 4238 super.copyValues(dst); 4239 dst.type = type == null ? null : type.copy(); 4240 dst.profile = profile == null ? null : profile.copy(); 4241 if (supportedProfile != null) { 4242 dst.supportedProfile = new ArrayList<CanonicalType>(); 4243 for (CanonicalType i : supportedProfile) 4244 dst.supportedProfile.add(i.copy()); 4245 }; 4246 dst.documentation = documentation == null ? null : documentation.copy(); 4247 if (interaction != null) { 4248 dst.interaction = new ArrayList<ResourceInteractionComponent>(); 4249 for (ResourceInteractionComponent i : interaction) 4250 dst.interaction.add(i.copy()); 4251 }; 4252 dst.versioning = versioning == null ? null : versioning.copy(); 4253 dst.readHistory = readHistory == null ? null : readHistory.copy(); 4254 dst.updateCreate = updateCreate == null ? null : updateCreate.copy(); 4255 dst.conditionalCreate = conditionalCreate == null ? null : conditionalCreate.copy(); 4256 dst.conditionalRead = conditionalRead == null ? null : conditionalRead.copy(); 4257 dst.conditionalUpdate = conditionalUpdate == null ? null : conditionalUpdate.copy(); 4258 dst.conditionalDelete = conditionalDelete == null ? null : conditionalDelete.copy(); 4259 if (referencePolicy != null) { 4260 dst.referencePolicy = new ArrayList<Enumeration<ReferenceHandlingPolicy>>(); 4261 for (Enumeration<ReferenceHandlingPolicy> i : referencePolicy) 4262 dst.referencePolicy.add(i.copy()); 4263 }; 4264 if (searchInclude != null) { 4265 dst.searchInclude = new ArrayList<StringType>(); 4266 for (StringType i : searchInclude) 4267 dst.searchInclude.add(i.copy()); 4268 }; 4269 if (searchRevInclude != null) { 4270 dst.searchRevInclude = new ArrayList<StringType>(); 4271 for (StringType i : searchRevInclude) 4272 dst.searchRevInclude.add(i.copy()); 4273 }; 4274 if (searchParam != null) { 4275 dst.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>(); 4276 for (CapabilityStatementRestResourceSearchParamComponent i : searchParam) 4277 dst.searchParam.add(i.copy()); 4278 }; 4279 if (operation != null) { 4280 dst.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>(); 4281 for (CapabilityStatementRestResourceOperationComponent i : operation) 4282 dst.operation.add(i.copy()); 4283 }; 4284 } 4285 4286 @Override 4287 public boolean equalsDeep(Base other_) { 4288 if (!super.equalsDeep(other_)) 4289 return false; 4290 if (!(other_ instanceof CapabilityStatementRestResourceComponent)) 4291 return false; 4292 CapabilityStatementRestResourceComponent o = (CapabilityStatementRestResourceComponent) other_; 4293 return compareDeep(type, o.type, true) && compareDeep(profile, o.profile, true) && compareDeep(supportedProfile, o.supportedProfile, true) 4294 && compareDeep(documentation, o.documentation, true) && compareDeep(interaction, o.interaction, true) 4295 && compareDeep(versioning, o.versioning, true) && compareDeep(readHistory, o.readHistory, true) 4296 && compareDeep(updateCreate, o.updateCreate, true) && compareDeep(conditionalCreate, o.conditionalCreate, true) 4297 && compareDeep(conditionalRead, o.conditionalRead, true) && compareDeep(conditionalUpdate, o.conditionalUpdate, true) 4298 && compareDeep(conditionalDelete, o.conditionalDelete, true) && compareDeep(referencePolicy, o.referencePolicy, true) 4299 && compareDeep(searchInclude, o.searchInclude, true) && compareDeep(searchRevInclude, o.searchRevInclude, true) 4300 && compareDeep(searchParam, o.searchParam, true) && compareDeep(operation, o.operation, true); 4301 } 4302 4303 @Override 4304 public boolean equalsShallow(Base other_) { 4305 if (!super.equalsShallow(other_)) 4306 return false; 4307 if (!(other_ instanceof CapabilityStatementRestResourceComponent)) 4308 return false; 4309 CapabilityStatementRestResourceComponent o = (CapabilityStatementRestResourceComponent) other_; 4310 return compareValues(type, o.type, true) && compareValues(documentation, o.documentation, true) && compareValues(versioning, o.versioning, true) 4311 && compareValues(readHistory, o.readHistory, true) && compareValues(updateCreate, o.updateCreate, true) 4312 && compareValues(conditionalCreate, o.conditionalCreate, true) && compareValues(conditionalRead, o.conditionalRead, true) 4313 && compareValues(conditionalUpdate, o.conditionalUpdate, true) && compareValues(conditionalDelete, o.conditionalDelete, true) 4314 && compareValues(referencePolicy, o.referencePolicy, true) && compareValues(searchInclude, o.searchInclude, true) 4315 && compareValues(searchRevInclude, o.searchRevInclude, true); 4316 } 4317 4318 public boolean isEmpty() { 4319 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, profile, supportedProfile 4320 , documentation, interaction, versioning, readHistory, updateCreate, conditionalCreate 4321 , conditionalRead, conditionalUpdate, conditionalDelete, referencePolicy, searchInclude 4322 , searchRevInclude, searchParam, operation); 4323 } 4324 4325 public String fhirType() { 4326 return "CapabilityStatement.rest.resource"; 4327 4328 } 4329 4330 } 4331 4332 @Block() 4333 public static class ResourceInteractionComponent extends BackboneElement implements IBaseBackboneElement { 4334 /** 4335 * Coded identifier of the operation, supported by the system resource. 4336 */ 4337 @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=false) 4338 @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." ) 4339 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/type-restful-interaction") 4340 protected Enumeration<TypeRestfulInteraction> code; 4341 4342 /** 4343 * 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'. 4344 */ 4345 @Child(name = "documentation", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=false) 4346 @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'." ) 4347 protected MarkdownType documentation; 4348 4349 private static final long serialVersionUID = 2128937796L; 4350 4351 /** 4352 * Constructor 4353 */ 4354 public ResourceInteractionComponent() { 4355 super(); 4356 } 4357 4358 /** 4359 * Constructor 4360 */ 4361 public ResourceInteractionComponent(Enumeration<TypeRestfulInteraction> code) { 4362 super(); 4363 this.code = code; 4364 } 4365 4366 /** 4367 * @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 4368 */ 4369 public Enumeration<TypeRestfulInteraction> getCodeElement() { 4370 if (this.code == null) 4371 if (Configuration.errorOnAutoCreate()) 4372 throw new Error("Attempt to auto-create ResourceInteractionComponent.code"); 4373 else if (Configuration.doAutoCreate()) 4374 this.code = new Enumeration<TypeRestfulInteraction>(new TypeRestfulInteractionEnumFactory()); // bb 4375 return this.code; 4376 } 4377 4378 public boolean hasCodeElement() { 4379 return this.code != null && !this.code.isEmpty(); 4380 } 4381 4382 public boolean hasCode() { 4383 return this.code != null && !this.code.isEmpty(); 4384 } 4385 4386 /** 4387 * @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 4388 */ 4389 public ResourceInteractionComponent setCodeElement(Enumeration<TypeRestfulInteraction> value) { 4390 this.code = value; 4391 return this; 4392 } 4393 4394 /** 4395 * @return Coded identifier of the operation, supported by the system resource. 4396 */ 4397 public TypeRestfulInteraction getCode() { 4398 return this.code == null ? null : this.code.getValue(); 4399 } 4400 4401 /** 4402 * @param value Coded identifier of the operation, supported by the system resource. 4403 */ 4404 public ResourceInteractionComponent setCode(TypeRestfulInteraction value) { 4405 if (this.code == null) 4406 this.code = new Enumeration<TypeRestfulInteraction>(new TypeRestfulInteractionEnumFactory()); 4407 this.code.setValue(value); 4408 return this; 4409 } 4410 4411 /** 4412 * @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 4413 */ 4414 public MarkdownType getDocumentationElement() { 4415 if (this.documentation == null) 4416 if (Configuration.errorOnAutoCreate()) 4417 throw new Error("Attempt to auto-create ResourceInteractionComponent.documentation"); 4418 else if (Configuration.doAutoCreate()) 4419 this.documentation = new MarkdownType(); // bb 4420 return this.documentation; 4421 } 4422 4423 public boolean hasDocumentationElement() { 4424 return this.documentation != null && !this.documentation.isEmpty(); 4425 } 4426 4427 public boolean hasDocumentation() { 4428 return this.documentation != null && !this.documentation.isEmpty(); 4429 } 4430 4431 /** 4432 * @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 4433 */ 4434 public ResourceInteractionComponent setDocumentationElement(MarkdownType value) { 4435 this.documentation = value; 4436 return this; 4437 } 4438 4439 /** 4440 * @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'. 4441 */ 4442 public String getDocumentation() { 4443 return this.documentation == null ? null : this.documentation.getValue(); 4444 } 4445 4446 /** 4447 * @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'. 4448 */ 4449 public ResourceInteractionComponent setDocumentation(String value) { 4450 if (value == null) 4451 this.documentation = null; 4452 else { 4453 if (this.documentation == null) 4454 this.documentation = new MarkdownType(); 4455 this.documentation.setValue(value); 4456 } 4457 return this; 4458 } 4459 4460 protected void listChildren(List<Property> children) { 4461 super.listChildren(children); 4462 children.add(new Property("code", "code", "Coded identifier of the operation, supported by the system resource.", 0, 1, code)); 4463 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)); 4464 } 4465 4466 @Override 4467 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 4468 switch (_hash) { 4469 case 3059181: /*code*/ return new Property("code", "code", "Coded identifier of the operation, supported by the system resource.", 0, 1, code); 4470 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); 4471 default: return super.getNamedProperty(_hash, _name, _checkValid); 4472 } 4473 4474 } 4475 4476 @Override 4477 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 4478 switch (hash) { 4479 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // Enumeration<TypeRestfulInteraction> 4480 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 4481 default: return super.getProperty(hash, name, checkValid); 4482 } 4483 4484 } 4485 4486 @Override 4487 public Base setProperty(int hash, String name, Base value) throws FHIRException { 4488 switch (hash) { 4489 case 3059181: // code 4490 value = new TypeRestfulInteractionEnumFactory().fromType(castToCode(value)); 4491 this.code = (Enumeration) value; // Enumeration<TypeRestfulInteraction> 4492 return value; 4493 case 1587405498: // documentation 4494 this.documentation = castToMarkdown(value); // MarkdownType 4495 return value; 4496 default: return super.setProperty(hash, name, value); 4497 } 4498 4499 } 4500 4501 @Override 4502 public Base setProperty(String name, Base value) throws FHIRException { 4503 if (name.equals("code")) { 4504 value = new TypeRestfulInteractionEnumFactory().fromType(castToCode(value)); 4505 this.code = (Enumeration) value; // Enumeration<TypeRestfulInteraction> 4506 } else if (name.equals("documentation")) { 4507 this.documentation = castToMarkdown(value); // MarkdownType 4508 } else 4509 return super.setProperty(name, value); 4510 return value; 4511 } 4512 4513 @Override 4514 public Base makeProperty(int hash, String name) throws FHIRException { 4515 switch (hash) { 4516 case 3059181: return getCodeElement(); 4517 case 1587405498: return getDocumentationElement(); 4518 default: return super.makeProperty(hash, name); 4519 } 4520 4521 } 4522 4523 @Override 4524 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 4525 switch (hash) { 4526 case 3059181: /*code*/ return new String[] {"code"}; 4527 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 4528 default: return super.getTypesForProperty(hash, name); 4529 } 4530 4531 } 4532 4533 @Override 4534 public Base addChild(String name) throws FHIRException { 4535 if (name.equals("code")) { 4536 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.code"); 4537 } 4538 else if (name.equals("documentation")) { 4539 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.documentation"); 4540 } 4541 else 4542 return super.addChild(name); 4543 } 4544 4545 public ResourceInteractionComponent copy() { 4546 ResourceInteractionComponent dst = new ResourceInteractionComponent(); 4547 copyValues(dst); 4548 return dst; 4549 } 4550 4551 public void copyValues(ResourceInteractionComponent dst) { 4552 super.copyValues(dst); 4553 dst.code = code == null ? null : code.copy(); 4554 dst.documentation = documentation == null ? null : documentation.copy(); 4555 } 4556 4557 @Override 4558 public boolean equalsDeep(Base other_) { 4559 if (!super.equalsDeep(other_)) 4560 return false; 4561 if (!(other_ instanceof ResourceInteractionComponent)) 4562 return false; 4563 ResourceInteractionComponent o = (ResourceInteractionComponent) other_; 4564 return compareDeep(code, o.code, true) && compareDeep(documentation, o.documentation, true); 4565 } 4566 4567 @Override 4568 public boolean equalsShallow(Base other_) { 4569 if (!super.equalsShallow(other_)) 4570 return false; 4571 if (!(other_ instanceof ResourceInteractionComponent)) 4572 return false; 4573 ResourceInteractionComponent o = (ResourceInteractionComponent) other_; 4574 return compareValues(code, o.code, true) && compareValues(documentation, o.documentation, true); 4575 } 4576 4577 public boolean isEmpty() { 4578 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, documentation); 4579 } 4580 4581 public String fhirType() { 4582 return "CapabilityStatement.rest.resource.interaction"; 4583 4584 } 4585 4586 } 4587 4588 @Block() 4589 public static class CapabilityStatementRestResourceSearchParamComponent extends BackboneElement implements IBaseBackboneElement { 4590 /** 4591 * The name of the search parameter used in the interface. 4592 */ 4593 @Child(name = "name", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=false) 4594 @Description(shortDefinition="Name of search parameter", formalDefinition="The name of the search parameter used in the interface." ) 4595 protected StringType name; 4596 4597 /** 4598 * 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]]]). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs. 4599 */ 4600 @Child(name = "definition", type = {CanonicalType.class}, order=2, min=0, max=1, modifier=false, summary=false) 4601 @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]]]). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs." ) 4602 protected CanonicalType definition; 4603 4604 /** 4605 * The type of value a search parameter refers to, and how the content is interpreted. 4606 */ 4607 @Child(name = "type", type = {CodeType.class}, order=3, min=1, max=1, modifier=false, summary=false) 4608 @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." ) 4609 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/search-param-type") 4610 protected Enumeration<SearchParamType> type; 4611 4612 /** 4613 * This allows documentation of any distinct behaviors about how the search parameter is used. For example, text matching algorithms. 4614 */ 4615 @Child(name = "documentation", type = {MarkdownType.class}, order=4, min=0, max=1, modifier=false, summary=false) 4616 @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." ) 4617 protected MarkdownType documentation; 4618 4619 private static final long serialVersionUID = -171123928L; 4620 4621 /** 4622 * Constructor 4623 */ 4624 public CapabilityStatementRestResourceSearchParamComponent() { 4625 super(); 4626 } 4627 4628 /** 4629 * Constructor 4630 */ 4631 public CapabilityStatementRestResourceSearchParamComponent(StringType name, Enumeration<SearchParamType> type) { 4632 super(); 4633 this.name = name; 4634 this.type = type; 4635 } 4636 4637 /** 4638 * @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 4639 */ 4640 public StringType getNameElement() { 4641 if (this.name == null) 4642 if (Configuration.errorOnAutoCreate()) 4643 throw new Error("Attempt to auto-create CapabilityStatementRestResourceSearchParamComponent.name"); 4644 else if (Configuration.doAutoCreate()) 4645 this.name = new StringType(); // bb 4646 return this.name; 4647 } 4648 4649 public boolean hasNameElement() { 4650 return this.name != null && !this.name.isEmpty(); 4651 } 4652 4653 public boolean hasName() { 4654 return this.name != null && !this.name.isEmpty(); 4655 } 4656 4657 /** 4658 * @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 4659 */ 4660 public CapabilityStatementRestResourceSearchParamComponent setNameElement(StringType value) { 4661 this.name = value; 4662 return this; 4663 } 4664 4665 /** 4666 * @return The name of the search parameter used in the interface. 4667 */ 4668 public String getName() { 4669 return this.name == null ? null : this.name.getValue(); 4670 } 4671 4672 /** 4673 * @param value The name of the search parameter used in the interface. 4674 */ 4675 public CapabilityStatementRestResourceSearchParamComponent setName(String value) { 4676 if (this.name == null) 4677 this.name = new StringType(); 4678 this.name.setValue(value); 4679 return this; 4680 } 4681 4682 /** 4683 * @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]]]). 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 4684 */ 4685 public CanonicalType getDefinitionElement() { 4686 if (this.definition == null) 4687 if (Configuration.errorOnAutoCreate()) 4688 throw new Error("Attempt to auto-create CapabilityStatementRestResourceSearchParamComponent.definition"); 4689 else if (Configuration.doAutoCreate()) 4690 this.definition = new CanonicalType(); // bb 4691 return this.definition; 4692 } 4693 4694 public boolean hasDefinitionElement() { 4695 return this.definition != null && !this.definition.isEmpty(); 4696 } 4697 4698 public boolean hasDefinition() { 4699 return this.definition != null && !this.definition.isEmpty(); 4700 } 4701 4702 /** 4703 * @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]]]). 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 4704 */ 4705 public CapabilityStatementRestResourceSearchParamComponent setDefinitionElement(CanonicalType value) { 4706 this.definition = value; 4707 return this; 4708 } 4709 4710 /** 4711 * @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]]]). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs. 4712 */ 4713 public String getDefinition() { 4714 return this.definition == null ? null : this.definition.getValue(); 4715 } 4716 4717 /** 4718 * @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]]]). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs. 4719 */ 4720 public CapabilityStatementRestResourceSearchParamComponent setDefinition(String value) { 4721 if (Utilities.noString(value)) 4722 this.definition = null; 4723 else { 4724 if (this.definition == null) 4725 this.definition = new CanonicalType(); 4726 this.definition.setValue(value); 4727 } 4728 return this; 4729 } 4730 4731 /** 4732 * @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 4733 */ 4734 public Enumeration<SearchParamType> getTypeElement() { 4735 if (this.type == null) 4736 if (Configuration.errorOnAutoCreate()) 4737 throw new Error("Attempt to auto-create CapabilityStatementRestResourceSearchParamComponent.type"); 4738 else if (Configuration.doAutoCreate()) 4739 this.type = new Enumeration<SearchParamType>(new SearchParamTypeEnumFactory()); // bb 4740 return this.type; 4741 } 4742 4743 public boolean hasTypeElement() { 4744 return this.type != null && !this.type.isEmpty(); 4745 } 4746 4747 public boolean hasType() { 4748 return this.type != null && !this.type.isEmpty(); 4749 } 4750 4751 /** 4752 * @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 4753 */ 4754 public CapabilityStatementRestResourceSearchParamComponent setTypeElement(Enumeration<SearchParamType> value) { 4755 this.type = value; 4756 return this; 4757 } 4758 4759 /** 4760 * @return The type of value a search parameter refers to, and how the content is interpreted. 4761 */ 4762 public SearchParamType getType() { 4763 return this.type == null ? null : this.type.getValue(); 4764 } 4765 4766 /** 4767 * @param value The type of value a search parameter refers to, and how the content is interpreted. 4768 */ 4769 public CapabilityStatementRestResourceSearchParamComponent setType(SearchParamType value) { 4770 if (this.type == null) 4771 this.type = new Enumeration<SearchParamType>(new SearchParamTypeEnumFactory()); 4772 this.type.setValue(value); 4773 return this; 4774 } 4775 4776 /** 4777 * @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 4778 */ 4779 public MarkdownType getDocumentationElement() { 4780 if (this.documentation == null) 4781 if (Configuration.errorOnAutoCreate()) 4782 throw new Error("Attempt to auto-create CapabilityStatementRestResourceSearchParamComponent.documentation"); 4783 else if (Configuration.doAutoCreate()) 4784 this.documentation = new MarkdownType(); // bb 4785 return this.documentation; 4786 } 4787 4788 public boolean hasDocumentationElement() { 4789 return this.documentation != null && !this.documentation.isEmpty(); 4790 } 4791 4792 public boolean hasDocumentation() { 4793 return this.documentation != null && !this.documentation.isEmpty(); 4794 } 4795 4796 /** 4797 * @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 4798 */ 4799 public CapabilityStatementRestResourceSearchParamComponent setDocumentationElement(MarkdownType value) { 4800 this.documentation = value; 4801 return this; 4802 } 4803 4804 /** 4805 * @return This allows documentation of any distinct behaviors about how the search parameter is used. For example, text matching algorithms. 4806 */ 4807 public String getDocumentation() { 4808 return this.documentation == null ? null : this.documentation.getValue(); 4809 } 4810 4811 /** 4812 * @param value This allows documentation of any distinct behaviors about how the search parameter is used. For example, text matching algorithms. 4813 */ 4814 public CapabilityStatementRestResourceSearchParamComponent setDocumentation(String value) { 4815 if (value == null) 4816 this.documentation = null; 4817 else { 4818 if (this.documentation == null) 4819 this.documentation = new MarkdownType(); 4820 this.documentation.setValue(value); 4821 } 4822 return this; 4823 } 4824 4825 protected void listChildren(List<Property> children) { 4826 super.listChildren(children); 4827 children.add(new Property("name", "string", "The name of the search parameter used in the interface.", 0, 1, name)); 4828 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]]]). 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)); 4829 children.add(new Property("type", "code", "The type of value a search parameter refers to, and how the content is interpreted.", 0, 1, type)); 4830 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)); 4831 } 4832 4833 @Override 4834 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 4835 switch (_hash) { 4836 case 3373707: /*name*/ return new Property("name", "string", "The name of the search parameter used in the interface.", 0, 1, name); 4837 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]]]). 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); 4838 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); 4839 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); 4840 default: return super.getNamedProperty(_hash, _name, _checkValid); 4841 } 4842 4843 } 4844 4845 @Override 4846 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 4847 switch (hash) { 4848 case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType 4849 case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : new Base[] {this.definition}; // CanonicalType 4850 case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<SearchParamType> 4851 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 4852 default: return super.getProperty(hash, name, checkValid); 4853 } 4854 4855 } 4856 4857 @Override 4858 public Base setProperty(int hash, String name, Base value) throws FHIRException { 4859 switch (hash) { 4860 case 3373707: // name 4861 this.name = castToString(value); // StringType 4862 return value; 4863 case -1014418093: // definition 4864 this.definition = castToCanonical(value); // CanonicalType 4865 return value; 4866 case 3575610: // type 4867 value = new SearchParamTypeEnumFactory().fromType(castToCode(value)); 4868 this.type = (Enumeration) value; // Enumeration<SearchParamType> 4869 return value; 4870 case 1587405498: // documentation 4871 this.documentation = castToMarkdown(value); // MarkdownType 4872 return value; 4873 default: return super.setProperty(hash, name, value); 4874 } 4875 4876 } 4877 4878 @Override 4879 public Base setProperty(String name, Base value) throws FHIRException { 4880 if (name.equals("name")) { 4881 this.name = castToString(value); // StringType 4882 } else if (name.equals("definition")) { 4883 this.definition = castToCanonical(value); // CanonicalType 4884 } else if (name.equals("type")) { 4885 value = new SearchParamTypeEnumFactory().fromType(castToCode(value)); 4886 this.type = (Enumeration) value; // Enumeration<SearchParamType> 4887 } else if (name.equals("documentation")) { 4888 this.documentation = castToMarkdown(value); // MarkdownType 4889 } else 4890 return super.setProperty(name, value); 4891 return value; 4892 } 4893 4894 @Override 4895 public Base makeProperty(int hash, String name) throws FHIRException { 4896 switch (hash) { 4897 case 3373707: return getNameElement(); 4898 case -1014418093: return getDefinitionElement(); 4899 case 3575610: return getTypeElement(); 4900 case 1587405498: return getDocumentationElement(); 4901 default: return super.makeProperty(hash, name); 4902 } 4903 4904 } 4905 4906 @Override 4907 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 4908 switch (hash) { 4909 case 3373707: /*name*/ return new String[] {"string"}; 4910 case -1014418093: /*definition*/ return new String[] {"canonical"}; 4911 case 3575610: /*type*/ return new String[] {"code"}; 4912 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 4913 default: return super.getTypesForProperty(hash, name); 4914 } 4915 4916 } 4917 4918 @Override 4919 public Base addChild(String name) throws FHIRException { 4920 if (name.equals("name")) { 4921 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.name"); 4922 } 4923 else if (name.equals("definition")) { 4924 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.definition"); 4925 } 4926 else if (name.equals("type")) { 4927 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.type"); 4928 } 4929 else if (name.equals("documentation")) { 4930 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.documentation"); 4931 } 4932 else 4933 return super.addChild(name); 4934 } 4935 4936 public CapabilityStatementRestResourceSearchParamComponent copy() { 4937 CapabilityStatementRestResourceSearchParamComponent dst = new CapabilityStatementRestResourceSearchParamComponent(); 4938 copyValues(dst); 4939 return dst; 4940 } 4941 4942 public void copyValues(CapabilityStatementRestResourceSearchParamComponent dst) { 4943 super.copyValues(dst); 4944 dst.name = name == null ? null : name.copy(); 4945 dst.definition = definition == null ? null : definition.copy(); 4946 dst.type = type == null ? null : type.copy(); 4947 dst.documentation = documentation == null ? null : documentation.copy(); 4948 } 4949 4950 @Override 4951 public boolean equalsDeep(Base other_) { 4952 if (!super.equalsDeep(other_)) 4953 return false; 4954 if (!(other_ instanceof CapabilityStatementRestResourceSearchParamComponent)) 4955 return false; 4956 CapabilityStatementRestResourceSearchParamComponent o = (CapabilityStatementRestResourceSearchParamComponent) other_; 4957 return compareDeep(name, o.name, true) && compareDeep(definition, o.definition, true) && compareDeep(type, o.type, true) 4958 && compareDeep(documentation, o.documentation, true); 4959 } 4960 4961 @Override 4962 public boolean equalsShallow(Base other_) { 4963 if (!super.equalsShallow(other_)) 4964 return false; 4965 if (!(other_ instanceof CapabilityStatementRestResourceSearchParamComponent)) 4966 return false; 4967 CapabilityStatementRestResourceSearchParamComponent o = (CapabilityStatementRestResourceSearchParamComponent) other_; 4968 return compareValues(name, o.name, true) && compareValues(type, o.type, true) && compareValues(documentation, o.documentation, true) 4969 ; 4970 } 4971 4972 public boolean isEmpty() { 4973 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, definition, type, documentation 4974 ); 4975 } 4976 4977 public String fhirType() { 4978 return "CapabilityStatement.rest.resource.searchParam"; 4979 4980 } 4981 4982 } 4983 4984 @Block() 4985 public static class CapabilityStatementRestResourceOperationComponent extends BackboneElement implements IBaseBackboneElement { 4986 /** 4987 * 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. 4988 */ 4989 @Child(name = "name", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true) 4990 @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." ) 4991 protected StringType name; 4992 4993 /** 4994 * 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]]] with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported. 4995 */ 4996 @Child(name = "definition", type = {CanonicalType.class}, order=2, min=1, max=1, modifier=false, summary=true) 4997 @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]]] with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported." ) 4998 protected CanonicalType definition; 4999 5000 /** 5001 * Documentation that describes anything special about the operation behavior, possibly detailing different behavior for system, type and instance-level invocation of the operation. 5002 */ 5003 @Child(name = "documentation", type = {MarkdownType.class}, order=3, min=0, max=1, modifier=false, summary=false) 5004 @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." ) 5005 protected MarkdownType documentation; 5006 5007 private static final long serialVersionUID = -388608084L; 5008 5009 /** 5010 * Constructor 5011 */ 5012 public CapabilityStatementRestResourceOperationComponent() { 5013 super(); 5014 } 5015 5016 /** 5017 * Constructor 5018 */ 5019 public CapabilityStatementRestResourceOperationComponent(StringType name, CanonicalType definition) { 5020 super(); 5021 this.name = name; 5022 this.definition = definition; 5023 } 5024 5025 /** 5026 * @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 5027 */ 5028 public StringType getNameElement() { 5029 if (this.name == null) 5030 if (Configuration.errorOnAutoCreate()) 5031 throw new Error("Attempt to auto-create CapabilityStatementRestResourceOperationComponent.name"); 5032 else if (Configuration.doAutoCreate()) 5033 this.name = new StringType(); // bb 5034 return this.name; 5035 } 5036 5037 public boolean hasNameElement() { 5038 return this.name != null && !this.name.isEmpty(); 5039 } 5040 5041 public boolean hasName() { 5042 return this.name != null && !this.name.isEmpty(); 5043 } 5044 5045 /** 5046 * @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 5047 */ 5048 public CapabilityStatementRestResourceOperationComponent setNameElement(StringType value) { 5049 this.name = value; 5050 return this; 5051 } 5052 5053 /** 5054 * @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. 5055 */ 5056 public String getName() { 5057 return this.name == null ? null : this.name.getValue(); 5058 } 5059 5060 /** 5061 * @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. 5062 */ 5063 public CapabilityStatementRestResourceOperationComponent setName(String value) { 5064 if (this.name == null) 5065 this.name = new StringType(); 5066 this.name.setValue(value); 5067 return this; 5068 } 5069 5070 /** 5071 * @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]]] 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 5072 */ 5073 public CanonicalType getDefinitionElement() { 5074 if (this.definition == null) 5075 if (Configuration.errorOnAutoCreate()) 5076 throw new Error("Attempt to auto-create CapabilityStatementRestResourceOperationComponent.definition"); 5077 else if (Configuration.doAutoCreate()) 5078 this.definition = new CanonicalType(); // bb 5079 return this.definition; 5080 } 5081 5082 public boolean hasDefinitionElement() { 5083 return this.definition != null && !this.definition.isEmpty(); 5084 } 5085 5086 public boolean hasDefinition() { 5087 return this.definition != null && !this.definition.isEmpty(); 5088 } 5089 5090 /** 5091 * @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]]] 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 5092 */ 5093 public CapabilityStatementRestResourceOperationComponent setDefinitionElement(CanonicalType value) { 5094 this.definition = value; 5095 return this; 5096 } 5097 5098 /** 5099 * @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]]] with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported. 5100 */ 5101 public String getDefinition() { 5102 return this.definition == null ? null : this.definition.getValue(); 5103 } 5104 5105 /** 5106 * @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]]] with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported. 5107 */ 5108 public CapabilityStatementRestResourceOperationComponent setDefinition(String value) { 5109 if (this.definition == null) 5110 this.definition = new CanonicalType(); 5111 this.definition.setValue(value); 5112 return this; 5113 } 5114 5115 /** 5116 * @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 5117 */ 5118 public MarkdownType getDocumentationElement() { 5119 if (this.documentation == null) 5120 if (Configuration.errorOnAutoCreate()) 5121 throw new Error("Attempt to auto-create CapabilityStatementRestResourceOperationComponent.documentation"); 5122 else if (Configuration.doAutoCreate()) 5123 this.documentation = new MarkdownType(); // bb 5124 return this.documentation; 5125 } 5126 5127 public boolean hasDocumentationElement() { 5128 return this.documentation != null && !this.documentation.isEmpty(); 5129 } 5130 5131 public boolean hasDocumentation() { 5132 return this.documentation != null && !this.documentation.isEmpty(); 5133 } 5134 5135 /** 5136 * @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 5137 */ 5138 public CapabilityStatementRestResourceOperationComponent setDocumentationElement(MarkdownType value) { 5139 this.documentation = value; 5140 return this; 5141 } 5142 5143 /** 5144 * @return Documentation that describes anything special about the operation behavior, possibly detailing different behavior for system, type and instance-level invocation of the operation. 5145 */ 5146 public String getDocumentation() { 5147 return this.documentation == null ? null : this.documentation.getValue(); 5148 } 5149 5150 /** 5151 * @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. 5152 */ 5153 public CapabilityStatementRestResourceOperationComponent setDocumentation(String value) { 5154 if (value == null) 5155 this.documentation = null; 5156 else { 5157 if (this.documentation == null) 5158 this.documentation = new MarkdownType(); 5159 this.documentation.setValue(value); 5160 } 5161 return this; 5162 } 5163 5164 protected void listChildren(List<Property> children) { 5165 super.listChildren(children); 5166 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)); 5167 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]]] with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported.", 0, 1, definition)); 5168 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)); 5169 } 5170 5171 @Override 5172 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 5173 switch (_hash) { 5174 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); 5175 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]]] with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported.", 0, 1, definition); 5176 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); 5177 default: return super.getNamedProperty(_hash, _name, _checkValid); 5178 } 5179 5180 } 5181 5182 @Override 5183 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 5184 switch (hash) { 5185 case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType 5186 case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : new Base[] {this.definition}; // CanonicalType 5187 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 5188 default: return super.getProperty(hash, name, checkValid); 5189 } 5190 5191 } 5192 5193 @Override 5194 public Base setProperty(int hash, String name, Base value) throws FHIRException { 5195 switch (hash) { 5196 case 3373707: // name 5197 this.name = castToString(value); // StringType 5198 return value; 5199 case -1014418093: // definition 5200 this.definition = castToCanonical(value); // CanonicalType 5201 return value; 5202 case 1587405498: // documentation 5203 this.documentation = castToMarkdown(value); // MarkdownType 5204 return value; 5205 default: return super.setProperty(hash, name, value); 5206 } 5207 5208 } 5209 5210 @Override 5211 public Base setProperty(String name, Base value) throws FHIRException { 5212 if (name.equals("name")) { 5213 this.name = castToString(value); // StringType 5214 } else if (name.equals("definition")) { 5215 this.definition = castToCanonical(value); // CanonicalType 5216 } else if (name.equals("documentation")) { 5217 this.documentation = castToMarkdown(value); // MarkdownType 5218 } else 5219 return super.setProperty(name, value); 5220 return value; 5221 } 5222 5223 @Override 5224 public Base makeProperty(int hash, String name) throws FHIRException { 5225 switch (hash) { 5226 case 3373707: return getNameElement(); 5227 case -1014418093: return getDefinitionElement(); 5228 case 1587405498: return getDocumentationElement(); 5229 default: return super.makeProperty(hash, name); 5230 } 5231 5232 } 5233 5234 @Override 5235 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 5236 switch (hash) { 5237 case 3373707: /*name*/ return new String[] {"string"}; 5238 case -1014418093: /*definition*/ return new String[] {"canonical"}; 5239 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 5240 default: return super.getTypesForProperty(hash, name); 5241 } 5242 5243 } 5244 5245 @Override 5246 public Base addChild(String name) throws FHIRException { 5247 if (name.equals("name")) { 5248 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.name"); 5249 } 5250 else if (name.equals("definition")) { 5251 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.definition"); 5252 } 5253 else if (name.equals("documentation")) { 5254 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.documentation"); 5255 } 5256 else 5257 return super.addChild(name); 5258 } 5259 5260 public CapabilityStatementRestResourceOperationComponent copy() { 5261 CapabilityStatementRestResourceOperationComponent dst = new CapabilityStatementRestResourceOperationComponent(); 5262 copyValues(dst); 5263 return dst; 5264 } 5265 5266 public void copyValues(CapabilityStatementRestResourceOperationComponent dst) { 5267 super.copyValues(dst); 5268 dst.name = name == null ? null : name.copy(); 5269 dst.definition = definition == null ? null : definition.copy(); 5270 dst.documentation = documentation == null ? null : documentation.copy(); 5271 } 5272 5273 @Override 5274 public boolean equalsDeep(Base other_) { 5275 if (!super.equalsDeep(other_)) 5276 return false; 5277 if (!(other_ instanceof CapabilityStatementRestResourceOperationComponent)) 5278 return false; 5279 CapabilityStatementRestResourceOperationComponent o = (CapabilityStatementRestResourceOperationComponent) other_; 5280 return compareDeep(name, o.name, true) && compareDeep(definition, o.definition, true) && compareDeep(documentation, o.documentation, true) 5281 ; 5282 } 5283 5284 @Override 5285 public boolean equalsShallow(Base other_) { 5286 if (!super.equalsShallow(other_)) 5287 return false; 5288 if (!(other_ instanceof CapabilityStatementRestResourceOperationComponent)) 5289 return false; 5290 CapabilityStatementRestResourceOperationComponent o = (CapabilityStatementRestResourceOperationComponent) other_; 5291 return compareValues(name, o.name, true) && compareValues(documentation, o.documentation, true); 5292 } 5293 5294 public boolean isEmpty() { 5295 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, definition, documentation 5296 ); 5297 } 5298 5299 public String fhirType() { 5300 return "CapabilityStatement.rest.resource.operation"; 5301 5302 } 5303 5304 } 5305 5306 @Block() 5307 public static class SystemInteractionComponent extends BackboneElement implements IBaseBackboneElement { 5308 /** 5309 * A coded identifier of the operation, supported by the system. 5310 */ 5311 @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=false) 5312 @Description(shortDefinition="transaction | batch | search-system | history-system", formalDefinition="A coded identifier of the operation, supported by the system." ) 5313 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/system-restful-interaction") 5314 protected Enumeration<SystemRestfulInteraction> code; 5315 5316 /** 5317 * 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. 5318 */ 5319 @Child(name = "documentation", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=false) 5320 @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." ) 5321 protected MarkdownType documentation; 5322 5323 private static final long serialVersionUID = -1495143879L; 5324 5325 /** 5326 * Constructor 5327 */ 5328 public SystemInteractionComponent() { 5329 super(); 5330 } 5331 5332 /** 5333 * Constructor 5334 */ 5335 public SystemInteractionComponent(Enumeration<SystemRestfulInteraction> code) { 5336 super(); 5337 this.code = code; 5338 } 5339 5340 /** 5341 * @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 5342 */ 5343 public Enumeration<SystemRestfulInteraction> getCodeElement() { 5344 if (this.code == null) 5345 if (Configuration.errorOnAutoCreate()) 5346 throw new Error("Attempt to auto-create SystemInteractionComponent.code"); 5347 else if (Configuration.doAutoCreate()) 5348 this.code = new Enumeration<SystemRestfulInteraction>(new SystemRestfulInteractionEnumFactory()); // bb 5349 return this.code; 5350 } 5351 5352 public boolean hasCodeElement() { 5353 return this.code != null && !this.code.isEmpty(); 5354 } 5355 5356 public boolean hasCode() { 5357 return this.code != null && !this.code.isEmpty(); 5358 } 5359 5360 /** 5361 * @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 5362 */ 5363 public SystemInteractionComponent setCodeElement(Enumeration<SystemRestfulInteraction> value) { 5364 this.code = value; 5365 return this; 5366 } 5367 5368 /** 5369 * @return A coded identifier of the operation, supported by the system. 5370 */ 5371 public SystemRestfulInteraction getCode() { 5372 return this.code == null ? null : this.code.getValue(); 5373 } 5374 5375 /** 5376 * @param value A coded identifier of the operation, supported by the system. 5377 */ 5378 public SystemInteractionComponent setCode(SystemRestfulInteraction value) { 5379 if (this.code == null) 5380 this.code = new Enumeration<SystemRestfulInteraction>(new SystemRestfulInteractionEnumFactory()); 5381 this.code.setValue(value); 5382 return this; 5383 } 5384 5385 /** 5386 * @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 5387 */ 5388 public MarkdownType getDocumentationElement() { 5389 if (this.documentation == null) 5390 if (Configuration.errorOnAutoCreate()) 5391 throw new Error("Attempt to auto-create SystemInteractionComponent.documentation"); 5392 else if (Configuration.doAutoCreate()) 5393 this.documentation = new MarkdownType(); // bb 5394 return this.documentation; 5395 } 5396 5397 public boolean hasDocumentationElement() { 5398 return this.documentation != null && !this.documentation.isEmpty(); 5399 } 5400 5401 public boolean hasDocumentation() { 5402 return this.documentation != null && !this.documentation.isEmpty(); 5403 } 5404 5405 /** 5406 * @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 5407 */ 5408 public SystemInteractionComponent setDocumentationElement(MarkdownType value) { 5409 this.documentation = value; 5410 return this; 5411 } 5412 5413 /** 5414 * @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. 5415 */ 5416 public String getDocumentation() { 5417 return this.documentation == null ? null : this.documentation.getValue(); 5418 } 5419 5420 /** 5421 * @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. 5422 */ 5423 public SystemInteractionComponent setDocumentation(String value) { 5424 if (value == null) 5425 this.documentation = null; 5426 else { 5427 if (this.documentation == null) 5428 this.documentation = new MarkdownType(); 5429 this.documentation.setValue(value); 5430 } 5431 return this; 5432 } 5433 5434 protected void listChildren(List<Property> children) { 5435 super.listChildren(children); 5436 children.add(new Property("code", "code", "A coded identifier of the operation, supported by the system.", 0, 1, code)); 5437 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)); 5438 } 5439 5440 @Override 5441 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 5442 switch (_hash) { 5443 case 3059181: /*code*/ return new Property("code", "code", "A coded identifier of the operation, supported by the system.", 0, 1, code); 5444 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); 5445 default: return super.getNamedProperty(_hash, _name, _checkValid); 5446 } 5447 5448 } 5449 5450 @Override 5451 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 5452 switch (hash) { 5453 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // Enumeration<SystemRestfulInteraction> 5454 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 5455 default: return super.getProperty(hash, name, checkValid); 5456 } 5457 5458 } 5459 5460 @Override 5461 public Base setProperty(int hash, String name, Base value) throws FHIRException { 5462 switch (hash) { 5463 case 3059181: // code 5464 value = new SystemRestfulInteractionEnumFactory().fromType(castToCode(value)); 5465 this.code = (Enumeration) value; // Enumeration<SystemRestfulInteraction> 5466 return value; 5467 case 1587405498: // documentation 5468 this.documentation = castToMarkdown(value); // MarkdownType 5469 return value; 5470 default: return super.setProperty(hash, name, value); 5471 } 5472 5473 } 5474 5475 @Override 5476 public Base setProperty(String name, Base value) throws FHIRException { 5477 if (name.equals("code")) { 5478 value = new SystemRestfulInteractionEnumFactory().fromType(castToCode(value)); 5479 this.code = (Enumeration) value; // Enumeration<SystemRestfulInteraction> 5480 } else if (name.equals("documentation")) { 5481 this.documentation = castToMarkdown(value); // MarkdownType 5482 } else 5483 return super.setProperty(name, value); 5484 return value; 5485 } 5486 5487 @Override 5488 public Base makeProperty(int hash, String name) throws FHIRException { 5489 switch (hash) { 5490 case 3059181: return getCodeElement(); 5491 case 1587405498: return getDocumentationElement(); 5492 default: return super.makeProperty(hash, name); 5493 } 5494 5495 } 5496 5497 @Override 5498 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 5499 switch (hash) { 5500 case 3059181: /*code*/ return new String[] {"code"}; 5501 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 5502 default: return super.getTypesForProperty(hash, name); 5503 } 5504 5505 } 5506 5507 @Override 5508 public Base addChild(String name) throws FHIRException { 5509 if (name.equals("code")) { 5510 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.code"); 5511 } 5512 else if (name.equals("documentation")) { 5513 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.documentation"); 5514 } 5515 else 5516 return super.addChild(name); 5517 } 5518 5519 public SystemInteractionComponent copy() { 5520 SystemInteractionComponent dst = new SystemInteractionComponent(); 5521 copyValues(dst); 5522 return dst; 5523 } 5524 5525 public void copyValues(SystemInteractionComponent dst) { 5526 super.copyValues(dst); 5527 dst.code = code == null ? null : code.copy(); 5528 dst.documentation = documentation == null ? null : documentation.copy(); 5529 } 5530 5531 @Override 5532 public boolean equalsDeep(Base other_) { 5533 if (!super.equalsDeep(other_)) 5534 return false; 5535 if (!(other_ instanceof SystemInteractionComponent)) 5536 return false; 5537 SystemInteractionComponent o = (SystemInteractionComponent) other_; 5538 return compareDeep(code, o.code, true) && compareDeep(documentation, o.documentation, true); 5539 } 5540 5541 @Override 5542 public boolean equalsShallow(Base other_) { 5543 if (!super.equalsShallow(other_)) 5544 return false; 5545 if (!(other_ instanceof SystemInteractionComponent)) 5546 return false; 5547 SystemInteractionComponent o = (SystemInteractionComponent) other_; 5548 return compareValues(code, o.code, true) && compareValues(documentation, o.documentation, true); 5549 } 5550 5551 public boolean isEmpty() { 5552 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, documentation); 5553 } 5554 5555 public String fhirType() { 5556 return "CapabilityStatement.rest.interaction"; 5557 5558 } 5559 5560 } 5561 5562 @Block() 5563 public static class CapabilityStatementMessagingComponent extends BackboneElement implements IBaseBackboneElement { 5564 /** 5565 * An endpoint (network accessible address) to which messages and/or replies are to be sent. 5566 */ 5567 @Child(name = "endpoint", type = {}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 5568 @Description(shortDefinition="Where messages should be sent", formalDefinition="An endpoint (network accessible address) to which messages and/or replies are to be sent." ) 5569 protected List<CapabilityStatementMessagingEndpointComponent> endpoint; 5570 5571 /** 5572 * 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). 5573 */ 5574 @Child(name = "reliableCache", type = {UnsignedIntType.class}, order=2, min=0, max=1, modifier=false, summary=false) 5575 @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)." ) 5576 protected UnsignedIntType reliableCache; 5577 5578 /** 5579 * 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. 5580 */ 5581 @Child(name = "documentation", type = {MarkdownType.class}, order=3, min=0, max=1, modifier=false, summary=false) 5582 @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." ) 5583 protected MarkdownType documentation; 5584 5585 /** 5586 * References to message definitions for messages this system can send or receive. 5587 */ 5588 @Child(name = "supportedMessage", type = {}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 5589 @Description(shortDefinition="Messages supported by this system", formalDefinition="References to message definitions for messages this system can send or receive." ) 5590 protected List<CapabilityStatementMessagingSupportedMessageComponent> supportedMessage; 5591 5592 private static final long serialVersionUID = 300411231L; 5593 5594 /** 5595 * Constructor 5596 */ 5597 public CapabilityStatementMessagingComponent() { 5598 super(); 5599 } 5600 5601 /** 5602 * @return {@link #endpoint} (An endpoint (network accessible address) to which messages and/or replies are to be sent.) 5603 */ 5604 public List<CapabilityStatementMessagingEndpointComponent> getEndpoint() { 5605 if (this.endpoint == null) 5606 this.endpoint = new ArrayList<CapabilityStatementMessagingEndpointComponent>(); 5607 return this.endpoint; 5608 } 5609 5610 /** 5611 * @return Returns a reference to <code>this</code> for easy method chaining 5612 */ 5613 public CapabilityStatementMessagingComponent setEndpoint(List<CapabilityStatementMessagingEndpointComponent> theEndpoint) { 5614 this.endpoint = theEndpoint; 5615 return this; 5616 } 5617 5618 public boolean hasEndpoint() { 5619 if (this.endpoint == null) 5620 return false; 5621 for (CapabilityStatementMessagingEndpointComponent item : this.endpoint) 5622 if (!item.isEmpty()) 5623 return true; 5624 return false; 5625 } 5626 5627 public CapabilityStatementMessagingEndpointComponent addEndpoint() { //3 5628 CapabilityStatementMessagingEndpointComponent t = new CapabilityStatementMessagingEndpointComponent(); 5629 if (this.endpoint == null) 5630 this.endpoint = new ArrayList<CapabilityStatementMessagingEndpointComponent>(); 5631 this.endpoint.add(t); 5632 return t; 5633 } 5634 5635 public CapabilityStatementMessagingComponent addEndpoint(CapabilityStatementMessagingEndpointComponent t) { //3 5636 if (t == null) 5637 return this; 5638 if (this.endpoint == null) 5639 this.endpoint = new ArrayList<CapabilityStatementMessagingEndpointComponent>(); 5640 this.endpoint.add(t); 5641 return this; 5642 } 5643 5644 /** 5645 * @return The first repetition of repeating field {@link #endpoint}, creating it if it does not already exist 5646 */ 5647 public CapabilityStatementMessagingEndpointComponent getEndpointFirstRep() { 5648 if (getEndpoint().isEmpty()) { 5649 addEndpoint(); 5650 } 5651 return getEndpoint().get(0); 5652 } 5653 5654 /** 5655 * @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 5656 */ 5657 public UnsignedIntType getReliableCacheElement() { 5658 if (this.reliableCache == null) 5659 if (Configuration.errorOnAutoCreate()) 5660 throw new Error("Attempt to auto-create CapabilityStatementMessagingComponent.reliableCache"); 5661 else if (Configuration.doAutoCreate()) 5662 this.reliableCache = new UnsignedIntType(); // bb 5663 return this.reliableCache; 5664 } 5665 5666 public boolean hasReliableCacheElement() { 5667 return this.reliableCache != null && !this.reliableCache.isEmpty(); 5668 } 5669 5670 public boolean hasReliableCache() { 5671 return this.reliableCache != null && !this.reliableCache.isEmpty(); 5672 } 5673 5674 /** 5675 * @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 5676 */ 5677 public CapabilityStatementMessagingComponent setReliableCacheElement(UnsignedIntType value) { 5678 this.reliableCache = value; 5679 return this; 5680 } 5681 5682 /** 5683 * @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). 5684 */ 5685 public int getReliableCache() { 5686 return this.reliableCache == null || this.reliableCache.isEmpty() ? 0 : this.reliableCache.getValue(); 5687 } 5688 5689 /** 5690 * @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). 5691 */ 5692 public CapabilityStatementMessagingComponent setReliableCache(int value) { 5693 if (this.reliableCache == null) 5694 this.reliableCache = new UnsignedIntType(); 5695 this.reliableCache.setValue(value); 5696 return this; 5697 } 5698 5699 /** 5700 * @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 5701 */ 5702 public MarkdownType getDocumentationElement() { 5703 if (this.documentation == null) 5704 if (Configuration.errorOnAutoCreate()) 5705 throw new Error("Attempt to auto-create CapabilityStatementMessagingComponent.documentation"); 5706 else if (Configuration.doAutoCreate()) 5707 this.documentation = new MarkdownType(); // bb 5708 return this.documentation; 5709 } 5710 5711 public boolean hasDocumentationElement() { 5712 return this.documentation != null && !this.documentation.isEmpty(); 5713 } 5714 5715 public boolean hasDocumentation() { 5716 return this.documentation != null && !this.documentation.isEmpty(); 5717 } 5718 5719 /** 5720 * @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 5721 */ 5722 public CapabilityStatementMessagingComponent setDocumentationElement(MarkdownType value) { 5723 this.documentation = value; 5724 return this; 5725 } 5726 5727 /** 5728 * @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. 5729 */ 5730 public String getDocumentation() { 5731 return this.documentation == null ? null : this.documentation.getValue(); 5732 } 5733 5734 /** 5735 * @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. 5736 */ 5737 public CapabilityStatementMessagingComponent setDocumentation(String value) { 5738 if (value == null) 5739 this.documentation = null; 5740 else { 5741 if (this.documentation == null) 5742 this.documentation = new MarkdownType(); 5743 this.documentation.setValue(value); 5744 } 5745 return this; 5746 } 5747 5748 /** 5749 * @return {@link #supportedMessage} (References to message definitions for messages this system can send or receive.) 5750 */ 5751 public List<CapabilityStatementMessagingSupportedMessageComponent> getSupportedMessage() { 5752 if (this.supportedMessage == null) 5753 this.supportedMessage = new ArrayList<CapabilityStatementMessagingSupportedMessageComponent>(); 5754 return this.supportedMessage; 5755 } 5756 5757 /** 5758 * @return Returns a reference to <code>this</code> for easy method chaining 5759 */ 5760 public CapabilityStatementMessagingComponent setSupportedMessage(List<CapabilityStatementMessagingSupportedMessageComponent> theSupportedMessage) { 5761 this.supportedMessage = theSupportedMessage; 5762 return this; 5763 } 5764 5765 public boolean hasSupportedMessage() { 5766 if (this.supportedMessage == null) 5767 return false; 5768 for (CapabilityStatementMessagingSupportedMessageComponent item : this.supportedMessage) 5769 if (!item.isEmpty()) 5770 return true; 5771 return false; 5772 } 5773 5774 public CapabilityStatementMessagingSupportedMessageComponent addSupportedMessage() { //3 5775 CapabilityStatementMessagingSupportedMessageComponent t = new CapabilityStatementMessagingSupportedMessageComponent(); 5776 if (this.supportedMessage == null) 5777 this.supportedMessage = new ArrayList<CapabilityStatementMessagingSupportedMessageComponent>(); 5778 this.supportedMessage.add(t); 5779 return t; 5780 } 5781 5782 public CapabilityStatementMessagingComponent addSupportedMessage(CapabilityStatementMessagingSupportedMessageComponent t) { //3 5783 if (t == null) 5784 return this; 5785 if (this.supportedMessage == null) 5786 this.supportedMessage = new ArrayList<CapabilityStatementMessagingSupportedMessageComponent>(); 5787 this.supportedMessage.add(t); 5788 return this; 5789 } 5790 5791 /** 5792 * @return The first repetition of repeating field {@link #supportedMessage}, creating it if it does not already exist 5793 */ 5794 public CapabilityStatementMessagingSupportedMessageComponent getSupportedMessageFirstRep() { 5795 if (getSupportedMessage().isEmpty()) { 5796 addSupportedMessage(); 5797 } 5798 return getSupportedMessage().get(0); 5799 } 5800 5801 protected void listChildren(List<Property> children) { 5802 super.listChildren(children); 5803 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)); 5804 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)); 5805 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)); 5806 children.add(new Property("supportedMessage", "", "References to message definitions for messages this system can send or receive.", 0, java.lang.Integer.MAX_VALUE, supportedMessage)); 5807 } 5808 5809 @Override 5810 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 5811 switch (_hash) { 5812 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); 5813 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); 5814 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); 5815 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); 5816 default: return super.getNamedProperty(_hash, _name, _checkValid); 5817 } 5818 5819 } 5820 5821 @Override 5822 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 5823 switch (hash) { 5824 case 1741102485: /*endpoint*/ return this.endpoint == null ? new Base[0] : this.endpoint.toArray(new Base[this.endpoint.size()]); // CapabilityStatementMessagingEndpointComponent 5825 case 897803608: /*reliableCache*/ return this.reliableCache == null ? new Base[0] : new Base[] {this.reliableCache}; // UnsignedIntType 5826 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 5827 case -1805139079: /*supportedMessage*/ return this.supportedMessage == null ? new Base[0] : this.supportedMessage.toArray(new Base[this.supportedMessage.size()]); // CapabilityStatementMessagingSupportedMessageComponent 5828 default: return super.getProperty(hash, name, checkValid); 5829 } 5830 5831 } 5832 5833 @Override 5834 public Base setProperty(int hash, String name, Base value) throws FHIRException { 5835 switch (hash) { 5836 case 1741102485: // endpoint 5837 this.getEndpoint().add((CapabilityStatementMessagingEndpointComponent) value); // CapabilityStatementMessagingEndpointComponent 5838 return value; 5839 case 897803608: // reliableCache 5840 this.reliableCache = castToUnsignedInt(value); // UnsignedIntType 5841 return value; 5842 case 1587405498: // documentation 5843 this.documentation = castToMarkdown(value); // MarkdownType 5844 return value; 5845 case -1805139079: // supportedMessage 5846 this.getSupportedMessage().add((CapabilityStatementMessagingSupportedMessageComponent) value); // CapabilityStatementMessagingSupportedMessageComponent 5847 return value; 5848 default: return super.setProperty(hash, name, value); 5849 } 5850 5851 } 5852 5853 @Override 5854 public Base setProperty(String name, Base value) throws FHIRException { 5855 if (name.equals("endpoint")) { 5856 this.getEndpoint().add((CapabilityStatementMessagingEndpointComponent) value); 5857 } else if (name.equals("reliableCache")) { 5858 this.reliableCache = castToUnsignedInt(value); // UnsignedIntType 5859 } else if (name.equals("documentation")) { 5860 this.documentation = castToMarkdown(value); // MarkdownType 5861 } else if (name.equals("supportedMessage")) { 5862 this.getSupportedMessage().add((CapabilityStatementMessagingSupportedMessageComponent) value); 5863 } else 5864 return super.setProperty(name, value); 5865 return value; 5866 } 5867 5868 @Override 5869 public Base makeProperty(int hash, String name) throws FHIRException { 5870 switch (hash) { 5871 case 1741102485: return addEndpoint(); 5872 case 897803608: return getReliableCacheElement(); 5873 case 1587405498: return getDocumentationElement(); 5874 case -1805139079: return addSupportedMessage(); 5875 default: return super.makeProperty(hash, name); 5876 } 5877 5878 } 5879 5880 @Override 5881 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 5882 switch (hash) { 5883 case 1741102485: /*endpoint*/ return new String[] {}; 5884 case 897803608: /*reliableCache*/ return new String[] {"unsignedInt"}; 5885 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 5886 case -1805139079: /*supportedMessage*/ return new String[] {}; 5887 default: return super.getTypesForProperty(hash, name); 5888 } 5889 5890 } 5891 5892 @Override 5893 public Base addChild(String name) throws FHIRException { 5894 if (name.equals("endpoint")) { 5895 return addEndpoint(); 5896 } 5897 else if (name.equals("reliableCache")) { 5898 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.reliableCache"); 5899 } 5900 else if (name.equals("documentation")) { 5901 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.documentation"); 5902 } 5903 else if (name.equals("supportedMessage")) { 5904 return addSupportedMessage(); 5905 } 5906 else 5907 return super.addChild(name); 5908 } 5909 5910 public CapabilityStatementMessagingComponent copy() { 5911 CapabilityStatementMessagingComponent dst = new CapabilityStatementMessagingComponent(); 5912 copyValues(dst); 5913 return dst; 5914 } 5915 5916 public void copyValues(CapabilityStatementMessagingComponent dst) { 5917 super.copyValues(dst); 5918 if (endpoint != null) { 5919 dst.endpoint = new ArrayList<CapabilityStatementMessagingEndpointComponent>(); 5920 for (CapabilityStatementMessagingEndpointComponent i : endpoint) 5921 dst.endpoint.add(i.copy()); 5922 }; 5923 dst.reliableCache = reliableCache == null ? null : reliableCache.copy(); 5924 dst.documentation = documentation == null ? null : documentation.copy(); 5925 if (supportedMessage != null) { 5926 dst.supportedMessage = new ArrayList<CapabilityStatementMessagingSupportedMessageComponent>(); 5927 for (CapabilityStatementMessagingSupportedMessageComponent i : supportedMessage) 5928 dst.supportedMessage.add(i.copy()); 5929 }; 5930 } 5931 5932 @Override 5933 public boolean equalsDeep(Base other_) { 5934 if (!super.equalsDeep(other_)) 5935 return false; 5936 if (!(other_ instanceof CapabilityStatementMessagingComponent)) 5937 return false; 5938 CapabilityStatementMessagingComponent o = (CapabilityStatementMessagingComponent) other_; 5939 return compareDeep(endpoint, o.endpoint, true) && compareDeep(reliableCache, o.reliableCache, true) 5940 && compareDeep(documentation, o.documentation, true) && compareDeep(supportedMessage, o.supportedMessage, true) 5941 ; 5942 } 5943 5944 @Override 5945 public boolean equalsShallow(Base other_) { 5946 if (!super.equalsShallow(other_)) 5947 return false; 5948 if (!(other_ instanceof CapabilityStatementMessagingComponent)) 5949 return false; 5950 CapabilityStatementMessagingComponent o = (CapabilityStatementMessagingComponent) other_; 5951 return compareValues(reliableCache, o.reliableCache, true) && compareValues(documentation, o.documentation, true) 5952 ; 5953 } 5954 5955 public boolean isEmpty() { 5956 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(endpoint, reliableCache, documentation 5957 , supportedMessage); 5958 } 5959 5960 public String fhirType() { 5961 return "CapabilityStatement.messaging"; 5962 5963 } 5964 5965 } 5966 5967 @Block() 5968 public static class CapabilityStatementMessagingEndpointComponent extends BackboneElement implements IBaseBackboneElement { 5969 /** 5970 * A list of the messaging transport protocol(s) identifiers, supported by this endpoint. 5971 */ 5972 @Child(name = "protocol", type = {Coding.class}, order=1, min=1, max=1, modifier=false, summary=false) 5973 @Description(shortDefinition="http | ftp | mllp +", formalDefinition="A list of the messaging transport protocol(s) identifiers, supported by this endpoint." ) 5974 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/message-transport") 5975 protected Coding protocol; 5976 5977 /** 5978 * The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier. 5979 */ 5980 @Child(name = "address", type = {UrlType.class}, order=2, min=1, max=1, modifier=false, summary=false) 5981 @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." ) 5982 protected UrlType address; 5983 5984 private static final long serialVersionUID = -236946103L; 5985 5986 /** 5987 * Constructor 5988 */ 5989 public CapabilityStatementMessagingEndpointComponent() { 5990 super(); 5991 } 5992 5993 /** 5994 * Constructor 5995 */ 5996 public CapabilityStatementMessagingEndpointComponent(Coding protocol, UrlType address) { 5997 super(); 5998 this.protocol = protocol; 5999 this.address = address; 6000 } 6001 6002 /** 6003 * @return {@link #protocol} (A list of the messaging transport protocol(s) identifiers, supported by this endpoint.) 6004 */ 6005 public Coding getProtocol() { 6006 if (this.protocol == null) 6007 if (Configuration.errorOnAutoCreate()) 6008 throw new Error("Attempt to auto-create CapabilityStatementMessagingEndpointComponent.protocol"); 6009 else if (Configuration.doAutoCreate()) 6010 this.protocol = new Coding(); // cc 6011 return this.protocol; 6012 } 6013 6014 public boolean hasProtocol() { 6015 return this.protocol != null && !this.protocol.isEmpty(); 6016 } 6017 6018 /** 6019 * @param value {@link #protocol} (A list of the messaging transport protocol(s) identifiers, supported by this endpoint.) 6020 */ 6021 public CapabilityStatementMessagingEndpointComponent setProtocol(Coding value) { 6022 this.protocol = value; 6023 return this; 6024 } 6025 6026 /** 6027 * @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 6028 */ 6029 public UrlType getAddressElement() { 6030 if (this.address == null) 6031 if (Configuration.errorOnAutoCreate()) 6032 throw new Error("Attempt to auto-create CapabilityStatementMessagingEndpointComponent.address"); 6033 else if (Configuration.doAutoCreate()) 6034 this.address = new UrlType(); // bb 6035 return this.address; 6036 } 6037 6038 public boolean hasAddressElement() { 6039 return this.address != null && !this.address.isEmpty(); 6040 } 6041 6042 public boolean hasAddress() { 6043 return this.address != null && !this.address.isEmpty(); 6044 } 6045 6046 /** 6047 * @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 6048 */ 6049 public CapabilityStatementMessagingEndpointComponent setAddressElement(UrlType value) { 6050 this.address = value; 6051 return this; 6052 } 6053 6054 /** 6055 * @return The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier. 6056 */ 6057 public String getAddress() { 6058 return this.address == null ? null : this.address.getValue(); 6059 } 6060 6061 /** 6062 * @param value The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier. 6063 */ 6064 public CapabilityStatementMessagingEndpointComponent setAddress(String value) { 6065 if (this.address == null) 6066 this.address = new UrlType(); 6067 this.address.setValue(value); 6068 return this; 6069 } 6070 6071 protected void listChildren(List<Property> children) { 6072 super.listChildren(children); 6073 children.add(new Property("protocol", "Coding", "A list of the messaging transport protocol(s) identifiers, supported by this endpoint.", 0, 1, protocol)); 6074 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)); 6075 } 6076 6077 @Override 6078 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 6079 switch (_hash) { 6080 case -989163880: /*protocol*/ return new Property("protocol", "Coding", "A list of the messaging transport protocol(s) identifiers, supported by this endpoint.", 0, 1, protocol); 6081 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); 6082 default: return super.getNamedProperty(_hash, _name, _checkValid); 6083 } 6084 6085 } 6086 6087 @Override 6088 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 6089 switch (hash) { 6090 case -989163880: /*protocol*/ return this.protocol == null ? new Base[0] : new Base[] {this.protocol}; // Coding 6091 case -1147692044: /*address*/ return this.address == null ? new Base[0] : new Base[] {this.address}; // UrlType 6092 default: return super.getProperty(hash, name, checkValid); 6093 } 6094 6095 } 6096 6097 @Override 6098 public Base setProperty(int hash, String name, Base value) throws FHIRException { 6099 switch (hash) { 6100 case -989163880: // protocol 6101 this.protocol = castToCoding(value); // Coding 6102 return value; 6103 case -1147692044: // address 6104 this.address = castToUrl(value); // UrlType 6105 return value; 6106 default: return super.setProperty(hash, name, value); 6107 } 6108 6109 } 6110 6111 @Override 6112 public Base setProperty(String name, Base value) throws FHIRException { 6113 if (name.equals("protocol")) { 6114 this.protocol = castToCoding(value); // Coding 6115 } else if (name.equals("address")) { 6116 this.address = castToUrl(value); // UrlType 6117 } else 6118 return super.setProperty(name, value); 6119 return value; 6120 } 6121 6122 @Override 6123 public Base makeProperty(int hash, String name) throws FHIRException { 6124 switch (hash) { 6125 case -989163880: return getProtocol(); 6126 case -1147692044: return getAddressElement(); 6127 default: return super.makeProperty(hash, name); 6128 } 6129 6130 } 6131 6132 @Override 6133 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 6134 switch (hash) { 6135 case -989163880: /*protocol*/ return new String[] {"Coding"}; 6136 case -1147692044: /*address*/ return new String[] {"url"}; 6137 default: return super.getTypesForProperty(hash, name); 6138 } 6139 6140 } 6141 6142 @Override 6143 public Base addChild(String name) throws FHIRException { 6144 if (name.equals("protocol")) { 6145 this.protocol = new Coding(); 6146 return this.protocol; 6147 } 6148 else if (name.equals("address")) { 6149 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.address"); 6150 } 6151 else 6152 return super.addChild(name); 6153 } 6154 6155 public CapabilityStatementMessagingEndpointComponent copy() { 6156 CapabilityStatementMessagingEndpointComponent dst = new CapabilityStatementMessagingEndpointComponent(); 6157 copyValues(dst); 6158 return dst; 6159 } 6160 6161 public void copyValues(CapabilityStatementMessagingEndpointComponent dst) { 6162 super.copyValues(dst); 6163 dst.protocol = protocol == null ? null : protocol.copy(); 6164 dst.address = address == null ? null : address.copy(); 6165 } 6166 6167 @Override 6168 public boolean equalsDeep(Base other_) { 6169 if (!super.equalsDeep(other_)) 6170 return false; 6171 if (!(other_ instanceof CapabilityStatementMessagingEndpointComponent)) 6172 return false; 6173 CapabilityStatementMessagingEndpointComponent o = (CapabilityStatementMessagingEndpointComponent) other_; 6174 return compareDeep(protocol, o.protocol, true) && compareDeep(address, o.address, true); 6175 } 6176 6177 @Override 6178 public boolean equalsShallow(Base other_) { 6179 if (!super.equalsShallow(other_)) 6180 return false; 6181 if (!(other_ instanceof CapabilityStatementMessagingEndpointComponent)) 6182 return false; 6183 CapabilityStatementMessagingEndpointComponent o = (CapabilityStatementMessagingEndpointComponent) other_; 6184 return compareValues(address, o.address, true); 6185 } 6186 6187 public boolean isEmpty() { 6188 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(protocol, address); 6189 } 6190 6191 public String fhirType() { 6192 return "CapabilityStatement.messaging.endpoint"; 6193 6194 } 6195 6196 } 6197 6198 @Block() 6199 public static class CapabilityStatementMessagingSupportedMessageComponent extends BackboneElement implements IBaseBackboneElement { 6200 /** 6201 * The mode of this event declaration - whether application is sender or receiver. 6202 */ 6203 @Child(name = "mode", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true) 6204 @Description(shortDefinition="sender | receiver", formalDefinition="The mode of this event declaration - whether application is sender or receiver." ) 6205 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/event-capability-mode") 6206 protected Enumeration<EventCapabilityMode> mode; 6207 6208 /** 6209 * Points to a message definition that identifies the messaging event, message structure, allowed responses, etc. 6210 */ 6211 @Child(name = "definition", type = {CanonicalType.class}, order=2, min=1, max=1, modifier=false, summary=true) 6212 @Description(shortDefinition="Message supported by this system", formalDefinition="Points to a message definition that identifies the messaging event, message structure, allowed responses, etc." ) 6213 protected CanonicalType definition; 6214 6215 private static final long serialVersionUID = -1172840676L; 6216 6217 /** 6218 * Constructor 6219 */ 6220 public CapabilityStatementMessagingSupportedMessageComponent() { 6221 super(); 6222 } 6223 6224 /** 6225 * Constructor 6226 */ 6227 public CapabilityStatementMessagingSupportedMessageComponent(Enumeration<EventCapabilityMode> mode, CanonicalType definition) { 6228 super(); 6229 this.mode = mode; 6230 this.definition = definition; 6231 } 6232 6233 /** 6234 * @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 6235 */ 6236 public Enumeration<EventCapabilityMode> getModeElement() { 6237 if (this.mode == null) 6238 if (Configuration.errorOnAutoCreate()) 6239 throw new Error("Attempt to auto-create CapabilityStatementMessagingSupportedMessageComponent.mode"); 6240 else if (Configuration.doAutoCreate()) 6241 this.mode = new Enumeration<EventCapabilityMode>(new EventCapabilityModeEnumFactory()); // bb 6242 return this.mode; 6243 } 6244 6245 public boolean hasModeElement() { 6246 return this.mode != null && !this.mode.isEmpty(); 6247 } 6248 6249 public boolean hasMode() { 6250 return this.mode != null && !this.mode.isEmpty(); 6251 } 6252 6253 /** 6254 * @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 6255 */ 6256 public CapabilityStatementMessagingSupportedMessageComponent setModeElement(Enumeration<EventCapabilityMode> value) { 6257 this.mode = value; 6258 return this; 6259 } 6260 6261 /** 6262 * @return The mode of this event declaration - whether application is sender or receiver. 6263 */ 6264 public EventCapabilityMode getMode() { 6265 return this.mode == null ? null : this.mode.getValue(); 6266 } 6267 6268 /** 6269 * @param value The mode of this event declaration - whether application is sender or receiver. 6270 */ 6271 public CapabilityStatementMessagingSupportedMessageComponent setMode(EventCapabilityMode value) { 6272 if (this.mode == null) 6273 this.mode = new Enumeration<EventCapabilityMode>(new EventCapabilityModeEnumFactory()); 6274 this.mode.setValue(value); 6275 return this; 6276 } 6277 6278 /** 6279 * @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 6280 */ 6281 public CanonicalType getDefinitionElement() { 6282 if (this.definition == null) 6283 if (Configuration.errorOnAutoCreate()) 6284 throw new Error("Attempt to auto-create CapabilityStatementMessagingSupportedMessageComponent.definition"); 6285 else if (Configuration.doAutoCreate()) 6286 this.definition = new CanonicalType(); // bb 6287 return this.definition; 6288 } 6289 6290 public boolean hasDefinitionElement() { 6291 return this.definition != null && !this.definition.isEmpty(); 6292 } 6293 6294 public boolean hasDefinition() { 6295 return this.definition != null && !this.definition.isEmpty(); 6296 } 6297 6298 /** 6299 * @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 6300 */ 6301 public CapabilityStatementMessagingSupportedMessageComponent setDefinitionElement(CanonicalType value) { 6302 this.definition = value; 6303 return this; 6304 } 6305 6306 /** 6307 * @return Points to a message definition that identifies the messaging event, message structure, allowed responses, etc. 6308 */ 6309 public String getDefinition() { 6310 return this.definition == null ? null : this.definition.getValue(); 6311 } 6312 6313 /** 6314 * @param value Points to a message definition that identifies the messaging event, message structure, allowed responses, etc. 6315 */ 6316 public CapabilityStatementMessagingSupportedMessageComponent setDefinition(String value) { 6317 if (this.definition == null) 6318 this.definition = new CanonicalType(); 6319 this.definition.setValue(value); 6320 return this; 6321 } 6322 6323 protected void listChildren(List<Property> children) { 6324 super.listChildren(children); 6325 children.add(new Property("mode", "code", "The mode of this event declaration - whether application is sender or receiver.", 0, 1, mode)); 6326 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)); 6327 } 6328 6329 @Override 6330 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 6331 switch (_hash) { 6332 case 3357091: /*mode*/ return new Property("mode", "code", "The mode of this event declaration - whether application is sender or receiver.", 0, 1, mode); 6333 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); 6334 default: return super.getNamedProperty(_hash, _name, _checkValid); 6335 } 6336 6337 } 6338 6339 @Override 6340 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 6341 switch (hash) { 6342 case 3357091: /*mode*/ return this.mode == null ? new Base[0] : new Base[] {this.mode}; // Enumeration<EventCapabilityMode> 6343 case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : new Base[] {this.definition}; // CanonicalType 6344 default: return super.getProperty(hash, name, checkValid); 6345 } 6346 6347 } 6348 6349 @Override 6350 public Base setProperty(int hash, String name, Base value) throws FHIRException { 6351 switch (hash) { 6352 case 3357091: // mode 6353 value = new EventCapabilityModeEnumFactory().fromType(castToCode(value)); 6354 this.mode = (Enumeration) value; // Enumeration<EventCapabilityMode> 6355 return value; 6356 case -1014418093: // definition 6357 this.definition = castToCanonical(value); // CanonicalType 6358 return value; 6359 default: return super.setProperty(hash, name, value); 6360 } 6361 6362 } 6363 6364 @Override 6365 public Base setProperty(String name, Base value) throws FHIRException { 6366 if (name.equals("mode")) { 6367 value = new EventCapabilityModeEnumFactory().fromType(castToCode(value)); 6368 this.mode = (Enumeration) value; // Enumeration<EventCapabilityMode> 6369 } else if (name.equals("definition")) { 6370 this.definition = castToCanonical(value); // CanonicalType 6371 } else 6372 return super.setProperty(name, value); 6373 return value; 6374 } 6375 6376 @Override 6377 public Base makeProperty(int hash, String name) throws FHIRException { 6378 switch (hash) { 6379 case 3357091: return getModeElement(); 6380 case -1014418093: return getDefinitionElement(); 6381 default: return super.makeProperty(hash, name); 6382 } 6383 6384 } 6385 6386 @Override 6387 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 6388 switch (hash) { 6389 case 3357091: /*mode*/ return new String[] {"code"}; 6390 case -1014418093: /*definition*/ return new String[] {"canonical"}; 6391 default: return super.getTypesForProperty(hash, name); 6392 } 6393 6394 } 6395 6396 @Override 6397 public Base addChild(String name) throws FHIRException { 6398 if (name.equals("mode")) { 6399 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.mode"); 6400 } 6401 else if (name.equals("definition")) { 6402 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.definition"); 6403 } 6404 else 6405 return super.addChild(name); 6406 } 6407 6408 public CapabilityStatementMessagingSupportedMessageComponent copy() { 6409 CapabilityStatementMessagingSupportedMessageComponent dst = new CapabilityStatementMessagingSupportedMessageComponent(); 6410 copyValues(dst); 6411 return dst; 6412 } 6413 6414 public void copyValues(CapabilityStatementMessagingSupportedMessageComponent dst) { 6415 super.copyValues(dst); 6416 dst.mode = mode == null ? null : mode.copy(); 6417 dst.definition = definition == null ? null : definition.copy(); 6418 } 6419 6420 @Override 6421 public boolean equalsDeep(Base other_) { 6422 if (!super.equalsDeep(other_)) 6423 return false; 6424 if (!(other_ instanceof CapabilityStatementMessagingSupportedMessageComponent)) 6425 return false; 6426 CapabilityStatementMessagingSupportedMessageComponent o = (CapabilityStatementMessagingSupportedMessageComponent) other_; 6427 return compareDeep(mode, o.mode, true) && compareDeep(definition, o.definition, true); 6428 } 6429 6430 @Override 6431 public boolean equalsShallow(Base other_) { 6432 if (!super.equalsShallow(other_)) 6433 return false; 6434 if (!(other_ instanceof CapabilityStatementMessagingSupportedMessageComponent)) 6435 return false; 6436 CapabilityStatementMessagingSupportedMessageComponent o = (CapabilityStatementMessagingSupportedMessageComponent) other_; 6437 return compareValues(mode, o.mode, true); 6438 } 6439 6440 public boolean isEmpty() { 6441 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(mode, definition); 6442 } 6443 6444 public String fhirType() { 6445 return "CapabilityStatement.messaging.supportedMessage"; 6446 6447 } 6448 6449 } 6450 6451 @Block() 6452 public static class CapabilityStatementDocumentComponent extends BackboneElement implements IBaseBackboneElement { 6453 /** 6454 * Mode of this document declaration - whether an application is a producer or consumer. 6455 */ 6456 @Child(name = "mode", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true) 6457 @Description(shortDefinition="producer | consumer", formalDefinition="Mode of this document declaration - whether an application is a producer or consumer." ) 6458 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/document-mode") 6459 protected Enumeration<DocumentMode> mode; 6460 6461 /** 6462 * 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. 6463 */ 6464 @Child(name = "documentation", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=false) 6465 @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." ) 6466 protected MarkdownType documentation; 6467 6468 /** 6469 * A profile on the document Bundle that constrains which resources are present, and their contents. 6470 */ 6471 @Child(name = "profile", type = {CanonicalType.class}, order=3, min=1, max=1, modifier=false, summary=true) 6472 @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." ) 6473 protected CanonicalType profile; 6474 6475 private static final long serialVersionUID = 18026632L; 6476 6477 /** 6478 * Constructor 6479 */ 6480 public CapabilityStatementDocumentComponent() { 6481 super(); 6482 } 6483 6484 /** 6485 * Constructor 6486 */ 6487 public CapabilityStatementDocumentComponent(Enumeration<DocumentMode> mode, CanonicalType profile) { 6488 super(); 6489 this.mode = mode; 6490 this.profile = profile; 6491 } 6492 6493 /** 6494 * @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 6495 */ 6496 public Enumeration<DocumentMode> getModeElement() { 6497 if (this.mode == null) 6498 if (Configuration.errorOnAutoCreate()) 6499 throw new Error("Attempt to auto-create CapabilityStatementDocumentComponent.mode"); 6500 else if (Configuration.doAutoCreate()) 6501 this.mode = new Enumeration<DocumentMode>(new DocumentModeEnumFactory()); // bb 6502 return this.mode; 6503 } 6504 6505 public boolean hasModeElement() { 6506 return this.mode != null && !this.mode.isEmpty(); 6507 } 6508 6509 public boolean hasMode() { 6510 return this.mode != null && !this.mode.isEmpty(); 6511 } 6512 6513 /** 6514 * @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 6515 */ 6516 public CapabilityStatementDocumentComponent setModeElement(Enumeration<DocumentMode> value) { 6517 this.mode = value; 6518 return this; 6519 } 6520 6521 /** 6522 * @return Mode of this document declaration - whether an application is a producer or consumer. 6523 */ 6524 public DocumentMode getMode() { 6525 return this.mode == null ? null : this.mode.getValue(); 6526 } 6527 6528 /** 6529 * @param value Mode of this document declaration - whether an application is a producer or consumer. 6530 */ 6531 public CapabilityStatementDocumentComponent setMode(DocumentMode value) { 6532 if (this.mode == null) 6533 this.mode = new Enumeration<DocumentMode>(new DocumentModeEnumFactory()); 6534 this.mode.setValue(value); 6535 return this; 6536 } 6537 6538 /** 6539 * @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 6540 */ 6541 public MarkdownType getDocumentationElement() { 6542 if (this.documentation == null) 6543 if (Configuration.errorOnAutoCreate()) 6544 throw new Error("Attempt to auto-create CapabilityStatementDocumentComponent.documentation"); 6545 else if (Configuration.doAutoCreate()) 6546 this.documentation = new MarkdownType(); // bb 6547 return this.documentation; 6548 } 6549 6550 public boolean hasDocumentationElement() { 6551 return this.documentation != null && !this.documentation.isEmpty(); 6552 } 6553 6554 public boolean hasDocumentation() { 6555 return this.documentation != null && !this.documentation.isEmpty(); 6556 } 6557 6558 /** 6559 * @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 6560 */ 6561 public CapabilityStatementDocumentComponent setDocumentationElement(MarkdownType value) { 6562 this.documentation = value; 6563 return this; 6564 } 6565 6566 /** 6567 * @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. 6568 */ 6569 public String getDocumentation() { 6570 return this.documentation == null ? null : this.documentation.getValue(); 6571 } 6572 6573 /** 6574 * @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. 6575 */ 6576 public CapabilityStatementDocumentComponent setDocumentation(String value) { 6577 if (value == null) 6578 this.documentation = null; 6579 else { 6580 if (this.documentation == null) 6581 this.documentation = new MarkdownType(); 6582 this.documentation.setValue(value); 6583 } 6584 return this; 6585 } 6586 6587 /** 6588 * @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 6589 */ 6590 public CanonicalType getProfileElement() { 6591 if (this.profile == null) 6592 if (Configuration.errorOnAutoCreate()) 6593 throw new Error("Attempt to auto-create CapabilityStatementDocumentComponent.profile"); 6594 else if (Configuration.doAutoCreate()) 6595 this.profile = new CanonicalType(); // bb 6596 return this.profile; 6597 } 6598 6599 public boolean hasProfileElement() { 6600 return this.profile != null && !this.profile.isEmpty(); 6601 } 6602 6603 public boolean hasProfile() { 6604 return this.profile != null && !this.profile.isEmpty(); 6605 } 6606 6607 /** 6608 * @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 6609 */ 6610 public CapabilityStatementDocumentComponent setProfileElement(CanonicalType value) { 6611 this.profile = value; 6612 return this; 6613 } 6614 6615 /** 6616 * @return A profile on the document Bundle that constrains which resources are present, and their contents. 6617 */ 6618 public String getProfile() { 6619 return this.profile == null ? null : this.profile.getValue(); 6620 } 6621 6622 /** 6623 * @param value A profile on the document Bundle that constrains which resources are present, and their contents. 6624 */ 6625 public CapabilityStatementDocumentComponent setProfile(String value) { 6626 if (this.profile == null) 6627 this.profile = new CanonicalType(); 6628 this.profile.setValue(value); 6629 return this; 6630 } 6631 6632 protected void listChildren(List<Property> children) { 6633 super.listChildren(children); 6634 children.add(new Property("mode", "code", "Mode of this document declaration - whether an application is a producer or consumer.", 0, 1, mode)); 6635 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)); 6636 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)); 6637 } 6638 6639 @Override 6640 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 6641 switch (_hash) { 6642 case 3357091: /*mode*/ return new Property("mode", "code", "Mode of this document declaration - whether an application is a producer or consumer.", 0, 1, mode); 6643 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); 6644 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); 6645 default: return super.getNamedProperty(_hash, _name, _checkValid); 6646 } 6647 6648 } 6649 6650 @Override 6651 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 6652 switch (hash) { 6653 case 3357091: /*mode*/ return this.mode == null ? new Base[0] : new Base[] {this.mode}; // Enumeration<DocumentMode> 6654 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 6655 case -309425751: /*profile*/ return this.profile == null ? new Base[0] : new Base[] {this.profile}; // CanonicalType 6656 default: return super.getProperty(hash, name, checkValid); 6657 } 6658 6659 } 6660 6661 @Override 6662 public Base setProperty(int hash, String name, Base value) throws FHIRException { 6663 switch (hash) { 6664 case 3357091: // mode 6665 value = new DocumentModeEnumFactory().fromType(castToCode(value)); 6666 this.mode = (Enumeration) value; // Enumeration<DocumentMode> 6667 return value; 6668 case 1587405498: // documentation 6669 this.documentation = castToMarkdown(value); // MarkdownType 6670 return value; 6671 case -309425751: // profile 6672 this.profile = castToCanonical(value); // CanonicalType 6673 return value; 6674 default: return super.setProperty(hash, name, value); 6675 } 6676 6677 } 6678 6679 @Override 6680 public Base setProperty(String name, Base value) throws FHIRException { 6681 if (name.equals("mode")) { 6682 value = new DocumentModeEnumFactory().fromType(castToCode(value)); 6683 this.mode = (Enumeration) value; // Enumeration<DocumentMode> 6684 } else if (name.equals("documentation")) { 6685 this.documentation = castToMarkdown(value); // MarkdownType 6686 } else if (name.equals("profile")) { 6687 this.profile = castToCanonical(value); // CanonicalType 6688 } else 6689 return super.setProperty(name, value); 6690 return value; 6691 } 6692 6693 @Override 6694 public Base makeProperty(int hash, String name) throws FHIRException { 6695 switch (hash) { 6696 case 3357091: return getModeElement(); 6697 case 1587405498: return getDocumentationElement(); 6698 case -309425751: return getProfileElement(); 6699 default: return super.makeProperty(hash, name); 6700 } 6701 6702 } 6703 6704 @Override 6705 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 6706 switch (hash) { 6707 case 3357091: /*mode*/ return new String[] {"code"}; 6708 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 6709 case -309425751: /*profile*/ return new String[] {"canonical"}; 6710 default: return super.getTypesForProperty(hash, name); 6711 } 6712 6713 } 6714 6715 @Override 6716 public Base addChild(String name) throws FHIRException { 6717 if (name.equals("mode")) { 6718 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.mode"); 6719 } 6720 else if (name.equals("documentation")) { 6721 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.documentation"); 6722 } 6723 else if (name.equals("profile")) { 6724 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.profile"); 6725 } 6726 else 6727 return super.addChild(name); 6728 } 6729 6730 public CapabilityStatementDocumentComponent copy() { 6731 CapabilityStatementDocumentComponent dst = new CapabilityStatementDocumentComponent(); 6732 copyValues(dst); 6733 return dst; 6734 } 6735 6736 public void copyValues(CapabilityStatementDocumentComponent dst) { 6737 super.copyValues(dst); 6738 dst.mode = mode == null ? null : mode.copy(); 6739 dst.documentation = documentation == null ? null : documentation.copy(); 6740 dst.profile = profile == null ? null : profile.copy(); 6741 } 6742 6743 @Override 6744 public boolean equalsDeep(Base other_) { 6745 if (!super.equalsDeep(other_)) 6746 return false; 6747 if (!(other_ instanceof CapabilityStatementDocumentComponent)) 6748 return false; 6749 CapabilityStatementDocumentComponent o = (CapabilityStatementDocumentComponent) other_; 6750 return compareDeep(mode, o.mode, true) && compareDeep(documentation, o.documentation, true) && compareDeep(profile, o.profile, true) 6751 ; 6752 } 6753 6754 @Override 6755 public boolean equalsShallow(Base other_) { 6756 if (!super.equalsShallow(other_)) 6757 return false; 6758 if (!(other_ instanceof CapabilityStatementDocumentComponent)) 6759 return false; 6760 CapabilityStatementDocumentComponent o = (CapabilityStatementDocumentComponent) other_; 6761 return compareValues(mode, o.mode, true) && compareValues(documentation, o.documentation, true); 6762 } 6763 6764 public boolean isEmpty() { 6765 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(mode, documentation, profile 6766 ); 6767 } 6768 6769 public String fhirType() { 6770 return "CapabilityStatement.document"; 6771 6772 } 6773 6774 } 6775 6776 /** 6777 * Explanation of why this capability statement is needed and why it has been designed as it has. 6778 */ 6779 @Child(name = "purpose", type = {MarkdownType.class}, order=0, min=0, max=1, modifier=false, summary=false) 6780 @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." ) 6781 protected MarkdownType purpose; 6782 6783 /** 6784 * 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. 6785 */ 6786 @Child(name = "copyright", type = {MarkdownType.class}, order=1, min=0, max=1, modifier=false, summary=false) 6787 @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." ) 6788 protected MarkdownType copyright; 6789 6790 /** 6791 * 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). 6792 */ 6793 @Child(name = "kind", type = {CodeType.class}, order=2, min=1, max=1, modifier=false, summary=true) 6794 @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)." ) 6795 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/capability-statement-kind") 6796 protected Enumeration<CapabilityStatementKind> kind; 6797 6798 /** 6799 * 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. 6800 */ 6801 @Child(name = "instantiates", type = {CanonicalType.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6802 @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." ) 6803 protected List<CanonicalType> instantiates; 6804 6805 /** 6806 * 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. 6807 */ 6808 @Child(name = "imports", type = {CanonicalType.class}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6809 @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." ) 6810 protected List<CanonicalType> imports; 6811 6812 /** 6813 * 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. 6814 */ 6815 @Child(name = "software", type = {}, order=5, min=0, max=1, modifier=false, summary=true) 6816 @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." ) 6817 protected CapabilityStatementSoftwareComponent software; 6818 6819 /** 6820 * 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. 6821 */ 6822 @Child(name = "implementation", type = {}, order=6, min=0, max=1, modifier=false, summary=true) 6823 @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." ) 6824 protected CapabilityStatementImplementationComponent implementation; 6825 6826 /** 6827 * 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. 6828 */ 6829 @Child(name = "fhirVersion", type = {CodeType.class}, order=7, min=1, max=1, modifier=false, summary=true) 6830 @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." ) 6831 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/FHIR-version") 6832 protected Enumeration<FHIRVersion> fhirVersion; 6833 6834 /** 6835 * A list of the formats supported by this implementation using their content types. 6836 */ 6837 @Child(name = "format", type = {CodeType.class}, order=8, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6838 @Description(shortDefinition="formats supported (xml | json | ttl | mime type)", formalDefinition="A list of the formats supported by this implementation using their content types." ) 6839 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/mimetypes") 6840 protected List<CodeType> format; 6841 6842 /** 6843 * A list of the patch formats supported by this implementation using their content types. 6844 */ 6845 @Child(name = "patchFormat", type = {CodeType.class}, order=9, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6846 @Description(shortDefinition="Patch formats supported", formalDefinition="A list of the patch formats supported by this implementation using their content types." ) 6847 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/mimetypes") 6848 protected List<CodeType> patchFormat; 6849 6850 /** 6851 * A list of implementation guides that the server does (or should) support in their entirety. 6852 */ 6853 @Child(name = "implementationGuide", type = {CanonicalType.class}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6854 @Description(shortDefinition="Implementation guides supported", formalDefinition="A list of implementation guides that the server does (or should) support in their entirety." ) 6855 protected List<CanonicalType> implementationGuide; 6856 6857 /** 6858 * A definition of the restful capabilities of the solution, if any. 6859 */ 6860 @Child(name = "rest", type = {}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6861 @Description(shortDefinition="If the endpoint is a RESTful one", formalDefinition="A definition of the restful capabilities of the solution, if any." ) 6862 protected List<CapabilityStatementRestComponent> rest; 6863 6864 /** 6865 * A description of the messaging capabilities of the solution. 6866 */ 6867 @Child(name = "messaging", type = {}, order=12, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6868 @Description(shortDefinition="If messaging is supported", formalDefinition="A description of the messaging capabilities of the solution." ) 6869 protected List<CapabilityStatementMessagingComponent> messaging; 6870 6871 /** 6872 * A document definition. 6873 */ 6874 @Child(name = "document", type = {}, order=13, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 6875 @Description(shortDefinition="Document definition", formalDefinition="A document definition." ) 6876 protected List<CapabilityStatementDocumentComponent> document; 6877 6878 private static final long serialVersionUID = -1050288843L; 6879 6880 /** 6881 * Constructor 6882 */ 6883 public CapabilityStatement() { 6884 super(); 6885 } 6886 6887 /** 6888 * Constructor 6889 */ 6890 public CapabilityStatement(Enumeration<PublicationStatus> status, DateTimeType date, Enumeration<CapabilityStatementKind> kind, Enumeration<FHIRVersion> fhirVersion) { 6891 super(); 6892 this.status = status; 6893 this.date = date; 6894 this.kind = kind; 6895 this.fhirVersion = fhirVersion; 6896 } 6897 6898 /** 6899 * @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 6900 */ 6901 public UriType getUrlElement() { 6902 if (this.url == null) 6903 if (Configuration.errorOnAutoCreate()) 6904 throw new Error("Attempt to auto-create CapabilityStatement.url"); 6905 else if (Configuration.doAutoCreate()) 6906 this.url = new UriType(); // bb 6907 return this.url; 6908 } 6909 6910 public boolean hasUrlElement() { 6911 return this.url != null && !this.url.isEmpty(); 6912 } 6913 6914 public boolean hasUrl() { 6915 return this.url != null && !this.url.isEmpty(); 6916 } 6917 6918 /** 6919 * @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 6920 */ 6921 public CapabilityStatement setUrlElement(UriType value) { 6922 this.url = value; 6923 return this; 6924 } 6925 6926 /** 6927 * @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. 6928 */ 6929 public String getUrl() { 6930 return this.url == null ? null : this.url.getValue(); 6931 } 6932 6933 /** 6934 * @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. 6935 */ 6936 public CapabilityStatement setUrl(String value) { 6937 if (Utilities.noString(value)) 6938 this.url = null; 6939 else { 6940 if (this.url == null) 6941 this.url = new UriType(); 6942 this.url.setValue(value); 6943 } 6944 return this; 6945 } 6946 6947 /** 6948 * @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 6949 */ 6950 public StringType getVersionElement() { 6951 if (this.version == null) 6952 if (Configuration.errorOnAutoCreate()) 6953 throw new Error("Attempt to auto-create CapabilityStatement.version"); 6954 else if (Configuration.doAutoCreate()) 6955 this.version = new StringType(); // bb 6956 return this.version; 6957 } 6958 6959 public boolean hasVersionElement() { 6960 return this.version != null && !this.version.isEmpty(); 6961 } 6962 6963 public boolean hasVersion() { 6964 return this.version != null && !this.version.isEmpty(); 6965 } 6966 6967 /** 6968 * @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 6969 */ 6970 public CapabilityStatement setVersionElement(StringType value) { 6971 this.version = value; 6972 return this; 6973 } 6974 6975 /** 6976 * @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. 6977 */ 6978 public String getVersion() { 6979 return this.version == null ? null : this.version.getValue(); 6980 } 6981 6982 /** 6983 * @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. 6984 */ 6985 public CapabilityStatement setVersion(String value) { 6986 if (Utilities.noString(value)) 6987 this.version = null; 6988 else { 6989 if (this.version == null) 6990 this.version = new StringType(); 6991 this.version.setValue(value); 6992 } 6993 return this; 6994 } 6995 6996 /** 6997 * @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 6998 */ 6999 public StringType getNameElement() { 7000 if (this.name == null) 7001 if (Configuration.errorOnAutoCreate()) 7002 throw new Error("Attempt to auto-create CapabilityStatement.name"); 7003 else if (Configuration.doAutoCreate()) 7004 this.name = new StringType(); // bb 7005 return this.name; 7006 } 7007 7008 public boolean hasNameElement() { 7009 return this.name != null && !this.name.isEmpty(); 7010 } 7011 7012 public boolean hasName() { 7013 return this.name != null && !this.name.isEmpty(); 7014 } 7015 7016 /** 7017 * @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 7018 */ 7019 public CapabilityStatement setNameElement(StringType value) { 7020 this.name = value; 7021 return this; 7022 } 7023 7024 /** 7025 * @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. 7026 */ 7027 public String getName() { 7028 return this.name == null ? null : this.name.getValue(); 7029 } 7030 7031 /** 7032 * @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. 7033 */ 7034 public CapabilityStatement setName(String value) { 7035 if (Utilities.noString(value)) 7036 this.name = null; 7037 else { 7038 if (this.name == null) 7039 this.name = new StringType(); 7040 this.name.setValue(value); 7041 } 7042 return this; 7043 } 7044 7045 /** 7046 * @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 7047 */ 7048 public StringType getTitleElement() { 7049 if (this.title == null) 7050 if (Configuration.errorOnAutoCreate()) 7051 throw new Error("Attempt to auto-create CapabilityStatement.title"); 7052 else if (Configuration.doAutoCreate()) 7053 this.title = new StringType(); // bb 7054 return this.title; 7055 } 7056 7057 public boolean hasTitleElement() { 7058 return this.title != null && !this.title.isEmpty(); 7059 } 7060 7061 public boolean hasTitle() { 7062 return this.title != null && !this.title.isEmpty(); 7063 } 7064 7065 /** 7066 * @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 7067 */ 7068 public CapabilityStatement setTitleElement(StringType value) { 7069 this.title = value; 7070 return this; 7071 } 7072 7073 /** 7074 * @return A short, descriptive, user-friendly title for the capability statement. 7075 */ 7076 public String getTitle() { 7077 return this.title == null ? null : this.title.getValue(); 7078 } 7079 7080 /** 7081 * @param value A short, descriptive, user-friendly title for the capability statement. 7082 */ 7083 public CapabilityStatement setTitle(String value) { 7084 if (Utilities.noString(value)) 7085 this.title = null; 7086 else { 7087 if (this.title == null) 7088 this.title = new StringType(); 7089 this.title.setValue(value); 7090 } 7091 return this; 7092 } 7093 7094 /** 7095 * @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 7096 */ 7097 public Enumeration<PublicationStatus> getStatusElement() { 7098 if (this.status == null) 7099 if (Configuration.errorOnAutoCreate()) 7100 throw new Error("Attempt to auto-create CapabilityStatement.status"); 7101 else if (Configuration.doAutoCreate()) 7102 this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb 7103 return this.status; 7104 } 7105 7106 public boolean hasStatusElement() { 7107 return this.status != null && !this.status.isEmpty(); 7108 } 7109 7110 public boolean hasStatus() { 7111 return this.status != null && !this.status.isEmpty(); 7112 } 7113 7114 /** 7115 * @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 7116 */ 7117 public CapabilityStatement setStatusElement(Enumeration<PublicationStatus> value) { 7118 this.status = value; 7119 return this; 7120 } 7121 7122 /** 7123 * @return The status of this capability statement. Enables tracking the life-cycle of the content. 7124 */ 7125 public PublicationStatus getStatus() { 7126 return this.status == null ? null : this.status.getValue(); 7127 } 7128 7129 /** 7130 * @param value The status of this capability statement. Enables tracking the life-cycle of the content. 7131 */ 7132 public CapabilityStatement setStatus(PublicationStatus value) { 7133 if (this.status == null) 7134 this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); 7135 this.status.setValue(value); 7136 return this; 7137 } 7138 7139 /** 7140 * @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 7141 */ 7142 public BooleanType getExperimentalElement() { 7143 if (this.experimental == null) 7144 if (Configuration.errorOnAutoCreate()) 7145 throw new Error("Attempt to auto-create CapabilityStatement.experimental"); 7146 else if (Configuration.doAutoCreate()) 7147 this.experimental = new BooleanType(); // bb 7148 return this.experimental; 7149 } 7150 7151 public boolean hasExperimentalElement() { 7152 return this.experimental != null && !this.experimental.isEmpty(); 7153 } 7154 7155 public boolean hasExperimental() { 7156 return this.experimental != null && !this.experimental.isEmpty(); 7157 } 7158 7159 /** 7160 * @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 7161 */ 7162 public CapabilityStatement setExperimentalElement(BooleanType value) { 7163 this.experimental = value; 7164 return this; 7165 } 7166 7167 /** 7168 * @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. 7169 */ 7170 public boolean getExperimental() { 7171 return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue(); 7172 } 7173 7174 /** 7175 * @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. 7176 */ 7177 public CapabilityStatement setExperimental(boolean value) { 7178 if (this.experimental == null) 7179 this.experimental = new BooleanType(); 7180 this.experimental.setValue(value); 7181 return this; 7182 } 7183 7184 /** 7185 * @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 7186 */ 7187 public DateTimeType getDateElement() { 7188 if (this.date == null) 7189 if (Configuration.errorOnAutoCreate()) 7190 throw new Error("Attempt to auto-create CapabilityStatement.date"); 7191 else if (Configuration.doAutoCreate()) 7192 this.date = new DateTimeType(); // bb 7193 return this.date; 7194 } 7195 7196 public boolean hasDateElement() { 7197 return this.date != null && !this.date.isEmpty(); 7198 } 7199 7200 public boolean hasDate() { 7201 return this.date != null && !this.date.isEmpty(); 7202 } 7203 7204 /** 7205 * @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 7206 */ 7207 public CapabilityStatement setDateElement(DateTimeType value) { 7208 this.date = value; 7209 return this; 7210 } 7211 7212 /** 7213 * @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. 7214 */ 7215 public Date getDate() { 7216 return this.date == null ? null : this.date.getValue(); 7217 } 7218 7219 /** 7220 * @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. 7221 */ 7222 public CapabilityStatement setDate(Date value) { 7223 if (this.date == null) 7224 this.date = new DateTimeType(); 7225 this.date.setValue(value); 7226 return this; 7227 } 7228 7229 /** 7230 * @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 7231 */ 7232 public StringType getPublisherElement() { 7233 if (this.publisher == null) 7234 if (Configuration.errorOnAutoCreate()) 7235 throw new Error("Attempt to auto-create CapabilityStatement.publisher"); 7236 else if (Configuration.doAutoCreate()) 7237 this.publisher = new StringType(); // bb 7238 return this.publisher; 7239 } 7240 7241 public boolean hasPublisherElement() { 7242 return this.publisher != null && !this.publisher.isEmpty(); 7243 } 7244 7245 public boolean hasPublisher() { 7246 return this.publisher != null && !this.publisher.isEmpty(); 7247 } 7248 7249 /** 7250 * @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 7251 */ 7252 public CapabilityStatement setPublisherElement(StringType value) { 7253 this.publisher = value; 7254 return this; 7255 } 7256 7257 /** 7258 * @return The name of the organization or individual that published the capability statement. 7259 */ 7260 public String getPublisher() { 7261 return this.publisher == null ? null : this.publisher.getValue(); 7262 } 7263 7264 /** 7265 * @param value The name of the organization or individual that published the capability statement. 7266 */ 7267 public CapabilityStatement setPublisher(String value) { 7268 if (Utilities.noString(value)) 7269 this.publisher = null; 7270 else { 7271 if (this.publisher == null) 7272 this.publisher = new StringType(); 7273 this.publisher.setValue(value); 7274 } 7275 return this; 7276 } 7277 7278 /** 7279 * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.) 7280 */ 7281 public List<ContactDetail> getContact() { 7282 if (this.contact == null) 7283 this.contact = new ArrayList<ContactDetail>(); 7284 return this.contact; 7285 } 7286 7287 /** 7288 * @return Returns a reference to <code>this</code> for easy method chaining 7289 */ 7290 public CapabilityStatement setContact(List<ContactDetail> theContact) { 7291 this.contact = theContact; 7292 return this; 7293 } 7294 7295 public boolean hasContact() { 7296 if (this.contact == null) 7297 return false; 7298 for (ContactDetail item : this.contact) 7299 if (!item.isEmpty()) 7300 return true; 7301 return false; 7302 } 7303 7304 public ContactDetail addContact() { //3 7305 ContactDetail t = new ContactDetail(); 7306 if (this.contact == null) 7307 this.contact = new ArrayList<ContactDetail>(); 7308 this.contact.add(t); 7309 return t; 7310 } 7311 7312 public CapabilityStatement addContact(ContactDetail t) { //3 7313 if (t == null) 7314 return this; 7315 if (this.contact == null) 7316 this.contact = new ArrayList<ContactDetail>(); 7317 this.contact.add(t); 7318 return this; 7319 } 7320 7321 /** 7322 * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist 7323 */ 7324 public ContactDetail getContactFirstRep() { 7325 if (getContact().isEmpty()) { 7326 addContact(); 7327 } 7328 return getContact().get(0); 7329 } 7330 7331 /** 7332 * @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 7333 */ 7334 public MarkdownType getDescriptionElement() { 7335 if (this.description == null) 7336 if (Configuration.errorOnAutoCreate()) 7337 throw new Error("Attempt to auto-create CapabilityStatement.description"); 7338 else if (Configuration.doAutoCreate()) 7339 this.description = new MarkdownType(); // bb 7340 return this.description; 7341 } 7342 7343 public boolean hasDescriptionElement() { 7344 return this.description != null && !this.description.isEmpty(); 7345 } 7346 7347 public boolean hasDescription() { 7348 return this.description != null && !this.description.isEmpty(); 7349 } 7350 7351 /** 7352 * @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 7353 */ 7354 public CapabilityStatement setDescriptionElement(MarkdownType value) { 7355 this.description = value; 7356 return this; 7357 } 7358 7359 /** 7360 * @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. 7361 */ 7362 public String getDescription() { 7363 return this.description == null ? null : this.description.getValue(); 7364 } 7365 7366 /** 7367 * @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. 7368 */ 7369 public CapabilityStatement setDescription(String value) { 7370 if (value == null) 7371 this.description = null; 7372 else { 7373 if (this.description == null) 7374 this.description = new MarkdownType(); 7375 this.description.setValue(value); 7376 } 7377 return this; 7378 } 7379 7380 /** 7381 * @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.) 7382 */ 7383 public List<UsageContext> getUseContext() { 7384 if (this.useContext == null) 7385 this.useContext = new ArrayList<UsageContext>(); 7386 return this.useContext; 7387 } 7388 7389 /** 7390 * @return Returns a reference to <code>this</code> for easy method chaining 7391 */ 7392 public CapabilityStatement setUseContext(List<UsageContext> theUseContext) { 7393 this.useContext = theUseContext; 7394 return this; 7395 } 7396 7397 public boolean hasUseContext() { 7398 if (this.useContext == null) 7399 return false; 7400 for (UsageContext item : this.useContext) 7401 if (!item.isEmpty()) 7402 return true; 7403 return false; 7404 } 7405 7406 public UsageContext addUseContext() { //3 7407 UsageContext t = new UsageContext(); 7408 if (this.useContext == null) 7409 this.useContext = new ArrayList<UsageContext>(); 7410 this.useContext.add(t); 7411 return t; 7412 } 7413 7414 public CapabilityStatement addUseContext(UsageContext t) { //3 7415 if (t == null) 7416 return this; 7417 if (this.useContext == null) 7418 this.useContext = new ArrayList<UsageContext>(); 7419 this.useContext.add(t); 7420 return this; 7421 } 7422 7423 /** 7424 * @return The first repetition of repeating field {@link #useContext}, creating it if it does not already exist 7425 */ 7426 public UsageContext getUseContextFirstRep() { 7427 if (getUseContext().isEmpty()) { 7428 addUseContext(); 7429 } 7430 return getUseContext().get(0); 7431 } 7432 7433 /** 7434 * @return {@link #jurisdiction} (A legal or geographic region in which the capability statement is intended to be used.) 7435 */ 7436 public List<CodeableConcept> getJurisdiction() { 7437 if (this.jurisdiction == null) 7438 this.jurisdiction = new ArrayList<CodeableConcept>(); 7439 return this.jurisdiction; 7440 } 7441 7442 /** 7443 * @return Returns a reference to <code>this</code> for easy method chaining 7444 */ 7445 public CapabilityStatement setJurisdiction(List<CodeableConcept> theJurisdiction) { 7446 this.jurisdiction = theJurisdiction; 7447 return this; 7448 } 7449 7450 public boolean hasJurisdiction() { 7451 if (this.jurisdiction == null) 7452 return false; 7453 for (CodeableConcept item : this.jurisdiction) 7454 if (!item.isEmpty()) 7455 return true; 7456 return false; 7457 } 7458 7459 public CodeableConcept addJurisdiction() { //3 7460 CodeableConcept t = new CodeableConcept(); 7461 if (this.jurisdiction == null) 7462 this.jurisdiction = new ArrayList<CodeableConcept>(); 7463 this.jurisdiction.add(t); 7464 return t; 7465 } 7466 7467 public CapabilityStatement addJurisdiction(CodeableConcept t) { //3 7468 if (t == null) 7469 return this; 7470 if (this.jurisdiction == null) 7471 this.jurisdiction = new ArrayList<CodeableConcept>(); 7472 this.jurisdiction.add(t); 7473 return this; 7474 } 7475 7476 /** 7477 * @return The first repetition of repeating field {@link #jurisdiction}, creating it if it does not already exist 7478 */ 7479 public CodeableConcept getJurisdictionFirstRep() { 7480 if (getJurisdiction().isEmpty()) { 7481 addJurisdiction(); 7482 } 7483 return getJurisdiction().get(0); 7484 } 7485 7486 /** 7487 * @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 7488 */ 7489 public MarkdownType getPurposeElement() { 7490 if (this.purpose == null) 7491 if (Configuration.errorOnAutoCreate()) 7492 throw new Error("Attempt to auto-create CapabilityStatement.purpose"); 7493 else if (Configuration.doAutoCreate()) 7494 this.purpose = new MarkdownType(); // bb 7495 return this.purpose; 7496 } 7497 7498 public boolean hasPurposeElement() { 7499 return this.purpose != null && !this.purpose.isEmpty(); 7500 } 7501 7502 public boolean hasPurpose() { 7503 return this.purpose != null && !this.purpose.isEmpty(); 7504 } 7505 7506 /** 7507 * @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 7508 */ 7509 public CapabilityStatement setPurposeElement(MarkdownType value) { 7510 this.purpose = value; 7511 return this; 7512 } 7513 7514 /** 7515 * @return Explanation of why this capability statement is needed and why it has been designed as it has. 7516 */ 7517 public String getPurpose() { 7518 return this.purpose == null ? null : this.purpose.getValue(); 7519 } 7520 7521 /** 7522 * @param value Explanation of why this capability statement is needed and why it has been designed as it has. 7523 */ 7524 public CapabilityStatement setPurpose(String value) { 7525 if (value == null) 7526 this.purpose = null; 7527 else { 7528 if (this.purpose == null) 7529 this.purpose = new MarkdownType(); 7530 this.purpose.setValue(value); 7531 } 7532 return this; 7533 } 7534 7535 /** 7536 * @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 7537 */ 7538 public MarkdownType getCopyrightElement() { 7539 if (this.copyright == null) 7540 if (Configuration.errorOnAutoCreate()) 7541 throw new Error("Attempt to auto-create CapabilityStatement.copyright"); 7542 else if (Configuration.doAutoCreate()) 7543 this.copyright = new MarkdownType(); // bb 7544 return this.copyright; 7545 } 7546 7547 public boolean hasCopyrightElement() { 7548 return this.copyright != null && !this.copyright.isEmpty(); 7549 } 7550 7551 public boolean hasCopyright() { 7552 return this.copyright != null && !this.copyright.isEmpty(); 7553 } 7554 7555 /** 7556 * @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 7557 */ 7558 public CapabilityStatement setCopyrightElement(MarkdownType value) { 7559 this.copyright = value; 7560 return this; 7561 } 7562 7563 /** 7564 * @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. 7565 */ 7566 public String getCopyright() { 7567 return this.copyright == null ? null : this.copyright.getValue(); 7568 } 7569 7570 /** 7571 * @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. 7572 */ 7573 public CapabilityStatement setCopyright(String value) { 7574 if (value == null) 7575 this.copyright = null; 7576 else { 7577 if (this.copyright == null) 7578 this.copyright = new MarkdownType(); 7579 this.copyright.setValue(value); 7580 } 7581 return this; 7582 } 7583 7584 /** 7585 * @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 7586 */ 7587 public Enumeration<CapabilityStatementKind> getKindElement() { 7588 if (this.kind == null) 7589 if (Configuration.errorOnAutoCreate()) 7590 throw new Error("Attempt to auto-create CapabilityStatement.kind"); 7591 else if (Configuration.doAutoCreate()) 7592 this.kind = new Enumeration<CapabilityStatementKind>(new CapabilityStatementKindEnumFactory()); // bb 7593 return this.kind; 7594 } 7595 7596 public boolean hasKindElement() { 7597 return this.kind != null && !this.kind.isEmpty(); 7598 } 7599 7600 public boolean hasKind() { 7601 return this.kind != null && !this.kind.isEmpty(); 7602 } 7603 7604 /** 7605 * @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 7606 */ 7607 public CapabilityStatement setKindElement(Enumeration<CapabilityStatementKind> value) { 7608 this.kind = value; 7609 return this; 7610 } 7611 7612 /** 7613 * @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). 7614 */ 7615 public CapabilityStatementKind getKind() { 7616 return this.kind == null ? null : this.kind.getValue(); 7617 } 7618 7619 /** 7620 * @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). 7621 */ 7622 public CapabilityStatement setKind(CapabilityStatementKind value) { 7623 if (this.kind == null) 7624 this.kind = new Enumeration<CapabilityStatementKind>(new CapabilityStatementKindEnumFactory()); 7625 this.kind.setValue(value); 7626 return this; 7627 } 7628 7629 /** 7630 * @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.) 7631 */ 7632 public List<CanonicalType> getInstantiates() { 7633 if (this.instantiates == null) 7634 this.instantiates = new ArrayList<CanonicalType>(); 7635 return this.instantiates; 7636 } 7637 7638 /** 7639 * @return Returns a reference to <code>this</code> for easy method chaining 7640 */ 7641 public CapabilityStatement setInstantiates(List<CanonicalType> theInstantiates) { 7642 this.instantiates = theInstantiates; 7643 return this; 7644 } 7645 7646 public boolean hasInstantiates() { 7647 if (this.instantiates == null) 7648 return false; 7649 for (CanonicalType item : this.instantiates) 7650 if (!item.isEmpty()) 7651 return true; 7652 return false; 7653 } 7654 7655 /** 7656 * @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.) 7657 */ 7658 public CanonicalType addInstantiatesElement() {//2 7659 CanonicalType t = new CanonicalType(); 7660 if (this.instantiates == null) 7661 this.instantiates = new ArrayList<CanonicalType>(); 7662 this.instantiates.add(t); 7663 return t; 7664 } 7665 7666 /** 7667 * @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.) 7668 */ 7669 public CapabilityStatement addInstantiates(String value) { //1 7670 CanonicalType t = new CanonicalType(); 7671 t.setValue(value); 7672 if (this.instantiates == null) 7673 this.instantiates = new ArrayList<CanonicalType>(); 7674 this.instantiates.add(t); 7675 return this; 7676 } 7677 7678 /** 7679 * @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.) 7680 */ 7681 public boolean hasInstantiates(String value) { 7682 if (this.instantiates == null) 7683 return false; 7684 for (CanonicalType v : this.instantiates) 7685 if (v.getValue().equals(value)) // canonical(CapabilityStatement) 7686 return true; 7687 return false; 7688 } 7689 7690 /** 7691 * @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.) 7692 */ 7693 public List<CanonicalType> getImports() { 7694 if (this.imports == null) 7695 this.imports = new ArrayList<CanonicalType>(); 7696 return this.imports; 7697 } 7698 7699 /** 7700 * @return Returns a reference to <code>this</code> for easy method chaining 7701 */ 7702 public CapabilityStatement setImports(List<CanonicalType> theImports) { 7703 this.imports = theImports; 7704 return this; 7705 } 7706 7707 public boolean hasImports() { 7708 if (this.imports == null) 7709 return false; 7710 for (CanonicalType item : this.imports) 7711 if (!item.isEmpty()) 7712 return true; 7713 return false; 7714 } 7715 7716 /** 7717 * @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.) 7718 */ 7719 public CanonicalType addImportsElement() {//2 7720 CanonicalType t = new CanonicalType(); 7721 if (this.imports == null) 7722 this.imports = new ArrayList<CanonicalType>(); 7723 this.imports.add(t); 7724 return t; 7725 } 7726 7727 /** 7728 * @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.) 7729 */ 7730 public CapabilityStatement addImports(String value) { //1 7731 CanonicalType t = new CanonicalType(); 7732 t.setValue(value); 7733 if (this.imports == null) 7734 this.imports = new ArrayList<CanonicalType>(); 7735 this.imports.add(t); 7736 return this; 7737 } 7738 7739 /** 7740 * @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.) 7741 */ 7742 public boolean hasImports(String value) { 7743 if (this.imports == null) 7744 return false; 7745 for (CanonicalType v : this.imports) 7746 if (v.getValue().equals(value)) // canonical(CapabilityStatement) 7747 return true; 7748 return false; 7749 } 7750 7751 /** 7752 * @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.) 7753 */ 7754 public CapabilityStatementSoftwareComponent getSoftware() { 7755 if (this.software == null) 7756 if (Configuration.errorOnAutoCreate()) 7757 throw new Error("Attempt to auto-create CapabilityStatement.software"); 7758 else if (Configuration.doAutoCreate()) 7759 this.software = new CapabilityStatementSoftwareComponent(); // cc 7760 return this.software; 7761 } 7762 7763 public boolean hasSoftware() { 7764 return this.software != null && !this.software.isEmpty(); 7765 } 7766 7767 /** 7768 * @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.) 7769 */ 7770 public CapabilityStatement setSoftware(CapabilityStatementSoftwareComponent value) { 7771 this.software = value; 7772 return this; 7773 } 7774 7775 /** 7776 * @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.) 7777 */ 7778 public CapabilityStatementImplementationComponent getImplementation() { 7779 if (this.implementation == null) 7780 if (Configuration.errorOnAutoCreate()) 7781 throw new Error("Attempt to auto-create CapabilityStatement.implementation"); 7782 else if (Configuration.doAutoCreate()) 7783 this.implementation = new CapabilityStatementImplementationComponent(); // cc 7784 return this.implementation; 7785 } 7786 7787 public boolean hasImplementation() { 7788 return this.implementation != null && !this.implementation.isEmpty(); 7789 } 7790 7791 /** 7792 * @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.) 7793 */ 7794 public CapabilityStatement setImplementation(CapabilityStatementImplementationComponent value) { 7795 this.implementation = value; 7796 return this; 7797 } 7798 7799 /** 7800 * @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 7801 */ 7802 public Enumeration<FHIRVersion> getFhirVersionElement() { 7803 if (this.fhirVersion == null) 7804 if (Configuration.errorOnAutoCreate()) 7805 throw new Error("Attempt to auto-create CapabilityStatement.fhirVersion"); 7806 else if (Configuration.doAutoCreate()) 7807 this.fhirVersion = new Enumeration<FHIRVersion>(new FHIRVersionEnumFactory()); // bb 7808 return this.fhirVersion; 7809 } 7810 7811 public boolean hasFhirVersionElement() { 7812 return this.fhirVersion != null && !this.fhirVersion.isEmpty(); 7813 } 7814 7815 public boolean hasFhirVersion() { 7816 return this.fhirVersion != null && !this.fhirVersion.isEmpty(); 7817 } 7818 7819 /** 7820 * @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 7821 */ 7822 public CapabilityStatement setFhirVersionElement(Enumeration<FHIRVersion> value) { 7823 this.fhirVersion = value; 7824 return this; 7825 } 7826 7827 /** 7828 * @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. 7829 */ 7830 public FHIRVersion getFhirVersion() { 7831 return this.fhirVersion == null ? null : this.fhirVersion.getValue(); 7832 } 7833 7834 /** 7835 * @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. 7836 */ 7837 public CapabilityStatement setFhirVersion(FHIRVersion value) { 7838 if (this.fhirVersion == null) 7839 this.fhirVersion = new Enumeration<FHIRVersion>(new FHIRVersionEnumFactory()); 7840 this.fhirVersion.setValue(value); 7841 return this; 7842 } 7843 7844 /** 7845 * @return {@link #format} (A list of the formats supported by this implementation using their content types.) 7846 */ 7847 public List<CodeType> getFormat() { 7848 if (this.format == null) 7849 this.format = new ArrayList<CodeType>(); 7850 return this.format; 7851 } 7852 7853 /** 7854 * @return Returns a reference to <code>this</code> for easy method chaining 7855 */ 7856 public CapabilityStatement setFormat(List<CodeType> theFormat) { 7857 this.format = theFormat; 7858 return this; 7859 } 7860 7861 public boolean hasFormat() { 7862 if (this.format == null) 7863 return false; 7864 for (CodeType item : this.format) 7865 if (!item.isEmpty()) 7866 return true; 7867 return false; 7868 } 7869 7870 /** 7871 * @return {@link #format} (A list of the formats supported by this implementation using their content types.) 7872 */ 7873 public CodeType addFormatElement() {//2 7874 CodeType t = new CodeType(); 7875 if (this.format == null) 7876 this.format = new ArrayList<CodeType>(); 7877 this.format.add(t); 7878 return t; 7879 } 7880 7881 /** 7882 * @param value {@link #format} (A list of the formats supported by this implementation using their content types.) 7883 */ 7884 public CapabilityStatement addFormat(String value) { //1 7885 CodeType t = new CodeType(); 7886 t.setValue(value); 7887 if (this.format == null) 7888 this.format = new ArrayList<CodeType>(); 7889 this.format.add(t); 7890 return this; 7891 } 7892 7893 /** 7894 * @param value {@link #format} (A list of the formats supported by this implementation using their content types.) 7895 */ 7896 public boolean hasFormat(String value) { 7897 if (this.format == null) 7898 return false; 7899 for (CodeType v : this.format) 7900 if (v.getValue().equals(value)) // code 7901 return true; 7902 return false; 7903 } 7904 7905 /** 7906 * @return {@link #patchFormat} (A list of the patch formats supported by this implementation using their content types.) 7907 */ 7908 public List<CodeType> getPatchFormat() { 7909 if (this.patchFormat == null) 7910 this.patchFormat = new ArrayList<CodeType>(); 7911 return this.patchFormat; 7912 } 7913 7914 /** 7915 * @return Returns a reference to <code>this</code> for easy method chaining 7916 */ 7917 public CapabilityStatement setPatchFormat(List<CodeType> thePatchFormat) { 7918 this.patchFormat = thePatchFormat; 7919 return this; 7920 } 7921 7922 public boolean hasPatchFormat() { 7923 if (this.patchFormat == null) 7924 return false; 7925 for (CodeType item : this.patchFormat) 7926 if (!item.isEmpty()) 7927 return true; 7928 return false; 7929 } 7930 7931 /** 7932 * @return {@link #patchFormat} (A list of the patch formats supported by this implementation using their content types.) 7933 */ 7934 public CodeType addPatchFormatElement() {//2 7935 CodeType t = new CodeType(); 7936 if (this.patchFormat == null) 7937 this.patchFormat = new ArrayList<CodeType>(); 7938 this.patchFormat.add(t); 7939 return t; 7940 } 7941 7942 /** 7943 * @param value {@link #patchFormat} (A list of the patch formats supported by this implementation using their content types.) 7944 */ 7945 public CapabilityStatement addPatchFormat(String value) { //1 7946 CodeType t = new CodeType(); 7947 t.setValue(value); 7948 if (this.patchFormat == null) 7949 this.patchFormat = new ArrayList<CodeType>(); 7950 this.patchFormat.add(t); 7951 return this; 7952 } 7953 7954 /** 7955 * @param value {@link #patchFormat} (A list of the patch formats supported by this implementation using their content types.) 7956 */ 7957 public boolean hasPatchFormat(String value) { 7958 if (this.patchFormat == null) 7959 return false; 7960 for (CodeType v : this.patchFormat) 7961 if (v.getValue().equals(value)) // code 7962 return true; 7963 return false; 7964 } 7965 7966 /** 7967 * @return {@link #implementationGuide} (A list of implementation guides that the server does (or should) support in their entirety.) 7968 */ 7969 public List<CanonicalType> getImplementationGuide() { 7970 if (this.implementationGuide == null) 7971 this.implementationGuide = new ArrayList<CanonicalType>(); 7972 return this.implementationGuide; 7973 } 7974 7975 /** 7976 * @return Returns a reference to <code>this</code> for easy method chaining 7977 */ 7978 public CapabilityStatement setImplementationGuide(List<CanonicalType> theImplementationGuide) { 7979 this.implementationGuide = theImplementationGuide; 7980 return this; 7981 } 7982 7983 public boolean hasImplementationGuide() { 7984 if (this.implementationGuide == null) 7985 return false; 7986 for (CanonicalType item : this.implementationGuide) 7987 if (!item.isEmpty()) 7988 return true; 7989 return false; 7990 } 7991 7992 /** 7993 * @return {@link #implementationGuide} (A list of implementation guides that the server does (or should) support in their entirety.) 7994 */ 7995 public CanonicalType addImplementationGuideElement() {//2 7996 CanonicalType t = new CanonicalType(); 7997 if (this.implementationGuide == null) 7998 this.implementationGuide = new ArrayList<CanonicalType>(); 7999 this.implementationGuide.add(t); 8000 return t; 8001 } 8002 8003 /** 8004 * @param value {@link #implementationGuide} (A list of implementation guides that the server does (or should) support in their entirety.) 8005 */ 8006 public CapabilityStatement addImplementationGuide(String value) { //1 8007 CanonicalType t = new CanonicalType(); 8008 t.setValue(value); 8009 if (this.implementationGuide == null) 8010 this.implementationGuide = new ArrayList<CanonicalType>(); 8011 this.implementationGuide.add(t); 8012 return this; 8013 } 8014 8015 /** 8016 * @param value {@link #implementationGuide} (A list of implementation guides that the server does (or should) support in their entirety.) 8017 */ 8018 public boolean hasImplementationGuide(String value) { 8019 if (this.implementationGuide == null) 8020 return false; 8021 for (CanonicalType v : this.implementationGuide) 8022 if (v.getValue().equals(value)) // canonical(ImplementationGuide) 8023 return true; 8024 return false; 8025 } 8026 8027 /** 8028 * @return {@link #rest} (A definition of the restful capabilities of the solution, if any.) 8029 */ 8030 public List<CapabilityStatementRestComponent> getRest() { 8031 if (this.rest == null) 8032 this.rest = new ArrayList<CapabilityStatementRestComponent>(); 8033 return this.rest; 8034 } 8035 8036 /** 8037 * @return Returns a reference to <code>this</code> for easy method chaining 8038 */ 8039 public CapabilityStatement setRest(List<CapabilityStatementRestComponent> theRest) { 8040 this.rest = theRest; 8041 return this; 8042 } 8043 8044 public boolean hasRest() { 8045 if (this.rest == null) 8046 return false; 8047 for (CapabilityStatementRestComponent item : this.rest) 8048 if (!item.isEmpty()) 8049 return true; 8050 return false; 8051 } 8052 8053 public CapabilityStatementRestComponent addRest() { //3 8054 CapabilityStatementRestComponent t = new CapabilityStatementRestComponent(); 8055 if (this.rest == null) 8056 this.rest = new ArrayList<CapabilityStatementRestComponent>(); 8057 this.rest.add(t); 8058 return t; 8059 } 8060 8061 public CapabilityStatement addRest(CapabilityStatementRestComponent t) { //3 8062 if (t == null) 8063 return this; 8064 if (this.rest == null) 8065 this.rest = new ArrayList<CapabilityStatementRestComponent>(); 8066 this.rest.add(t); 8067 return this; 8068 } 8069 8070 /** 8071 * @return The first repetition of repeating field {@link #rest}, creating it if it does not already exist 8072 */ 8073 public CapabilityStatementRestComponent getRestFirstRep() { 8074 if (getRest().isEmpty()) { 8075 addRest(); 8076 } 8077 return getRest().get(0); 8078 } 8079 8080 /** 8081 * @return {@link #messaging} (A description of the messaging capabilities of the solution.) 8082 */ 8083 public List<CapabilityStatementMessagingComponent> getMessaging() { 8084 if (this.messaging == null) 8085 this.messaging = new ArrayList<CapabilityStatementMessagingComponent>(); 8086 return this.messaging; 8087 } 8088 8089 /** 8090 * @return Returns a reference to <code>this</code> for easy method chaining 8091 */ 8092 public CapabilityStatement setMessaging(List<CapabilityStatementMessagingComponent> theMessaging) { 8093 this.messaging = theMessaging; 8094 return this; 8095 } 8096 8097 public boolean hasMessaging() { 8098 if (this.messaging == null) 8099 return false; 8100 for (CapabilityStatementMessagingComponent item : this.messaging) 8101 if (!item.isEmpty()) 8102 return true; 8103 return false; 8104 } 8105 8106 public CapabilityStatementMessagingComponent addMessaging() { //3 8107 CapabilityStatementMessagingComponent t = new CapabilityStatementMessagingComponent(); 8108 if (this.messaging == null) 8109 this.messaging = new ArrayList<CapabilityStatementMessagingComponent>(); 8110 this.messaging.add(t); 8111 return t; 8112 } 8113 8114 public CapabilityStatement addMessaging(CapabilityStatementMessagingComponent t) { //3 8115 if (t == null) 8116 return this; 8117 if (this.messaging == null) 8118 this.messaging = new ArrayList<CapabilityStatementMessagingComponent>(); 8119 this.messaging.add(t); 8120 return this; 8121 } 8122 8123 /** 8124 * @return The first repetition of repeating field {@link #messaging}, creating it if it does not already exist 8125 */ 8126 public CapabilityStatementMessagingComponent getMessagingFirstRep() { 8127 if (getMessaging().isEmpty()) { 8128 addMessaging(); 8129 } 8130 return getMessaging().get(0); 8131 } 8132 8133 /** 8134 * @return {@link #document} (A document definition.) 8135 */ 8136 public List<CapabilityStatementDocumentComponent> getDocument() { 8137 if (this.document == null) 8138 this.document = new ArrayList<CapabilityStatementDocumentComponent>(); 8139 return this.document; 8140 } 8141 8142 /** 8143 * @return Returns a reference to <code>this</code> for easy method chaining 8144 */ 8145 public CapabilityStatement setDocument(List<CapabilityStatementDocumentComponent> theDocument) { 8146 this.document = theDocument; 8147 return this; 8148 } 8149 8150 public boolean hasDocument() { 8151 if (this.document == null) 8152 return false; 8153 for (CapabilityStatementDocumentComponent item : this.document) 8154 if (!item.isEmpty()) 8155 return true; 8156 return false; 8157 } 8158 8159 public CapabilityStatementDocumentComponent addDocument() { //3 8160 CapabilityStatementDocumentComponent t = new CapabilityStatementDocumentComponent(); 8161 if (this.document == null) 8162 this.document = new ArrayList<CapabilityStatementDocumentComponent>(); 8163 this.document.add(t); 8164 return t; 8165 } 8166 8167 public CapabilityStatement addDocument(CapabilityStatementDocumentComponent t) { //3 8168 if (t == null) 8169 return this; 8170 if (this.document == null) 8171 this.document = new ArrayList<CapabilityStatementDocumentComponent>(); 8172 this.document.add(t); 8173 return this; 8174 } 8175 8176 /** 8177 * @return The first repetition of repeating field {@link #document}, creating it if it does not already exist 8178 */ 8179 public CapabilityStatementDocumentComponent getDocumentFirstRep() { 8180 if (getDocument().isEmpty()) { 8181 addDocument(); 8182 } 8183 return getDocument().get(0); 8184 } 8185 8186 protected void listChildren(List<Property> children) { 8187 super.listChildren(children); 8188 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)); 8189 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)); 8190 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)); 8191 children.add(new Property("title", "string", "A short, descriptive, user-friendly title for the capability statement.", 0, 1, title)); 8192 children.add(new Property("status", "code", "The status of this capability statement. Enables tracking the life-cycle of the content.", 0, 1, status)); 8193 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)); 8194 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)); 8195 children.add(new Property("publisher", "string", "The name of the organization or individual that published the capability statement.", 0, 1, publisher)); 8196 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)); 8197 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)); 8198 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)); 8199 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)); 8200 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)); 8201 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)); 8202 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)); 8203 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)); 8204 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)); 8205 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)); 8206 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)); 8207 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)); 8208 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)); 8209 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)); 8210 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)); 8211 children.add(new Property("rest", "", "A definition of the restful capabilities of the solution, if any.", 0, java.lang.Integer.MAX_VALUE, rest)); 8212 children.add(new Property("messaging", "", "A description of the messaging capabilities of the solution.", 0, java.lang.Integer.MAX_VALUE, messaging)); 8213 children.add(new Property("document", "", "A document definition.", 0, java.lang.Integer.MAX_VALUE, document)); 8214 } 8215 8216 @Override 8217 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 8218 switch (_hash) { 8219 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); 8220 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); 8221 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); 8222 case 110371416: /*title*/ return new Property("title", "string", "A short, descriptive, user-friendly title for the capability statement.", 0, 1, title); 8223 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); 8224 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); 8225 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); 8226 case 1447404028: /*publisher*/ return new Property("publisher", "string", "The name of the organization or individual that published the capability statement.", 0, 1, publisher); 8227 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); 8228 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); 8229 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); 8230 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); 8231 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); 8232 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); 8233 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); 8234 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); 8235 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); 8236 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); 8237 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); 8238 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); 8239 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); 8240 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); 8241 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); 8242 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); 8243 case -1440008444: /*messaging*/ return new Property("messaging", "", "A description of the messaging capabilities of the solution.", 0, java.lang.Integer.MAX_VALUE, messaging); 8244 case 861720859: /*document*/ return new Property("document", "", "A document definition.", 0, java.lang.Integer.MAX_VALUE, document); 8245 default: return super.getNamedProperty(_hash, _name, _checkValid); 8246 } 8247 8248 } 8249 8250 @Override 8251 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 8252 switch (hash) { 8253 case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType 8254 case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType 8255 case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType 8256 case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType 8257 case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<PublicationStatus> 8258 case -404562712: /*experimental*/ return this.experimental == null ? new Base[0] : new Base[] {this.experimental}; // BooleanType 8259 case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType 8260 case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType 8261 case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail 8262 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType 8263 case -669707736: /*useContext*/ return this.useContext == null ? new Base[0] : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext 8264 case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept 8265 case -220463842: /*purpose*/ return this.purpose == null ? new Base[0] : new Base[] {this.purpose}; // MarkdownType 8266 case 1522889671: /*copyright*/ return this.copyright == null ? new Base[0] : new Base[] {this.copyright}; // MarkdownType 8267 case 3292052: /*kind*/ return this.kind == null ? new Base[0] : new Base[] {this.kind}; // Enumeration<CapabilityStatementKind> 8268 case -246883639: /*instantiates*/ return this.instantiates == null ? new Base[0] : this.instantiates.toArray(new Base[this.instantiates.size()]); // CanonicalType 8269 case 1926037870: /*imports*/ return this.imports == null ? new Base[0] : this.imports.toArray(new Base[this.imports.size()]); // CanonicalType 8270 case 1319330215: /*software*/ return this.software == null ? new Base[0] : new Base[] {this.software}; // CapabilityStatementSoftwareComponent 8271 case 1683336114: /*implementation*/ return this.implementation == null ? new Base[0] : new Base[] {this.implementation}; // CapabilityStatementImplementationComponent 8272 case 461006061: /*fhirVersion*/ return this.fhirVersion == null ? new Base[0] : new Base[] {this.fhirVersion}; // Enumeration<FHIRVersion> 8273 case -1268779017: /*format*/ return this.format == null ? new Base[0] : this.format.toArray(new Base[this.format.size()]); // CodeType 8274 case 172338783: /*patchFormat*/ return this.patchFormat == null ? new Base[0] : this.patchFormat.toArray(new Base[this.patchFormat.size()]); // CodeType 8275 case 156966506: /*implementationGuide*/ return this.implementationGuide == null ? new Base[0] : this.implementationGuide.toArray(new Base[this.implementationGuide.size()]); // CanonicalType 8276 case 3496916: /*rest*/ return this.rest == null ? new Base[0] : this.rest.toArray(new Base[this.rest.size()]); // CapabilityStatementRestComponent 8277 case -1440008444: /*messaging*/ return this.messaging == null ? new Base[0] : this.messaging.toArray(new Base[this.messaging.size()]); // CapabilityStatementMessagingComponent 8278 case 861720859: /*document*/ return this.document == null ? new Base[0] : this.document.toArray(new Base[this.document.size()]); // CapabilityStatementDocumentComponent 8279 default: return super.getProperty(hash, name, checkValid); 8280 } 8281 8282 } 8283 8284 @Override 8285 public Base setProperty(int hash, String name, Base value) throws FHIRException { 8286 switch (hash) { 8287 case 116079: // url 8288 this.url = castToUri(value); // UriType 8289 return value; 8290 case 351608024: // version 8291 this.version = castToString(value); // StringType 8292 return value; 8293 case 3373707: // name 8294 this.name = castToString(value); // StringType 8295 return value; 8296 case 110371416: // title 8297 this.title = castToString(value); // StringType 8298 return value; 8299 case -892481550: // status 8300 value = new PublicationStatusEnumFactory().fromType(castToCode(value)); 8301 this.status = (Enumeration) value; // Enumeration<PublicationStatus> 8302 return value; 8303 case -404562712: // experimental 8304 this.experimental = castToBoolean(value); // BooleanType 8305 return value; 8306 case 3076014: // date 8307 this.date = castToDateTime(value); // DateTimeType 8308 return value; 8309 case 1447404028: // publisher 8310 this.publisher = castToString(value); // StringType 8311 return value; 8312 case 951526432: // contact 8313 this.getContact().add(castToContactDetail(value)); // ContactDetail 8314 return value; 8315 case -1724546052: // description 8316 this.description = castToMarkdown(value); // MarkdownType 8317 return value; 8318 case -669707736: // useContext 8319 this.getUseContext().add(castToUsageContext(value)); // UsageContext 8320 return value; 8321 case -507075711: // jurisdiction 8322 this.getJurisdiction().add(castToCodeableConcept(value)); // CodeableConcept 8323 return value; 8324 case -220463842: // purpose 8325 this.purpose = castToMarkdown(value); // MarkdownType 8326 return value; 8327 case 1522889671: // copyright 8328 this.copyright = castToMarkdown(value); // MarkdownType 8329 return value; 8330 case 3292052: // kind 8331 value = new CapabilityStatementKindEnumFactory().fromType(castToCode(value)); 8332 this.kind = (Enumeration) value; // Enumeration<CapabilityStatementKind> 8333 return value; 8334 case -246883639: // instantiates 8335 this.getInstantiates().add(castToCanonical(value)); // CanonicalType 8336 return value; 8337 case 1926037870: // imports 8338 this.getImports().add(castToCanonical(value)); // CanonicalType 8339 return value; 8340 case 1319330215: // software 8341 this.software = (CapabilityStatementSoftwareComponent) value; // CapabilityStatementSoftwareComponent 8342 return value; 8343 case 1683336114: // implementation 8344 this.implementation = (CapabilityStatementImplementationComponent) value; // CapabilityStatementImplementationComponent 8345 return value; 8346 case 461006061: // fhirVersion 8347 value = new FHIRVersionEnumFactory().fromType(castToCode(value)); 8348 this.fhirVersion = (Enumeration) value; // Enumeration<FHIRVersion> 8349 return value; 8350 case -1268779017: // format 8351 this.getFormat().add(castToCode(value)); // CodeType 8352 return value; 8353 case 172338783: // patchFormat 8354 this.getPatchFormat().add(castToCode(value)); // CodeType 8355 return value; 8356 case 156966506: // implementationGuide 8357 this.getImplementationGuide().add(castToCanonical(value)); // CanonicalType 8358 return value; 8359 case 3496916: // rest 8360 this.getRest().add((CapabilityStatementRestComponent) value); // CapabilityStatementRestComponent 8361 return value; 8362 case -1440008444: // messaging 8363 this.getMessaging().add((CapabilityStatementMessagingComponent) value); // CapabilityStatementMessagingComponent 8364 return value; 8365 case 861720859: // document 8366 this.getDocument().add((CapabilityStatementDocumentComponent) value); // CapabilityStatementDocumentComponent 8367 return value; 8368 default: return super.setProperty(hash, name, value); 8369 } 8370 8371 } 8372 8373 @Override 8374 public Base setProperty(String name, Base value) throws FHIRException { 8375 if (name.equals("url")) { 8376 this.url = castToUri(value); // UriType 8377 } else if (name.equals("version")) { 8378 this.version = castToString(value); // StringType 8379 } else if (name.equals("name")) { 8380 this.name = castToString(value); // StringType 8381 } else if (name.equals("title")) { 8382 this.title = castToString(value); // StringType 8383 } else if (name.equals("status")) { 8384 value = new PublicationStatusEnumFactory().fromType(castToCode(value)); 8385 this.status = (Enumeration) value; // Enumeration<PublicationStatus> 8386 } else if (name.equals("experimental")) { 8387 this.experimental = castToBoolean(value); // BooleanType 8388 } else if (name.equals("date")) { 8389 this.date = castToDateTime(value); // DateTimeType 8390 } else if (name.equals("publisher")) { 8391 this.publisher = castToString(value); // StringType 8392 } else if (name.equals("contact")) { 8393 this.getContact().add(castToContactDetail(value)); 8394 } else if (name.equals("description")) { 8395 this.description = castToMarkdown(value); // MarkdownType 8396 } else if (name.equals("useContext")) { 8397 this.getUseContext().add(castToUsageContext(value)); 8398 } else if (name.equals("jurisdiction")) { 8399 this.getJurisdiction().add(castToCodeableConcept(value)); 8400 } else if (name.equals("purpose")) { 8401 this.purpose = castToMarkdown(value); // MarkdownType 8402 } else if (name.equals("copyright")) { 8403 this.copyright = castToMarkdown(value); // MarkdownType 8404 } else if (name.equals("kind")) { 8405 value = new CapabilityStatementKindEnumFactory().fromType(castToCode(value)); 8406 this.kind = (Enumeration) value; // Enumeration<CapabilityStatementKind> 8407 } else if (name.equals("instantiates")) { 8408 this.getInstantiates().add(castToCanonical(value)); 8409 } else if (name.equals("imports")) { 8410 this.getImports().add(castToCanonical(value)); 8411 } else if (name.equals("software")) { 8412 this.software = (CapabilityStatementSoftwareComponent) value; // CapabilityStatementSoftwareComponent 8413 } else if (name.equals("implementation")) { 8414 this.implementation = (CapabilityStatementImplementationComponent) value; // CapabilityStatementImplementationComponent 8415 } else if (name.equals("fhirVersion")) { 8416 value = new FHIRVersionEnumFactory().fromType(castToCode(value)); 8417 this.fhirVersion = (Enumeration) value; // Enumeration<FHIRVersion> 8418 } else if (name.equals("format")) { 8419 this.getFormat().add(castToCode(value)); 8420 } else if (name.equals("patchFormat")) { 8421 this.getPatchFormat().add(castToCode(value)); 8422 } else if (name.equals("implementationGuide")) { 8423 this.getImplementationGuide().add(castToCanonical(value)); 8424 } else if (name.equals("rest")) { 8425 this.getRest().add((CapabilityStatementRestComponent) value); 8426 } else if (name.equals("messaging")) { 8427 this.getMessaging().add((CapabilityStatementMessagingComponent) value); 8428 } else if (name.equals("document")) { 8429 this.getDocument().add((CapabilityStatementDocumentComponent) value); 8430 } else 8431 return super.setProperty(name, value); 8432 return value; 8433 } 8434 8435 @Override 8436 public Base makeProperty(int hash, String name) throws FHIRException { 8437 switch (hash) { 8438 case 116079: return getUrlElement(); 8439 case 351608024: return getVersionElement(); 8440 case 3373707: return getNameElement(); 8441 case 110371416: return getTitleElement(); 8442 case -892481550: return getStatusElement(); 8443 case -404562712: return getExperimentalElement(); 8444 case 3076014: return getDateElement(); 8445 case 1447404028: return getPublisherElement(); 8446 case 951526432: return addContact(); 8447 case -1724546052: return getDescriptionElement(); 8448 case -669707736: return addUseContext(); 8449 case -507075711: return addJurisdiction(); 8450 case -220463842: return getPurposeElement(); 8451 case 1522889671: return getCopyrightElement(); 8452 case 3292052: return getKindElement(); 8453 case -246883639: return addInstantiatesElement(); 8454 case 1926037870: return addImportsElement(); 8455 case 1319330215: return getSoftware(); 8456 case 1683336114: return getImplementation(); 8457 case 461006061: return getFhirVersionElement(); 8458 case -1268779017: return addFormatElement(); 8459 case 172338783: return addPatchFormatElement(); 8460 case 156966506: return addImplementationGuideElement(); 8461 case 3496916: return addRest(); 8462 case -1440008444: return addMessaging(); 8463 case 861720859: return addDocument(); 8464 default: return super.makeProperty(hash, name); 8465 } 8466 8467 } 8468 8469 @Override 8470 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 8471 switch (hash) { 8472 case 116079: /*url*/ return new String[] {"uri"}; 8473 case 351608024: /*version*/ return new String[] {"string"}; 8474 case 3373707: /*name*/ return new String[] {"string"}; 8475 case 110371416: /*title*/ return new String[] {"string"}; 8476 case -892481550: /*status*/ return new String[] {"code"}; 8477 case -404562712: /*experimental*/ return new String[] {"boolean"}; 8478 case 3076014: /*date*/ return new String[] {"dateTime"}; 8479 case 1447404028: /*publisher*/ return new String[] {"string"}; 8480 case 951526432: /*contact*/ return new String[] {"ContactDetail"}; 8481 case -1724546052: /*description*/ return new String[] {"markdown"}; 8482 case -669707736: /*useContext*/ return new String[] {"UsageContext"}; 8483 case -507075711: /*jurisdiction*/ return new String[] {"CodeableConcept"}; 8484 case -220463842: /*purpose*/ return new String[] {"markdown"}; 8485 case 1522889671: /*copyright*/ return new String[] {"markdown"}; 8486 case 3292052: /*kind*/ return new String[] {"code"}; 8487 case -246883639: /*instantiates*/ return new String[] {"canonical"}; 8488 case 1926037870: /*imports*/ return new String[] {"canonical"}; 8489 case 1319330215: /*software*/ return new String[] {}; 8490 case 1683336114: /*implementation*/ return new String[] {}; 8491 case 461006061: /*fhirVersion*/ return new String[] {"code"}; 8492 case -1268779017: /*format*/ return new String[] {"code"}; 8493 case 172338783: /*patchFormat*/ return new String[] {"code"}; 8494 case 156966506: /*implementationGuide*/ return new String[] {"canonical"}; 8495 case 3496916: /*rest*/ return new String[] {}; 8496 case -1440008444: /*messaging*/ return new String[] {}; 8497 case 861720859: /*document*/ return new String[] {}; 8498 default: return super.getTypesForProperty(hash, name); 8499 } 8500 8501 } 8502 8503 @Override 8504 public Base addChild(String name) throws FHIRException { 8505 if (name.equals("url")) { 8506 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.url"); 8507 } 8508 else if (name.equals("version")) { 8509 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.version"); 8510 } 8511 else if (name.equals("name")) { 8512 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.name"); 8513 } 8514 else if (name.equals("title")) { 8515 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.title"); 8516 } 8517 else if (name.equals("status")) { 8518 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.status"); 8519 } 8520 else if (name.equals("experimental")) { 8521 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.experimental"); 8522 } 8523 else if (name.equals("date")) { 8524 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.date"); 8525 } 8526 else if (name.equals("publisher")) { 8527 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.publisher"); 8528 } 8529 else if (name.equals("contact")) { 8530 return addContact(); 8531 } 8532 else if (name.equals("description")) { 8533 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.description"); 8534 } 8535 else if (name.equals("useContext")) { 8536 return addUseContext(); 8537 } 8538 else if (name.equals("jurisdiction")) { 8539 return addJurisdiction(); 8540 } 8541 else if (name.equals("purpose")) { 8542 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.purpose"); 8543 } 8544 else if (name.equals("copyright")) { 8545 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.copyright"); 8546 } 8547 else if (name.equals("kind")) { 8548 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.kind"); 8549 } 8550 else if (name.equals("instantiates")) { 8551 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.instantiates"); 8552 } 8553 else if (name.equals("imports")) { 8554 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.imports"); 8555 } 8556 else if (name.equals("software")) { 8557 this.software = new CapabilityStatementSoftwareComponent(); 8558 return this.software; 8559 } 8560 else if (name.equals("implementation")) { 8561 this.implementation = new CapabilityStatementImplementationComponent(); 8562 return this.implementation; 8563 } 8564 else if (name.equals("fhirVersion")) { 8565 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.fhirVersion"); 8566 } 8567 else if (name.equals("format")) { 8568 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.format"); 8569 } 8570 else if (name.equals("patchFormat")) { 8571 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.patchFormat"); 8572 } 8573 else if (name.equals("implementationGuide")) { 8574 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement.implementationGuide"); 8575 } 8576 else if (name.equals("rest")) { 8577 return addRest(); 8578 } 8579 else if (name.equals("messaging")) { 8580 return addMessaging(); 8581 } 8582 else if (name.equals("document")) { 8583 return addDocument(); 8584 } 8585 else 8586 return super.addChild(name); 8587 } 8588 8589 public String fhirType() { 8590 return "CapabilityStatement"; 8591 8592 } 8593 8594 public CapabilityStatement copy() { 8595 CapabilityStatement dst = new CapabilityStatement(); 8596 copyValues(dst); 8597 return dst; 8598 } 8599 8600 public void copyValues(CapabilityStatement dst) { 8601 super.copyValues(dst); 8602 dst.url = url == null ? null : url.copy(); 8603 dst.version = version == null ? null : version.copy(); 8604 dst.name = name == null ? null : name.copy(); 8605 dst.title = title == null ? null : title.copy(); 8606 dst.status = status == null ? null : status.copy(); 8607 dst.experimental = experimental == null ? null : experimental.copy(); 8608 dst.date = date == null ? null : date.copy(); 8609 dst.publisher = publisher == null ? null : publisher.copy(); 8610 if (contact != null) { 8611 dst.contact = new ArrayList<ContactDetail>(); 8612 for (ContactDetail i : contact) 8613 dst.contact.add(i.copy()); 8614 }; 8615 dst.description = description == null ? null : description.copy(); 8616 if (useContext != null) { 8617 dst.useContext = new ArrayList<UsageContext>(); 8618 for (UsageContext i : useContext) 8619 dst.useContext.add(i.copy()); 8620 }; 8621 if (jurisdiction != null) { 8622 dst.jurisdiction = new ArrayList<CodeableConcept>(); 8623 for (CodeableConcept i : jurisdiction) 8624 dst.jurisdiction.add(i.copy()); 8625 }; 8626 dst.purpose = purpose == null ? null : purpose.copy(); 8627 dst.copyright = copyright == null ? null : copyright.copy(); 8628 dst.kind = kind == null ? null : kind.copy(); 8629 if (instantiates != null) { 8630 dst.instantiates = new ArrayList<CanonicalType>(); 8631 for (CanonicalType i : instantiates) 8632 dst.instantiates.add(i.copy()); 8633 }; 8634 if (imports != null) { 8635 dst.imports = new ArrayList<CanonicalType>(); 8636 for (CanonicalType i : imports) 8637 dst.imports.add(i.copy()); 8638 }; 8639 dst.software = software == null ? null : software.copy(); 8640 dst.implementation = implementation == null ? null : implementation.copy(); 8641 dst.fhirVersion = fhirVersion == null ? null : fhirVersion.copy(); 8642 if (format != null) { 8643 dst.format = new ArrayList<CodeType>(); 8644 for (CodeType i : format) 8645 dst.format.add(i.copy()); 8646 }; 8647 if (patchFormat != null) { 8648 dst.patchFormat = new ArrayList<CodeType>(); 8649 for (CodeType i : patchFormat) 8650 dst.patchFormat.add(i.copy()); 8651 }; 8652 if (implementationGuide != null) { 8653 dst.implementationGuide = new ArrayList<CanonicalType>(); 8654 for (CanonicalType i : implementationGuide) 8655 dst.implementationGuide.add(i.copy()); 8656 }; 8657 if (rest != null) { 8658 dst.rest = new ArrayList<CapabilityStatementRestComponent>(); 8659 for (CapabilityStatementRestComponent i : rest) 8660 dst.rest.add(i.copy()); 8661 }; 8662 if (messaging != null) { 8663 dst.messaging = new ArrayList<CapabilityStatementMessagingComponent>(); 8664 for (CapabilityStatementMessagingComponent i : messaging) 8665 dst.messaging.add(i.copy()); 8666 }; 8667 if (document != null) { 8668 dst.document = new ArrayList<CapabilityStatementDocumentComponent>(); 8669 for (CapabilityStatementDocumentComponent i : document) 8670 dst.document.add(i.copy()); 8671 }; 8672 } 8673 8674 protected CapabilityStatement typedCopy() { 8675 return copy(); 8676 } 8677 8678 @Override 8679 public boolean equalsDeep(Base other_) { 8680 if (!super.equalsDeep(other_)) 8681 return false; 8682 if (!(other_ instanceof CapabilityStatement)) 8683 return false; 8684 CapabilityStatement o = (CapabilityStatement) other_; 8685 return compareDeep(purpose, o.purpose, true) && compareDeep(copyright, o.copyright, true) && compareDeep(kind, o.kind, true) 8686 && compareDeep(instantiates, o.instantiates, true) && compareDeep(imports, o.imports, true) && compareDeep(software, o.software, true) 8687 && compareDeep(implementation, o.implementation, true) && compareDeep(fhirVersion, o.fhirVersion, true) 8688 && compareDeep(format, o.format, true) && compareDeep(patchFormat, o.patchFormat, true) && compareDeep(implementationGuide, o.implementationGuide, true) 8689 && compareDeep(rest, o.rest, true) && compareDeep(messaging, o.messaging, true) && compareDeep(document, o.document, true) 8690 ; 8691 } 8692 8693 @Override 8694 public boolean equalsShallow(Base other_) { 8695 if (!super.equalsShallow(other_)) 8696 return false; 8697 if (!(other_ instanceof CapabilityStatement)) 8698 return false; 8699 CapabilityStatement o = (CapabilityStatement) other_; 8700 return compareValues(purpose, o.purpose, true) && compareValues(copyright, o.copyright, true) && compareValues(kind, o.kind, true) 8701 && compareValues(fhirVersion, o.fhirVersion, true) && compareValues(format, o.format, true) && compareValues(patchFormat, o.patchFormat, true) 8702 ; 8703 } 8704 8705 public boolean isEmpty() { 8706 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(purpose, copyright, kind 8707 , instantiates, imports, software, implementation, fhirVersion, format, patchFormat 8708 , implementationGuide, rest, messaging, document); 8709 } 8710 8711 @Override 8712 public ResourceType getResourceType() { 8713 return ResourceType.CapabilityStatement; 8714 } 8715 8716 /** 8717 * Search parameter: <b>date</b> 8718 * <p> 8719 * Description: <b>The capability statement publication date</b><br> 8720 * Type: <b>date</b><br> 8721 * Path: <b>CapabilityStatement.date</b><br> 8722 * </p> 8723 */ 8724 @SearchParamDefinition(name="date", path="CapabilityStatement.date", description="The capability statement publication date", type="date" ) 8725 public static final String SP_DATE = "date"; 8726 /** 8727 * <b>Fluent Client</b> search parameter constant for <b>date</b> 8728 * <p> 8729 * Description: <b>The capability statement publication date</b><br> 8730 * Type: <b>date</b><br> 8731 * Path: <b>CapabilityStatement.date</b><br> 8732 * </p> 8733 */ 8734 public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE); 8735 8736 /** 8737 * Search parameter: <b>resource-profile</b> 8738 * <p> 8739 * Description: <b>A profile id invoked in a capability statement</b><br> 8740 * Type: <b>reference</b><br> 8741 * Path: <b>CapabilityStatement.rest.resource.profile</b><br> 8742 * </p> 8743 */ 8744 @SearchParamDefinition(name="resource-profile", path="CapabilityStatement.rest.resource.profile", description="A profile id invoked in a capability statement", type="reference", target={StructureDefinition.class } ) 8745 public static final String SP_RESOURCE_PROFILE = "resource-profile"; 8746 /** 8747 * <b>Fluent Client</b> search parameter constant for <b>resource-profile</b> 8748 * <p> 8749 * Description: <b>A profile id invoked in a capability statement</b><br> 8750 * Type: <b>reference</b><br> 8751 * Path: <b>CapabilityStatement.rest.resource.profile</b><br> 8752 * </p> 8753 */ 8754 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam RESOURCE_PROFILE = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_RESOURCE_PROFILE); 8755 8756/** 8757 * Constant for fluent queries to be used to add include statements. Specifies 8758 * the path value of "<b>CapabilityStatement:resource-profile</b>". 8759 */ 8760 public static final ca.uhn.fhir.model.api.Include INCLUDE_RESOURCE_PROFILE = new ca.uhn.fhir.model.api.Include("CapabilityStatement:resource-profile").toLocked(); 8761 8762 /** 8763 * Search parameter: <b>context-type-value</b> 8764 * <p> 8765 * Description: <b>A use context type and value assigned to the capability statement</b><br> 8766 * Type: <b>composite</b><br> 8767 * Path: <b></b><br> 8768 * </p> 8769 */ 8770 @SearchParamDefinition(name="context-type-value", path="CapabilityStatement.useContext", description="A use context type and value assigned to the capability statement", type="composite", compositeOf={"context-type", "context"} ) 8771 public static final String SP_CONTEXT_TYPE_VALUE = "context-type-value"; 8772 /** 8773 * <b>Fluent Client</b> search parameter constant for <b>context-type-value</b> 8774 * <p> 8775 * Description: <b>A use context type and value assigned to the capability statement</b><br> 8776 * Type: <b>composite</b><br> 8777 * Path: <b></b><br> 8778 * </p> 8779 */ 8780 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); 8781 8782 /** 8783 * Search parameter: <b>software</b> 8784 * <p> 8785 * Description: <b>Part of the name of a software application</b><br> 8786 * Type: <b>string</b><br> 8787 * Path: <b>CapabilityStatement.software.name</b><br> 8788 * </p> 8789 */ 8790 @SearchParamDefinition(name="software", path="CapabilityStatement.software.name", description="Part of the name of a software application", type="string" ) 8791 public static final String SP_SOFTWARE = "software"; 8792 /** 8793 * <b>Fluent Client</b> search parameter constant for <b>software</b> 8794 * <p> 8795 * Description: <b>Part of the name of a software application</b><br> 8796 * Type: <b>string</b><br> 8797 * Path: <b>CapabilityStatement.software.name</b><br> 8798 * </p> 8799 */ 8800 public static final ca.uhn.fhir.rest.gclient.StringClientParam SOFTWARE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_SOFTWARE); 8801 8802 /** 8803 * Search parameter: <b>resource</b> 8804 * <p> 8805 * Description: <b>Name of a resource mentioned in a capability statement</b><br> 8806 * Type: <b>token</b><br> 8807 * Path: <b>CapabilityStatement.rest.resource.type</b><br> 8808 * </p> 8809 */ 8810 @SearchParamDefinition(name="resource", path="CapabilityStatement.rest.resource.type", description="Name of a resource mentioned in a capability statement", type="token" ) 8811 public static final String SP_RESOURCE = "resource"; 8812 /** 8813 * <b>Fluent Client</b> search parameter constant for <b>resource</b> 8814 * <p> 8815 * Description: <b>Name of a resource mentioned in a capability statement</b><br> 8816 * Type: <b>token</b><br> 8817 * Path: <b>CapabilityStatement.rest.resource.type</b><br> 8818 * </p> 8819 */ 8820 public static final ca.uhn.fhir.rest.gclient.TokenClientParam RESOURCE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_RESOURCE); 8821 8822 /** 8823 * Search parameter: <b>jurisdiction</b> 8824 * <p> 8825 * Description: <b>Intended jurisdiction for the capability statement</b><br> 8826 * Type: <b>token</b><br> 8827 * Path: <b>CapabilityStatement.jurisdiction</b><br> 8828 * </p> 8829 */ 8830 @SearchParamDefinition(name="jurisdiction", path="CapabilityStatement.jurisdiction", description="Intended jurisdiction for the capability statement", type="token" ) 8831 public static final String SP_JURISDICTION = "jurisdiction"; 8832 /** 8833 * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b> 8834 * <p> 8835 * Description: <b>Intended jurisdiction for the capability statement</b><br> 8836 * Type: <b>token</b><br> 8837 * Path: <b>CapabilityStatement.jurisdiction</b><br> 8838 * </p> 8839 */ 8840 public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_JURISDICTION); 8841 8842 /** 8843 * Search parameter: <b>format</b> 8844 * <p> 8845 * Description: <b>formats supported (xml | json | ttl | mime type)</b><br> 8846 * Type: <b>token</b><br> 8847 * Path: <b>CapabilityStatement.format</b><br> 8848 * </p> 8849 */ 8850 @SearchParamDefinition(name="format", path="CapabilityStatement.format", description="formats supported (xml | json | ttl | mime type)", type="token" ) 8851 public static final String SP_FORMAT = "format"; 8852 /** 8853 * <b>Fluent Client</b> search parameter constant for <b>format</b> 8854 * <p> 8855 * Description: <b>formats supported (xml | json | ttl | mime type)</b><br> 8856 * Type: <b>token</b><br> 8857 * Path: <b>CapabilityStatement.format</b><br> 8858 * </p> 8859 */ 8860 public static final ca.uhn.fhir.rest.gclient.TokenClientParam FORMAT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_FORMAT); 8861 8862 /** 8863 * Search parameter: <b>description</b> 8864 * <p> 8865 * Description: <b>The description of the capability statement</b><br> 8866 * Type: <b>string</b><br> 8867 * Path: <b>CapabilityStatement.description</b><br> 8868 * </p> 8869 */ 8870 @SearchParamDefinition(name="description", path="CapabilityStatement.description", description="The description of the capability statement", type="string" ) 8871 public static final String SP_DESCRIPTION = "description"; 8872 /** 8873 * <b>Fluent Client</b> search parameter constant for <b>description</b> 8874 * <p> 8875 * Description: <b>The description of the capability statement</b><br> 8876 * Type: <b>string</b><br> 8877 * Path: <b>CapabilityStatement.description</b><br> 8878 * </p> 8879 */ 8880 public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION); 8881 8882 /** 8883 * Search parameter: <b>context-type</b> 8884 * <p> 8885 * Description: <b>A type of use context assigned to the capability statement</b><br> 8886 * Type: <b>token</b><br> 8887 * Path: <b>CapabilityStatement.useContext.code</b><br> 8888 * </p> 8889 */ 8890 @SearchParamDefinition(name="context-type", path="CapabilityStatement.useContext.code", description="A type of use context assigned to the capability statement", type="token" ) 8891 public static final String SP_CONTEXT_TYPE = "context-type"; 8892 /** 8893 * <b>Fluent Client</b> search parameter constant for <b>context-type</b> 8894 * <p> 8895 * Description: <b>A type of use context assigned to the capability statement</b><br> 8896 * Type: <b>token</b><br> 8897 * Path: <b>CapabilityStatement.useContext.code</b><br> 8898 * </p> 8899 */ 8900 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT_TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT_TYPE); 8901 8902 /** 8903 * Search parameter: <b>title</b> 8904 * <p> 8905 * Description: <b>The human-friendly name of the capability statement</b><br> 8906 * Type: <b>string</b><br> 8907 * Path: <b>CapabilityStatement.title</b><br> 8908 * </p> 8909 */ 8910 @SearchParamDefinition(name="title", path="CapabilityStatement.title", description="The human-friendly name of the capability statement", type="string" ) 8911 public static final String SP_TITLE = "title"; 8912 /** 8913 * <b>Fluent Client</b> search parameter constant for <b>title</b> 8914 * <p> 8915 * Description: <b>The human-friendly name of the capability statement</b><br> 8916 * Type: <b>string</b><br> 8917 * Path: <b>CapabilityStatement.title</b><br> 8918 * </p> 8919 */ 8920 public static final ca.uhn.fhir.rest.gclient.StringClientParam TITLE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_TITLE); 8921 8922 /** 8923 * Search parameter: <b>fhirversion</b> 8924 * <p> 8925 * Description: <b>The version of FHIR</b><br> 8926 * Type: <b>token</b><br> 8927 * Path: <b>CapabilityStatement.version</b><br> 8928 * </p> 8929 */ 8930 @SearchParamDefinition(name="fhirversion", path="CapabilityStatement.version", description="The version of FHIR", type="token" ) 8931 public static final String SP_FHIRVERSION = "fhirversion"; 8932 /** 8933 * <b>Fluent Client</b> search parameter constant for <b>fhirversion</b> 8934 * <p> 8935 * Description: <b>The version of FHIR</b><br> 8936 * Type: <b>token</b><br> 8937 * Path: <b>CapabilityStatement.version</b><br> 8938 * </p> 8939 */ 8940 public static final ca.uhn.fhir.rest.gclient.TokenClientParam FHIRVERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_FHIRVERSION); 8941 8942 /** 8943 * Search parameter: <b>version</b> 8944 * <p> 8945 * Description: <b>The business version of the capability statement</b><br> 8946 * Type: <b>token</b><br> 8947 * Path: <b>CapabilityStatement.version</b><br> 8948 * </p> 8949 */ 8950 @SearchParamDefinition(name="version", path="CapabilityStatement.version", description="The business version of the capability statement", type="token" ) 8951 public static final String SP_VERSION = "version"; 8952 /** 8953 * <b>Fluent Client</b> search parameter constant for <b>version</b> 8954 * <p> 8955 * Description: <b>The business version of the capability statement</b><br> 8956 * Type: <b>token</b><br> 8957 * Path: <b>CapabilityStatement.version</b><br> 8958 * </p> 8959 */ 8960 public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VERSION); 8961 8962 /** 8963 * Search parameter: <b>url</b> 8964 * <p> 8965 * Description: <b>The uri that identifies the capability statement</b><br> 8966 * Type: <b>uri</b><br> 8967 * Path: <b>CapabilityStatement.url</b><br> 8968 * </p> 8969 */ 8970 @SearchParamDefinition(name="url", path="CapabilityStatement.url", description="The uri that identifies the capability statement", type="uri" ) 8971 public static final String SP_URL = "url"; 8972 /** 8973 * <b>Fluent Client</b> search parameter constant for <b>url</b> 8974 * <p> 8975 * Description: <b>The uri that identifies the capability statement</b><br> 8976 * Type: <b>uri</b><br> 8977 * Path: <b>CapabilityStatement.url</b><br> 8978 * </p> 8979 */ 8980 public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL); 8981 8982 /** 8983 * Search parameter: <b>supported-profile</b> 8984 * <p> 8985 * Description: <b>Profiles for use cases supported</b><br> 8986 * Type: <b>reference</b><br> 8987 * Path: <b>CapabilityStatement.rest.resource.supportedProfile</b><br> 8988 * </p> 8989 */ 8990 @SearchParamDefinition(name="supported-profile", path="CapabilityStatement.rest.resource.supportedProfile", description="Profiles for use cases supported", type="reference", target={StructureDefinition.class } ) 8991 public static final String SP_SUPPORTED_PROFILE = "supported-profile"; 8992 /** 8993 * <b>Fluent Client</b> search parameter constant for <b>supported-profile</b> 8994 * <p> 8995 * Description: <b>Profiles for use cases supported</b><br> 8996 * Type: <b>reference</b><br> 8997 * Path: <b>CapabilityStatement.rest.resource.supportedProfile</b><br> 8998 * </p> 8999 */ 9000 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SUPPORTED_PROFILE = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_SUPPORTED_PROFILE); 9001 9002/** 9003 * Constant for fluent queries to be used to add include statements. Specifies 9004 * the path value of "<b>CapabilityStatement:supported-profile</b>". 9005 */ 9006 public static final ca.uhn.fhir.model.api.Include INCLUDE_SUPPORTED_PROFILE = new ca.uhn.fhir.model.api.Include("CapabilityStatement:supported-profile").toLocked(); 9007 9008 /** 9009 * Search parameter: <b>mode</b> 9010 * <p> 9011 * Description: <b>Mode - restful (server/client) or messaging (sender/receiver)</b><br> 9012 * Type: <b>token</b><br> 9013 * Path: <b>CapabilityStatement.rest.mode</b><br> 9014 * </p> 9015 */ 9016 @SearchParamDefinition(name="mode", path="CapabilityStatement.rest.mode", description="Mode - restful (server/client) or messaging (sender/receiver)", type="token" ) 9017 public static final String SP_MODE = "mode"; 9018 /** 9019 * <b>Fluent Client</b> search parameter constant for <b>mode</b> 9020 * <p> 9021 * Description: <b>Mode - restful (server/client) or messaging (sender/receiver)</b><br> 9022 * Type: <b>token</b><br> 9023 * Path: <b>CapabilityStatement.rest.mode</b><br> 9024 * </p> 9025 */ 9026 public static final ca.uhn.fhir.rest.gclient.TokenClientParam MODE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_MODE); 9027 9028 /** 9029 * Search parameter: <b>context-quantity</b> 9030 * <p> 9031 * Description: <b>A quantity- or range-valued use context assigned to the capability statement</b><br> 9032 * Type: <b>quantity</b><br> 9033 * Path: <b>CapabilityStatement.useContext.valueQuantity, CapabilityStatement.useContext.valueRange</b><br> 9034 * </p> 9035 */ 9036 @SearchParamDefinition(name="context-quantity", path="(CapabilityStatement.useContext.value as Quantity) | (CapabilityStatement.useContext.value as Range)", description="A quantity- or range-valued use context assigned to the capability statement", type="quantity" ) 9037 public static final String SP_CONTEXT_QUANTITY = "context-quantity"; 9038 /** 9039 * <b>Fluent Client</b> search parameter constant for <b>context-quantity</b> 9040 * <p> 9041 * Description: <b>A quantity- or range-valued use context assigned to the capability statement</b><br> 9042 * Type: <b>quantity</b><br> 9043 * Path: <b>CapabilityStatement.useContext.valueQuantity, CapabilityStatement.useContext.valueRange</b><br> 9044 * </p> 9045 */ 9046 public static final ca.uhn.fhir.rest.gclient.QuantityClientParam CONTEXT_QUANTITY = new ca.uhn.fhir.rest.gclient.QuantityClientParam(SP_CONTEXT_QUANTITY); 9047 9048 /** 9049 * Search parameter: <b>security-service</b> 9050 * <p> 9051 * Description: <b>OAuth | SMART-on-FHIR | NTLM | Basic | Kerberos | Certificates</b><br> 9052 * Type: <b>token</b><br> 9053 * Path: <b>CapabilityStatement.rest.security.service</b><br> 9054 * </p> 9055 */ 9056 @SearchParamDefinition(name="security-service", path="CapabilityStatement.rest.security.service", description="OAuth | SMART-on-FHIR | NTLM | Basic | Kerberos | Certificates", type="token" ) 9057 public static final String SP_SECURITY_SERVICE = "security-service"; 9058 /** 9059 * <b>Fluent Client</b> search parameter constant for <b>security-service</b> 9060 * <p> 9061 * Description: <b>OAuth | SMART-on-FHIR | NTLM | Basic | Kerberos | Certificates</b><br> 9062 * Type: <b>token</b><br> 9063 * Path: <b>CapabilityStatement.rest.security.service</b><br> 9064 * </p> 9065 */ 9066 public static final ca.uhn.fhir.rest.gclient.TokenClientParam SECURITY_SERVICE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_SECURITY_SERVICE); 9067 9068 /** 9069 * Search parameter: <b>name</b> 9070 * <p> 9071 * Description: <b>Computationally friendly name of the capability statement</b><br> 9072 * Type: <b>string</b><br> 9073 * Path: <b>CapabilityStatement.name</b><br> 9074 * </p> 9075 */ 9076 @SearchParamDefinition(name="name", path="CapabilityStatement.name", description="Computationally friendly name of the capability statement", type="string" ) 9077 public static final String SP_NAME = "name"; 9078 /** 9079 * <b>Fluent Client</b> search parameter constant for <b>name</b> 9080 * <p> 9081 * Description: <b>Computationally friendly name of the capability statement</b><br> 9082 * Type: <b>string</b><br> 9083 * Path: <b>CapabilityStatement.name</b><br> 9084 * </p> 9085 */ 9086 public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME); 9087 9088 /** 9089 * Search parameter: <b>context</b> 9090 * <p> 9091 * Description: <b>A use context assigned to the capability statement</b><br> 9092 * Type: <b>token</b><br> 9093 * Path: <b>CapabilityStatement.useContext.valueCodeableConcept</b><br> 9094 * </p> 9095 */ 9096 @SearchParamDefinition(name="context", path="(CapabilityStatement.useContext.value as CodeableConcept)", description="A use context assigned to the capability statement", type="token" ) 9097 public static final String SP_CONTEXT = "context"; 9098 /** 9099 * <b>Fluent Client</b> search parameter constant for <b>context</b> 9100 * <p> 9101 * Description: <b>A use context assigned to the capability statement</b><br> 9102 * Type: <b>token</b><br> 9103 * Path: <b>CapabilityStatement.useContext.valueCodeableConcept</b><br> 9104 * </p> 9105 */ 9106 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT); 9107 9108 /** 9109 * Search parameter: <b>publisher</b> 9110 * <p> 9111 * Description: <b>Name of the publisher of the capability statement</b><br> 9112 * Type: <b>string</b><br> 9113 * Path: <b>CapabilityStatement.publisher</b><br> 9114 * </p> 9115 */ 9116 @SearchParamDefinition(name="publisher", path="CapabilityStatement.publisher", description="Name of the publisher of the capability statement", type="string" ) 9117 public static final String SP_PUBLISHER = "publisher"; 9118 /** 9119 * <b>Fluent Client</b> search parameter constant for <b>publisher</b> 9120 * <p> 9121 * Description: <b>Name of the publisher of the capability statement</b><br> 9122 * Type: <b>string</b><br> 9123 * Path: <b>CapabilityStatement.publisher</b><br> 9124 * </p> 9125 */ 9126 public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_PUBLISHER); 9127 9128 /** 9129 * Search parameter: <b>context-type-quantity</b> 9130 * <p> 9131 * Description: <b>A use context type and quantity- or range-based value assigned to the capability statement</b><br> 9132 * Type: <b>composite</b><br> 9133 * Path: <b></b><br> 9134 * </p> 9135 */ 9136 @SearchParamDefinition(name="context-type-quantity", path="CapabilityStatement.useContext", description="A use context type and quantity- or range-based value assigned to the capability statement", type="composite", compositeOf={"context-type", "context-quantity"} ) 9137 public static final String SP_CONTEXT_TYPE_QUANTITY = "context-type-quantity"; 9138 /** 9139 * <b>Fluent Client</b> search parameter constant for <b>context-type-quantity</b> 9140 * <p> 9141 * Description: <b>A use context type and quantity- or range-based value assigned to the capability statement</b><br> 9142 * Type: <b>composite</b><br> 9143 * Path: <b></b><br> 9144 * </p> 9145 */ 9146 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); 9147 9148 /** 9149 * Search parameter: <b>guide</b> 9150 * <p> 9151 * Description: <b>Implementation guides supported</b><br> 9152 * Type: <b>reference</b><br> 9153 * Path: <b>CapabilityStatement.implementationGuide</b><br> 9154 * </p> 9155 */ 9156 @SearchParamDefinition(name="guide", path="CapabilityStatement.implementationGuide", description="Implementation guides supported", type="reference", target={ImplementationGuide.class } ) 9157 public static final String SP_GUIDE = "guide"; 9158 /** 9159 * <b>Fluent Client</b> search parameter constant for <b>guide</b> 9160 * <p> 9161 * Description: <b>Implementation guides supported</b><br> 9162 * Type: <b>reference</b><br> 9163 * Path: <b>CapabilityStatement.implementationGuide</b><br> 9164 * </p> 9165 */ 9166 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam GUIDE = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_GUIDE); 9167 9168/** 9169 * Constant for fluent queries to be used to add include statements. Specifies 9170 * the path value of "<b>CapabilityStatement:guide</b>". 9171 */ 9172 public static final ca.uhn.fhir.model.api.Include INCLUDE_GUIDE = new ca.uhn.fhir.model.api.Include("CapabilityStatement:guide").toLocked(); 9173 9174 /** 9175 * Search parameter: <b>status</b> 9176 * <p> 9177 * Description: <b>The current status of the capability statement</b><br> 9178 * Type: <b>token</b><br> 9179 * Path: <b>CapabilityStatement.status</b><br> 9180 * </p> 9181 */ 9182 @SearchParamDefinition(name="status", path="CapabilityStatement.status", description="The current status of the capability statement", type="token" ) 9183 public static final String SP_STATUS = "status"; 9184 /** 9185 * <b>Fluent Client</b> search parameter constant for <b>status</b> 9186 * <p> 9187 * Description: <b>The current status of the capability statement</b><br> 9188 * Type: <b>token</b><br> 9189 * Path: <b>CapabilityStatement.status</b><br> 9190 * </p> 9191 */ 9192 public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS); 9193 9194 9195}