
001package org.hl7.fhir.r5.model; 002 003 004/* 005 Copyright (c) 2011+, HL7, Inc. 006 All rights reserved. 007 008 Redistribution and use in source and binary forms, with or without modification, \ 009 are permitted provided that the following conditions are met: 010 011 * Redistributions of source code must retain the above copyright notice, this \ 012 list of conditions and the following disclaimer. 013 * Redistributions in binary form must reproduce the above copyright notice, \ 014 this list of conditions and the following disclaimer in the documentation \ 015 and/or other materials provided with the distribution. 016 * Neither the name of HL7 nor the names of its contributors may be used to 017 endorse or promote products derived from this software without specific 018 prior written permission. 019 020 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \ 021 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \ 022 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \ 023 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \ 024 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \ 025 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \ 026 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \ 027 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \ 028 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \ 029 POSSIBILITY OF SUCH DAMAGE. 030 */ 031 032// Generated on Tue, Dec 28, 2021 07:16+1100 for FHIR v5.0.0-snapshot1 033 034import java.util.ArrayList; 035import java.util.Date; 036import java.util.List; 037import org.hl7.fhir.utilities.Utilities; 038import org.hl7.fhir.r5.model.Enumerations.*; 039import org.hl7.fhir.instance.model.api.IBaseBackboneElement; 040import org.hl7.fhir.exceptions.FHIRException; 041import org.hl7.fhir.instance.model.api.ICompositeType; 042import ca.uhn.fhir.model.api.annotation.ResourceDef; 043import ca.uhn.fhir.model.api.annotation.SearchParamDefinition; 044import org.hl7.fhir.instance.model.api.IBaseBackboneElement; 045import ca.uhn.fhir.model.api.annotation.Child; 046import ca.uhn.fhir.model.api.annotation.ChildOrder; 047import ca.uhn.fhir.model.api.annotation.Description; 048import ca.uhn.fhir.model.api.annotation.Block; 049 050/** 051 * 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. 052 */ 053@ResourceDef(name="CapabilityStatement2", profile="http://hl7.org/fhir/StructureDefinition/CapabilityStatement2") 054public class CapabilityStatement2 extends CanonicalResource { 055 056 public enum CapabilityFeature { 057 /** 058 * 059 */ 060 FEATUREHEADER, 061 /** 062 * 063 */ 064 SECURITYCORS, 065 /** 066 * 067 */ 068 SECURITYSERVICE, 069 /** 070 * 071 */ 072 VERSIONING, 073 /** 074 * 075 */ 076 READHISTORY, 077 /** 078 * 079 */ 080 UPDATECREATE, 081 /** 082 * 083 */ 084 CONDITIONALCREATE, 085 /** 086 * 087 */ 088 CONDITIONALREAD, 089 /** 090 * 091 */ 092 CONDITIONALUPDATE, 093 /** 094 * 095 */ 096 CONDITIONALDELETE, 097 /** 098 * 099 */ 100 REFERENCEPOLICY, 101 /** 102 * 103 */ 104 SEARCHINCLUDE, 105 /** 106 * 107 */ 108 SEARCHREVINCLUDE, 109 /** 110 * added to help the parsers with the generic types 111 */ 112 NULL; 113 public static CapabilityFeature fromCode(String codeString) throws FHIRException { 114 if (codeString == null || "".equals(codeString)) 115 return null; 116 if ("feature-header".equals(codeString)) 117 return FEATUREHEADER; 118 if ("security-cors".equals(codeString)) 119 return SECURITYCORS; 120 if ("security-service".equals(codeString)) 121 return SECURITYSERVICE; 122 if ("versioning".equals(codeString)) 123 return VERSIONING; 124 if ("readHistory".equals(codeString)) 125 return READHISTORY; 126 if ("updateCreate".equals(codeString)) 127 return UPDATECREATE; 128 if ("conditionalCreate".equals(codeString)) 129 return CONDITIONALCREATE; 130 if ("conditionalRead".equals(codeString)) 131 return CONDITIONALREAD; 132 if ("conditionalUpdate".equals(codeString)) 133 return CONDITIONALUPDATE; 134 if ("conditionalDelete".equals(codeString)) 135 return CONDITIONALDELETE; 136 if ("referencePolicy".equals(codeString)) 137 return REFERENCEPOLICY; 138 if ("searchInclude".equals(codeString)) 139 return SEARCHINCLUDE; 140 if ("searchRevInclude".equals(codeString)) 141 return SEARCHREVINCLUDE; 142 if (Configuration.isAcceptInvalidEnums()) 143 return null; 144 else 145 throw new FHIRException("Unknown CapabilityFeature code '"+codeString+"'"); 146 } 147 public String toCode() { 148 switch (this) { 149 case FEATUREHEADER: return "feature-header"; 150 case SECURITYCORS: return "security-cors"; 151 case SECURITYSERVICE: return "security-service"; 152 case VERSIONING: return "versioning"; 153 case READHISTORY: return "readHistory"; 154 case UPDATECREATE: return "updateCreate"; 155 case CONDITIONALCREATE: return "conditionalCreate"; 156 case CONDITIONALREAD: return "conditionalRead"; 157 case CONDITIONALUPDATE: return "conditionalUpdate"; 158 case CONDITIONALDELETE: return "conditionalDelete"; 159 case REFERENCEPOLICY: return "referencePolicy"; 160 case SEARCHINCLUDE: return "searchInclude"; 161 case SEARCHREVINCLUDE: return "searchRevInclude"; 162 default: return "?"; 163 } 164 } 165 public String getSystem() { 166 switch (this) { 167 case FEATUREHEADER: return "http://hl7.org/fhir/CodeSystem/capability-features"; 168 case SECURITYCORS: return "http://hl7.org/fhir/CodeSystem/capability-features"; 169 case SECURITYSERVICE: return "http://hl7.org/fhir/CodeSystem/capability-features"; 170 case VERSIONING: return "http://hl7.org/fhir/CodeSystem/capability-features"; 171 case READHISTORY: return "http://hl7.org/fhir/CodeSystem/capability-features"; 172 case UPDATECREATE: return "http://hl7.org/fhir/CodeSystem/capability-features"; 173 case CONDITIONALCREATE: return "http://hl7.org/fhir/CodeSystem/capability-features"; 174 case CONDITIONALREAD: return "http://hl7.org/fhir/CodeSystem/capability-features"; 175 case CONDITIONALUPDATE: return "http://hl7.org/fhir/CodeSystem/capability-features"; 176 case CONDITIONALDELETE: return "http://hl7.org/fhir/CodeSystem/capability-features"; 177 case REFERENCEPOLICY: return "http://hl7.org/fhir/CodeSystem/capability-features"; 178 case SEARCHINCLUDE: return "http://hl7.org/fhir/CodeSystem/capability-features"; 179 case SEARCHREVINCLUDE: return "http://hl7.org/fhir/CodeSystem/capability-features"; 180 default: return "?"; 181 } 182 } 183 public String getDefinition() { 184 switch (this) { 185 case FEATUREHEADER: return ""; 186 case SECURITYCORS: return ""; 187 case SECURITYSERVICE: return ""; 188 case VERSIONING: return ""; 189 case READHISTORY: return ""; 190 case UPDATECREATE: return ""; 191 case CONDITIONALCREATE: return ""; 192 case CONDITIONALREAD: return ""; 193 case CONDITIONALUPDATE: return ""; 194 case CONDITIONALDELETE: return ""; 195 case REFERENCEPOLICY: return ""; 196 case SEARCHINCLUDE: return ""; 197 case SEARCHREVINCLUDE: return ""; 198 default: return "?"; 199 } 200 } 201 public String getDisplay() { 202 switch (this) { 203 case FEATUREHEADER: return "Whether the server supports the Required-Feature header by which a client makes a feature as mandatory for processing a requrest properly"; 204 case SECURITYCORS: return "security-cors"; 205 case SECURITYSERVICE: return "security-service"; 206 case VERSIONING: return "versioning"; 207 case READHISTORY: return "readHistory"; 208 case UPDATECREATE: return "updateCreate"; 209 case CONDITIONALCREATE: return "conditionalCreate"; 210 case CONDITIONALREAD: return "conditionalRead"; 211 case CONDITIONALUPDATE: return "conditionalUpdate"; 212 case CONDITIONALDELETE: return "conditionalDelete"; 213 case REFERENCEPOLICY: return "referencePolicy"; 214 case SEARCHINCLUDE: return "searchInclude"; 215 case SEARCHREVINCLUDE: return "searchRevInclude"; 216 default: return "?"; 217 } 218 } 219 } 220 221 public static class CapabilityFeatureEnumFactory implements EnumFactory<CapabilityFeature> { 222 public CapabilityFeature fromCode(String codeString) throws IllegalArgumentException { 223 if (codeString == null || "".equals(codeString)) 224 if (codeString == null || "".equals(codeString)) 225 return null; 226 if ("feature-header".equals(codeString)) 227 return CapabilityFeature.FEATUREHEADER; 228 if ("security-cors".equals(codeString)) 229 return CapabilityFeature.SECURITYCORS; 230 if ("security-service".equals(codeString)) 231 return CapabilityFeature.SECURITYSERVICE; 232 if ("versioning".equals(codeString)) 233 return CapabilityFeature.VERSIONING; 234 if ("readHistory".equals(codeString)) 235 return CapabilityFeature.READHISTORY; 236 if ("updateCreate".equals(codeString)) 237 return CapabilityFeature.UPDATECREATE; 238 if ("conditionalCreate".equals(codeString)) 239 return CapabilityFeature.CONDITIONALCREATE; 240 if ("conditionalRead".equals(codeString)) 241 return CapabilityFeature.CONDITIONALREAD; 242 if ("conditionalUpdate".equals(codeString)) 243 return CapabilityFeature.CONDITIONALUPDATE; 244 if ("conditionalDelete".equals(codeString)) 245 return CapabilityFeature.CONDITIONALDELETE; 246 if ("referencePolicy".equals(codeString)) 247 return CapabilityFeature.REFERENCEPOLICY; 248 if ("searchInclude".equals(codeString)) 249 return CapabilityFeature.SEARCHINCLUDE; 250 if ("searchRevInclude".equals(codeString)) 251 return CapabilityFeature.SEARCHREVINCLUDE; 252 throw new IllegalArgumentException("Unknown CapabilityFeature code '"+codeString+"'"); 253 } 254 public Enumeration<CapabilityFeature> fromType(Base code) throws FHIRException { 255 if (code == null) 256 return null; 257 if (code.isEmpty()) 258 return new Enumeration<CapabilityFeature>(this); 259 String codeString = ((PrimitiveType) code).asStringValue(); 260 if (codeString == null || "".equals(codeString)) 261 return null; 262 if ("feature-header".equals(codeString)) 263 return new Enumeration<CapabilityFeature>(this, CapabilityFeature.FEATUREHEADER); 264 if ("security-cors".equals(codeString)) 265 return new Enumeration<CapabilityFeature>(this, CapabilityFeature.SECURITYCORS); 266 if ("security-service".equals(codeString)) 267 return new Enumeration<CapabilityFeature>(this, CapabilityFeature.SECURITYSERVICE); 268 if ("versioning".equals(codeString)) 269 return new Enumeration<CapabilityFeature>(this, CapabilityFeature.VERSIONING); 270 if ("readHistory".equals(codeString)) 271 return new Enumeration<CapabilityFeature>(this, CapabilityFeature.READHISTORY); 272 if ("updateCreate".equals(codeString)) 273 return new Enumeration<CapabilityFeature>(this, CapabilityFeature.UPDATECREATE); 274 if ("conditionalCreate".equals(codeString)) 275 return new Enumeration<CapabilityFeature>(this, CapabilityFeature.CONDITIONALCREATE); 276 if ("conditionalRead".equals(codeString)) 277 return new Enumeration<CapabilityFeature>(this, CapabilityFeature.CONDITIONALREAD); 278 if ("conditionalUpdate".equals(codeString)) 279 return new Enumeration<CapabilityFeature>(this, CapabilityFeature.CONDITIONALUPDATE); 280 if ("conditionalDelete".equals(codeString)) 281 return new Enumeration<CapabilityFeature>(this, CapabilityFeature.CONDITIONALDELETE); 282 if ("referencePolicy".equals(codeString)) 283 return new Enumeration<CapabilityFeature>(this, CapabilityFeature.REFERENCEPOLICY); 284 if ("searchInclude".equals(codeString)) 285 return new Enumeration<CapabilityFeature>(this, CapabilityFeature.SEARCHINCLUDE); 286 if ("searchRevInclude".equals(codeString)) 287 return new Enumeration<CapabilityFeature>(this, CapabilityFeature.SEARCHREVINCLUDE); 288 throw new FHIRException("Unknown CapabilityFeature code '"+codeString+"'"); 289 } 290 public String toCode(CapabilityFeature code) { 291 if (code == CapabilityFeature.FEATUREHEADER) 292 return "feature-header"; 293 if (code == CapabilityFeature.SECURITYCORS) 294 return "security-cors"; 295 if (code == CapabilityFeature.SECURITYSERVICE) 296 return "security-service"; 297 if (code == CapabilityFeature.VERSIONING) 298 return "versioning"; 299 if (code == CapabilityFeature.READHISTORY) 300 return "readHistory"; 301 if (code == CapabilityFeature.UPDATECREATE) 302 return "updateCreate"; 303 if (code == CapabilityFeature.CONDITIONALCREATE) 304 return "conditionalCreate"; 305 if (code == CapabilityFeature.CONDITIONALREAD) 306 return "conditionalRead"; 307 if (code == CapabilityFeature.CONDITIONALUPDATE) 308 return "conditionalUpdate"; 309 if (code == CapabilityFeature.CONDITIONALDELETE) 310 return "conditionalDelete"; 311 if (code == CapabilityFeature.REFERENCEPOLICY) 312 return "referencePolicy"; 313 if (code == CapabilityFeature.SEARCHINCLUDE) 314 return "searchInclude"; 315 if (code == CapabilityFeature.SEARCHREVINCLUDE) 316 return "searchRevInclude"; 317 return "?"; 318 } 319 public String toSystem(CapabilityFeature code) { 320 return code.getSystem(); 321 } 322 } 323 324 public enum CapabilityFeatureValue { 325 /** 326 * 327 */ 328 TRUE, 329 /** 330 * 331 */ 332 FALSE, 333 /** 334 * VersionId meta-property is not supported (server) or used (client). 335 */ 336 NOVERSION, 337 /** 338 * VersionId meta-property is supported (server) or used (client). 339 */ 340 VERSIONED, 341 /** 342 * VersionId must be correct for updates (server) or will be specified (If-match header) for updates (client). 343 */ 344 VERSIONEDUPDATE, 345 /** 346 * No support for conditional reads. 347 */ 348 NOTSUPPORTED, 349 /** 350 * Conditional reads are supported, but only with the If-Modified-Since HTTP Header. 351 */ 352 MODIFIEDSINCE, 353 /** 354 * Conditional reads are supported, but only with the If-None-Match HTTP Header. 355 */ 356 NOTMATCH, 357 /** 358 * Conditional reads are supported, with both If-Modified-Since and If-None-Match HTTP Headers. 359 */ 360 FULLSUPPORT, 361 /** 362 * Conditional deletes are supported, but only single resources at a time. 363 */ 364 SINGLE, 365 /** 366 * Conditional deletes are supported, and multiple resources can be deleted in a single interaction. 367 */ 368 MULTIPLE, 369 /** 370 * 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'). 371 */ 372 LITERAL, 373 /** 374 * The server allows logical references (i.e. using Reference.identifier). 375 */ 376 LOGICAL, 377 /** 378 * 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). 379 */ 380 RESOLVES, 381 /** 382 * 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. 383 */ 384 ENFORCED, 385 /** 386 * The server does not support references that point to other servers. 387 */ 388 LOCAL, 389 /** 390 * added to help the parsers with the generic types 391 */ 392 NULL; 393 public static CapabilityFeatureValue fromCode(String codeString) throws FHIRException { 394 if (codeString == null || "".equals(codeString)) 395 return null; 396 if ("true".equals(codeString)) 397 return TRUE; 398 if ("false".equals(codeString)) 399 return FALSE; 400 if ("no-version".equals(codeString)) 401 return NOVERSION; 402 if ("versioned".equals(codeString)) 403 return VERSIONED; 404 if ("versioned-update".equals(codeString)) 405 return VERSIONEDUPDATE; 406 if ("not-supported".equals(codeString)) 407 return NOTSUPPORTED; 408 if ("modified-since".equals(codeString)) 409 return MODIFIEDSINCE; 410 if ("not-match".equals(codeString)) 411 return NOTMATCH; 412 if ("full-support".equals(codeString)) 413 return FULLSUPPORT; 414 if ("single".equals(codeString)) 415 return SINGLE; 416 if ("multiple".equals(codeString)) 417 return MULTIPLE; 418 if ("literal".equals(codeString)) 419 return LITERAL; 420 if ("logical".equals(codeString)) 421 return LOGICAL; 422 if ("resolves".equals(codeString)) 423 return RESOLVES; 424 if ("enforced".equals(codeString)) 425 return ENFORCED; 426 if ("local".equals(codeString)) 427 return LOCAL; 428 if (Configuration.isAcceptInvalidEnums()) 429 return null; 430 else 431 throw new FHIRException("Unknown CapabilityFeatureValue code '"+codeString+"'"); 432 } 433 public String toCode() { 434 switch (this) { 435 case TRUE: return "true"; 436 case FALSE: return "false"; 437 case NOVERSION: return "no-version"; 438 case VERSIONED: return "versioned"; 439 case VERSIONEDUPDATE: return "versioned-update"; 440 case NOTSUPPORTED: return "not-supported"; 441 case MODIFIEDSINCE: return "modified-since"; 442 case NOTMATCH: return "not-match"; 443 case FULLSUPPORT: return "full-support"; 444 case SINGLE: return "single"; 445 case MULTIPLE: return "multiple"; 446 case LITERAL: return "literal"; 447 case LOGICAL: return "logical"; 448 case RESOLVES: return "resolves"; 449 case ENFORCED: return "enforced"; 450 case LOCAL: return "local"; 451 default: return "?"; 452 } 453 } 454 public String getSystem() { 455 switch (this) { 456 case TRUE: return "http://hl7.org/fhir/CodeSystem/capability-features"; 457 case FALSE: return "http://hl7.org/fhir/CodeSystem/capability-features"; 458 case NOVERSION: return "http://hl7.org/fhir/CodeSystem/capability-features"; 459 case VERSIONED: return "http://hl7.org/fhir/CodeSystem/capability-features"; 460 case VERSIONEDUPDATE: return "http://hl7.org/fhir/CodeSystem/capability-features"; 461 case NOTSUPPORTED: return "http://hl7.org/fhir/CodeSystem/capability-features"; 462 case MODIFIEDSINCE: return "http://hl7.org/fhir/CodeSystem/capability-features"; 463 case NOTMATCH: return "http://hl7.org/fhir/CodeSystem/capability-features"; 464 case FULLSUPPORT: return "http://hl7.org/fhir/CodeSystem/capability-features"; 465 case SINGLE: return "http://hl7.org/fhir/CodeSystem/capability-features"; 466 case MULTIPLE: return "http://hl7.org/fhir/CodeSystem/capability-features"; 467 case LITERAL: return "http://hl7.org/fhir/CodeSystem/capability-features"; 468 case LOGICAL: return "http://hl7.org/fhir/CodeSystem/capability-features"; 469 case RESOLVES: return "http://hl7.org/fhir/CodeSystem/capability-features"; 470 case ENFORCED: return "http://hl7.org/fhir/CodeSystem/capability-features"; 471 case LOCAL: return "http://hl7.org/fhir/CodeSystem/capability-features"; 472 default: return "?"; 473 } 474 } 475 public String getDefinition() { 476 switch (this) { 477 case TRUE: return ""; 478 case FALSE: return ""; 479 case NOVERSION: return "VersionId meta-property is not supported (server) or used (client)."; 480 case VERSIONED: return "VersionId meta-property is supported (server) or used (client)."; 481 case VERSIONEDUPDATE: return "VersionId must be correct for updates (server) or will be specified (If-match header) for updates (client)."; 482 case NOTSUPPORTED: return "No support for conditional reads."; 483 case MODIFIEDSINCE: return "Conditional reads are supported, but only with the If-Modified-Since HTTP Header."; 484 case NOTMATCH: return "Conditional reads are supported, but only with the If-None-Match HTTP Header."; 485 case FULLSUPPORT: return "Conditional reads are supported, with both If-Modified-Since and If-None-Match HTTP Headers."; 486 case SINGLE: return "Conditional deletes are supported, but only single resources at a time."; 487 case MULTIPLE: return "Conditional deletes are supported, and multiple resources can be deleted in a single interaction."; 488 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')."; 489 case LOGICAL: return "The server allows logical references (i.e. using Reference.identifier)."; 490 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)."; 491 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."; 492 case LOCAL: return "The server does not support references that point to other servers."; 493 default: return "?"; 494 } 495 } 496 public String getDisplay() { 497 switch (this) { 498 case TRUE: return "Value is true"; 499 case FALSE: return "Value is false"; 500 case NOVERSION: return "No VersionId Support"; 501 case VERSIONED: return "Versioned"; 502 case VERSIONEDUPDATE: return "VersionId tracked fully"; 503 case NOTSUPPORTED: return "Not Supported"; 504 case MODIFIEDSINCE: return "If-Modified-Since"; 505 case NOTMATCH: return "If-None-Match"; 506 case FULLSUPPORT: return "Full Support"; 507 case SINGLE: return "Single Deletes Supported"; 508 case MULTIPLE: return "Multiple Deletes Supported"; 509 case LITERAL: return "Literal References"; 510 case LOGICAL: return "Logical References"; 511 case RESOLVES: return "Resolves References"; 512 case ENFORCED: return "Reference Integrity Enforced"; 513 case LOCAL: return "Local References Only"; 514 default: return "?"; 515 } 516 } 517 } 518 519 public static class CapabilityFeatureValueEnumFactory implements EnumFactory<CapabilityFeatureValue> { 520 public CapabilityFeatureValue fromCode(String codeString) throws IllegalArgumentException { 521 if (codeString == null || "".equals(codeString)) 522 if (codeString == null || "".equals(codeString)) 523 return null; 524 if ("true".equals(codeString)) 525 return CapabilityFeatureValue.TRUE; 526 if ("false".equals(codeString)) 527 return CapabilityFeatureValue.FALSE; 528 if ("no-version".equals(codeString)) 529 return CapabilityFeatureValue.NOVERSION; 530 if ("versioned".equals(codeString)) 531 return CapabilityFeatureValue.VERSIONED; 532 if ("versioned-update".equals(codeString)) 533 return CapabilityFeatureValue.VERSIONEDUPDATE; 534 if ("not-supported".equals(codeString)) 535 return CapabilityFeatureValue.NOTSUPPORTED; 536 if ("modified-since".equals(codeString)) 537 return CapabilityFeatureValue.MODIFIEDSINCE; 538 if ("not-match".equals(codeString)) 539 return CapabilityFeatureValue.NOTMATCH; 540 if ("full-support".equals(codeString)) 541 return CapabilityFeatureValue.FULLSUPPORT; 542 if ("single".equals(codeString)) 543 return CapabilityFeatureValue.SINGLE; 544 if ("multiple".equals(codeString)) 545 return CapabilityFeatureValue.MULTIPLE; 546 if ("literal".equals(codeString)) 547 return CapabilityFeatureValue.LITERAL; 548 if ("logical".equals(codeString)) 549 return CapabilityFeatureValue.LOGICAL; 550 if ("resolves".equals(codeString)) 551 return CapabilityFeatureValue.RESOLVES; 552 if ("enforced".equals(codeString)) 553 return CapabilityFeatureValue.ENFORCED; 554 if ("local".equals(codeString)) 555 return CapabilityFeatureValue.LOCAL; 556 throw new IllegalArgumentException("Unknown CapabilityFeatureValue code '"+codeString+"'"); 557 } 558 public Enumeration<CapabilityFeatureValue> fromType(Base code) throws FHIRException { 559 if (code == null) 560 return null; 561 if (code.isEmpty()) 562 return new Enumeration<CapabilityFeatureValue>(this); 563 String codeString = ((PrimitiveType) code).asStringValue(); 564 if (codeString == null || "".equals(codeString)) 565 return null; 566 if ("true".equals(codeString)) 567 return new Enumeration<CapabilityFeatureValue>(this, CapabilityFeatureValue.TRUE); 568 if ("false".equals(codeString)) 569 return new Enumeration<CapabilityFeatureValue>(this, CapabilityFeatureValue.FALSE); 570 if ("no-version".equals(codeString)) 571 return new Enumeration<CapabilityFeatureValue>(this, CapabilityFeatureValue.NOVERSION); 572 if ("versioned".equals(codeString)) 573 return new Enumeration<CapabilityFeatureValue>(this, CapabilityFeatureValue.VERSIONED); 574 if ("versioned-update".equals(codeString)) 575 return new Enumeration<CapabilityFeatureValue>(this, CapabilityFeatureValue.VERSIONEDUPDATE); 576 if ("not-supported".equals(codeString)) 577 return new Enumeration<CapabilityFeatureValue>(this, CapabilityFeatureValue.NOTSUPPORTED); 578 if ("modified-since".equals(codeString)) 579 return new Enumeration<CapabilityFeatureValue>(this, CapabilityFeatureValue.MODIFIEDSINCE); 580 if ("not-match".equals(codeString)) 581 return new Enumeration<CapabilityFeatureValue>(this, CapabilityFeatureValue.NOTMATCH); 582 if ("full-support".equals(codeString)) 583 return new Enumeration<CapabilityFeatureValue>(this, CapabilityFeatureValue.FULLSUPPORT); 584 if ("single".equals(codeString)) 585 return new Enumeration<CapabilityFeatureValue>(this, CapabilityFeatureValue.SINGLE); 586 if ("multiple".equals(codeString)) 587 return new Enumeration<CapabilityFeatureValue>(this, CapabilityFeatureValue.MULTIPLE); 588 if ("literal".equals(codeString)) 589 return new Enumeration<CapabilityFeatureValue>(this, CapabilityFeatureValue.LITERAL); 590 if ("logical".equals(codeString)) 591 return new Enumeration<CapabilityFeatureValue>(this, CapabilityFeatureValue.LOGICAL); 592 if ("resolves".equals(codeString)) 593 return new Enumeration<CapabilityFeatureValue>(this, CapabilityFeatureValue.RESOLVES); 594 if ("enforced".equals(codeString)) 595 return new Enumeration<CapabilityFeatureValue>(this, CapabilityFeatureValue.ENFORCED); 596 if ("local".equals(codeString)) 597 return new Enumeration<CapabilityFeatureValue>(this, CapabilityFeatureValue.LOCAL); 598 throw new FHIRException("Unknown CapabilityFeatureValue code '"+codeString+"'"); 599 } 600 public String toCode(CapabilityFeatureValue code) { 601 if (code == CapabilityFeatureValue.TRUE) 602 return "true"; 603 if (code == CapabilityFeatureValue.FALSE) 604 return "false"; 605 if (code == CapabilityFeatureValue.NOVERSION) 606 return "no-version"; 607 if (code == CapabilityFeatureValue.VERSIONED) 608 return "versioned"; 609 if (code == CapabilityFeatureValue.VERSIONEDUPDATE) 610 return "versioned-update"; 611 if (code == CapabilityFeatureValue.NOTSUPPORTED) 612 return "not-supported"; 613 if (code == CapabilityFeatureValue.MODIFIEDSINCE) 614 return "modified-since"; 615 if (code == CapabilityFeatureValue.NOTMATCH) 616 return "not-match"; 617 if (code == CapabilityFeatureValue.FULLSUPPORT) 618 return "full-support"; 619 if (code == CapabilityFeatureValue.SINGLE) 620 return "single"; 621 if (code == CapabilityFeatureValue.MULTIPLE) 622 return "multiple"; 623 if (code == CapabilityFeatureValue.LITERAL) 624 return "literal"; 625 if (code == CapabilityFeatureValue.LOGICAL) 626 return "logical"; 627 if (code == CapabilityFeatureValue.RESOLVES) 628 return "resolves"; 629 if (code == CapabilityFeatureValue.ENFORCED) 630 return "enforced"; 631 if (code == CapabilityFeatureValue.LOCAL) 632 return "local"; 633 return "?"; 634 } 635 public String toSystem(CapabilityFeatureValue code) { 636 return code.getSystem(); 637 } 638 } 639 640 public enum SystemRestfulInteraction { 641 /** 642 * Update, create or delete a set of resources as a single transaction. 643 */ 644 TRANSACTION, 645 /** 646 * perform a set of a separate interactions in a single http operation 647 */ 648 BATCH, 649 /** 650 * Search all resources based on some filter criteria. 651 */ 652 SEARCHSYSTEM, 653 /** 654 * Retrieve the change history for all resources on a system. 655 */ 656 HISTORYSYSTEM, 657 /** 658 * added to help the parsers with the generic types 659 */ 660 NULL; 661 public static SystemRestfulInteraction fromCode(String codeString) throws FHIRException { 662 if (codeString == null || "".equals(codeString)) 663 return null; 664 if ("transaction".equals(codeString)) 665 return TRANSACTION; 666 if ("batch".equals(codeString)) 667 return BATCH; 668 if ("search-system".equals(codeString)) 669 return SEARCHSYSTEM; 670 if ("history-system".equals(codeString)) 671 return HISTORYSYSTEM; 672 if (Configuration.isAcceptInvalidEnums()) 673 return null; 674 else 675 throw new FHIRException("Unknown SystemRestfulInteraction code '"+codeString+"'"); 676 } 677 public String toCode() { 678 switch (this) { 679 case TRANSACTION: return "transaction"; 680 case BATCH: return "batch"; 681 case SEARCHSYSTEM: return "search-system"; 682 case HISTORYSYSTEM: return "history-system"; 683 default: return "?"; 684 } 685 } 686 public String getSystem() { 687 switch (this) { 688 case TRANSACTION: return "http://hl7.org/fhir/restful-interaction"; 689 case BATCH: return "http://hl7.org/fhir/restful-interaction"; 690 case SEARCHSYSTEM: return "http://hl7.org/fhir/restful-interaction"; 691 case HISTORYSYSTEM: return "http://hl7.org/fhir/restful-interaction"; 692 default: return "?"; 693 } 694 } 695 public String getDefinition() { 696 switch (this) { 697 case TRANSACTION: return "Update, create or delete a set of resources as a single transaction."; 698 case BATCH: return "perform a set of a separate interactions in a single http operation"; 699 case SEARCHSYSTEM: return "Search all resources based on some filter criteria."; 700 case HISTORYSYSTEM: return "Retrieve the change history for all resources on a system."; 701 default: return "?"; 702 } 703 } 704 public String getDisplay() { 705 switch (this) { 706 case TRANSACTION: return "transaction"; 707 case BATCH: return "batch"; 708 case SEARCHSYSTEM: return "search-system"; 709 case HISTORYSYSTEM: return "history-system"; 710 default: return "?"; 711 } 712 } 713 } 714 715 public static class SystemRestfulInteractionEnumFactory implements EnumFactory<SystemRestfulInteraction> { 716 public SystemRestfulInteraction fromCode(String codeString) throws IllegalArgumentException { 717 if (codeString == null || "".equals(codeString)) 718 if (codeString == null || "".equals(codeString)) 719 return null; 720 if ("transaction".equals(codeString)) 721 return SystemRestfulInteraction.TRANSACTION; 722 if ("batch".equals(codeString)) 723 return SystemRestfulInteraction.BATCH; 724 if ("search-system".equals(codeString)) 725 return SystemRestfulInteraction.SEARCHSYSTEM; 726 if ("history-system".equals(codeString)) 727 return SystemRestfulInteraction.HISTORYSYSTEM; 728 throw new IllegalArgumentException("Unknown SystemRestfulInteraction code '"+codeString+"'"); 729 } 730 public Enumeration<SystemRestfulInteraction> fromType(Base code) throws FHIRException { 731 if (code == null) 732 return null; 733 if (code.isEmpty()) 734 return new Enumeration<SystemRestfulInteraction>(this); 735 String codeString = ((PrimitiveType) code).asStringValue(); 736 if (codeString == null || "".equals(codeString)) 737 return null; 738 if ("transaction".equals(codeString)) 739 return new Enumeration<SystemRestfulInteraction>(this, SystemRestfulInteraction.TRANSACTION); 740 if ("batch".equals(codeString)) 741 return new Enumeration<SystemRestfulInteraction>(this, SystemRestfulInteraction.BATCH); 742 if ("search-system".equals(codeString)) 743 return new Enumeration<SystemRestfulInteraction>(this, SystemRestfulInteraction.SEARCHSYSTEM); 744 if ("history-system".equals(codeString)) 745 return new Enumeration<SystemRestfulInteraction>(this, SystemRestfulInteraction.HISTORYSYSTEM); 746 throw new FHIRException("Unknown SystemRestfulInteraction code '"+codeString+"'"); 747 } 748 public String toCode(SystemRestfulInteraction code) { 749 if (code == SystemRestfulInteraction.TRANSACTION) 750 return "transaction"; 751 if (code == SystemRestfulInteraction.BATCH) 752 return "batch"; 753 if (code == SystemRestfulInteraction.SEARCHSYSTEM) 754 return "search-system"; 755 if (code == SystemRestfulInteraction.HISTORYSYSTEM) 756 return "history-system"; 757 return "?"; 758 } 759 public String toSystem(SystemRestfulInteraction code) { 760 return code.getSystem(); 761 } 762 } 763 764 public enum TypeRestfulInteraction { 765 /** 766 * Read the current state of the resource. 767 */ 768 READ, 769 /** 770 * Read the state of a specific version of the resource. 771 */ 772 VREAD, 773 /** 774 * Update an existing resource by its id (or create it if it is new). 775 */ 776 UPDATE, 777 /** 778 * Update an existing resource by posting a set of changes to it. 779 */ 780 PATCH, 781 /** 782 * Delete a resource. 783 */ 784 DELETE, 785 /** 786 * Retrieve the change history for a particular resource. 787 */ 788 HISTORYINSTANCE, 789 /** 790 * Retrieve the change history for all resources of a particular type. 791 */ 792 HISTORYTYPE, 793 /** 794 * Create a new resource with a server assigned id. 795 */ 796 CREATE, 797 /** 798 * Search all resources of the specified type based on some filter criteria. 799 */ 800 SEARCHTYPE, 801 /** 802 * added to help the parsers with the generic types 803 */ 804 NULL; 805 public static TypeRestfulInteraction fromCode(String codeString) throws FHIRException { 806 if (codeString == null || "".equals(codeString)) 807 return null; 808 if ("read".equals(codeString)) 809 return READ; 810 if ("vread".equals(codeString)) 811 return VREAD; 812 if ("update".equals(codeString)) 813 return UPDATE; 814 if ("patch".equals(codeString)) 815 return PATCH; 816 if ("delete".equals(codeString)) 817 return DELETE; 818 if ("history-instance".equals(codeString)) 819 return HISTORYINSTANCE; 820 if ("history-type".equals(codeString)) 821 return HISTORYTYPE; 822 if ("create".equals(codeString)) 823 return CREATE; 824 if ("search-type".equals(codeString)) 825 return SEARCHTYPE; 826 if (Configuration.isAcceptInvalidEnums()) 827 return null; 828 else 829 throw new FHIRException("Unknown TypeRestfulInteraction code '"+codeString+"'"); 830 } 831 public String toCode() { 832 switch (this) { 833 case READ: return "read"; 834 case VREAD: return "vread"; 835 case UPDATE: return "update"; 836 case PATCH: return "patch"; 837 case DELETE: return "delete"; 838 case HISTORYINSTANCE: return "history-instance"; 839 case HISTORYTYPE: return "history-type"; 840 case CREATE: return "create"; 841 case SEARCHTYPE: return "search-type"; 842 default: return "?"; 843 } 844 } 845 public String getSystem() { 846 switch (this) { 847 case READ: return "http://hl7.org/fhir/restful-interaction"; 848 case VREAD: return "http://hl7.org/fhir/restful-interaction"; 849 case UPDATE: return "http://hl7.org/fhir/restful-interaction"; 850 case PATCH: return "http://hl7.org/fhir/restful-interaction"; 851 case DELETE: return "http://hl7.org/fhir/restful-interaction"; 852 case HISTORYINSTANCE: return "http://hl7.org/fhir/restful-interaction"; 853 case HISTORYTYPE: return "http://hl7.org/fhir/restful-interaction"; 854 case CREATE: return "http://hl7.org/fhir/restful-interaction"; 855 case SEARCHTYPE: return "http://hl7.org/fhir/restful-interaction"; 856 default: return "?"; 857 } 858 } 859 public String getDefinition() { 860 switch (this) { 861 case READ: return "Read the current state of the resource."; 862 case VREAD: return "Read the state of a specific version of the resource."; 863 case UPDATE: return "Update an existing resource by its id (or create it if it is new)."; 864 case PATCH: return "Update an existing resource by posting a set of changes to it."; 865 case DELETE: return "Delete a resource."; 866 case HISTORYINSTANCE: return "Retrieve the change history for a particular resource."; 867 case HISTORYTYPE: return "Retrieve the change history for all resources of a particular type."; 868 case CREATE: return "Create a new resource with a server assigned id."; 869 case SEARCHTYPE: return "Search all resources of the specified type based on some filter criteria."; 870 default: return "?"; 871 } 872 } 873 public String getDisplay() { 874 switch (this) { 875 case READ: return "read"; 876 case VREAD: return "vread"; 877 case UPDATE: return "update"; 878 case PATCH: return "patch"; 879 case DELETE: return "delete"; 880 case HISTORYINSTANCE: return "history-instance"; 881 case HISTORYTYPE: return "history-type"; 882 case CREATE: return "create"; 883 case SEARCHTYPE: return "search-type"; 884 default: return "?"; 885 } 886 } 887 } 888 889 public static class TypeRestfulInteractionEnumFactory implements EnumFactory<TypeRestfulInteraction> { 890 public TypeRestfulInteraction fromCode(String codeString) throws IllegalArgumentException { 891 if (codeString == null || "".equals(codeString)) 892 if (codeString == null || "".equals(codeString)) 893 return null; 894 if ("read".equals(codeString)) 895 return TypeRestfulInteraction.READ; 896 if ("vread".equals(codeString)) 897 return TypeRestfulInteraction.VREAD; 898 if ("update".equals(codeString)) 899 return TypeRestfulInteraction.UPDATE; 900 if ("patch".equals(codeString)) 901 return TypeRestfulInteraction.PATCH; 902 if ("delete".equals(codeString)) 903 return TypeRestfulInteraction.DELETE; 904 if ("history-instance".equals(codeString)) 905 return TypeRestfulInteraction.HISTORYINSTANCE; 906 if ("history-type".equals(codeString)) 907 return TypeRestfulInteraction.HISTORYTYPE; 908 if ("create".equals(codeString)) 909 return TypeRestfulInteraction.CREATE; 910 if ("search-type".equals(codeString)) 911 return TypeRestfulInteraction.SEARCHTYPE; 912 throw new IllegalArgumentException("Unknown TypeRestfulInteraction code '"+codeString+"'"); 913 } 914 public Enumeration<TypeRestfulInteraction> fromType(Base code) throws FHIRException { 915 if (code == null) 916 return null; 917 if (code.isEmpty()) 918 return new Enumeration<TypeRestfulInteraction>(this); 919 String codeString = ((PrimitiveType) code).asStringValue(); 920 if (codeString == null || "".equals(codeString)) 921 return null; 922 if ("read".equals(codeString)) 923 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.READ); 924 if ("vread".equals(codeString)) 925 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.VREAD); 926 if ("update".equals(codeString)) 927 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.UPDATE); 928 if ("patch".equals(codeString)) 929 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.PATCH); 930 if ("delete".equals(codeString)) 931 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.DELETE); 932 if ("history-instance".equals(codeString)) 933 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.HISTORYINSTANCE); 934 if ("history-type".equals(codeString)) 935 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.HISTORYTYPE); 936 if ("create".equals(codeString)) 937 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.CREATE); 938 if ("search-type".equals(codeString)) 939 return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.SEARCHTYPE); 940 throw new FHIRException("Unknown TypeRestfulInteraction code '"+codeString+"'"); 941 } 942 public String toCode(TypeRestfulInteraction code) { 943 if (code == TypeRestfulInteraction.READ) 944 return "read"; 945 if (code == TypeRestfulInteraction.VREAD) 946 return "vread"; 947 if (code == TypeRestfulInteraction.UPDATE) 948 return "update"; 949 if (code == TypeRestfulInteraction.PATCH) 950 return "patch"; 951 if (code == TypeRestfulInteraction.DELETE) 952 return "delete"; 953 if (code == TypeRestfulInteraction.HISTORYINSTANCE) 954 return "history-instance"; 955 if (code == TypeRestfulInteraction.HISTORYTYPE) 956 return "history-type"; 957 if (code == TypeRestfulInteraction.CREATE) 958 return "create"; 959 if (code == TypeRestfulInteraction.SEARCHTYPE) 960 return "search-type"; 961 return "?"; 962 } 963 public String toSystem(TypeRestfulInteraction code) { 964 return code.getSystem(); 965 } 966 } 967 968 @Block() 969 public static class CapabilityStatement2SoftwareComponent extends BackboneElement implements IBaseBackboneElement { 970 /** 971 * Name the software is known by. 972 */ 973 @Child(name = "name", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true) 974 @Description(shortDefinition="A name the software is known by", formalDefinition="Name the software is known by." ) 975 protected StringType name; 976 977 /** 978 * The version identifier for the software covered by this statement. 979 */ 980 @Child(name = "version", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true) 981 @Description(shortDefinition="Version covered by this statement", formalDefinition="The version identifier for the software covered by this statement." ) 982 protected StringType version; 983 984 /** 985 * Date this version of the software was released. 986 */ 987 @Child(name = "releaseDate", type = {DateTimeType.class}, order=3, min=0, max=1, modifier=false, summary=true) 988 @Description(shortDefinition="Date this version was released", formalDefinition="Date this version of the software was released." ) 989 protected DateTimeType releaseDate; 990 991 private static final long serialVersionUID = 1819769027L; 992 993 /** 994 * Constructor 995 */ 996 public CapabilityStatement2SoftwareComponent() { 997 super(); 998 } 999 1000 /** 1001 * Constructor 1002 */ 1003 public CapabilityStatement2SoftwareComponent(String name) { 1004 super(); 1005 this.setName(name); 1006 } 1007 1008 /** 1009 * @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 1010 */ 1011 public StringType getNameElement() { 1012 if (this.name == null) 1013 if (Configuration.errorOnAutoCreate()) 1014 throw new Error("Attempt to auto-create CapabilityStatement2SoftwareComponent.name"); 1015 else if (Configuration.doAutoCreate()) 1016 this.name = new StringType(); // bb 1017 return this.name; 1018 } 1019 1020 public boolean hasNameElement() { 1021 return this.name != null && !this.name.isEmpty(); 1022 } 1023 1024 public boolean hasName() { 1025 return this.name != null && !this.name.isEmpty(); 1026 } 1027 1028 /** 1029 * @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 1030 */ 1031 public CapabilityStatement2SoftwareComponent setNameElement(StringType value) { 1032 this.name = value; 1033 return this; 1034 } 1035 1036 /** 1037 * @return Name the software is known by. 1038 */ 1039 public String getName() { 1040 return this.name == null ? null : this.name.getValue(); 1041 } 1042 1043 /** 1044 * @param value Name the software is known by. 1045 */ 1046 public CapabilityStatement2SoftwareComponent setName(String value) { 1047 if (this.name == null) 1048 this.name = new StringType(); 1049 this.name.setValue(value); 1050 return this; 1051 } 1052 1053 /** 1054 * @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 1055 */ 1056 public StringType getVersionElement() { 1057 if (this.version == null) 1058 if (Configuration.errorOnAutoCreate()) 1059 throw new Error("Attempt to auto-create CapabilityStatement2SoftwareComponent.version"); 1060 else if (Configuration.doAutoCreate()) 1061 this.version = new StringType(); // bb 1062 return this.version; 1063 } 1064 1065 public boolean hasVersionElement() { 1066 return this.version != null && !this.version.isEmpty(); 1067 } 1068 1069 public boolean hasVersion() { 1070 return this.version != null && !this.version.isEmpty(); 1071 } 1072 1073 /** 1074 * @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 1075 */ 1076 public CapabilityStatement2SoftwareComponent setVersionElement(StringType value) { 1077 this.version = value; 1078 return this; 1079 } 1080 1081 /** 1082 * @return The version identifier for the software covered by this statement. 1083 */ 1084 public String getVersion() { 1085 return this.version == null ? null : this.version.getValue(); 1086 } 1087 1088 /** 1089 * @param value The version identifier for the software covered by this statement. 1090 */ 1091 public CapabilityStatement2SoftwareComponent setVersion(String value) { 1092 if (Utilities.noString(value)) 1093 this.version = null; 1094 else { 1095 if (this.version == null) 1096 this.version = new StringType(); 1097 this.version.setValue(value); 1098 } 1099 return this; 1100 } 1101 1102 /** 1103 * @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 1104 */ 1105 public DateTimeType getReleaseDateElement() { 1106 if (this.releaseDate == null) 1107 if (Configuration.errorOnAutoCreate()) 1108 throw new Error("Attempt to auto-create CapabilityStatement2SoftwareComponent.releaseDate"); 1109 else if (Configuration.doAutoCreate()) 1110 this.releaseDate = new DateTimeType(); // bb 1111 return this.releaseDate; 1112 } 1113 1114 public boolean hasReleaseDateElement() { 1115 return this.releaseDate != null && !this.releaseDate.isEmpty(); 1116 } 1117 1118 public boolean hasReleaseDate() { 1119 return this.releaseDate != null && !this.releaseDate.isEmpty(); 1120 } 1121 1122 /** 1123 * @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 1124 */ 1125 public CapabilityStatement2SoftwareComponent setReleaseDateElement(DateTimeType value) { 1126 this.releaseDate = value; 1127 return this; 1128 } 1129 1130 /** 1131 * @return Date this version of the software was released. 1132 */ 1133 public Date getReleaseDate() { 1134 return this.releaseDate == null ? null : this.releaseDate.getValue(); 1135 } 1136 1137 /** 1138 * @param value Date this version of the software was released. 1139 */ 1140 public CapabilityStatement2SoftwareComponent setReleaseDate(Date value) { 1141 if (value == null) 1142 this.releaseDate = null; 1143 else { 1144 if (this.releaseDate == null) 1145 this.releaseDate = new DateTimeType(); 1146 this.releaseDate.setValue(value); 1147 } 1148 return this; 1149 } 1150 1151 protected void listChildren(List<Property> children) { 1152 super.listChildren(children); 1153 children.add(new Property("name", "string", "Name the software is known by.", 0, 1, name)); 1154 children.add(new Property("version", "string", "The version identifier for the software covered by this statement.", 0, 1, version)); 1155 children.add(new Property("releaseDate", "dateTime", "Date this version of the software was released.", 0, 1, releaseDate)); 1156 } 1157 1158 @Override 1159 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1160 switch (_hash) { 1161 case 3373707: /*name*/ return new Property("name", "string", "Name the software is known by.", 0, 1, name); 1162 case 351608024: /*version*/ return new Property("version", "string", "The version identifier for the software covered by this statement.", 0, 1, version); 1163 case 212873301: /*releaseDate*/ return new Property("releaseDate", "dateTime", "Date this version of the software was released.", 0, 1, releaseDate); 1164 default: return super.getNamedProperty(_hash, _name, _checkValid); 1165 } 1166 1167 } 1168 1169 @Override 1170 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1171 switch (hash) { 1172 case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType 1173 case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType 1174 case 212873301: /*releaseDate*/ return this.releaseDate == null ? new Base[0] : new Base[] {this.releaseDate}; // DateTimeType 1175 default: return super.getProperty(hash, name, checkValid); 1176 } 1177 1178 } 1179 1180 @Override 1181 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1182 switch (hash) { 1183 case 3373707: // name 1184 this.name = TypeConvertor.castToString(value); // StringType 1185 return value; 1186 case 351608024: // version 1187 this.version = TypeConvertor.castToString(value); // StringType 1188 return value; 1189 case 212873301: // releaseDate 1190 this.releaseDate = TypeConvertor.castToDateTime(value); // DateTimeType 1191 return value; 1192 default: return super.setProperty(hash, name, value); 1193 } 1194 1195 } 1196 1197 @Override 1198 public Base setProperty(String name, Base value) throws FHIRException { 1199 if (name.equals("name")) { 1200 this.name = TypeConvertor.castToString(value); // StringType 1201 } else if (name.equals("version")) { 1202 this.version = TypeConvertor.castToString(value); // StringType 1203 } else if (name.equals("releaseDate")) { 1204 this.releaseDate = TypeConvertor.castToDateTime(value); // DateTimeType 1205 } else 1206 return super.setProperty(name, value); 1207 return value; 1208 } 1209 1210 @Override 1211 public Base makeProperty(int hash, String name) throws FHIRException { 1212 switch (hash) { 1213 case 3373707: return getNameElement(); 1214 case 351608024: return getVersionElement(); 1215 case 212873301: return getReleaseDateElement(); 1216 default: return super.makeProperty(hash, name); 1217 } 1218 1219 } 1220 1221 @Override 1222 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1223 switch (hash) { 1224 case 3373707: /*name*/ return new String[] {"string"}; 1225 case 351608024: /*version*/ return new String[] {"string"}; 1226 case 212873301: /*releaseDate*/ return new String[] {"dateTime"}; 1227 default: return super.getTypesForProperty(hash, name); 1228 } 1229 1230 } 1231 1232 @Override 1233 public Base addChild(String name) throws FHIRException { 1234 if (name.equals("name")) { 1235 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.software.name"); 1236 } 1237 else if (name.equals("version")) { 1238 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.software.version"); 1239 } 1240 else if (name.equals("releaseDate")) { 1241 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.software.releaseDate"); 1242 } 1243 else 1244 return super.addChild(name); 1245 } 1246 1247 public CapabilityStatement2SoftwareComponent copy() { 1248 CapabilityStatement2SoftwareComponent dst = new CapabilityStatement2SoftwareComponent(); 1249 copyValues(dst); 1250 return dst; 1251 } 1252 1253 public void copyValues(CapabilityStatement2SoftwareComponent dst) { 1254 super.copyValues(dst); 1255 dst.name = name == null ? null : name.copy(); 1256 dst.version = version == null ? null : version.copy(); 1257 dst.releaseDate = releaseDate == null ? null : releaseDate.copy(); 1258 } 1259 1260 @Override 1261 public boolean equalsDeep(Base other_) { 1262 if (!super.equalsDeep(other_)) 1263 return false; 1264 if (!(other_ instanceof CapabilityStatement2SoftwareComponent)) 1265 return false; 1266 CapabilityStatement2SoftwareComponent o = (CapabilityStatement2SoftwareComponent) other_; 1267 return compareDeep(name, o.name, true) && compareDeep(version, o.version, true) && compareDeep(releaseDate, o.releaseDate, true) 1268 ; 1269 } 1270 1271 @Override 1272 public boolean equalsShallow(Base other_) { 1273 if (!super.equalsShallow(other_)) 1274 return false; 1275 if (!(other_ instanceof CapabilityStatement2SoftwareComponent)) 1276 return false; 1277 CapabilityStatement2SoftwareComponent o = (CapabilityStatement2SoftwareComponent) other_; 1278 return compareValues(name, o.name, true) && compareValues(version, o.version, true) && compareValues(releaseDate, o.releaseDate, true) 1279 ; 1280 } 1281 1282 public boolean isEmpty() { 1283 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, version, releaseDate 1284 ); 1285 } 1286 1287 public String fhirType() { 1288 return "CapabilityStatement2.software"; 1289 1290 } 1291 1292 } 1293 1294 @Block() 1295 public static class CapabilityStatement2ImplementationComponent extends BackboneElement implements IBaseBackboneElement { 1296 /** 1297 * Information about the specific installation that this capability statement relates to. 1298 */ 1299 @Child(name = "description", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true) 1300 @Description(shortDefinition="Describes this specific instance", formalDefinition="Information about the specific installation that this capability statement relates to." ) 1301 protected StringType description; 1302 1303 /** 1304 * An absolute base URL for the implementation. This forms the base for REST interfaces as well as the mailbox and document interfaces. 1305 */ 1306 @Child(name = "url", type = {UrlType.class}, order=2, min=0, max=1, modifier=false, summary=true) 1307 @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." ) 1308 protected UrlType url; 1309 1310 /** 1311 * The organization responsible for the management of the instance and oversight of the data on the server at the specified URL. 1312 */ 1313 @Child(name = "custodian", type = {Organization.class}, order=3, min=0, max=1, modifier=false, summary=true) 1314 @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." ) 1315 protected Reference custodian; 1316 1317 private static final long serialVersionUID = 1681322786L; 1318 1319 /** 1320 * Constructor 1321 */ 1322 public CapabilityStatement2ImplementationComponent() { 1323 super(); 1324 } 1325 1326 /** 1327 * Constructor 1328 */ 1329 public CapabilityStatement2ImplementationComponent(String description) { 1330 super(); 1331 this.setDescription(description); 1332 } 1333 1334 /** 1335 * @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 1336 */ 1337 public StringType getDescriptionElement() { 1338 if (this.description == null) 1339 if (Configuration.errorOnAutoCreate()) 1340 throw new Error("Attempt to auto-create CapabilityStatement2ImplementationComponent.description"); 1341 else if (Configuration.doAutoCreate()) 1342 this.description = new StringType(); // bb 1343 return this.description; 1344 } 1345 1346 public boolean hasDescriptionElement() { 1347 return this.description != null && !this.description.isEmpty(); 1348 } 1349 1350 public boolean hasDescription() { 1351 return this.description != null && !this.description.isEmpty(); 1352 } 1353 1354 /** 1355 * @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 1356 */ 1357 public CapabilityStatement2ImplementationComponent setDescriptionElement(StringType value) { 1358 this.description = value; 1359 return this; 1360 } 1361 1362 /** 1363 * @return Information about the specific installation that this capability statement relates to. 1364 */ 1365 public String getDescription() { 1366 return this.description == null ? null : this.description.getValue(); 1367 } 1368 1369 /** 1370 * @param value Information about the specific installation that this capability statement relates to. 1371 */ 1372 public CapabilityStatement2ImplementationComponent setDescription(String value) { 1373 if (this.description == null) 1374 this.description = new StringType(); 1375 this.description.setValue(value); 1376 return this; 1377 } 1378 1379 /** 1380 * @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 1381 */ 1382 public UrlType getUrlElement() { 1383 if (this.url == null) 1384 if (Configuration.errorOnAutoCreate()) 1385 throw new Error("Attempt to auto-create CapabilityStatement2ImplementationComponent.url"); 1386 else if (Configuration.doAutoCreate()) 1387 this.url = new UrlType(); // bb 1388 return this.url; 1389 } 1390 1391 public boolean hasUrlElement() { 1392 return this.url != null && !this.url.isEmpty(); 1393 } 1394 1395 public boolean hasUrl() { 1396 return this.url != null && !this.url.isEmpty(); 1397 } 1398 1399 /** 1400 * @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 1401 */ 1402 public CapabilityStatement2ImplementationComponent setUrlElement(UrlType value) { 1403 this.url = value; 1404 return this; 1405 } 1406 1407 /** 1408 * @return An absolute base URL for the implementation. This forms the base for REST interfaces as well as the mailbox and document interfaces. 1409 */ 1410 public String getUrl() { 1411 return this.url == null ? null : this.url.getValue(); 1412 } 1413 1414 /** 1415 * @param value An absolute base URL for the implementation. This forms the base for REST interfaces as well as the mailbox and document interfaces. 1416 */ 1417 public CapabilityStatement2ImplementationComponent setUrl(String value) { 1418 if (Utilities.noString(value)) 1419 this.url = null; 1420 else { 1421 if (this.url == null) 1422 this.url = new UrlType(); 1423 this.url.setValue(value); 1424 } 1425 return this; 1426 } 1427 1428 /** 1429 * @return {@link #custodian} (The organization responsible for the management of the instance and oversight of the data on the server at the specified URL.) 1430 */ 1431 public Reference getCustodian() { 1432 if (this.custodian == null) 1433 if (Configuration.errorOnAutoCreate()) 1434 throw new Error("Attempt to auto-create CapabilityStatement2ImplementationComponent.custodian"); 1435 else if (Configuration.doAutoCreate()) 1436 this.custodian = new Reference(); // cc 1437 return this.custodian; 1438 } 1439 1440 public boolean hasCustodian() { 1441 return this.custodian != null && !this.custodian.isEmpty(); 1442 } 1443 1444 /** 1445 * @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.) 1446 */ 1447 public CapabilityStatement2ImplementationComponent setCustodian(Reference value) { 1448 this.custodian = value; 1449 return this; 1450 } 1451 1452 protected void listChildren(List<Property> children) { 1453 super.listChildren(children); 1454 children.add(new Property("description", "string", "Information about the specific installation that this capability statement relates to.", 0, 1, description)); 1455 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)); 1456 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)); 1457 } 1458 1459 @Override 1460 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 1461 switch (_hash) { 1462 case -1724546052: /*description*/ return new Property("description", "string", "Information about the specific installation that this capability statement relates to.", 0, 1, description); 1463 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); 1464 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); 1465 default: return super.getNamedProperty(_hash, _name, _checkValid); 1466 } 1467 1468 } 1469 1470 @Override 1471 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 1472 switch (hash) { 1473 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType 1474 case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UrlType 1475 case 1611297262: /*custodian*/ return this.custodian == null ? new Base[0] : new Base[] {this.custodian}; // Reference 1476 default: return super.getProperty(hash, name, checkValid); 1477 } 1478 1479 } 1480 1481 @Override 1482 public Base setProperty(int hash, String name, Base value) throws FHIRException { 1483 switch (hash) { 1484 case -1724546052: // description 1485 this.description = TypeConvertor.castToString(value); // StringType 1486 return value; 1487 case 116079: // url 1488 this.url = TypeConvertor.castToUrl(value); // UrlType 1489 return value; 1490 case 1611297262: // custodian 1491 this.custodian = TypeConvertor.castToReference(value); // Reference 1492 return value; 1493 default: return super.setProperty(hash, name, value); 1494 } 1495 1496 } 1497 1498 @Override 1499 public Base setProperty(String name, Base value) throws FHIRException { 1500 if (name.equals("description")) { 1501 this.description = TypeConvertor.castToString(value); // StringType 1502 } else if (name.equals("url")) { 1503 this.url = TypeConvertor.castToUrl(value); // UrlType 1504 } else if (name.equals("custodian")) { 1505 this.custodian = TypeConvertor.castToReference(value); // Reference 1506 } else 1507 return super.setProperty(name, value); 1508 return value; 1509 } 1510 1511 @Override 1512 public Base makeProperty(int hash, String name) throws FHIRException { 1513 switch (hash) { 1514 case -1724546052: return getDescriptionElement(); 1515 case 116079: return getUrlElement(); 1516 case 1611297262: return getCustodian(); 1517 default: return super.makeProperty(hash, name); 1518 } 1519 1520 } 1521 1522 @Override 1523 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 1524 switch (hash) { 1525 case -1724546052: /*description*/ return new String[] {"string"}; 1526 case 116079: /*url*/ return new String[] {"url"}; 1527 case 1611297262: /*custodian*/ return new String[] {"Reference"}; 1528 default: return super.getTypesForProperty(hash, name); 1529 } 1530 1531 } 1532 1533 @Override 1534 public Base addChild(String name) throws FHIRException { 1535 if (name.equals("description")) { 1536 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.implementation.description"); 1537 } 1538 else if (name.equals("url")) { 1539 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.implementation.url"); 1540 } 1541 else if (name.equals("custodian")) { 1542 this.custodian = new Reference(); 1543 return this.custodian; 1544 } 1545 else 1546 return super.addChild(name); 1547 } 1548 1549 public CapabilityStatement2ImplementationComponent copy() { 1550 CapabilityStatement2ImplementationComponent dst = new CapabilityStatement2ImplementationComponent(); 1551 copyValues(dst); 1552 return dst; 1553 } 1554 1555 public void copyValues(CapabilityStatement2ImplementationComponent dst) { 1556 super.copyValues(dst); 1557 dst.description = description == null ? null : description.copy(); 1558 dst.url = url == null ? null : url.copy(); 1559 dst.custodian = custodian == null ? null : custodian.copy(); 1560 } 1561 1562 @Override 1563 public boolean equalsDeep(Base other_) { 1564 if (!super.equalsDeep(other_)) 1565 return false; 1566 if (!(other_ instanceof CapabilityStatement2ImplementationComponent)) 1567 return false; 1568 CapabilityStatement2ImplementationComponent o = (CapabilityStatement2ImplementationComponent) other_; 1569 return compareDeep(description, o.description, true) && compareDeep(url, o.url, true) && compareDeep(custodian, o.custodian, true) 1570 ; 1571 } 1572 1573 @Override 1574 public boolean equalsShallow(Base other_) { 1575 if (!super.equalsShallow(other_)) 1576 return false; 1577 if (!(other_ instanceof CapabilityStatement2ImplementationComponent)) 1578 return false; 1579 CapabilityStatement2ImplementationComponent o = (CapabilityStatement2ImplementationComponent) other_; 1580 return compareValues(description, o.description, true) && compareValues(url, o.url, true); 1581 } 1582 1583 public boolean isEmpty() { 1584 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(description, url, custodian 1585 ); 1586 } 1587 1588 public String fhirType() { 1589 return "CapabilityStatement2.implementation"; 1590 1591 } 1592 1593 } 1594 1595 @Block() 1596 public static class CapabilityStatement2RestComponent extends BackboneElement implements IBaseBackboneElement { 1597 /** 1598 * Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations. 1599 */ 1600 @Child(name = "mode", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true) 1601 @Description(shortDefinition="client | server", formalDefinition="Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations." ) 1602 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/restful-capability-mode") 1603 protected Enumeration<RestfulCapabilityMode> mode; 1604 1605 /** 1606 * Information about the system's restful capabilities that apply across all applications, such as security. 1607 */ 1608 @Child(name = "documentation", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=false) 1609 @Description(shortDefinition="General description of implementation", formalDefinition="Information about the system's restful capabilities that apply across all applications, such as security." ) 1610 protected MarkdownType documentation; 1611 1612 /** 1613 * A statement that affirms support for a feature. 1614 */ 1615 @Child(name = "feature", type = {}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1616 @Description(shortDefinition="Statement of support for a feature", formalDefinition="A statement that affirms support for a feature." ) 1617 protected List<CapabilityStatement2RestFeatureComponent> feature; 1618 1619 /** 1620 * A specification of the restful capabilities of the solution for a specific resource type. 1621 */ 1622 @Child(name = "resource", type = {}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 1623 @Description(shortDefinition="Resource served on the REST interface", formalDefinition="A specification of the restful capabilities of the solution for a specific resource type." ) 1624 protected List<CapabilityStatement2RestResourceComponent> resource; 1625 1626 /** 1627 * A specification of restful operations supported by the system. 1628 */ 1629 @Child(name = "interaction", type = {}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1630 @Description(shortDefinition="What operations are supported?", formalDefinition="A specification of restful operations supported by the system." ) 1631 protected List<SystemInteractionComponent> interaction; 1632 1633 /** 1634 * 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. 1635 */ 1636 @Child(name = "searchParam", type = {CapabilityStatement2RestResourceSearchParamComponent.class}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1637 @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." ) 1638 protected List<CapabilityStatement2RestResourceSearchParamComponent> searchParam; 1639 1640 /** 1641 * Definition of an operation or a named query together with its parameters and their meaning and type. 1642 */ 1643 @Child(name = "operation", type = {CapabilityStatement2RestResourceOperationComponent.class}, order=7, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 1644 @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." ) 1645 protected List<CapabilityStatement2RestResourceOperationComponent> operation; 1646 1647 /** 1648 * 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 . 1649 */ 1650 @Child(name = "compartment", type = {CanonicalType.class}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 1651 @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 ." ) 1652 protected List<CanonicalType> compartment; 1653 1654 private static final long serialVersionUID = 2139914073L; 1655 1656 /** 1657 * Constructor 1658 */ 1659 public CapabilityStatement2RestComponent() { 1660 super(); 1661 } 1662 1663 /** 1664 * Constructor 1665 */ 1666 public CapabilityStatement2RestComponent(RestfulCapabilityMode mode) { 1667 super(); 1668 this.setMode(mode); 1669 } 1670 1671 /** 1672 * @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 1673 */ 1674 public Enumeration<RestfulCapabilityMode> getModeElement() { 1675 if (this.mode == null) 1676 if (Configuration.errorOnAutoCreate()) 1677 throw new Error("Attempt to auto-create CapabilityStatement2RestComponent.mode"); 1678 else if (Configuration.doAutoCreate()) 1679 this.mode = new Enumeration<RestfulCapabilityMode>(new RestfulCapabilityModeEnumFactory()); // bb 1680 return this.mode; 1681 } 1682 1683 public boolean hasModeElement() { 1684 return this.mode != null && !this.mode.isEmpty(); 1685 } 1686 1687 public boolean hasMode() { 1688 return this.mode != null && !this.mode.isEmpty(); 1689 } 1690 1691 /** 1692 * @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 1693 */ 1694 public CapabilityStatement2RestComponent setModeElement(Enumeration<RestfulCapabilityMode> value) { 1695 this.mode = value; 1696 return this; 1697 } 1698 1699 /** 1700 * @return Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations. 1701 */ 1702 public RestfulCapabilityMode getMode() { 1703 return this.mode == null ? null : this.mode.getValue(); 1704 } 1705 1706 /** 1707 * @param value Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations. 1708 */ 1709 public CapabilityStatement2RestComponent setMode(RestfulCapabilityMode value) { 1710 if (this.mode == null) 1711 this.mode = new Enumeration<RestfulCapabilityMode>(new RestfulCapabilityModeEnumFactory()); 1712 this.mode.setValue(value); 1713 return this; 1714 } 1715 1716 /** 1717 * @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 1718 */ 1719 public MarkdownType getDocumentationElement() { 1720 if (this.documentation == null) 1721 if (Configuration.errorOnAutoCreate()) 1722 throw new Error("Attempt to auto-create CapabilityStatement2RestComponent.documentation"); 1723 else if (Configuration.doAutoCreate()) 1724 this.documentation = new MarkdownType(); // bb 1725 return this.documentation; 1726 } 1727 1728 public boolean hasDocumentationElement() { 1729 return this.documentation != null && !this.documentation.isEmpty(); 1730 } 1731 1732 public boolean hasDocumentation() { 1733 return this.documentation != null && !this.documentation.isEmpty(); 1734 } 1735 1736 /** 1737 * @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 1738 */ 1739 public CapabilityStatement2RestComponent setDocumentationElement(MarkdownType value) { 1740 this.documentation = value; 1741 return this; 1742 } 1743 1744 /** 1745 * @return Information about the system's restful capabilities that apply across all applications, such as security. 1746 */ 1747 public String getDocumentation() { 1748 return this.documentation == null ? null : this.documentation.getValue(); 1749 } 1750 1751 /** 1752 * @param value Information about the system's restful capabilities that apply across all applications, such as security. 1753 */ 1754 public CapabilityStatement2RestComponent setDocumentation(String value) { 1755 if (value == null) 1756 this.documentation = null; 1757 else { 1758 if (this.documentation == null) 1759 this.documentation = new MarkdownType(); 1760 this.documentation.setValue(value); 1761 } 1762 return this; 1763 } 1764 1765 /** 1766 * @return {@link #feature} (A statement that affirms support for a feature.) 1767 */ 1768 public List<CapabilityStatement2RestFeatureComponent> getFeature() { 1769 if (this.feature == null) 1770 this.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 1771 return this.feature; 1772 } 1773 1774 /** 1775 * @return Returns a reference to <code>this</code> for easy method chaining 1776 */ 1777 public CapabilityStatement2RestComponent setFeature(List<CapabilityStatement2RestFeatureComponent> theFeature) { 1778 this.feature = theFeature; 1779 return this; 1780 } 1781 1782 public boolean hasFeature() { 1783 if (this.feature == null) 1784 return false; 1785 for (CapabilityStatement2RestFeatureComponent item : this.feature) 1786 if (!item.isEmpty()) 1787 return true; 1788 return false; 1789 } 1790 1791 public CapabilityStatement2RestFeatureComponent addFeature() { //3 1792 CapabilityStatement2RestFeatureComponent t = new CapabilityStatement2RestFeatureComponent(); 1793 if (this.feature == null) 1794 this.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 1795 this.feature.add(t); 1796 return t; 1797 } 1798 1799 public CapabilityStatement2RestComponent addFeature(CapabilityStatement2RestFeatureComponent t) { //3 1800 if (t == null) 1801 return this; 1802 if (this.feature == null) 1803 this.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 1804 this.feature.add(t); 1805 return this; 1806 } 1807 1808 /** 1809 * @return The first repetition of repeating field {@link #feature}, creating it if it does not already exist {3} 1810 */ 1811 public CapabilityStatement2RestFeatureComponent getFeatureFirstRep() { 1812 if (getFeature().isEmpty()) { 1813 addFeature(); 1814 } 1815 return getFeature().get(0); 1816 } 1817 1818 /** 1819 * @return {@link #resource} (A specification of the restful capabilities of the solution for a specific resource type.) 1820 */ 1821 public List<CapabilityStatement2RestResourceComponent> getResource() { 1822 if (this.resource == null) 1823 this.resource = new ArrayList<CapabilityStatement2RestResourceComponent>(); 1824 return this.resource; 1825 } 1826 1827 /** 1828 * @return Returns a reference to <code>this</code> for easy method chaining 1829 */ 1830 public CapabilityStatement2RestComponent setResource(List<CapabilityStatement2RestResourceComponent> theResource) { 1831 this.resource = theResource; 1832 return this; 1833 } 1834 1835 public boolean hasResource() { 1836 if (this.resource == null) 1837 return false; 1838 for (CapabilityStatement2RestResourceComponent item : this.resource) 1839 if (!item.isEmpty()) 1840 return true; 1841 return false; 1842 } 1843 1844 public CapabilityStatement2RestResourceComponent addResource() { //3 1845 CapabilityStatement2RestResourceComponent t = new CapabilityStatement2RestResourceComponent(); 1846 if (this.resource == null) 1847 this.resource = new ArrayList<CapabilityStatement2RestResourceComponent>(); 1848 this.resource.add(t); 1849 return t; 1850 } 1851 1852 public CapabilityStatement2RestComponent addResource(CapabilityStatement2RestResourceComponent t) { //3 1853 if (t == null) 1854 return this; 1855 if (this.resource == null) 1856 this.resource = new ArrayList<CapabilityStatement2RestResourceComponent>(); 1857 this.resource.add(t); 1858 return this; 1859 } 1860 1861 /** 1862 * @return The first repetition of repeating field {@link #resource}, creating it if it does not already exist {3} 1863 */ 1864 public CapabilityStatement2RestResourceComponent getResourceFirstRep() { 1865 if (getResource().isEmpty()) { 1866 addResource(); 1867 } 1868 return getResource().get(0); 1869 } 1870 1871 /** 1872 * @return {@link #interaction} (A specification of restful operations supported by the system.) 1873 */ 1874 public List<SystemInteractionComponent> getInteraction() { 1875 if (this.interaction == null) 1876 this.interaction = new ArrayList<SystemInteractionComponent>(); 1877 return this.interaction; 1878 } 1879 1880 /** 1881 * @return Returns a reference to <code>this</code> for easy method chaining 1882 */ 1883 public CapabilityStatement2RestComponent setInteraction(List<SystemInteractionComponent> theInteraction) { 1884 this.interaction = theInteraction; 1885 return this; 1886 } 1887 1888 public boolean hasInteraction() { 1889 if (this.interaction == null) 1890 return false; 1891 for (SystemInteractionComponent item : this.interaction) 1892 if (!item.isEmpty()) 1893 return true; 1894 return false; 1895 } 1896 1897 public SystemInteractionComponent addInteraction() { //3 1898 SystemInteractionComponent t = new SystemInteractionComponent(); 1899 if (this.interaction == null) 1900 this.interaction = new ArrayList<SystemInteractionComponent>(); 1901 this.interaction.add(t); 1902 return t; 1903 } 1904 1905 public CapabilityStatement2RestComponent addInteraction(SystemInteractionComponent t) { //3 1906 if (t == null) 1907 return this; 1908 if (this.interaction == null) 1909 this.interaction = new ArrayList<SystemInteractionComponent>(); 1910 this.interaction.add(t); 1911 return this; 1912 } 1913 1914 /** 1915 * @return The first repetition of repeating field {@link #interaction}, creating it if it does not already exist {3} 1916 */ 1917 public SystemInteractionComponent getInteractionFirstRep() { 1918 if (getInteraction().isEmpty()) { 1919 addInteraction(); 1920 } 1921 return getInteraction().get(0); 1922 } 1923 1924 /** 1925 * @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.) 1926 */ 1927 public List<CapabilityStatement2RestResourceSearchParamComponent> getSearchParam() { 1928 if (this.searchParam == null) 1929 this.searchParam = new ArrayList<CapabilityStatement2RestResourceSearchParamComponent>(); 1930 return this.searchParam; 1931 } 1932 1933 /** 1934 * @return Returns a reference to <code>this</code> for easy method chaining 1935 */ 1936 public CapabilityStatement2RestComponent setSearchParam(List<CapabilityStatement2RestResourceSearchParamComponent> theSearchParam) { 1937 this.searchParam = theSearchParam; 1938 return this; 1939 } 1940 1941 public boolean hasSearchParam() { 1942 if (this.searchParam == null) 1943 return false; 1944 for (CapabilityStatement2RestResourceSearchParamComponent item : this.searchParam) 1945 if (!item.isEmpty()) 1946 return true; 1947 return false; 1948 } 1949 1950 public CapabilityStatement2RestResourceSearchParamComponent addSearchParam() { //3 1951 CapabilityStatement2RestResourceSearchParamComponent t = new CapabilityStatement2RestResourceSearchParamComponent(); 1952 if (this.searchParam == null) 1953 this.searchParam = new ArrayList<CapabilityStatement2RestResourceSearchParamComponent>(); 1954 this.searchParam.add(t); 1955 return t; 1956 } 1957 1958 public CapabilityStatement2RestComponent addSearchParam(CapabilityStatement2RestResourceSearchParamComponent t) { //3 1959 if (t == null) 1960 return this; 1961 if (this.searchParam == null) 1962 this.searchParam = new ArrayList<CapabilityStatement2RestResourceSearchParamComponent>(); 1963 this.searchParam.add(t); 1964 return this; 1965 } 1966 1967 /** 1968 * @return The first repetition of repeating field {@link #searchParam}, creating it if it does not already exist {3} 1969 */ 1970 public CapabilityStatement2RestResourceSearchParamComponent getSearchParamFirstRep() { 1971 if (getSearchParam().isEmpty()) { 1972 addSearchParam(); 1973 } 1974 return getSearchParam().get(0); 1975 } 1976 1977 /** 1978 * @return {@link #operation} (Definition of an operation or a named query together with its parameters and their meaning and type.) 1979 */ 1980 public List<CapabilityStatement2RestResourceOperationComponent> getOperation() { 1981 if (this.operation == null) 1982 this.operation = new ArrayList<CapabilityStatement2RestResourceOperationComponent>(); 1983 return this.operation; 1984 } 1985 1986 /** 1987 * @return Returns a reference to <code>this</code> for easy method chaining 1988 */ 1989 public CapabilityStatement2RestComponent setOperation(List<CapabilityStatement2RestResourceOperationComponent> theOperation) { 1990 this.operation = theOperation; 1991 return this; 1992 } 1993 1994 public boolean hasOperation() { 1995 if (this.operation == null) 1996 return false; 1997 for (CapabilityStatement2RestResourceOperationComponent item : this.operation) 1998 if (!item.isEmpty()) 1999 return true; 2000 return false; 2001 } 2002 2003 public CapabilityStatement2RestResourceOperationComponent addOperation() { //3 2004 CapabilityStatement2RestResourceOperationComponent t = new CapabilityStatement2RestResourceOperationComponent(); 2005 if (this.operation == null) 2006 this.operation = new ArrayList<CapabilityStatement2RestResourceOperationComponent>(); 2007 this.operation.add(t); 2008 return t; 2009 } 2010 2011 public CapabilityStatement2RestComponent addOperation(CapabilityStatement2RestResourceOperationComponent t) { //3 2012 if (t == null) 2013 return this; 2014 if (this.operation == null) 2015 this.operation = new ArrayList<CapabilityStatement2RestResourceOperationComponent>(); 2016 this.operation.add(t); 2017 return this; 2018 } 2019 2020 /** 2021 * @return The first repetition of repeating field {@link #operation}, creating it if it does not already exist {3} 2022 */ 2023 public CapabilityStatement2RestResourceOperationComponent getOperationFirstRep() { 2024 if (getOperation().isEmpty()) { 2025 addOperation(); 2026 } 2027 return getOperation().get(0); 2028 } 2029 2030 /** 2031 * @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 .) 2032 */ 2033 public List<CanonicalType> getCompartment() { 2034 if (this.compartment == null) 2035 this.compartment = new ArrayList<CanonicalType>(); 2036 return this.compartment; 2037 } 2038 2039 /** 2040 * @return Returns a reference to <code>this</code> for easy method chaining 2041 */ 2042 public CapabilityStatement2RestComponent setCompartment(List<CanonicalType> theCompartment) { 2043 this.compartment = theCompartment; 2044 return this; 2045 } 2046 2047 public boolean hasCompartment() { 2048 if (this.compartment == null) 2049 return false; 2050 for (CanonicalType item : this.compartment) 2051 if (!item.isEmpty()) 2052 return true; 2053 return false; 2054 } 2055 2056 /** 2057 * @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 .) 2058 */ 2059 public CanonicalType addCompartmentElement() {//2 2060 CanonicalType t = new CanonicalType(); 2061 if (this.compartment == null) 2062 this.compartment = new ArrayList<CanonicalType>(); 2063 this.compartment.add(t); 2064 return t; 2065 } 2066 2067 /** 2068 * @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 .) 2069 */ 2070 public CapabilityStatement2RestComponent addCompartment(String value) { //1 2071 CanonicalType t = new CanonicalType(); 2072 t.setValue(value); 2073 if (this.compartment == null) 2074 this.compartment = new ArrayList<CanonicalType>(); 2075 this.compartment.add(t); 2076 return this; 2077 } 2078 2079 /** 2080 * @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 .) 2081 */ 2082 public boolean hasCompartment(String value) { 2083 if (this.compartment == null) 2084 return false; 2085 for (CanonicalType v : this.compartment) 2086 if (v.getValue().equals(value)) // canonical 2087 return true; 2088 return false; 2089 } 2090 2091 protected void listChildren(List<Property> children) { 2092 super.listChildren(children); 2093 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)); 2094 children.add(new Property("documentation", "markdown", "Information about the system's restful capabilities that apply across all applications, such as security.", 0, 1, documentation)); 2095 children.add(new Property("feature", "", "A statement that affirms support for a feature.", 0, java.lang.Integer.MAX_VALUE, feature)); 2096 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)); 2097 children.add(new Property("interaction", "", "A specification of restful operations supported by the system.", 0, java.lang.Integer.MAX_VALUE, interaction)); 2098 children.add(new Property("searchParam", "@CapabilityStatement2.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)); 2099 children.add(new Property("operation", "@CapabilityStatement2.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)); 2100 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)); 2101 } 2102 2103 @Override 2104 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 2105 switch (_hash) { 2106 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); 2107 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); 2108 case -979207434: /*feature*/ return new Property("feature", "", "A statement that affirms support for a feature.", 0, java.lang.Integer.MAX_VALUE, feature); 2109 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); 2110 case 1844104722: /*interaction*/ return new Property("interaction", "", "A specification of restful operations supported by the system.", 0, java.lang.Integer.MAX_VALUE, interaction); 2111 case -553645115: /*searchParam*/ return new Property("searchParam", "@CapabilityStatement2.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); 2112 case 1662702951: /*operation*/ return new Property("operation", "@CapabilityStatement2.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); 2113 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); 2114 default: return super.getNamedProperty(_hash, _name, _checkValid); 2115 } 2116 2117 } 2118 2119 @Override 2120 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 2121 switch (hash) { 2122 case 3357091: /*mode*/ return this.mode == null ? new Base[0] : new Base[] {this.mode}; // Enumeration<RestfulCapabilityMode> 2123 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 2124 case -979207434: /*feature*/ return this.feature == null ? new Base[0] : this.feature.toArray(new Base[this.feature.size()]); // CapabilityStatement2RestFeatureComponent 2125 case -341064690: /*resource*/ return this.resource == null ? new Base[0] : this.resource.toArray(new Base[this.resource.size()]); // CapabilityStatement2RestResourceComponent 2126 case 1844104722: /*interaction*/ return this.interaction == null ? new Base[0] : this.interaction.toArray(new Base[this.interaction.size()]); // SystemInteractionComponent 2127 case -553645115: /*searchParam*/ return this.searchParam == null ? new Base[0] : this.searchParam.toArray(new Base[this.searchParam.size()]); // CapabilityStatement2RestResourceSearchParamComponent 2128 case 1662702951: /*operation*/ return this.operation == null ? new Base[0] : this.operation.toArray(new Base[this.operation.size()]); // CapabilityStatement2RestResourceOperationComponent 2129 case -397756334: /*compartment*/ return this.compartment == null ? new Base[0] : this.compartment.toArray(new Base[this.compartment.size()]); // CanonicalType 2130 default: return super.getProperty(hash, name, checkValid); 2131 } 2132 2133 } 2134 2135 @Override 2136 public Base setProperty(int hash, String name, Base value) throws FHIRException { 2137 switch (hash) { 2138 case 3357091: // mode 2139 value = new RestfulCapabilityModeEnumFactory().fromType(TypeConvertor.castToCode(value)); 2140 this.mode = (Enumeration) value; // Enumeration<RestfulCapabilityMode> 2141 return value; 2142 case 1587405498: // documentation 2143 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 2144 return value; 2145 case -979207434: // feature 2146 this.getFeature().add((CapabilityStatement2RestFeatureComponent) value); // CapabilityStatement2RestFeatureComponent 2147 return value; 2148 case -341064690: // resource 2149 this.getResource().add((CapabilityStatement2RestResourceComponent) value); // CapabilityStatement2RestResourceComponent 2150 return value; 2151 case 1844104722: // interaction 2152 this.getInteraction().add((SystemInteractionComponent) value); // SystemInteractionComponent 2153 return value; 2154 case -553645115: // searchParam 2155 this.getSearchParam().add((CapabilityStatement2RestResourceSearchParamComponent) value); // CapabilityStatement2RestResourceSearchParamComponent 2156 return value; 2157 case 1662702951: // operation 2158 this.getOperation().add((CapabilityStatement2RestResourceOperationComponent) value); // CapabilityStatement2RestResourceOperationComponent 2159 return value; 2160 case -397756334: // compartment 2161 this.getCompartment().add(TypeConvertor.castToCanonical(value)); // CanonicalType 2162 return value; 2163 default: return super.setProperty(hash, name, value); 2164 } 2165 2166 } 2167 2168 @Override 2169 public Base setProperty(String name, Base value) throws FHIRException { 2170 if (name.equals("mode")) { 2171 value = new RestfulCapabilityModeEnumFactory().fromType(TypeConvertor.castToCode(value)); 2172 this.mode = (Enumeration) value; // Enumeration<RestfulCapabilityMode> 2173 } else if (name.equals("documentation")) { 2174 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 2175 } else if (name.equals("feature")) { 2176 this.getFeature().add((CapabilityStatement2RestFeatureComponent) value); 2177 } else if (name.equals("resource")) { 2178 this.getResource().add((CapabilityStatement2RestResourceComponent) value); 2179 } else if (name.equals("interaction")) { 2180 this.getInteraction().add((SystemInteractionComponent) value); 2181 } else if (name.equals("searchParam")) { 2182 this.getSearchParam().add((CapabilityStatement2RestResourceSearchParamComponent) value); 2183 } else if (name.equals("operation")) { 2184 this.getOperation().add((CapabilityStatement2RestResourceOperationComponent) value); 2185 } else if (name.equals("compartment")) { 2186 this.getCompartment().add(TypeConvertor.castToCanonical(value)); 2187 } else 2188 return super.setProperty(name, value); 2189 return value; 2190 } 2191 2192 @Override 2193 public Base makeProperty(int hash, String name) throws FHIRException { 2194 switch (hash) { 2195 case 3357091: return getModeElement(); 2196 case 1587405498: return getDocumentationElement(); 2197 case -979207434: return addFeature(); 2198 case -341064690: return addResource(); 2199 case 1844104722: return addInteraction(); 2200 case -553645115: return addSearchParam(); 2201 case 1662702951: return addOperation(); 2202 case -397756334: return addCompartmentElement(); 2203 default: return super.makeProperty(hash, name); 2204 } 2205 2206 } 2207 2208 @Override 2209 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 2210 switch (hash) { 2211 case 3357091: /*mode*/ return new String[] {"code"}; 2212 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 2213 case -979207434: /*feature*/ return new String[] {}; 2214 case -341064690: /*resource*/ return new String[] {}; 2215 case 1844104722: /*interaction*/ return new String[] {}; 2216 case -553645115: /*searchParam*/ return new String[] {"@CapabilityStatement2.rest.resource.searchParam"}; 2217 case 1662702951: /*operation*/ return new String[] {"@CapabilityStatement2.rest.resource.operation"}; 2218 case -397756334: /*compartment*/ return new String[] {"canonical"}; 2219 default: return super.getTypesForProperty(hash, name); 2220 } 2221 2222 } 2223 2224 @Override 2225 public Base addChild(String name) throws FHIRException { 2226 if (name.equals("mode")) { 2227 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.mode"); 2228 } 2229 else if (name.equals("documentation")) { 2230 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.documentation"); 2231 } 2232 else if (name.equals("feature")) { 2233 return addFeature(); 2234 } 2235 else if (name.equals("resource")) { 2236 return addResource(); 2237 } 2238 else if (name.equals("interaction")) { 2239 return addInteraction(); 2240 } 2241 else if (name.equals("searchParam")) { 2242 return addSearchParam(); 2243 } 2244 else if (name.equals("operation")) { 2245 return addOperation(); 2246 } 2247 else if (name.equals("compartment")) { 2248 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.compartment"); 2249 } 2250 else 2251 return super.addChild(name); 2252 } 2253 2254 public CapabilityStatement2RestComponent copy() { 2255 CapabilityStatement2RestComponent dst = new CapabilityStatement2RestComponent(); 2256 copyValues(dst); 2257 return dst; 2258 } 2259 2260 public void copyValues(CapabilityStatement2RestComponent dst) { 2261 super.copyValues(dst); 2262 dst.mode = mode == null ? null : mode.copy(); 2263 dst.documentation = documentation == null ? null : documentation.copy(); 2264 if (feature != null) { 2265 dst.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 2266 for (CapabilityStatement2RestFeatureComponent i : feature) 2267 dst.feature.add(i.copy()); 2268 }; 2269 if (resource != null) { 2270 dst.resource = new ArrayList<CapabilityStatement2RestResourceComponent>(); 2271 for (CapabilityStatement2RestResourceComponent i : resource) 2272 dst.resource.add(i.copy()); 2273 }; 2274 if (interaction != null) { 2275 dst.interaction = new ArrayList<SystemInteractionComponent>(); 2276 for (SystemInteractionComponent i : interaction) 2277 dst.interaction.add(i.copy()); 2278 }; 2279 if (searchParam != null) { 2280 dst.searchParam = new ArrayList<CapabilityStatement2RestResourceSearchParamComponent>(); 2281 for (CapabilityStatement2RestResourceSearchParamComponent i : searchParam) 2282 dst.searchParam.add(i.copy()); 2283 }; 2284 if (operation != null) { 2285 dst.operation = new ArrayList<CapabilityStatement2RestResourceOperationComponent>(); 2286 for (CapabilityStatement2RestResourceOperationComponent i : operation) 2287 dst.operation.add(i.copy()); 2288 }; 2289 if (compartment != null) { 2290 dst.compartment = new ArrayList<CanonicalType>(); 2291 for (CanonicalType i : compartment) 2292 dst.compartment.add(i.copy()); 2293 }; 2294 } 2295 2296 @Override 2297 public boolean equalsDeep(Base other_) { 2298 if (!super.equalsDeep(other_)) 2299 return false; 2300 if (!(other_ instanceof CapabilityStatement2RestComponent)) 2301 return false; 2302 CapabilityStatement2RestComponent o = (CapabilityStatement2RestComponent) other_; 2303 return compareDeep(mode, o.mode, true) && compareDeep(documentation, o.documentation, true) && compareDeep(feature, o.feature, true) 2304 && compareDeep(resource, o.resource, true) && compareDeep(interaction, o.interaction, true) && compareDeep(searchParam, o.searchParam, true) 2305 && compareDeep(operation, o.operation, true) && compareDeep(compartment, o.compartment, true); 2306 } 2307 2308 @Override 2309 public boolean equalsShallow(Base other_) { 2310 if (!super.equalsShallow(other_)) 2311 return false; 2312 if (!(other_ instanceof CapabilityStatement2RestComponent)) 2313 return false; 2314 CapabilityStatement2RestComponent o = (CapabilityStatement2RestComponent) other_; 2315 return compareValues(mode, o.mode, true) && compareValues(documentation, o.documentation, true) && compareValues(compartment, o.compartment, true) 2316 ; 2317 } 2318 2319 public boolean isEmpty() { 2320 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(mode, documentation, feature 2321 , resource, interaction, searchParam, operation, compartment); 2322 } 2323 2324 public String fhirType() { 2325 return "CapabilityStatement2.rest"; 2326 2327 } 2328 2329 } 2330 2331 @Block() 2332 public static class CapabilityStatement2RestFeatureComponent extends BackboneElement implements IBaseBackboneElement { 2333 /** 2334 * A code that describes the feature being reported on. 2335 */ 2336 @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=false) 2337 @Description(shortDefinition="Feature that is being reported", formalDefinition="A code that describes the feature being reported on." ) 2338 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/capability-feature") 2339 protected Enumeration<CapabilityFeature> code; 2340 2341 /** 2342 * A value for the feature - maybe true, false, or one of the set of codes allowed in the definition of the feature code. 2343 */ 2344 @Child(name = "value", type = {CodeType.class}, order=2, min=1, max=1, modifier=false, summary=false) 2345 @Description(shortDefinition="Value of the feature (true, false, or a code)", formalDefinition="A value for the feature - maybe true, false, or one of the set of codes allowed in the definition of the feature code." ) 2346 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/capability-feature-value") 2347 protected Enumeration<CapabilityFeatureValue> value; 2348 2349 private static final long serialVersionUID = 782619829L; 2350 2351 /** 2352 * Constructor 2353 */ 2354 public CapabilityStatement2RestFeatureComponent() { 2355 super(); 2356 } 2357 2358 /** 2359 * Constructor 2360 */ 2361 public CapabilityStatement2RestFeatureComponent(CapabilityFeature code, CapabilityFeatureValue value) { 2362 super(); 2363 this.setCode(code); 2364 this.setValue(value); 2365 } 2366 2367 /** 2368 * @return {@link #code} (A code that describes the feature being reported on.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value 2369 */ 2370 public Enumeration<CapabilityFeature> getCodeElement() { 2371 if (this.code == null) 2372 if (Configuration.errorOnAutoCreate()) 2373 throw new Error("Attempt to auto-create CapabilityStatement2RestFeatureComponent.code"); 2374 else if (Configuration.doAutoCreate()) 2375 this.code = new Enumeration<CapabilityFeature>(new CapabilityFeatureEnumFactory()); // bb 2376 return this.code; 2377 } 2378 2379 public boolean hasCodeElement() { 2380 return this.code != null && !this.code.isEmpty(); 2381 } 2382 2383 public boolean hasCode() { 2384 return this.code != null && !this.code.isEmpty(); 2385 } 2386 2387 /** 2388 * @param value {@link #code} (A code that describes the feature being reported on.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value 2389 */ 2390 public CapabilityStatement2RestFeatureComponent setCodeElement(Enumeration<CapabilityFeature> value) { 2391 this.code = value; 2392 return this; 2393 } 2394 2395 /** 2396 * @return A code that describes the feature being reported on. 2397 */ 2398 public CapabilityFeature getCode() { 2399 return this.code == null ? null : this.code.getValue(); 2400 } 2401 2402 /** 2403 * @param value A code that describes the feature being reported on. 2404 */ 2405 public CapabilityStatement2RestFeatureComponent setCode(CapabilityFeature value) { 2406 if (this.code == null) 2407 this.code = new Enumeration<CapabilityFeature>(new CapabilityFeatureEnumFactory()); 2408 this.code.setValue(value); 2409 return this; 2410 } 2411 2412 /** 2413 * @return {@link #value} (A value for the feature - maybe true, false, or one of the set of codes allowed in the definition of the feature code.). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value 2414 */ 2415 public Enumeration<CapabilityFeatureValue> getValueElement() { 2416 if (this.value == null) 2417 if (Configuration.errorOnAutoCreate()) 2418 throw new Error("Attempt to auto-create CapabilityStatement2RestFeatureComponent.value"); 2419 else if (Configuration.doAutoCreate()) 2420 this.value = new Enumeration<CapabilityFeatureValue>(new CapabilityFeatureValueEnumFactory()); // bb 2421 return this.value; 2422 } 2423 2424 public boolean hasValueElement() { 2425 return this.value != null && !this.value.isEmpty(); 2426 } 2427 2428 public boolean hasValue() { 2429 return this.value != null && !this.value.isEmpty(); 2430 } 2431 2432 /** 2433 * @param value {@link #value} (A value for the feature - maybe true, false, or one of the set of codes allowed in the definition of the feature code.). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value 2434 */ 2435 public CapabilityStatement2RestFeatureComponent setValueElement(Enumeration<CapabilityFeatureValue> value) { 2436 this.value = value; 2437 return this; 2438 } 2439 2440 /** 2441 * @return A value for the feature - maybe true, false, or one of the set of codes allowed in the definition of the feature code. 2442 */ 2443 public CapabilityFeatureValue getValue() { 2444 return this.value == null ? null : this.value.getValue(); 2445 } 2446 2447 /** 2448 * @param value A value for the feature - maybe true, false, or one of the set of codes allowed in the definition of the feature code. 2449 */ 2450 public CapabilityStatement2RestFeatureComponent setValue(CapabilityFeatureValue value) { 2451 if (this.value == null) 2452 this.value = new Enumeration<CapabilityFeatureValue>(new CapabilityFeatureValueEnumFactory()); 2453 this.value.setValue(value); 2454 return this; 2455 } 2456 2457 protected void listChildren(List<Property> children) { 2458 super.listChildren(children); 2459 children.add(new Property("code", "code", "A code that describes the feature being reported on.", 0, 1, code)); 2460 children.add(new Property("value", "code", "A value for the feature - maybe true, false, or one of the set of codes allowed in the definition of the feature code.", 0, 1, value)); 2461 } 2462 2463 @Override 2464 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 2465 switch (_hash) { 2466 case 3059181: /*code*/ return new Property("code", "code", "A code that describes the feature being reported on.", 0, 1, code); 2467 case 111972721: /*value*/ return new Property("value", "code", "A value for the feature - maybe true, false, or one of the set of codes allowed in the definition of the feature code.", 0, 1, value); 2468 default: return super.getNamedProperty(_hash, _name, _checkValid); 2469 } 2470 2471 } 2472 2473 @Override 2474 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 2475 switch (hash) { 2476 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // Enumeration<CapabilityFeature> 2477 case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // Enumeration<CapabilityFeatureValue> 2478 default: return super.getProperty(hash, name, checkValid); 2479 } 2480 2481 } 2482 2483 @Override 2484 public Base setProperty(int hash, String name, Base value) throws FHIRException { 2485 switch (hash) { 2486 case 3059181: // code 2487 value = new CapabilityFeatureEnumFactory().fromType(TypeConvertor.castToCode(value)); 2488 this.code = (Enumeration) value; // Enumeration<CapabilityFeature> 2489 return value; 2490 case 111972721: // value 2491 value = new CapabilityFeatureValueEnumFactory().fromType(TypeConvertor.castToCode(value)); 2492 this.value = (Enumeration) value; // Enumeration<CapabilityFeatureValue> 2493 return value; 2494 default: return super.setProperty(hash, name, value); 2495 } 2496 2497 } 2498 2499 @Override 2500 public Base setProperty(String name, Base value) throws FHIRException { 2501 if (name.equals("code")) { 2502 value = new CapabilityFeatureEnumFactory().fromType(TypeConvertor.castToCode(value)); 2503 this.code = (Enumeration) value; // Enumeration<CapabilityFeature> 2504 } else if (name.equals("value")) { 2505 value = new CapabilityFeatureValueEnumFactory().fromType(TypeConvertor.castToCode(value)); 2506 this.value = (Enumeration) value; // Enumeration<CapabilityFeatureValue> 2507 } else 2508 return super.setProperty(name, value); 2509 return value; 2510 } 2511 2512 @Override 2513 public Base makeProperty(int hash, String name) throws FHIRException { 2514 switch (hash) { 2515 case 3059181: return getCodeElement(); 2516 case 111972721: return getValueElement(); 2517 default: return super.makeProperty(hash, name); 2518 } 2519 2520 } 2521 2522 @Override 2523 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 2524 switch (hash) { 2525 case 3059181: /*code*/ return new String[] {"code"}; 2526 case 111972721: /*value*/ return new String[] {"code"}; 2527 default: return super.getTypesForProperty(hash, name); 2528 } 2529 2530 } 2531 2532 @Override 2533 public Base addChild(String name) throws FHIRException { 2534 if (name.equals("code")) { 2535 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.feature.code"); 2536 } 2537 else if (name.equals("value")) { 2538 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.feature.value"); 2539 } 2540 else 2541 return super.addChild(name); 2542 } 2543 2544 public CapabilityStatement2RestFeatureComponent copy() { 2545 CapabilityStatement2RestFeatureComponent dst = new CapabilityStatement2RestFeatureComponent(); 2546 copyValues(dst); 2547 return dst; 2548 } 2549 2550 public void copyValues(CapabilityStatement2RestFeatureComponent dst) { 2551 super.copyValues(dst); 2552 dst.code = code == null ? null : code.copy(); 2553 dst.value = value == null ? null : value.copy(); 2554 } 2555 2556 @Override 2557 public boolean equalsDeep(Base other_) { 2558 if (!super.equalsDeep(other_)) 2559 return false; 2560 if (!(other_ instanceof CapabilityStatement2RestFeatureComponent)) 2561 return false; 2562 CapabilityStatement2RestFeatureComponent o = (CapabilityStatement2RestFeatureComponent) other_; 2563 return compareDeep(code, o.code, true) && compareDeep(value, o.value, true); 2564 } 2565 2566 @Override 2567 public boolean equalsShallow(Base other_) { 2568 if (!super.equalsShallow(other_)) 2569 return false; 2570 if (!(other_ instanceof CapabilityStatement2RestFeatureComponent)) 2571 return false; 2572 CapabilityStatement2RestFeatureComponent o = (CapabilityStatement2RestFeatureComponent) other_; 2573 return compareValues(code, o.code, true) && compareValues(value, o.value, true); 2574 } 2575 2576 public boolean isEmpty() { 2577 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, value); 2578 } 2579 2580 public String fhirType() { 2581 return "CapabilityStatement2.rest.feature"; 2582 2583 } 2584 2585 } 2586 2587 @Block() 2588 public static class CapabilityStatement2RestResourceComponent extends BackboneElement implements IBaseBackboneElement { 2589 /** 2590 * A type of resource exposed via the restful interface. 2591 */ 2592 @Child(name = "type", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true) 2593 @Description(shortDefinition="A resource type that is supported", formalDefinition="A type of resource exposed via the restful interface." ) 2594 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/resource-types") 2595 protected CodeType type; 2596 2597 /** 2598 * 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). 2599 */ 2600 @Child(name = "profile", type = {CanonicalType.class}, order=2, min=0, max=1, modifier=false, summary=true) 2601 @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)." ) 2602 protected CanonicalType profile; 2603 2604 /** 2605 * 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). 2606 */ 2607 @Child(name = "supportedProfile", type = {CanonicalType.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 2608 @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)." ) 2609 protected List<CanonicalType> supportedProfile; 2610 2611 /** 2612 * Additional information about the resource type used by the system. 2613 */ 2614 @Child(name = "documentation", type = {MarkdownType.class}, order=4, min=0, max=1, modifier=false, summary=false) 2615 @Description(shortDefinition="Additional information about the use of the resource type", formalDefinition="Additional information about the resource type used by the system." ) 2616 protected MarkdownType documentation; 2617 2618 /** 2619 * A statement that affirms support for a feature, in this context. 2620 */ 2621 @Child(name = "feature", type = {CapabilityStatement2RestFeatureComponent.class}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 2622 @Description(shortDefinition="Statement of support for a feature in this context", formalDefinition="A statement that affirms support for a feature, in this context." ) 2623 protected List<CapabilityStatement2RestFeatureComponent> feature; 2624 2625 /** 2626 * Identifies a restful operation supported by the solution. 2627 */ 2628 @Child(name = "interaction", type = {}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 2629 @Description(shortDefinition="What operations are supported?", formalDefinition="Identifies a restful operation supported by the solution." ) 2630 protected List<ResourceInteractionComponent> interaction; 2631 2632 /** 2633 * 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. 2634 */ 2635 @Child(name = "searchParam", type = {}, order=7, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 2636 @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." ) 2637 protected List<CapabilityStatement2RestResourceSearchParamComponent> searchParam; 2638 2639 /** 2640 * 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. 2641 */ 2642 @Child(name = "operation", type = {}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 2643 @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." ) 2644 protected List<CapabilityStatement2RestResourceOperationComponent> operation; 2645 2646 private static final long serialVersionUID = -815167785L; 2647 2648 /** 2649 * Constructor 2650 */ 2651 public CapabilityStatement2RestResourceComponent() { 2652 super(); 2653 } 2654 2655 /** 2656 * Constructor 2657 */ 2658 public CapabilityStatement2RestResourceComponent(String type) { 2659 super(); 2660 this.setType(type); 2661 } 2662 2663 /** 2664 * @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 2665 */ 2666 public CodeType getTypeElement() { 2667 if (this.type == null) 2668 if (Configuration.errorOnAutoCreate()) 2669 throw new Error("Attempt to auto-create CapabilityStatement2RestResourceComponent.type"); 2670 else if (Configuration.doAutoCreate()) 2671 this.type = new CodeType(); // bb 2672 return this.type; 2673 } 2674 2675 public boolean hasTypeElement() { 2676 return this.type != null && !this.type.isEmpty(); 2677 } 2678 2679 public boolean hasType() { 2680 return this.type != null && !this.type.isEmpty(); 2681 } 2682 2683 /** 2684 * @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 2685 */ 2686 public CapabilityStatement2RestResourceComponent setTypeElement(CodeType value) { 2687 this.type = value; 2688 return this; 2689 } 2690 2691 /** 2692 * @return A type of resource exposed via the restful interface. 2693 */ 2694 public String getType() { 2695 return this.type == null ? null : this.type.getValue(); 2696 } 2697 2698 /** 2699 * @param value A type of resource exposed via the restful interface. 2700 */ 2701 public CapabilityStatement2RestResourceComponent setType(String value) { 2702 if (this.type == null) 2703 this.type = new CodeType(); 2704 this.type.setValue(value); 2705 return this; 2706 } 2707 2708 /** 2709 * @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 2710 */ 2711 public CanonicalType getProfileElement() { 2712 if (this.profile == null) 2713 if (Configuration.errorOnAutoCreate()) 2714 throw new Error("Attempt to auto-create CapabilityStatement2RestResourceComponent.profile"); 2715 else if (Configuration.doAutoCreate()) 2716 this.profile = new CanonicalType(); // bb 2717 return this.profile; 2718 } 2719 2720 public boolean hasProfileElement() { 2721 return this.profile != null && !this.profile.isEmpty(); 2722 } 2723 2724 public boolean hasProfile() { 2725 return this.profile != null && !this.profile.isEmpty(); 2726 } 2727 2728 /** 2729 * @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 2730 */ 2731 public CapabilityStatement2RestResourceComponent setProfileElement(CanonicalType value) { 2732 this.profile = value; 2733 return this; 2734 } 2735 2736 /** 2737 * @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). 2738 */ 2739 public String getProfile() { 2740 return this.profile == null ? null : this.profile.getValue(); 2741 } 2742 2743 /** 2744 * @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). 2745 */ 2746 public CapabilityStatement2RestResourceComponent setProfile(String value) { 2747 if (Utilities.noString(value)) 2748 this.profile = null; 2749 else { 2750 if (this.profile == null) 2751 this.profile = new CanonicalType(); 2752 this.profile.setValue(value); 2753 } 2754 return this; 2755 } 2756 2757 /** 2758 * @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).) 2759 */ 2760 public List<CanonicalType> getSupportedProfile() { 2761 if (this.supportedProfile == null) 2762 this.supportedProfile = new ArrayList<CanonicalType>(); 2763 return this.supportedProfile; 2764 } 2765 2766 /** 2767 * @return Returns a reference to <code>this</code> for easy method chaining 2768 */ 2769 public CapabilityStatement2RestResourceComponent setSupportedProfile(List<CanonicalType> theSupportedProfile) { 2770 this.supportedProfile = theSupportedProfile; 2771 return this; 2772 } 2773 2774 public boolean hasSupportedProfile() { 2775 if (this.supportedProfile == null) 2776 return false; 2777 for (CanonicalType item : this.supportedProfile) 2778 if (!item.isEmpty()) 2779 return true; 2780 return false; 2781 } 2782 2783 /** 2784 * @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).) 2785 */ 2786 public CanonicalType addSupportedProfileElement() {//2 2787 CanonicalType t = new CanonicalType(); 2788 if (this.supportedProfile == null) 2789 this.supportedProfile = new ArrayList<CanonicalType>(); 2790 this.supportedProfile.add(t); 2791 return t; 2792 } 2793 2794 /** 2795 * @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).) 2796 */ 2797 public CapabilityStatement2RestResourceComponent addSupportedProfile(String value) { //1 2798 CanonicalType t = new CanonicalType(); 2799 t.setValue(value); 2800 if (this.supportedProfile == null) 2801 this.supportedProfile = new ArrayList<CanonicalType>(); 2802 this.supportedProfile.add(t); 2803 return this; 2804 } 2805 2806 /** 2807 * @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).) 2808 */ 2809 public boolean hasSupportedProfile(String value) { 2810 if (this.supportedProfile == null) 2811 return false; 2812 for (CanonicalType v : this.supportedProfile) 2813 if (v.getValue().equals(value)) // canonical 2814 return true; 2815 return false; 2816 } 2817 2818 /** 2819 * @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 2820 */ 2821 public MarkdownType getDocumentationElement() { 2822 if (this.documentation == null) 2823 if (Configuration.errorOnAutoCreate()) 2824 throw new Error("Attempt to auto-create CapabilityStatement2RestResourceComponent.documentation"); 2825 else if (Configuration.doAutoCreate()) 2826 this.documentation = new MarkdownType(); // bb 2827 return this.documentation; 2828 } 2829 2830 public boolean hasDocumentationElement() { 2831 return this.documentation != null && !this.documentation.isEmpty(); 2832 } 2833 2834 public boolean hasDocumentation() { 2835 return this.documentation != null && !this.documentation.isEmpty(); 2836 } 2837 2838 /** 2839 * @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 2840 */ 2841 public CapabilityStatement2RestResourceComponent setDocumentationElement(MarkdownType value) { 2842 this.documentation = value; 2843 return this; 2844 } 2845 2846 /** 2847 * @return Additional information about the resource type used by the system. 2848 */ 2849 public String getDocumentation() { 2850 return this.documentation == null ? null : this.documentation.getValue(); 2851 } 2852 2853 /** 2854 * @param value Additional information about the resource type used by the system. 2855 */ 2856 public CapabilityStatement2RestResourceComponent setDocumentation(String value) { 2857 if (value == null) 2858 this.documentation = null; 2859 else { 2860 if (this.documentation == null) 2861 this.documentation = new MarkdownType(); 2862 this.documentation.setValue(value); 2863 } 2864 return this; 2865 } 2866 2867 /** 2868 * @return {@link #feature} (A statement that affirms support for a feature, in this context.) 2869 */ 2870 public List<CapabilityStatement2RestFeatureComponent> getFeature() { 2871 if (this.feature == null) 2872 this.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 2873 return this.feature; 2874 } 2875 2876 /** 2877 * @return Returns a reference to <code>this</code> for easy method chaining 2878 */ 2879 public CapabilityStatement2RestResourceComponent setFeature(List<CapabilityStatement2RestFeatureComponent> theFeature) { 2880 this.feature = theFeature; 2881 return this; 2882 } 2883 2884 public boolean hasFeature() { 2885 if (this.feature == null) 2886 return false; 2887 for (CapabilityStatement2RestFeatureComponent item : this.feature) 2888 if (!item.isEmpty()) 2889 return true; 2890 return false; 2891 } 2892 2893 public CapabilityStatement2RestFeatureComponent addFeature() { //3 2894 CapabilityStatement2RestFeatureComponent t = new CapabilityStatement2RestFeatureComponent(); 2895 if (this.feature == null) 2896 this.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 2897 this.feature.add(t); 2898 return t; 2899 } 2900 2901 public CapabilityStatement2RestResourceComponent addFeature(CapabilityStatement2RestFeatureComponent t) { //3 2902 if (t == null) 2903 return this; 2904 if (this.feature == null) 2905 this.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 2906 this.feature.add(t); 2907 return this; 2908 } 2909 2910 /** 2911 * @return The first repetition of repeating field {@link #feature}, creating it if it does not already exist {3} 2912 */ 2913 public CapabilityStatement2RestFeatureComponent getFeatureFirstRep() { 2914 if (getFeature().isEmpty()) { 2915 addFeature(); 2916 } 2917 return getFeature().get(0); 2918 } 2919 2920 /** 2921 * @return {@link #interaction} (Identifies a restful operation supported by the solution.) 2922 */ 2923 public List<ResourceInteractionComponent> getInteraction() { 2924 if (this.interaction == null) 2925 this.interaction = new ArrayList<ResourceInteractionComponent>(); 2926 return this.interaction; 2927 } 2928 2929 /** 2930 * @return Returns a reference to <code>this</code> for easy method chaining 2931 */ 2932 public CapabilityStatement2RestResourceComponent setInteraction(List<ResourceInteractionComponent> theInteraction) { 2933 this.interaction = theInteraction; 2934 return this; 2935 } 2936 2937 public boolean hasInteraction() { 2938 if (this.interaction == null) 2939 return false; 2940 for (ResourceInteractionComponent item : this.interaction) 2941 if (!item.isEmpty()) 2942 return true; 2943 return false; 2944 } 2945 2946 public ResourceInteractionComponent addInteraction() { //3 2947 ResourceInteractionComponent t = new ResourceInteractionComponent(); 2948 if (this.interaction == null) 2949 this.interaction = new ArrayList<ResourceInteractionComponent>(); 2950 this.interaction.add(t); 2951 return t; 2952 } 2953 2954 public CapabilityStatement2RestResourceComponent addInteraction(ResourceInteractionComponent t) { //3 2955 if (t == null) 2956 return this; 2957 if (this.interaction == null) 2958 this.interaction = new ArrayList<ResourceInteractionComponent>(); 2959 this.interaction.add(t); 2960 return this; 2961 } 2962 2963 /** 2964 * @return The first repetition of repeating field {@link #interaction}, creating it if it does not already exist {3} 2965 */ 2966 public ResourceInteractionComponent getInteractionFirstRep() { 2967 if (getInteraction().isEmpty()) { 2968 addInteraction(); 2969 } 2970 return getInteraction().get(0); 2971 } 2972 2973 /** 2974 * @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.) 2975 */ 2976 public List<CapabilityStatement2RestResourceSearchParamComponent> getSearchParam() { 2977 if (this.searchParam == null) 2978 this.searchParam = new ArrayList<CapabilityStatement2RestResourceSearchParamComponent>(); 2979 return this.searchParam; 2980 } 2981 2982 /** 2983 * @return Returns a reference to <code>this</code> for easy method chaining 2984 */ 2985 public CapabilityStatement2RestResourceComponent setSearchParam(List<CapabilityStatement2RestResourceSearchParamComponent> theSearchParam) { 2986 this.searchParam = theSearchParam; 2987 return this; 2988 } 2989 2990 public boolean hasSearchParam() { 2991 if (this.searchParam == null) 2992 return false; 2993 for (CapabilityStatement2RestResourceSearchParamComponent item : this.searchParam) 2994 if (!item.isEmpty()) 2995 return true; 2996 return false; 2997 } 2998 2999 public CapabilityStatement2RestResourceSearchParamComponent addSearchParam() { //3 3000 CapabilityStatement2RestResourceSearchParamComponent t = new CapabilityStatement2RestResourceSearchParamComponent(); 3001 if (this.searchParam == null) 3002 this.searchParam = new ArrayList<CapabilityStatement2RestResourceSearchParamComponent>(); 3003 this.searchParam.add(t); 3004 return t; 3005 } 3006 3007 public CapabilityStatement2RestResourceComponent addSearchParam(CapabilityStatement2RestResourceSearchParamComponent t) { //3 3008 if (t == null) 3009 return this; 3010 if (this.searchParam == null) 3011 this.searchParam = new ArrayList<CapabilityStatement2RestResourceSearchParamComponent>(); 3012 this.searchParam.add(t); 3013 return this; 3014 } 3015 3016 /** 3017 * @return The first repetition of repeating field {@link #searchParam}, creating it if it does not already exist {3} 3018 */ 3019 public CapabilityStatement2RestResourceSearchParamComponent getSearchParamFirstRep() { 3020 if (getSearchParam().isEmpty()) { 3021 addSearchParam(); 3022 } 3023 return getSearchParam().get(0); 3024 } 3025 3026 /** 3027 * @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.) 3028 */ 3029 public List<CapabilityStatement2RestResourceOperationComponent> getOperation() { 3030 if (this.operation == null) 3031 this.operation = new ArrayList<CapabilityStatement2RestResourceOperationComponent>(); 3032 return this.operation; 3033 } 3034 3035 /** 3036 * @return Returns a reference to <code>this</code> for easy method chaining 3037 */ 3038 public CapabilityStatement2RestResourceComponent setOperation(List<CapabilityStatement2RestResourceOperationComponent> theOperation) { 3039 this.operation = theOperation; 3040 return this; 3041 } 3042 3043 public boolean hasOperation() { 3044 if (this.operation == null) 3045 return false; 3046 for (CapabilityStatement2RestResourceOperationComponent item : this.operation) 3047 if (!item.isEmpty()) 3048 return true; 3049 return false; 3050 } 3051 3052 public CapabilityStatement2RestResourceOperationComponent addOperation() { //3 3053 CapabilityStatement2RestResourceOperationComponent t = new CapabilityStatement2RestResourceOperationComponent(); 3054 if (this.operation == null) 3055 this.operation = new ArrayList<CapabilityStatement2RestResourceOperationComponent>(); 3056 this.operation.add(t); 3057 return t; 3058 } 3059 3060 public CapabilityStatement2RestResourceComponent addOperation(CapabilityStatement2RestResourceOperationComponent t) { //3 3061 if (t == null) 3062 return this; 3063 if (this.operation == null) 3064 this.operation = new ArrayList<CapabilityStatement2RestResourceOperationComponent>(); 3065 this.operation.add(t); 3066 return this; 3067 } 3068 3069 /** 3070 * @return The first repetition of repeating field {@link #operation}, creating it if it does not already exist {3} 3071 */ 3072 public CapabilityStatement2RestResourceOperationComponent getOperationFirstRep() { 3073 if (getOperation().isEmpty()) { 3074 addOperation(); 3075 } 3076 return getOperation().get(0); 3077 } 3078 3079 protected void listChildren(List<Property> children) { 3080 super.listChildren(children); 3081 children.add(new Property("type", "code", "A type of resource exposed via the restful interface.", 0, 1, type)); 3082 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)); 3083 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)); 3084 children.add(new Property("documentation", "markdown", "Additional information about the resource type used by the system.", 0, 1, documentation)); 3085 children.add(new Property("feature", "@CapabilityStatement2.rest.feature", "A statement that affirms support for a feature, in this context.", 0, java.lang.Integer.MAX_VALUE, feature)); 3086 children.add(new Property("interaction", "", "Identifies a restful operation supported by the solution.", 0, java.lang.Integer.MAX_VALUE, interaction)); 3087 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)); 3088 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)); 3089 } 3090 3091 @Override 3092 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 3093 switch (_hash) { 3094 case 3575610: /*type*/ return new Property("type", "code", "A type of resource exposed via the restful interface.", 0, 1, type); 3095 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); 3096 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); 3097 case 1587405498: /*documentation*/ return new Property("documentation", "markdown", "Additional information about the resource type used by the system.", 0, 1, documentation); 3098 case -979207434: /*feature*/ return new Property("feature", "@CapabilityStatement2.rest.feature", "A statement that affirms support for a feature, in this context.", 0, java.lang.Integer.MAX_VALUE, feature); 3099 case 1844104722: /*interaction*/ return new Property("interaction", "", "Identifies a restful operation supported by the solution.", 0, java.lang.Integer.MAX_VALUE, interaction); 3100 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); 3101 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); 3102 default: return super.getNamedProperty(_hash, _name, _checkValid); 3103 } 3104 3105 } 3106 3107 @Override 3108 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 3109 switch (hash) { 3110 case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // CodeType 3111 case -309425751: /*profile*/ return this.profile == null ? new Base[0] : new Base[] {this.profile}; // CanonicalType 3112 case 1225477403: /*supportedProfile*/ return this.supportedProfile == null ? new Base[0] : this.supportedProfile.toArray(new Base[this.supportedProfile.size()]); // CanonicalType 3113 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 3114 case -979207434: /*feature*/ return this.feature == null ? new Base[0] : this.feature.toArray(new Base[this.feature.size()]); // CapabilityStatement2RestFeatureComponent 3115 case 1844104722: /*interaction*/ return this.interaction == null ? new Base[0] : this.interaction.toArray(new Base[this.interaction.size()]); // ResourceInteractionComponent 3116 case -553645115: /*searchParam*/ return this.searchParam == null ? new Base[0] : this.searchParam.toArray(new Base[this.searchParam.size()]); // CapabilityStatement2RestResourceSearchParamComponent 3117 case 1662702951: /*operation*/ return this.operation == null ? new Base[0] : this.operation.toArray(new Base[this.operation.size()]); // CapabilityStatement2RestResourceOperationComponent 3118 default: return super.getProperty(hash, name, checkValid); 3119 } 3120 3121 } 3122 3123 @Override 3124 public Base setProperty(int hash, String name, Base value) throws FHIRException { 3125 switch (hash) { 3126 case 3575610: // type 3127 this.type = TypeConvertor.castToCode(value); // CodeType 3128 return value; 3129 case -309425751: // profile 3130 this.profile = TypeConvertor.castToCanonical(value); // CanonicalType 3131 return value; 3132 case 1225477403: // supportedProfile 3133 this.getSupportedProfile().add(TypeConvertor.castToCanonical(value)); // CanonicalType 3134 return value; 3135 case 1587405498: // documentation 3136 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 3137 return value; 3138 case -979207434: // feature 3139 this.getFeature().add((CapabilityStatement2RestFeatureComponent) value); // CapabilityStatement2RestFeatureComponent 3140 return value; 3141 case 1844104722: // interaction 3142 this.getInteraction().add((ResourceInteractionComponent) value); // ResourceInteractionComponent 3143 return value; 3144 case -553645115: // searchParam 3145 this.getSearchParam().add((CapabilityStatement2RestResourceSearchParamComponent) value); // CapabilityStatement2RestResourceSearchParamComponent 3146 return value; 3147 case 1662702951: // operation 3148 this.getOperation().add((CapabilityStatement2RestResourceOperationComponent) value); // CapabilityStatement2RestResourceOperationComponent 3149 return value; 3150 default: return super.setProperty(hash, name, value); 3151 } 3152 3153 } 3154 3155 @Override 3156 public Base setProperty(String name, Base value) throws FHIRException { 3157 if (name.equals("type")) { 3158 this.type = TypeConvertor.castToCode(value); // CodeType 3159 } else if (name.equals("profile")) { 3160 this.profile = TypeConvertor.castToCanonical(value); // CanonicalType 3161 } else if (name.equals("supportedProfile")) { 3162 this.getSupportedProfile().add(TypeConvertor.castToCanonical(value)); 3163 } else if (name.equals("documentation")) { 3164 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 3165 } else if (name.equals("feature")) { 3166 this.getFeature().add((CapabilityStatement2RestFeatureComponent) value); 3167 } else if (name.equals("interaction")) { 3168 this.getInteraction().add((ResourceInteractionComponent) value); 3169 } else if (name.equals("searchParam")) { 3170 this.getSearchParam().add((CapabilityStatement2RestResourceSearchParamComponent) value); 3171 } else if (name.equals("operation")) { 3172 this.getOperation().add((CapabilityStatement2RestResourceOperationComponent) value); 3173 } else 3174 return super.setProperty(name, value); 3175 return value; 3176 } 3177 3178 @Override 3179 public Base makeProperty(int hash, String name) throws FHIRException { 3180 switch (hash) { 3181 case 3575610: return getTypeElement(); 3182 case -309425751: return getProfileElement(); 3183 case 1225477403: return addSupportedProfileElement(); 3184 case 1587405498: return getDocumentationElement(); 3185 case -979207434: return addFeature(); 3186 case 1844104722: return addInteraction(); 3187 case -553645115: return addSearchParam(); 3188 case 1662702951: return addOperation(); 3189 default: return super.makeProperty(hash, name); 3190 } 3191 3192 } 3193 3194 @Override 3195 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 3196 switch (hash) { 3197 case 3575610: /*type*/ return new String[] {"code"}; 3198 case -309425751: /*profile*/ return new String[] {"canonical"}; 3199 case 1225477403: /*supportedProfile*/ return new String[] {"canonical"}; 3200 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 3201 case -979207434: /*feature*/ return new String[] {"@CapabilityStatement2.rest.feature"}; 3202 case 1844104722: /*interaction*/ return new String[] {}; 3203 case -553645115: /*searchParam*/ return new String[] {}; 3204 case 1662702951: /*operation*/ return new String[] {}; 3205 default: return super.getTypesForProperty(hash, name); 3206 } 3207 3208 } 3209 3210 @Override 3211 public Base addChild(String name) throws FHIRException { 3212 if (name.equals("type")) { 3213 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.resource.type"); 3214 } 3215 else if (name.equals("profile")) { 3216 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.resource.profile"); 3217 } 3218 else if (name.equals("supportedProfile")) { 3219 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.resource.supportedProfile"); 3220 } 3221 else if (name.equals("documentation")) { 3222 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.resource.documentation"); 3223 } 3224 else if (name.equals("feature")) { 3225 return addFeature(); 3226 } 3227 else if (name.equals("interaction")) { 3228 return addInteraction(); 3229 } 3230 else if (name.equals("searchParam")) { 3231 return addSearchParam(); 3232 } 3233 else if (name.equals("operation")) { 3234 return addOperation(); 3235 } 3236 else 3237 return super.addChild(name); 3238 } 3239 3240 public CapabilityStatement2RestResourceComponent copy() { 3241 CapabilityStatement2RestResourceComponent dst = new CapabilityStatement2RestResourceComponent(); 3242 copyValues(dst); 3243 return dst; 3244 } 3245 3246 public void copyValues(CapabilityStatement2RestResourceComponent dst) { 3247 super.copyValues(dst); 3248 dst.type = type == null ? null : type.copy(); 3249 dst.profile = profile == null ? null : profile.copy(); 3250 if (supportedProfile != null) { 3251 dst.supportedProfile = new ArrayList<CanonicalType>(); 3252 for (CanonicalType i : supportedProfile) 3253 dst.supportedProfile.add(i.copy()); 3254 }; 3255 dst.documentation = documentation == null ? null : documentation.copy(); 3256 if (feature != null) { 3257 dst.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 3258 for (CapabilityStatement2RestFeatureComponent i : feature) 3259 dst.feature.add(i.copy()); 3260 }; 3261 if (interaction != null) { 3262 dst.interaction = new ArrayList<ResourceInteractionComponent>(); 3263 for (ResourceInteractionComponent i : interaction) 3264 dst.interaction.add(i.copy()); 3265 }; 3266 if (searchParam != null) { 3267 dst.searchParam = new ArrayList<CapabilityStatement2RestResourceSearchParamComponent>(); 3268 for (CapabilityStatement2RestResourceSearchParamComponent i : searchParam) 3269 dst.searchParam.add(i.copy()); 3270 }; 3271 if (operation != null) { 3272 dst.operation = new ArrayList<CapabilityStatement2RestResourceOperationComponent>(); 3273 for (CapabilityStatement2RestResourceOperationComponent i : operation) 3274 dst.operation.add(i.copy()); 3275 }; 3276 } 3277 3278 @Override 3279 public boolean equalsDeep(Base other_) { 3280 if (!super.equalsDeep(other_)) 3281 return false; 3282 if (!(other_ instanceof CapabilityStatement2RestResourceComponent)) 3283 return false; 3284 CapabilityStatement2RestResourceComponent o = (CapabilityStatement2RestResourceComponent) other_; 3285 return compareDeep(type, o.type, true) && compareDeep(profile, o.profile, true) && compareDeep(supportedProfile, o.supportedProfile, true) 3286 && compareDeep(documentation, o.documentation, true) && compareDeep(feature, o.feature, true) && compareDeep(interaction, o.interaction, true) 3287 && compareDeep(searchParam, o.searchParam, true) && compareDeep(operation, o.operation, true); 3288 } 3289 3290 @Override 3291 public boolean equalsShallow(Base other_) { 3292 if (!super.equalsShallow(other_)) 3293 return false; 3294 if (!(other_ instanceof CapabilityStatement2RestResourceComponent)) 3295 return false; 3296 CapabilityStatement2RestResourceComponent o = (CapabilityStatement2RestResourceComponent) other_; 3297 return compareValues(type, o.type, true) && compareValues(profile, o.profile, true) && compareValues(supportedProfile, o.supportedProfile, true) 3298 && compareValues(documentation, o.documentation, true); 3299 } 3300 3301 public boolean isEmpty() { 3302 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, profile, supportedProfile 3303 , documentation, feature, interaction, searchParam, operation); 3304 } 3305 3306 public String fhirType() { 3307 return "CapabilityStatement2.rest.resource"; 3308 3309 } 3310 3311 } 3312 3313 @Block() 3314 public static class ResourceInteractionComponent extends BackboneElement implements IBaseBackboneElement { 3315 /** 3316 * Coded identifier of the operation, supported by the system resource. 3317 */ 3318 @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=false) 3319 @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." ) 3320 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/type-restful-interaction") 3321 protected Enumeration<TypeRestfulInteraction> code; 3322 3323 /** 3324 * 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'. 3325 */ 3326 @Child(name = "documentation", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=false) 3327 @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'." ) 3328 protected MarkdownType documentation; 3329 3330 /** 3331 * A statement that affirms support for a feature, in this context. 3332 */ 3333 @Child(name = "feature", type = {CapabilityStatement2RestFeatureComponent.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 3334 @Description(shortDefinition="Statement of support for a feature in this context", formalDefinition="A statement that affirms support for a feature, in this context." ) 3335 protected List<CapabilityStatement2RestFeatureComponent> feature; 3336 3337 private static final long serialVersionUID = -543206334L; 3338 3339 /** 3340 * Constructor 3341 */ 3342 public ResourceInteractionComponent() { 3343 super(); 3344 } 3345 3346 /** 3347 * Constructor 3348 */ 3349 public ResourceInteractionComponent(TypeRestfulInteraction code) { 3350 super(); 3351 this.setCode(code); 3352 } 3353 3354 /** 3355 * @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 3356 */ 3357 public Enumeration<TypeRestfulInteraction> getCodeElement() { 3358 if (this.code == null) 3359 if (Configuration.errorOnAutoCreate()) 3360 throw new Error("Attempt to auto-create ResourceInteractionComponent.code"); 3361 else if (Configuration.doAutoCreate()) 3362 this.code = new Enumeration<TypeRestfulInteraction>(new TypeRestfulInteractionEnumFactory()); // bb 3363 return this.code; 3364 } 3365 3366 public boolean hasCodeElement() { 3367 return this.code != null && !this.code.isEmpty(); 3368 } 3369 3370 public boolean hasCode() { 3371 return this.code != null && !this.code.isEmpty(); 3372 } 3373 3374 /** 3375 * @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 3376 */ 3377 public ResourceInteractionComponent setCodeElement(Enumeration<TypeRestfulInteraction> value) { 3378 this.code = value; 3379 return this; 3380 } 3381 3382 /** 3383 * @return Coded identifier of the operation, supported by the system resource. 3384 */ 3385 public TypeRestfulInteraction getCode() { 3386 return this.code == null ? null : this.code.getValue(); 3387 } 3388 3389 /** 3390 * @param value Coded identifier of the operation, supported by the system resource. 3391 */ 3392 public ResourceInteractionComponent setCode(TypeRestfulInteraction value) { 3393 if (this.code == null) 3394 this.code = new Enumeration<TypeRestfulInteraction>(new TypeRestfulInteractionEnumFactory()); 3395 this.code.setValue(value); 3396 return this; 3397 } 3398 3399 /** 3400 * @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 3401 */ 3402 public MarkdownType getDocumentationElement() { 3403 if (this.documentation == null) 3404 if (Configuration.errorOnAutoCreate()) 3405 throw new Error("Attempt to auto-create ResourceInteractionComponent.documentation"); 3406 else if (Configuration.doAutoCreate()) 3407 this.documentation = new MarkdownType(); // bb 3408 return this.documentation; 3409 } 3410 3411 public boolean hasDocumentationElement() { 3412 return this.documentation != null && !this.documentation.isEmpty(); 3413 } 3414 3415 public boolean hasDocumentation() { 3416 return this.documentation != null && !this.documentation.isEmpty(); 3417 } 3418 3419 /** 3420 * @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 3421 */ 3422 public ResourceInteractionComponent setDocumentationElement(MarkdownType value) { 3423 this.documentation = value; 3424 return this; 3425 } 3426 3427 /** 3428 * @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'. 3429 */ 3430 public String getDocumentation() { 3431 return this.documentation == null ? null : this.documentation.getValue(); 3432 } 3433 3434 /** 3435 * @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'. 3436 */ 3437 public ResourceInteractionComponent setDocumentation(String value) { 3438 if (value == null) 3439 this.documentation = null; 3440 else { 3441 if (this.documentation == null) 3442 this.documentation = new MarkdownType(); 3443 this.documentation.setValue(value); 3444 } 3445 return this; 3446 } 3447 3448 /** 3449 * @return {@link #feature} (A statement that affirms support for a feature, in this context.) 3450 */ 3451 public List<CapabilityStatement2RestFeatureComponent> getFeature() { 3452 if (this.feature == null) 3453 this.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 3454 return this.feature; 3455 } 3456 3457 /** 3458 * @return Returns a reference to <code>this</code> for easy method chaining 3459 */ 3460 public ResourceInteractionComponent setFeature(List<CapabilityStatement2RestFeatureComponent> theFeature) { 3461 this.feature = theFeature; 3462 return this; 3463 } 3464 3465 public boolean hasFeature() { 3466 if (this.feature == null) 3467 return false; 3468 for (CapabilityStatement2RestFeatureComponent item : this.feature) 3469 if (!item.isEmpty()) 3470 return true; 3471 return false; 3472 } 3473 3474 public CapabilityStatement2RestFeatureComponent addFeature() { //3 3475 CapabilityStatement2RestFeatureComponent t = new CapabilityStatement2RestFeatureComponent(); 3476 if (this.feature == null) 3477 this.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 3478 this.feature.add(t); 3479 return t; 3480 } 3481 3482 public ResourceInteractionComponent addFeature(CapabilityStatement2RestFeatureComponent t) { //3 3483 if (t == null) 3484 return this; 3485 if (this.feature == null) 3486 this.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 3487 this.feature.add(t); 3488 return this; 3489 } 3490 3491 /** 3492 * @return The first repetition of repeating field {@link #feature}, creating it if it does not already exist {3} 3493 */ 3494 public CapabilityStatement2RestFeatureComponent getFeatureFirstRep() { 3495 if (getFeature().isEmpty()) { 3496 addFeature(); 3497 } 3498 return getFeature().get(0); 3499 } 3500 3501 protected void listChildren(List<Property> children) { 3502 super.listChildren(children); 3503 children.add(new Property("code", "code", "Coded identifier of the operation, supported by the system resource.", 0, 1, code)); 3504 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)); 3505 children.add(new Property("feature", "@CapabilityStatement2.rest.feature", "A statement that affirms support for a feature, in this context.", 0, java.lang.Integer.MAX_VALUE, feature)); 3506 } 3507 3508 @Override 3509 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 3510 switch (_hash) { 3511 case 3059181: /*code*/ return new Property("code", "code", "Coded identifier of the operation, supported by the system resource.", 0, 1, code); 3512 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); 3513 case -979207434: /*feature*/ return new Property("feature", "@CapabilityStatement2.rest.feature", "A statement that affirms support for a feature, in this context.", 0, java.lang.Integer.MAX_VALUE, feature); 3514 default: return super.getNamedProperty(_hash, _name, _checkValid); 3515 } 3516 3517 } 3518 3519 @Override 3520 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 3521 switch (hash) { 3522 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // Enumeration<TypeRestfulInteraction> 3523 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 3524 case -979207434: /*feature*/ return this.feature == null ? new Base[0] : this.feature.toArray(new Base[this.feature.size()]); // CapabilityStatement2RestFeatureComponent 3525 default: return super.getProperty(hash, name, checkValid); 3526 } 3527 3528 } 3529 3530 @Override 3531 public Base setProperty(int hash, String name, Base value) throws FHIRException { 3532 switch (hash) { 3533 case 3059181: // code 3534 value = new TypeRestfulInteractionEnumFactory().fromType(TypeConvertor.castToCode(value)); 3535 this.code = (Enumeration) value; // Enumeration<TypeRestfulInteraction> 3536 return value; 3537 case 1587405498: // documentation 3538 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 3539 return value; 3540 case -979207434: // feature 3541 this.getFeature().add((CapabilityStatement2RestFeatureComponent) value); // CapabilityStatement2RestFeatureComponent 3542 return value; 3543 default: return super.setProperty(hash, name, value); 3544 } 3545 3546 } 3547 3548 @Override 3549 public Base setProperty(String name, Base value) throws FHIRException { 3550 if (name.equals("code")) { 3551 value = new TypeRestfulInteractionEnumFactory().fromType(TypeConvertor.castToCode(value)); 3552 this.code = (Enumeration) value; // Enumeration<TypeRestfulInteraction> 3553 } else if (name.equals("documentation")) { 3554 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 3555 } else if (name.equals("feature")) { 3556 this.getFeature().add((CapabilityStatement2RestFeatureComponent) value); 3557 } else 3558 return super.setProperty(name, value); 3559 return value; 3560 } 3561 3562 @Override 3563 public Base makeProperty(int hash, String name) throws FHIRException { 3564 switch (hash) { 3565 case 3059181: return getCodeElement(); 3566 case 1587405498: return getDocumentationElement(); 3567 case -979207434: return addFeature(); 3568 default: return super.makeProperty(hash, name); 3569 } 3570 3571 } 3572 3573 @Override 3574 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 3575 switch (hash) { 3576 case 3059181: /*code*/ return new String[] {"code"}; 3577 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 3578 case -979207434: /*feature*/ return new String[] {"@CapabilityStatement2.rest.feature"}; 3579 default: return super.getTypesForProperty(hash, name); 3580 } 3581 3582 } 3583 3584 @Override 3585 public Base addChild(String name) throws FHIRException { 3586 if (name.equals("code")) { 3587 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.resource.interaction.code"); 3588 } 3589 else if (name.equals("documentation")) { 3590 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.resource.interaction.documentation"); 3591 } 3592 else if (name.equals("feature")) { 3593 return addFeature(); 3594 } 3595 else 3596 return super.addChild(name); 3597 } 3598 3599 public ResourceInteractionComponent copy() { 3600 ResourceInteractionComponent dst = new ResourceInteractionComponent(); 3601 copyValues(dst); 3602 return dst; 3603 } 3604 3605 public void copyValues(ResourceInteractionComponent dst) { 3606 super.copyValues(dst); 3607 dst.code = code == null ? null : code.copy(); 3608 dst.documentation = documentation == null ? null : documentation.copy(); 3609 if (feature != null) { 3610 dst.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 3611 for (CapabilityStatement2RestFeatureComponent i : feature) 3612 dst.feature.add(i.copy()); 3613 }; 3614 } 3615 3616 @Override 3617 public boolean equalsDeep(Base other_) { 3618 if (!super.equalsDeep(other_)) 3619 return false; 3620 if (!(other_ instanceof ResourceInteractionComponent)) 3621 return false; 3622 ResourceInteractionComponent o = (ResourceInteractionComponent) other_; 3623 return compareDeep(code, o.code, true) && compareDeep(documentation, o.documentation, true) && compareDeep(feature, o.feature, true) 3624 ; 3625 } 3626 3627 @Override 3628 public boolean equalsShallow(Base other_) { 3629 if (!super.equalsShallow(other_)) 3630 return false; 3631 if (!(other_ instanceof ResourceInteractionComponent)) 3632 return false; 3633 ResourceInteractionComponent o = (ResourceInteractionComponent) other_; 3634 return compareValues(code, o.code, true) && compareValues(documentation, o.documentation, true); 3635 } 3636 3637 public boolean isEmpty() { 3638 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, documentation, feature 3639 ); 3640 } 3641 3642 public String fhirType() { 3643 return "CapabilityStatement2.rest.resource.interaction"; 3644 3645 } 3646 3647 } 3648 3649 @Block() 3650 public static class CapabilityStatement2RestResourceSearchParamComponent extends BackboneElement implements IBaseBackboneElement { 3651 /** 3652 * The name of the search parameter used in the interface. 3653 */ 3654 @Child(name = "name", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=false) 3655 @Description(shortDefinition="Name of search parameter", formalDefinition="The name of the search parameter used in the interface." ) 3656 protected StringType name; 3657 3658 /** 3659 * An absolute URI that is a formal reference to where this parameter was first defined, so that a client can be confident of the meaning of the search parameter (a reference to [SearchParameter.url](searchparameter-definitions.html#SearchParameter.url)). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs. 3660 */ 3661 @Child(name = "definition", type = {CanonicalType.class}, order=2, min=0, max=1, modifier=false, summary=false) 3662 @Description(shortDefinition="Source of definition for parameter", formalDefinition="An absolute URI that is a formal reference to where this parameter was first defined, so that a client can be confident of the meaning of the search parameter (a reference to [SearchParameter.url](searchparameter-definitions.html#SearchParameter.url)). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs." ) 3663 protected CanonicalType definition; 3664 3665 /** 3666 * The type of value a search parameter refers to, and how the content is interpreted. 3667 */ 3668 @Child(name = "type", type = {CodeType.class}, order=3, min=1, max=1, modifier=false, summary=false) 3669 @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." ) 3670 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/search-param-type") 3671 protected Enumeration<SearchParamType> type; 3672 3673 /** 3674 * This allows documentation of any distinct behaviors about how the search parameter is used. For example, text matching algorithms. 3675 */ 3676 @Child(name = "documentation", type = {MarkdownType.class}, order=4, min=0, max=1, modifier=false, summary=false) 3677 @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." ) 3678 protected MarkdownType documentation; 3679 3680 /** 3681 * A statement that affirms support for a feature, in this context. 3682 */ 3683 @Child(name = "feature", type = {CapabilityStatement2RestFeatureComponent.class}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 3684 @Description(shortDefinition="Statement of support for a feature in this context", formalDefinition="A statement that affirms support for a feature, in this context." ) 3685 protected List<CapabilityStatement2RestFeatureComponent> feature; 3686 3687 private static final long serialVersionUID = -300448290L; 3688 3689 /** 3690 * Constructor 3691 */ 3692 public CapabilityStatement2RestResourceSearchParamComponent() { 3693 super(); 3694 } 3695 3696 /** 3697 * Constructor 3698 */ 3699 public CapabilityStatement2RestResourceSearchParamComponent(String name, SearchParamType type) { 3700 super(); 3701 this.setName(name); 3702 this.setType(type); 3703 } 3704 3705 /** 3706 * @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 3707 */ 3708 public StringType getNameElement() { 3709 if (this.name == null) 3710 if (Configuration.errorOnAutoCreate()) 3711 throw new Error("Attempt to auto-create CapabilityStatement2RestResourceSearchParamComponent.name"); 3712 else if (Configuration.doAutoCreate()) 3713 this.name = new StringType(); // bb 3714 return this.name; 3715 } 3716 3717 public boolean hasNameElement() { 3718 return this.name != null && !this.name.isEmpty(); 3719 } 3720 3721 public boolean hasName() { 3722 return this.name != null && !this.name.isEmpty(); 3723 } 3724 3725 /** 3726 * @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 3727 */ 3728 public CapabilityStatement2RestResourceSearchParamComponent setNameElement(StringType value) { 3729 this.name = value; 3730 return this; 3731 } 3732 3733 /** 3734 * @return The name of the search parameter used in the interface. 3735 */ 3736 public String getName() { 3737 return this.name == null ? null : this.name.getValue(); 3738 } 3739 3740 /** 3741 * @param value The name of the search parameter used in the interface. 3742 */ 3743 public CapabilityStatement2RestResourceSearchParamComponent setName(String value) { 3744 if (this.name == null) 3745 this.name = new StringType(); 3746 this.name.setValue(value); 3747 return this; 3748 } 3749 3750 /** 3751 * @return {@link #definition} (An absolute URI that is a formal reference to where this parameter was first defined, so that a client can be confident of the meaning of the search parameter (a reference to [SearchParameter.url](searchparameter-definitions.html#SearchParameter.url)). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs.). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value 3752 */ 3753 public CanonicalType getDefinitionElement() { 3754 if (this.definition == null) 3755 if (Configuration.errorOnAutoCreate()) 3756 throw new Error("Attempt to auto-create CapabilityStatement2RestResourceSearchParamComponent.definition"); 3757 else if (Configuration.doAutoCreate()) 3758 this.definition = new CanonicalType(); // bb 3759 return this.definition; 3760 } 3761 3762 public boolean hasDefinitionElement() { 3763 return this.definition != null && !this.definition.isEmpty(); 3764 } 3765 3766 public boolean hasDefinition() { 3767 return this.definition != null && !this.definition.isEmpty(); 3768 } 3769 3770 /** 3771 * @param value {@link #definition} (An absolute URI that is a formal reference to where this parameter was first defined, so that a client can be confident of the meaning of the search parameter (a reference to [SearchParameter.url](searchparameter-definitions.html#SearchParameter.url)). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs.). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value 3772 */ 3773 public CapabilityStatement2RestResourceSearchParamComponent setDefinitionElement(CanonicalType value) { 3774 this.definition = value; 3775 return this; 3776 } 3777 3778 /** 3779 * @return An absolute URI that is a formal reference to where this parameter was first defined, so that a client can be confident of the meaning of the search parameter (a reference to [SearchParameter.url](searchparameter-definitions.html#SearchParameter.url)). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs. 3780 */ 3781 public String getDefinition() { 3782 return this.definition == null ? null : this.definition.getValue(); 3783 } 3784 3785 /** 3786 * @param value An absolute URI that is a formal reference to where this parameter was first defined, so that a client can be confident of the meaning of the search parameter (a reference to [SearchParameter.url](searchparameter-definitions.html#SearchParameter.url)). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs. 3787 */ 3788 public CapabilityStatement2RestResourceSearchParamComponent setDefinition(String value) { 3789 if (Utilities.noString(value)) 3790 this.definition = null; 3791 else { 3792 if (this.definition == null) 3793 this.definition = new CanonicalType(); 3794 this.definition.setValue(value); 3795 } 3796 return this; 3797 } 3798 3799 /** 3800 * @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 3801 */ 3802 public Enumeration<SearchParamType> getTypeElement() { 3803 if (this.type == null) 3804 if (Configuration.errorOnAutoCreate()) 3805 throw new Error("Attempt to auto-create CapabilityStatement2RestResourceSearchParamComponent.type"); 3806 else if (Configuration.doAutoCreate()) 3807 this.type = new Enumeration<SearchParamType>(new SearchParamTypeEnumFactory()); // bb 3808 return this.type; 3809 } 3810 3811 public boolean hasTypeElement() { 3812 return this.type != null && !this.type.isEmpty(); 3813 } 3814 3815 public boolean hasType() { 3816 return this.type != null && !this.type.isEmpty(); 3817 } 3818 3819 /** 3820 * @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 3821 */ 3822 public CapabilityStatement2RestResourceSearchParamComponent setTypeElement(Enumeration<SearchParamType> value) { 3823 this.type = value; 3824 return this; 3825 } 3826 3827 /** 3828 * @return The type of value a search parameter refers to, and how the content is interpreted. 3829 */ 3830 public SearchParamType getType() { 3831 return this.type == null ? null : this.type.getValue(); 3832 } 3833 3834 /** 3835 * @param value The type of value a search parameter refers to, and how the content is interpreted. 3836 */ 3837 public CapabilityStatement2RestResourceSearchParamComponent setType(SearchParamType value) { 3838 if (this.type == null) 3839 this.type = new Enumeration<SearchParamType>(new SearchParamTypeEnumFactory()); 3840 this.type.setValue(value); 3841 return this; 3842 } 3843 3844 /** 3845 * @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 3846 */ 3847 public MarkdownType getDocumentationElement() { 3848 if (this.documentation == null) 3849 if (Configuration.errorOnAutoCreate()) 3850 throw new Error("Attempt to auto-create CapabilityStatement2RestResourceSearchParamComponent.documentation"); 3851 else if (Configuration.doAutoCreate()) 3852 this.documentation = new MarkdownType(); // bb 3853 return this.documentation; 3854 } 3855 3856 public boolean hasDocumentationElement() { 3857 return this.documentation != null && !this.documentation.isEmpty(); 3858 } 3859 3860 public boolean hasDocumentation() { 3861 return this.documentation != null && !this.documentation.isEmpty(); 3862 } 3863 3864 /** 3865 * @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 3866 */ 3867 public CapabilityStatement2RestResourceSearchParamComponent setDocumentationElement(MarkdownType value) { 3868 this.documentation = value; 3869 return this; 3870 } 3871 3872 /** 3873 * @return This allows documentation of any distinct behaviors about how the search parameter is used. For example, text matching algorithms. 3874 */ 3875 public String getDocumentation() { 3876 return this.documentation == null ? null : this.documentation.getValue(); 3877 } 3878 3879 /** 3880 * @param value This allows documentation of any distinct behaviors about how the search parameter is used. For example, text matching algorithms. 3881 */ 3882 public CapabilityStatement2RestResourceSearchParamComponent setDocumentation(String value) { 3883 if (value == null) 3884 this.documentation = null; 3885 else { 3886 if (this.documentation == null) 3887 this.documentation = new MarkdownType(); 3888 this.documentation.setValue(value); 3889 } 3890 return this; 3891 } 3892 3893 /** 3894 * @return {@link #feature} (A statement that affirms support for a feature, in this context.) 3895 */ 3896 public List<CapabilityStatement2RestFeatureComponent> getFeature() { 3897 if (this.feature == null) 3898 this.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 3899 return this.feature; 3900 } 3901 3902 /** 3903 * @return Returns a reference to <code>this</code> for easy method chaining 3904 */ 3905 public CapabilityStatement2RestResourceSearchParamComponent setFeature(List<CapabilityStatement2RestFeatureComponent> theFeature) { 3906 this.feature = theFeature; 3907 return this; 3908 } 3909 3910 public boolean hasFeature() { 3911 if (this.feature == null) 3912 return false; 3913 for (CapabilityStatement2RestFeatureComponent item : this.feature) 3914 if (!item.isEmpty()) 3915 return true; 3916 return false; 3917 } 3918 3919 public CapabilityStatement2RestFeatureComponent addFeature() { //3 3920 CapabilityStatement2RestFeatureComponent t = new CapabilityStatement2RestFeatureComponent(); 3921 if (this.feature == null) 3922 this.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 3923 this.feature.add(t); 3924 return t; 3925 } 3926 3927 public CapabilityStatement2RestResourceSearchParamComponent addFeature(CapabilityStatement2RestFeatureComponent t) { //3 3928 if (t == null) 3929 return this; 3930 if (this.feature == null) 3931 this.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 3932 this.feature.add(t); 3933 return this; 3934 } 3935 3936 /** 3937 * @return The first repetition of repeating field {@link #feature}, creating it if it does not already exist {3} 3938 */ 3939 public CapabilityStatement2RestFeatureComponent getFeatureFirstRep() { 3940 if (getFeature().isEmpty()) { 3941 addFeature(); 3942 } 3943 return getFeature().get(0); 3944 } 3945 3946 protected void listChildren(List<Property> children) { 3947 super.listChildren(children); 3948 children.add(new Property("name", "string", "The name of the search parameter used in the interface.", 0, 1, name)); 3949 children.add(new Property("definition", "canonical(SearchParameter)", "An absolute URI that is a formal reference to where this parameter was first defined, so that a client can be confident of the meaning of the search parameter (a reference to [SearchParameter.url](searchparameter-definitions.html#SearchParameter.url)). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs.", 0, 1, definition)); 3950 children.add(new Property("type", "code", "The type of value a search parameter refers to, and how the content is interpreted.", 0, 1, type)); 3951 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)); 3952 children.add(new Property("feature", "@CapabilityStatement2.rest.feature", "A statement that affirms support for a feature, in this context.", 0, java.lang.Integer.MAX_VALUE, feature)); 3953 } 3954 3955 @Override 3956 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 3957 switch (_hash) { 3958 case 3373707: /*name*/ return new Property("name", "string", "The name of the search parameter used in the interface.", 0, 1, name); 3959 case -1014418093: /*definition*/ return new Property("definition", "canonical(SearchParameter)", "An absolute URI that is a formal reference to where this parameter was first defined, so that a client can be confident of the meaning of the search parameter (a reference to [SearchParameter.url](searchparameter-definitions.html#SearchParameter.url)). This element SHALL be populated if the search parameter refers to a SearchParameter defined by the FHIR core specification or externally defined IGs.", 0, 1, definition); 3960 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); 3961 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); 3962 case -979207434: /*feature*/ return new Property("feature", "@CapabilityStatement2.rest.feature", "A statement that affirms support for a feature, in this context.", 0, java.lang.Integer.MAX_VALUE, feature); 3963 default: return super.getNamedProperty(_hash, _name, _checkValid); 3964 } 3965 3966 } 3967 3968 @Override 3969 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 3970 switch (hash) { 3971 case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType 3972 case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : new Base[] {this.definition}; // CanonicalType 3973 case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<SearchParamType> 3974 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 3975 case -979207434: /*feature*/ return this.feature == null ? new Base[0] : this.feature.toArray(new Base[this.feature.size()]); // CapabilityStatement2RestFeatureComponent 3976 default: return super.getProperty(hash, name, checkValid); 3977 } 3978 3979 } 3980 3981 @Override 3982 public Base setProperty(int hash, String name, Base value) throws FHIRException { 3983 switch (hash) { 3984 case 3373707: // name 3985 this.name = TypeConvertor.castToString(value); // StringType 3986 return value; 3987 case -1014418093: // definition 3988 this.definition = TypeConvertor.castToCanonical(value); // CanonicalType 3989 return value; 3990 case 3575610: // type 3991 value = new SearchParamTypeEnumFactory().fromType(TypeConvertor.castToCode(value)); 3992 this.type = (Enumeration) value; // Enumeration<SearchParamType> 3993 return value; 3994 case 1587405498: // documentation 3995 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 3996 return value; 3997 case -979207434: // feature 3998 this.getFeature().add((CapabilityStatement2RestFeatureComponent) value); // CapabilityStatement2RestFeatureComponent 3999 return value; 4000 default: return super.setProperty(hash, name, value); 4001 } 4002 4003 } 4004 4005 @Override 4006 public Base setProperty(String name, Base value) throws FHIRException { 4007 if (name.equals("name")) { 4008 this.name = TypeConvertor.castToString(value); // StringType 4009 } else if (name.equals("definition")) { 4010 this.definition = TypeConvertor.castToCanonical(value); // CanonicalType 4011 } else if (name.equals("type")) { 4012 value = new SearchParamTypeEnumFactory().fromType(TypeConvertor.castToCode(value)); 4013 this.type = (Enumeration) value; // Enumeration<SearchParamType> 4014 } else if (name.equals("documentation")) { 4015 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 4016 } else if (name.equals("feature")) { 4017 this.getFeature().add((CapabilityStatement2RestFeatureComponent) value); 4018 } else 4019 return super.setProperty(name, value); 4020 return value; 4021 } 4022 4023 @Override 4024 public Base makeProperty(int hash, String name) throws FHIRException { 4025 switch (hash) { 4026 case 3373707: return getNameElement(); 4027 case -1014418093: return getDefinitionElement(); 4028 case 3575610: return getTypeElement(); 4029 case 1587405498: return getDocumentationElement(); 4030 case -979207434: return addFeature(); 4031 default: return super.makeProperty(hash, name); 4032 } 4033 4034 } 4035 4036 @Override 4037 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 4038 switch (hash) { 4039 case 3373707: /*name*/ return new String[] {"string"}; 4040 case -1014418093: /*definition*/ return new String[] {"canonical"}; 4041 case 3575610: /*type*/ return new String[] {"code"}; 4042 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 4043 case -979207434: /*feature*/ return new String[] {"@CapabilityStatement2.rest.feature"}; 4044 default: return super.getTypesForProperty(hash, name); 4045 } 4046 4047 } 4048 4049 @Override 4050 public Base addChild(String name) throws FHIRException { 4051 if (name.equals("name")) { 4052 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.resource.searchParam.name"); 4053 } 4054 else if (name.equals("definition")) { 4055 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.resource.searchParam.definition"); 4056 } 4057 else if (name.equals("type")) { 4058 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.resource.searchParam.type"); 4059 } 4060 else if (name.equals("documentation")) { 4061 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.resource.searchParam.documentation"); 4062 } 4063 else if (name.equals("feature")) { 4064 return addFeature(); 4065 } 4066 else 4067 return super.addChild(name); 4068 } 4069 4070 public CapabilityStatement2RestResourceSearchParamComponent copy() { 4071 CapabilityStatement2RestResourceSearchParamComponent dst = new CapabilityStatement2RestResourceSearchParamComponent(); 4072 copyValues(dst); 4073 return dst; 4074 } 4075 4076 public void copyValues(CapabilityStatement2RestResourceSearchParamComponent dst) { 4077 super.copyValues(dst); 4078 dst.name = name == null ? null : name.copy(); 4079 dst.definition = definition == null ? null : definition.copy(); 4080 dst.type = type == null ? null : type.copy(); 4081 dst.documentation = documentation == null ? null : documentation.copy(); 4082 if (feature != null) { 4083 dst.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 4084 for (CapabilityStatement2RestFeatureComponent i : feature) 4085 dst.feature.add(i.copy()); 4086 }; 4087 } 4088 4089 @Override 4090 public boolean equalsDeep(Base other_) { 4091 if (!super.equalsDeep(other_)) 4092 return false; 4093 if (!(other_ instanceof CapabilityStatement2RestResourceSearchParamComponent)) 4094 return false; 4095 CapabilityStatement2RestResourceSearchParamComponent o = (CapabilityStatement2RestResourceSearchParamComponent) other_; 4096 return compareDeep(name, o.name, true) && compareDeep(definition, o.definition, true) && compareDeep(type, o.type, true) 4097 && compareDeep(documentation, o.documentation, true) && compareDeep(feature, o.feature, true); 4098 } 4099 4100 @Override 4101 public boolean equalsShallow(Base other_) { 4102 if (!super.equalsShallow(other_)) 4103 return false; 4104 if (!(other_ instanceof CapabilityStatement2RestResourceSearchParamComponent)) 4105 return false; 4106 CapabilityStatement2RestResourceSearchParamComponent o = (CapabilityStatement2RestResourceSearchParamComponent) other_; 4107 return compareValues(name, o.name, true) && compareValues(definition, o.definition, true) && compareValues(type, o.type, true) 4108 && compareValues(documentation, o.documentation, true); 4109 } 4110 4111 public boolean isEmpty() { 4112 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, definition, type, documentation 4113 , feature); 4114 } 4115 4116 public String fhirType() { 4117 return "CapabilityStatement2.rest.resource.searchParam"; 4118 4119 } 4120 4121 } 4122 4123 @Block() 4124 public static class CapabilityStatement2RestResourceOperationComponent extends BackboneElement implements IBaseBackboneElement { 4125 /** 4126 * 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. 4127 */ 4128 @Child(name = "name", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true) 4129 @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." ) 4130 protected StringType name; 4131 4132 /** 4133 * Where the formal definition can be found. If a server references the base definition of an Operation (i.e. from the specification itself such as ```http://hl7.org/fhir/OperationDefinition/ValueSet-expand```), that means it supports the full capabilities of the operation - e.g. both GET and POST invocation. If it only supports a subset, it must define its own custom [OperationDefinition](operationdefinition.html#) with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported. 4134 */ 4135 @Child(name = "definition", type = {CanonicalType.class}, order=2, min=1, max=1, modifier=false, summary=true) 4136 @Description(shortDefinition="The defined operation/query", formalDefinition="Where the formal definition can be found. If a server references the base definition of an Operation (i.e. from the specification itself such as ```http://hl7.org/fhir/OperationDefinition/ValueSet-expand```), that means it supports the full capabilities of the operation - e.g. both GET and POST invocation. If it only supports a subset, it must define its own custom [OperationDefinition](operationdefinition.html#) with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported." ) 4137 protected CanonicalType definition; 4138 4139 /** 4140 * Documentation that describes anything special about the operation behavior, possibly detailing different behavior for system, type and instance-level invocation of the operation. 4141 */ 4142 @Child(name = "documentation", type = {MarkdownType.class}, order=3, min=0, max=1, modifier=false, summary=false) 4143 @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." ) 4144 protected MarkdownType documentation; 4145 4146 /** 4147 * A statement that affirms support for a feature, in this context. 4148 */ 4149 @Child(name = "feature", type = {CapabilityStatement2RestFeatureComponent.class}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 4150 @Description(shortDefinition="Statement of support for a feature in this context", formalDefinition="A statement that affirms support for a feature, in this context." ) 4151 protected List<CapabilityStatement2RestFeatureComponent> feature; 4152 4153 private static final long serialVersionUID = 1206974170L; 4154 4155 /** 4156 * Constructor 4157 */ 4158 public CapabilityStatement2RestResourceOperationComponent() { 4159 super(); 4160 } 4161 4162 /** 4163 * Constructor 4164 */ 4165 public CapabilityStatement2RestResourceOperationComponent(String name, String definition) { 4166 super(); 4167 this.setName(name); 4168 this.setDefinition(definition); 4169 } 4170 4171 /** 4172 * @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 4173 */ 4174 public StringType getNameElement() { 4175 if (this.name == null) 4176 if (Configuration.errorOnAutoCreate()) 4177 throw new Error("Attempt to auto-create CapabilityStatement2RestResourceOperationComponent.name"); 4178 else if (Configuration.doAutoCreate()) 4179 this.name = new StringType(); // bb 4180 return this.name; 4181 } 4182 4183 public boolean hasNameElement() { 4184 return this.name != null && !this.name.isEmpty(); 4185 } 4186 4187 public boolean hasName() { 4188 return this.name != null && !this.name.isEmpty(); 4189 } 4190 4191 /** 4192 * @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 4193 */ 4194 public CapabilityStatement2RestResourceOperationComponent setNameElement(StringType value) { 4195 this.name = value; 4196 return this; 4197 } 4198 4199 /** 4200 * @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. 4201 */ 4202 public String getName() { 4203 return this.name == null ? null : this.name.getValue(); 4204 } 4205 4206 /** 4207 * @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. 4208 */ 4209 public CapabilityStatement2RestResourceOperationComponent setName(String value) { 4210 if (this.name == null) 4211 this.name = new StringType(); 4212 this.name.setValue(value); 4213 return this; 4214 } 4215 4216 /** 4217 * @return {@link #definition} (Where the formal definition can be found. If a server references the base definition of an Operation (i.e. from the specification itself such as ```http://hl7.org/fhir/OperationDefinition/ValueSet-expand```), that means it supports the full capabilities of the operation - e.g. both GET and POST invocation. If it only supports a subset, it must define its own custom [OperationDefinition](operationdefinition.html#) with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported.). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value 4218 */ 4219 public CanonicalType getDefinitionElement() { 4220 if (this.definition == null) 4221 if (Configuration.errorOnAutoCreate()) 4222 throw new Error("Attempt to auto-create CapabilityStatement2RestResourceOperationComponent.definition"); 4223 else if (Configuration.doAutoCreate()) 4224 this.definition = new CanonicalType(); // bb 4225 return this.definition; 4226 } 4227 4228 public boolean hasDefinitionElement() { 4229 return this.definition != null && !this.definition.isEmpty(); 4230 } 4231 4232 public boolean hasDefinition() { 4233 return this.definition != null && !this.definition.isEmpty(); 4234 } 4235 4236 /** 4237 * @param value {@link #definition} (Where the formal definition can be found. If a server references the base definition of an Operation (i.e. from the specification itself such as ```http://hl7.org/fhir/OperationDefinition/ValueSet-expand```), that means it supports the full capabilities of the operation - e.g. both GET and POST invocation. If it only supports a subset, it must define its own custom [OperationDefinition](operationdefinition.html#) with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported.). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value 4238 */ 4239 public CapabilityStatement2RestResourceOperationComponent setDefinitionElement(CanonicalType value) { 4240 this.definition = value; 4241 return this; 4242 } 4243 4244 /** 4245 * @return Where the formal definition can be found. If a server references the base definition of an Operation (i.e. from the specification itself such as ```http://hl7.org/fhir/OperationDefinition/ValueSet-expand```), that means it supports the full capabilities of the operation - e.g. both GET and POST invocation. If it only supports a subset, it must define its own custom [OperationDefinition](operationdefinition.html#) with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported. 4246 */ 4247 public String getDefinition() { 4248 return this.definition == null ? null : this.definition.getValue(); 4249 } 4250 4251 /** 4252 * @param value Where the formal definition can be found. If a server references the base definition of an Operation (i.e. from the specification itself such as ```http://hl7.org/fhir/OperationDefinition/ValueSet-expand```), that means it supports the full capabilities of the operation - e.g. both GET and POST invocation. If it only supports a subset, it must define its own custom [OperationDefinition](operationdefinition.html#) with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported. 4253 */ 4254 public CapabilityStatement2RestResourceOperationComponent setDefinition(String value) { 4255 if (this.definition == null) 4256 this.definition = new CanonicalType(); 4257 this.definition.setValue(value); 4258 return this; 4259 } 4260 4261 /** 4262 * @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 4263 */ 4264 public MarkdownType getDocumentationElement() { 4265 if (this.documentation == null) 4266 if (Configuration.errorOnAutoCreate()) 4267 throw new Error("Attempt to auto-create CapabilityStatement2RestResourceOperationComponent.documentation"); 4268 else if (Configuration.doAutoCreate()) 4269 this.documentation = new MarkdownType(); // bb 4270 return this.documentation; 4271 } 4272 4273 public boolean hasDocumentationElement() { 4274 return this.documentation != null && !this.documentation.isEmpty(); 4275 } 4276 4277 public boolean hasDocumentation() { 4278 return this.documentation != null && !this.documentation.isEmpty(); 4279 } 4280 4281 /** 4282 * @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 4283 */ 4284 public CapabilityStatement2RestResourceOperationComponent setDocumentationElement(MarkdownType value) { 4285 this.documentation = value; 4286 return this; 4287 } 4288 4289 /** 4290 * @return Documentation that describes anything special about the operation behavior, possibly detailing different behavior for system, type and instance-level invocation of the operation. 4291 */ 4292 public String getDocumentation() { 4293 return this.documentation == null ? null : this.documentation.getValue(); 4294 } 4295 4296 /** 4297 * @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. 4298 */ 4299 public CapabilityStatement2RestResourceOperationComponent setDocumentation(String value) { 4300 if (value == null) 4301 this.documentation = null; 4302 else { 4303 if (this.documentation == null) 4304 this.documentation = new MarkdownType(); 4305 this.documentation.setValue(value); 4306 } 4307 return this; 4308 } 4309 4310 /** 4311 * @return {@link #feature} (A statement that affirms support for a feature, in this context.) 4312 */ 4313 public List<CapabilityStatement2RestFeatureComponent> getFeature() { 4314 if (this.feature == null) 4315 this.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 4316 return this.feature; 4317 } 4318 4319 /** 4320 * @return Returns a reference to <code>this</code> for easy method chaining 4321 */ 4322 public CapabilityStatement2RestResourceOperationComponent setFeature(List<CapabilityStatement2RestFeatureComponent> theFeature) { 4323 this.feature = theFeature; 4324 return this; 4325 } 4326 4327 public boolean hasFeature() { 4328 if (this.feature == null) 4329 return false; 4330 for (CapabilityStatement2RestFeatureComponent item : this.feature) 4331 if (!item.isEmpty()) 4332 return true; 4333 return false; 4334 } 4335 4336 public CapabilityStatement2RestFeatureComponent addFeature() { //3 4337 CapabilityStatement2RestFeatureComponent t = new CapabilityStatement2RestFeatureComponent(); 4338 if (this.feature == null) 4339 this.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 4340 this.feature.add(t); 4341 return t; 4342 } 4343 4344 public CapabilityStatement2RestResourceOperationComponent addFeature(CapabilityStatement2RestFeatureComponent t) { //3 4345 if (t == null) 4346 return this; 4347 if (this.feature == null) 4348 this.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 4349 this.feature.add(t); 4350 return this; 4351 } 4352 4353 /** 4354 * @return The first repetition of repeating field {@link #feature}, creating it if it does not already exist {3} 4355 */ 4356 public CapabilityStatement2RestFeatureComponent getFeatureFirstRep() { 4357 if (getFeature().isEmpty()) { 4358 addFeature(); 4359 } 4360 return getFeature().get(0); 4361 } 4362 4363 protected void listChildren(List<Property> children) { 4364 super.listChildren(children); 4365 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)); 4366 children.add(new Property("definition", "canonical(OperationDefinition)", "Where the formal definition can be found. If a server references the base definition of an Operation (i.e. from the specification itself such as ```http://hl7.org/fhir/OperationDefinition/ValueSet-expand```), that means it supports the full capabilities of the operation - e.g. both GET and POST invocation. If it only supports a subset, it must define its own custom [OperationDefinition](operationdefinition.html#) with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported.", 0, 1, definition)); 4367 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)); 4368 children.add(new Property("feature", "@CapabilityStatement2.rest.feature", "A statement that affirms support for a feature, in this context.", 0, java.lang.Integer.MAX_VALUE, feature)); 4369 } 4370 4371 @Override 4372 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 4373 switch (_hash) { 4374 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); 4375 case -1014418093: /*definition*/ return new Property("definition", "canonical(OperationDefinition)", "Where the formal definition can be found. If a server references the base definition of an Operation (i.e. from the specification itself such as ```http://hl7.org/fhir/OperationDefinition/ValueSet-expand```), that means it supports the full capabilities of the operation - e.g. both GET and POST invocation. If it only supports a subset, it must define its own custom [OperationDefinition](operationdefinition.html#) with a 'base' of the original OperationDefinition. The custom definition would describe the specific subset of functionality supported.", 0, 1, definition); 4376 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); 4377 case -979207434: /*feature*/ return new Property("feature", "@CapabilityStatement2.rest.feature", "A statement that affirms support for a feature, in this context.", 0, java.lang.Integer.MAX_VALUE, feature); 4378 default: return super.getNamedProperty(_hash, _name, _checkValid); 4379 } 4380 4381 } 4382 4383 @Override 4384 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 4385 switch (hash) { 4386 case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType 4387 case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : new Base[] {this.definition}; // CanonicalType 4388 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 4389 case -979207434: /*feature*/ return this.feature == null ? new Base[0] : this.feature.toArray(new Base[this.feature.size()]); // CapabilityStatement2RestFeatureComponent 4390 default: return super.getProperty(hash, name, checkValid); 4391 } 4392 4393 } 4394 4395 @Override 4396 public Base setProperty(int hash, String name, Base value) throws FHIRException { 4397 switch (hash) { 4398 case 3373707: // name 4399 this.name = TypeConvertor.castToString(value); // StringType 4400 return value; 4401 case -1014418093: // definition 4402 this.definition = TypeConvertor.castToCanonical(value); // CanonicalType 4403 return value; 4404 case 1587405498: // documentation 4405 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 4406 return value; 4407 case -979207434: // feature 4408 this.getFeature().add((CapabilityStatement2RestFeatureComponent) value); // CapabilityStatement2RestFeatureComponent 4409 return value; 4410 default: return super.setProperty(hash, name, value); 4411 } 4412 4413 } 4414 4415 @Override 4416 public Base setProperty(String name, Base value) throws FHIRException { 4417 if (name.equals("name")) { 4418 this.name = TypeConvertor.castToString(value); // StringType 4419 } else if (name.equals("definition")) { 4420 this.definition = TypeConvertor.castToCanonical(value); // CanonicalType 4421 } else if (name.equals("documentation")) { 4422 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 4423 } else if (name.equals("feature")) { 4424 this.getFeature().add((CapabilityStatement2RestFeatureComponent) value); 4425 } else 4426 return super.setProperty(name, value); 4427 return value; 4428 } 4429 4430 @Override 4431 public Base makeProperty(int hash, String name) throws FHIRException { 4432 switch (hash) { 4433 case 3373707: return getNameElement(); 4434 case -1014418093: return getDefinitionElement(); 4435 case 1587405498: return getDocumentationElement(); 4436 case -979207434: return addFeature(); 4437 default: return super.makeProperty(hash, name); 4438 } 4439 4440 } 4441 4442 @Override 4443 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 4444 switch (hash) { 4445 case 3373707: /*name*/ return new String[] {"string"}; 4446 case -1014418093: /*definition*/ return new String[] {"canonical"}; 4447 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 4448 case -979207434: /*feature*/ return new String[] {"@CapabilityStatement2.rest.feature"}; 4449 default: return super.getTypesForProperty(hash, name); 4450 } 4451 4452 } 4453 4454 @Override 4455 public Base addChild(String name) throws FHIRException { 4456 if (name.equals("name")) { 4457 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.resource.operation.name"); 4458 } 4459 else if (name.equals("definition")) { 4460 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.resource.operation.definition"); 4461 } 4462 else if (name.equals("documentation")) { 4463 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.resource.operation.documentation"); 4464 } 4465 else if (name.equals("feature")) { 4466 return addFeature(); 4467 } 4468 else 4469 return super.addChild(name); 4470 } 4471 4472 public CapabilityStatement2RestResourceOperationComponent copy() { 4473 CapabilityStatement2RestResourceOperationComponent dst = new CapabilityStatement2RestResourceOperationComponent(); 4474 copyValues(dst); 4475 return dst; 4476 } 4477 4478 public void copyValues(CapabilityStatement2RestResourceOperationComponent dst) { 4479 super.copyValues(dst); 4480 dst.name = name == null ? null : name.copy(); 4481 dst.definition = definition == null ? null : definition.copy(); 4482 dst.documentation = documentation == null ? null : documentation.copy(); 4483 if (feature != null) { 4484 dst.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 4485 for (CapabilityStatement2RestFeatureComponent i : feature) 4486 dst.feature.add(i.copy()); 4487 }; 4488 } 4489 4490 @Override 4491 public boolean equalsDeep(Base other_) { 4492 if (!super.equalsDeep(other_)) 4493 return false; 4494 if (!(other_ instanceof CapabilityStatement2RestResourceOperationComponent)) 4495 return false; 4496 CapabilityStatement2RestResourceOperationComponent o = (CapabilityStatement2RestResourceOperationComponent) other_; 4497 return compareDeep(name, o.name, true) && compareDeep(definition, o.definition, true) && compareDeep(documentation, o.documentation, true) 4498 && compareDeep(feature, o.feature, true); 4499 } 4500 4501 @Override 4502 public boolean equalsShallow(Base other_) { 4503 if (!super.equalsShallow(other_)) 4504 return false; 4505 if (!(other_ instanceof CapabilityStatement2RestResourceOperationComponent)) 4506 return false; 4507 CapabilityStatement2RestResourceOperationComponent o = (CapabilityStatement2RestResourceOperationComponent) other_; 4508 return compareValues(name, o.name, true) && compareValues(definition, o.definition, true) && compareValues(documentation, o.documentation, true) 4509 ; 4510 } 4511 4512 public boolean isEmpty() { 4513 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, definition, documentation 4514 , feature); 4515 } 4516 4517 public String fhirType() { 4518 return "CapabilityStatement2.rest.resource.operation"; 4519 4520 } 4521 4522 } 4523 4524 @Block() 4525 public static class SystemInteractionComponent extends BackboneElement implements IBaseBackboneElement { 4526 /** 4527 * A coded identifier of the operation, supported by the system. 4528 */ 4529 @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=false) 4530 @Description(shortDefinition="transaction | batch | search-system | history-system", formalDefinition="A coded identifier of the operation, supported by the system." ) 4531 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/system-restful-interaction") 4532 protected Enumeration<SystemRestfulInteraction> code; 4533 4534 /** 4535 * 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. 4536 */ 4537 @Child(name = "documentation", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=false) 4538 @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." ) 4539 protected MarkdownType documentation; 4540 4541 /** 4542 * A statement that affirms support for a feature, in this context. 4543 */ 4544 @Child(name = "feature", type = {CapabilityStatement2RestFeatureComponent.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false) 4545 @Description(shortDefinition="Statement of support for a feature in this context", formalDefinition="A statement that affirms support for a feature, in this context." ) 4546 protected List<CapabilityStatement2RestFeatureComponent> feature; 4547 4548 private static final long serialVersionUID = 353704493L; 4549 4550 /** 4551 * Constructor 4552 */ 4553 public SystemInteractionComponent() { 4554 super(); 4555 } 4556 4557 /** 4558 * Constructor 4559 */ 4560 public SystemInteractionComponent(SystemRestfulInteraction code) { 4561 super(); 4562 this.setCode(code); 4563 } 4564 4565 /** 4566 * @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 4567 */ 4568 public Enumeration<SystemRestfulInteraction> getCodeElement() { 4569 if (this.code == null) 4570 if (Configuration.errorOnAutoCreate()) 4571 throw new Error("Attempt to auto-create SystemInteractionComponent.code"); 4572 else if (Configuration.doAutoCreate()) 4573 this.code = new Enumeration<SystemRestfulInteraction>(new SystemRestfulInteractionEnumFactory()); // bb 4574 return this.code; 4575 } 4576 4577 public boolean hasCodeElement() { 4578 return this.code != null && !this.code.isEmpty(); 4579 } 4580 4581 public boolean hasCode() { 4582 return this.code != null && !this.code.isEmpty(); 4583 } 4584 4585 /** 4586 * @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 4587 */ 4588 public SystemInteractionComponent setCodeElement(Enumeration<SystemRestfulInteraction> value) { 4589 this.code = value; 4590 return this; 4591 } 4592 4593 /** 4594 * @return A coded identifier of the operation, supported by the system. 4595 */ 4596 public SystemRestfulInteraction getCode() { 4597 return this.code == null ? null : this.code.getValue(); 4598 } 4599 4600 /** 4601 * @param value A coded identifier of the operation, supported by the system. 4602 */ 4603 public SystemInteractionComponent setCode(SystemRestfulInteraction value) { 4604 if (this.code == null) 4605 this.code = new Enumeration<SystemRestfulInteraction>(new SystemRestfulInteractionEnumFactory()); 4606 this.code.setValue(value); 4607 return this; 4608 } 4609 4610 /** 4611 * @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 4612 */ 4613 public MarkdownType getDocumentationElement() { 4614 if (this.documentation == null) 4615 if (Configuration.errorOnAutoCreate()) 4616 throw new Error("Attempt to auto-create SystemInteractionComponent.documentation"); 4617 else if (Configuration.doAutoCreate()) 4618 this.documentation = new MarkdownType(); // bb 4619 return this.documentation; 4620 } 4621 4622 public boolean hasDocumentationElement() { 4623 return this.documentation != null && !this.documentation.isEmpty(); 4624 } 4625 4626 public boolean hasDocumentation() { 4627 return this.documentation != null && !this.documentation.isEmpty(); 4628 } 4629 4630 /** 4631 * @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 4632 */ 4633 public SystemInteractionComponent setDocumentationElement(MarkdownType value) { 4634 this.documentation = value; 4635 return this; 4636 } 4637 4638 /** 4639 * @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. 4640 */ 4641 public String getDocumentation() { 4642 return this.documentation == null ? null : this.documentation.getValue(); 4643 } 4644 4645 /** 4646 * @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. 4647 */ 4648 public SystemInteractionComponent setDocumentation(String value) { 4649 if (value == null) 4650 this.documentation = null; 4651 else { 4652 if (this.documentation == null) 4653 this.documentation = new MarkdownType(); 4654 this.documentation.setValue(value); 4655 } 4656 return this; 4657 } 4658 4659 /** 4660 * @return {@link #feature} (A statement that affirms support for a feature, in this context.) 4661 */ 4662 public List<CapabilityStatement2RestFeatureComponent> getFeature() { 4663 if (this.feature == null) 4664 this.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 4665 return this.feature; 4666 } 4667 4668 /** 4669 * @return Returns a reference to <code>this</code> for easy method chaining 4670 */ 4671 public SystemInteractionComponent setFeature(List<CapabilityStatement2RestFeatureComponent> theFeature) { 4672 this.feature = theFeature; 4673 return this; 4674 } 4675 4676 public boolean hasFeature() { 4677 if (this.feature == null) 4678 return false; 4679 for (CapabilityStatement2RestFeatureComponent item : this.feature) 4680 if (!item.isEmpty()) 4681 return true; 4682 return false; 4683 } 4684 4685 public CapabilityStatement2RestFeatureComponent addFeature() { //3 4686 CapabilityStatement2RestFeatureComponent t = new CapabilityStatement2RestFeatureComponent(); 4687 if (this.feature == null) 4688 this.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 4689 this.feature.add(t); 4690 return t; 4691 } 4692 4693 public SystemInteractionComponent addFeature(CapabilityStatement2RestFeatureComponent t) { //3 4694 if (t == null) 4695 return this; 4696 if (this.feature == null) 4697 this.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 4698 this.feature.add(t); 4699 return this; 4700 } 4701 4702 /** 4703 * @return The first repetition of repeating field {@link #feature}, creating it if it does not already exist {3} 4704 */ 4705 public CapabilityStatement2RestFeatureComponent getFeatureFirstRep() { 4706 if (getFeature().isEmpty()) { 4707 addFeature(); 4708 } 4709 return getFeature().get(0); 4710 } 4711 4712 protected void listChildren(List<Property> children) { 4713 super.listChildren(children); 4714 children.add(new Property("code", "code", "A coded identifier of the operation, supported by the system.", 0, 1, code)); 4715 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)); 4716 children.add(new Property("feature", "@CapabilityStatement2.rest.feature", "A statement that affirms support for a feature, in this context.", 0, java.lang.Integer.MAX_VALUE, feature)); 4717 } 4718 4719 @Override 4720 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 4721 switch (_hash) { 4722 case 3059181: /*code*/ return new Property("code", "code", "A coded identifier of the operation, supported by the system.", 0, 1, code); 4723 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); 4724 case -979207434: /*feature*/ return new Property("feature", "@CapabilityStatement2.rest.feature", "A statement that affirms support for a feature, in this context.", 0, java.lang.Integer.MAX_VALUE, feature); 4725 default: return super.getNamedProperty(_hash, _name, _checkValid); 4726 } 4727 4728 } 4729 4730 @Override 4731 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 4732 switch (hash) { 4733 case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // Enumeration<SystemRestfulInteraction> 4734 case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType 4735 case -979207434: /*feature*/ return this.feature == null ? new Base[0] : this.feature.toArray(new Base[this.feature.size()]); // CapabilityStatement2RestFeatureComponent 4736 default: return super.getProperty(hash, name, checkValid); 4737 } 4738 4739 } 4740 4741 @Override 4742 public Base setProperty(int hash, String name, Base value) throws FHIRException { 4743 switch (hash) { 4744 case 3059181: // code 4745 value = new SystemRestfulInteractionEnumFactory().fromType(TypeConvertor.castToCode(value)); 4746 this.code = (Enumeration) value; // Enumeration<SystemRestfulInteraction> 4747 return value; 4748 case 1587405498: // documentation 4749 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 4750 return value; 4751 case -979207434: // feature 4752 this.getFeature().add((CapabilityStatement2RestFeatureComponent) value); // CapabilityStatement2RestFeatureComponent 4753 return value; 4754 default: return super.setProperty(hash, name, value); 4755 } 4756 4757 } 4758 4759 @Override 4760 public Base setProperty(String name, Base value) throws FHIRException { 4761 if (name.equals("code")) { 4762 value = new SystemRestfulInteractionEnumFactory().fromType(TypeConvertor.castToCode(value)); 4763 this.code = (Enumeration) value; // Enumeration<SystemRestfulInteraction> 4764 } else if (name.equals("documentation")) { 4765 this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType 4766 } else if (name.equals("feature")) { 4767 this.getFeature().add((CapabilityStatement2RestFeatureComponent) value); 4768 } else 4769 return super.setProperty(name, value); 4770 return value; 4771 } 4772 4773 @Override 4774 public Base makeProperty(int hash, String name) throws FHIRException { 4775 switch (hash) { 4776 case 3059181: return getCodeElement(); 4777 case 1587405498: return getDocumentationElement(); 4778 case -979207434: return addFeature(); 4779 default: return super.makeProperty(hash, name); 4780 } 4781 4782 } 4783 4784 @Override 4785 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 4786 switch (hash) { 4787 case 3059181: /*code*/ return new String[] {"code"}; 4788 case 1587405498: /*documentation*/ return new String[] {"markdown"}; 4789 case -979207434: /*feature*/ return new String[] {"@CapabilityStatement2.rest.feature"}; 4790 default: return super.getTypesForProperty(hash, name); 4791 } 4792 4793 } 4794 4795 @Override 4796 public Base addChild(String name) throws FHIRException { 4797 if (name.equals("code")) { 4798 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.interaction.code"); 4799 } 4800 else if (name.equals("documentation")) { 4801 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.rest.interaction.documentation"); 4802 } 4803 else if (name.equals("feature")) { 4804 return addFeature(); 4805 } 4806 else 4807 return super.addChild(name); 4808 } 4809 4810 public SystemInteractionComponent copy() { 4811 SystemInteractionComponent dst = new SystemInteractionComponent(); 4812 copyValues(dst); 4813 return dst; 4814 } 4815 4816 public void copyValues(SystemInteractionComponent dst) { 4817 super.copyValues(dst); 4818 dst.code = code == null ? null : code.copy(); 4819 dst.documentation = documentation == null ? null : documentation.copy(); 4820 if (feature != null) { 4821 dst.feature = new ArrayList<CapabilityStatement2RestFeatureComponent>(); 4822 for (CapabilityStatement2RestFeatureComponent i : feature) 4823 dst.feature.add(i.copy()); 4824 }; 4825 } 4826 4827 @Override 4828 public boolean equalsDeep(Base other_) { 4829 if (!super.equalsDeep(other_)) 4830 return false; 4831 if (!(other_ instanceof SystemInteractionComponent)) 4832 return false; 4833 SystemInteractionComponent o = (SystemInteractionComponent) other_; 4834 return compareDeep(code, o.code, true) && compareDeep(documentation, o.documentation, true) && compareDeep(feature, o.feature, true) 4835 ; 4836 } 4837 4838 @Override 4839 public boolean equalsShallow(Base other_) { 4840 if (!super.equalsShallow(other_)) 4841 return false; 4842 if (!(other_ instanceof SystemInteractionComponent)) 4843 return false; 4844 SystemInteractionComponent o = (SystemInteractionComponent) other_; 4845 return compareValues(code, o.code, true) && compareValues(documentation, o.documentation, true); 4846 } 4847 4848 public boolean isEmpty() { 4849 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, documentation, feature 4850 ); 4851 } 4852 4853 public String fhirType() { 4854 return "CapabilityStatement2.rest.interaction"; 4855 4856 } 4857 4858 } 4859 4860 /** 4861 * An absolute URI that is used to identify this capability statement2 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 statement2 is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement2 is stored on different servers. 4862 */ 4863 @Child(name = "url", type = {UriType.class}, order=0, min=0, max=1, modifier=false, summary=true) 4864 @Description(shortDefinition="Canonical identifier for this capability statement2, represented as a URI (globally unique)", formalDefinition="An absolute URI that is used to identify this capability statement2 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 statement2 is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement2 is stored on different servers." ) 4865 protected UriType url; 4866 4867 /** 4868 * The identifier that is used to identify this version of the capability statement2 when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement2 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. 4869 */ 4870 @Child(name = "version", type = {StringType.class}, order=1, min=0, max=1, modifier=false, summary=true) 4871 @Description(shortDefinition="Business version of the capability statement2", formalDefinition="The identifier that is used to identify this version of the capability statement2 when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement2 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." ) 4872 protected StringType version; 4873 4874 /** 4875 * A natural language name identifying the capability statement2. This name should be usable as an identifier for the module by machine processing applications such as code generation. 4876 */ 4877 @Child(name = "name", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true) 4878 @Description(shortDefinition="Name for this capability statement2 (computer friendly)", formalDefinition="A natural language name identifying the capability statement2. This name should be usable as an identifier for the module by machine processing applications such as code generation." ) 4879 protected StringType name; 4880 4881 /** 4882 * A short, descriptive, user-friendly title for the capability statement2. 4883 */ 4884 @Child(name = "title", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=true) 4885 @Description(shortDefinition="Name for this capability statement2 (human friendly)", formalDefinition="A short, descriptive, user-friendly title for the capability statement2." ) 4886 protected StringType title; 4887 4888 /** 4889 * The status of this capability statement2. Enables tracking the life-cycle of the content. 4890 */ 4891 @Child(name = "status", type = {CodeType.class}, order=4, min=1, max=1, modifier=true, summary=true) 4892 @Description(shortDefinition="draft | active | retired | unknown", formalDefinition="The status of this capability statement2. Enables tracking the life-cycle of the content." ) 4893 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/publication-status") 4894 protected Enumeration<PublicationStatus> status; 4895 4896 /** 4897 * A Boolean value to indicate that this capability statement2 is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage. 4898 */ 4899 @Child(name = "experimental", type = {BooleanType.class}, order=5, min=0, max=1, modifier=false, summary=true) 4900 @Description(shortDefinition="For testing purposes, not real usage", formalDefinition="A Boolean value to indicate that this capability statement2 is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage." ) 4901 protected BooleanType experimental; 4902 4903 /** 4904 * The date (and optionally time) when the capability statement2 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 statement2 changes. 4905 */ 4906 @Child(name = "date", type = {DateTimeType.class}, order=6, min=1, max=1, modifier=false, summary=true) 4907 @Description(shortDefinition="Date last changed", formalDefinition="The date (and optionally time) when the capability statement2 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 statement2 changes." ) 4908 protected DateTimeType date; 4909 4910 /** 4911 * The name of the organization or individual that published the capability statement2. 4912 */ 4913 @Child(name = "publisher", type = {StringType.class}, order=7, min=0, max=1, modifier=false, summary=true) 4914 @Description(shortDefinition="Name of the publisher (organization or individual)", formalDefinition="The name of the organization or individual that published the capability statement2." ) 4915 protected StringType publisher; 4916 4917 /** 4918 * Contact details to assist a user in finding and communicating with the publisher. 4919 */ 4920 @Child(name = "contact", type = {ContactDetail.class}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 4921 @Description(shortDefinition="Contact details for the publisher", formalDefinition="Contact details to assist a user in finding and communicating with the publisher." ) 4922 protected List<ContactDetail> contact; 4923 4924 /** 4925 * A free text natural language description of the capability statement2 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. 4926 */ 4927 @Child(name = "description", type = {MarkdownType.class}, order=9, min=0, max=1, modifier=false, summary=false) 4928 @Description(shortDefinition="Natural language description of the capability statement2", formalDefinition="A free text natural language description of the capability statement2 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." ) 4929 protected MarkdownType description; 4930 4931 /** 4932 * 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 statement2 instances. 4933 */ 4934 @Child(name = "useContext", type = {UsageContext.class}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 4935 @Description(shortDefinition="The context that the content is intended to support", formalDefinition="The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate capability statement2 instances." ) 4936 protected List<UsageContext> useContext; 4937 4938 /** 4939 * A legal or geographic region in which the capability statement2 is intended to be used. 4940 */ 4941 @Child(name = "jurisdiction", type = {CodeableConcept.class}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 4942 @Description(shortDefinition="Intended jurisdiction for capability statement2 (if applicable)", formalDefinition="A legal or geographic region in which the capability statement2 is intended to be used." ) 4943 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/jurisdiction") 4944 protected List<CodeableConcept> jurisdiction; 4945 4946 /** 4947 * Explanation of why this capability statement2 is needed and why it has been designed as it has. 4948 */ 4949 @Child(name = "purpose", type = {MarkdownType.class}, order=12, min=0, max=1, modifier=false, summary=false) 4950 @Description(shortDefinition="Why this capability statement2 is defined", formalDefinition="Explanation of why this capability statement2 is needed and why it has been designed as it has." ) 4951 protected MarkdownType purpose; 4952 4953 /** 4954 * A copyright statement relating to the capability statement2 and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement2. 4955 */ 4956 @Child(name = "copyright", type = {MarkdownType.class}, order=13, min=0, max=1, modifier=false, summary=false) 4957 @Description(shortDefinition="Use and/or publishing restrictions", formalDefinition="A copyright statement relating to the capability statement2 and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement2." ) 4958 protected MarkdownType copyright; 4959 4960 /** 4961 * 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). 4962 */ 4963 @Child(name = "kind", type = {CodeType.class}, order=14, min=1, max=1, modifier=false, summary=true) 4964 @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)." ) 4965 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/capability-statement-kind") 4966 protected Enumeration<CapabilityStatementKind> kind; 4967 4968 /** 4969 * Reference to a canonical URL of another CapabilityStatement2 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. 4970 */ 4971 @Child(name = "instantiates", type = {CanonicalType.class}, order=15, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 4972 @Description(shortDefinition="Canonical URL of another capability statement this implements", formalDefinition="Reference to a canonical URL of another CapabilityStatement2 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." ) 4973 protected List<CanonicalType> instantiates; 4974 4975 /** 4976 * Reference to a canonical URL of another CapabilityStatement2 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. 4977 */ 4978 @Child(name = "imports", type = {CanonicalType.class}, order=16, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 4979 @Description(shortDefinition="Canonical URL of another capability statement this adds to", formalDefinition="Reference to a canonical URL of another CapabilityStatement2 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." ) 4980 protected List<CanonicalType> imports; 4981 4982 /** 4983 * 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. 4984 */ 4985 @Child(name = "software", type = {}, order=17, min=0, max=1, modifier=false, summary=true) 4986 @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." ) 4987 protected CapabilityStatement2SoftwareComponent software; 4988 4989 /** 4990 * 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. 4991 */ 4992 @Child(name = "implementation", type = {}, order=18, min=0, max=1, modifier=false, summary=true) 4993 @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." ) 4994 protected CapabilityStatement2ImplementationComponent implementation; 4995 4996 /** 4997 * The version of the FHIR specification that this CapabilityStatement2 describes (which SHALL be the same as the FHIR version of the CapabilityStatement2 itself). There is no default value. 4998 */ 4999 @Child(name = "fhirVersion", type = {CodeType.class}, order=19, min=1, max=1, modifier=false, summary=true) 5000 @Description(shortDefinition="FHIR Version the system supports", formalDefinition="The version of the FHIR specification that this CapabilityStatement2 describes (which SHALL be the same as the FHIR version of the CapabilityStatement2 itself). There is no default value." ) 5001 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/FHIR-version") 5002 protected Enumeration<FHIRVersion> fhirVersion; 5003 5004 /** 5005 * A list of the formats supported by this implementation using their content types. 5006 */ 5007 @Child(name = "format", type = {CodeType.class}, order=20, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 5008 @Description(shortDefinition="formats supported (xml | json | ttl | mime type)", formalDefinition="A list of the formats supported by this implementation using their content types." ) 5009 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/mimetypes") 5010 protected List<CodeType> format; 5011 5012 /** 5013 * A list of the patch formats supported by this implementation using their content types. 5014 */ 5015 @Child(name = "patchFormat", type = {CodeType.class}, order=21, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 5016 @Description(shortDefinition="Patch formats supported", formalDefinition="A list of the patch formats supported by this implementation using their content types." ) 5017 @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/mimetypes") 5018 protected List<CodeType> patchFormat; 5019 5020 /** 5021 * A list of implementation guides that the server does (or should) support in their entirety. 5022 */ 5023 @Child(name = "implementationGuide", type = {CanonicalType.class}, order=22, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 5024 @Description(shortDefinition="Implementation guides supported", formalDefinition="A list of implementation guides that the server does (or should) support in their entirety." ) 5025 protected List<CanonicalType> implementationGuide; 5026 5027 /** 5028 * A definition of the restful capabilities of the solution, if any. 5029 */ 5030 @Child(name = "rest", type = {}, order=23, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true) 5031 @Description(shortDefinition="If the endpoint is a RESTful one", formalDefinition="A definition of the restful capabilities of the solution, if any." ) 5032 protected List<CapabilityStatement2RestComponent> rest; 5033 5034 private static final long serialVersionUID = -242661375L; 5035 5036 /** 5037 * Constructor 5038 */ 5039 public CapabilityStatement2() { 5040 super(); 5041 } 5042 5043 /** 5044 * Constructor 5045 */ 5046 public CapabilityStatement2(PublicationStatus status, Date date, CapabilityStatementKind kind, FHIRVersion fhirVersion, String format) { 5047 super(); 5048 this.setStatus(status); 5049 this.setDate(date); 5050 this.setKind(kind); 5051 this.setFhirVersion(fhirVersion); 5052 this.addFormat(format); 5053 } 5054 5055 /** 5056 * @return {@link #url} (An absolute URI that is used to identify this capability statement2 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 statement2 is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement2 is stored on different servers.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value 5057 */ 5058 public UriType getUrlElement() { 5059 if (this.url == null) 5060 if (Configuration.errorOnAutoCreate()) 5061 throw new Error("Attempt to auto-create CapabilityStatement2.url"); 5062 else if (Configuration.doAutoCreate()) 5063 this.url = new UriType(); // bb 5064 return this.url; 5065 } 5066 5067 public boolean hasUrlElement() { 5068 return this.url != null && !this.url.isEmpty(); 5069 } 5070 5071 public boolean hasUrl() { 5072 return this.url != null && !this.url.isEmpty(); 5073 } 5074 5075 /** 5076 * @param value {@link #url} (An absolute URI that is used to identify this capability statement2 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 statement2 is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement2 is stored on different servers.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value 5077 */ 5078 public CapabilityStatement2 setUrlElement(UriType value) { 5079 this.url = value; 5080 return this; 5081 } 5082 5083 /** 5084 * @return An absolute URI that is used to identify this capability statement2 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 statement2 is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement2 is stored on different servers. 5085 */ 5086 public String getUrl() { 5087 return this.url == null ? null : this.url.getValue(); 5088 } 5089 5090 /** 5091 * @param value An absolute URI that is used to identify this capability statement2 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 statement2 is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement2 is stored on different servers. 5092 */ 5093 public CapabilityStatement2 setUrl(String value) { 5094 if (Utilities.noString(value)) 5095 this.url = null; 5096 else { 5097 if (this.url == null) 5098 this.url = new UriType(); 5099 this.url.setValue(value); 5100 } 5101 return this; 5102 } 5103 5104 /** 5105 * @return {@link #version} (The identifier that is used to identify this version of the capability statement2 when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement2 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 5106 */ 5107 public StringType getVersionElement() { 5108 if (this.version == null) 5109 if (Configuration.errorOnAutoCreate()) 5110 throw new Error("Attempt to auto-create CapabilityStatement2.version"); 5111 else if (Configuration.doAutoCreate()) 5112 this.version = new StringType(); // bb 5113 return this.version; 5114 } 5115 5116 public boolean hasVersionElement() { 5117 return this.version != null && !this.version.isEmpty(); 5118 } 5119 5120 public boolean hasVersion() { 5121 return this.version != null && !this.version.isEmpty(); 5122 } 5123 5124 /** 5125 * @param value {@link #version} (The identifier that is used to identify this version of the capability statement2 when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement2 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 5126 */ 5127 public CapabilityStatement2 setVersionElement(StringType value) { 5128 this.version = value; 5129 return this; 5130 } 5131 5132 /** 5133 * @return The identifier that is used to identify this version of the capability statement2 when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement2 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. 5134 */ 5135 public String getVersion() { 5136 return this.version == null ? null : this.version.getValue(); 5137 } 5138 5139 /** 5140 * @param value The identifier that is used to identify this version of the capability statement2 when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement2 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. 5141 */ 5142 public CapabilityStatement2 setVersion(String value) { 5143 if (Utilities.noString(value)) 5144 this.version = null; 5145 else { 5146 if (this.version == null) 5147 this.version = new StringType(); 5148 this.version.setValue(value); 5149 } 5150 return this; 5151 } 5152 5153 /** 5154 * @return {@link #name} (A natural language name identifying the capability statement2. 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 5155 */ 5156 public StringType getNameElement() { 5157 if (this.name == null) 5158 if (Configuration.errorOnAutoCreate()) 5159 throw new Error("Attempt to auto-create CapabilityStatement2.name"); 5160 else if (Configuration.doAutoCreate()) 5161 this.name = new StringType(); // bb 5162 return this.name; 5163 } 5164 5165 public boolean hasNameElement() { 5166 return this.name != null && !this.name.isEmpty(); 5167 } 5168 5169 public boolean hasName() { 5170 return this.name != null && !this.name.isEmpty(); 5171 } 5172 5173 /** 5174 * @param value {@link #name} (A natural language name identifying the capability statement2. 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 5175 */ 5176 public CapabilityStatement2 setNameElement(StringType value) { 5177 this.name = value; 5178 return this; 5179 } 5180 5181 /** 5182 * @return A natural language name identifying the capability statement2. This name should be usable as an identifier for the module by machine processing applications such as code generation. 5183 */ 5184 public String getName() { 5185 return this.name == null ? null : this.name.getValue(); 5186 } 5187 5188 /** 5189 * @param value A natural language name identifying the capability statement2. This name should be usable as an identifier for the module by machine processing applications such as code generation. 5190 */ 5191 public CapabilityStatement2 setName(String value) { 5192 if (Utilities.noString(value)) 5193 this.name = null; 5194 else { 5195 if (this.name == null) 5196 this.name = new StringType(); 5197 this.name.setValue(value); 5198 } 5199 return this; 5200 } 5201 5202 /** 5203 * @return {@link #title} (A short, descriptive, user-friendly title for the capability statement2.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value 5204 */ 5205 public StringType getTitleElement() { 5206 if (this.title == null) 5207 if (Configuration.errorOnAutoCreate()) 5208 throw new Error("Attempt to auto-create CapabilityStatement2.title"); 5209 else if (Configuration.doAutoCreate()) 5210 this.title = new StringType(); // bb 5211 return this.title; 5212 } 5213 5214 public boolean hasTitleElement() { 5215 return this.title != null && !this.title.isEmpty(); 5216 } 5217 5218 public boolean hasTitle() { 5219 return this.title != null && !this.title.isEmpty(); 5220 } 5221 5222 /** 5223 * @param value {@link #title} (A short, descriptive, user-friendly title for the capability statement2.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value 5224 */ 5225 public CapabilityStatement2 setTitleElement(StringType value) { 5226 this.title = value; 5227 return this; 5228 } 5229 5230 /** 5231 * @return A short, descriptive, user-friendly title for the capability statement2. 5232 */ 5233 public String getTitle() { 5234 return this.title == null ? null : this.title.getValue(); 5235 } 5236 5237 /** 5238 * @param value A short, descriptive, user-friendly title for the capability statement2. 5239 */ 5240 public CapabilityStatement2 setTitle(String value) { 5241 if (Utilities.noString(value)) 5242 this.title = null; 5243 else { 5244 if (this.title == null) 5245 this.title = new StringType(); 5246 this.title.setValue(value); 5247 } 5248 return this; 5249 } 5250 5251 /** 5252 * @return {@link #status} (The status of this capability statement2. 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 5253 */ 5254 public Enumeration<PublicationStatus> getStatusElement() { 5255 if (this.status == null) 5256 if (Configuration.errorOnAutoCreate()) 5257 throw new Error("Attempt to auto-create CapabilityStatement2.status"); 5258 else if (Configuration.doAutoCreate()) 5259 this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb 5260 return this.status; 5261 } 5262 5263 public boolean hasStatusElement() { 5264 return this.status != null && !this.status.isEmpty(); 5265 } 5266 5267 public boolean hasStatus() { 5268 return this.status != null && !this.status.isEmpty(); 5269 } 5270 5271 /** 5272 * @param value {@link #status} (The status of this capability statement2. 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 5273 */ 5274 public CapabilityStatement2 setStatusElement(Enumeration<PublicationStatus> value) { 5275 this.status = value; 5276 return this; 5277 } 5278 5279 /** 5280 * @return The status of this capability statement2. Enables tracking the life-cycle of the content. 5281 */ 5282 public PublicationStatus getStatus() { 5283 return this.status == null ? null : this.status.getValue(); 5284 } 5285 5286 /** 5287 * @param value The status of this capability statement2. Enables tracking the life-cycle of the content. 5288 */ 5289 public CapabilityStatement2 setStatus(PublicationStatus value) { 5290 if (this.status == null) 5291 this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); 5292 this.status.setValue(value); 5293 return this; 5294 } 5295 5296 /** 5297 * @return {@link #experimental} (A Boolean value to indicate that this capability statement2 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 5298 */ 5299 public BooleanType getExperimentalElement() { 5300 if (this.experimental == null) 5301 if (Configuration.errorOnAutoCreate()) 5302 throw new Error("Attempt to auto-create CapabilityStatement2.experimental"); 5303 else if (Configuration.doAutoCreate()) 5304 this.experimental = new BooleanType(); // bb 5305 return this.experimental; 5306 } 5307 5308 public boolean hasExperimentalElement() { 5309 return this.experimental != null && !this.experimental.isEmpty(); 5310 } 5311 5312 public boolean hasExperimental() { 5313 return this.experimental != null && !this.experimental.isEmpty(); 5314 } 5315 5316 /** 5317 * @param value {@link #experimental} (A Boolean value to indicate that this capability statement2 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 5318 */ 5319 public CapabilityStatement2 setExperimentalElement(BooleanType value) { 5320 this.experimental = value; 5321 return this; 5322 } 5323 5324 /** 5325 * @return A Boolean value to indicate that this capability statement2 is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage. 5326 */ 5327 public boolean getExperimental() { 5328 return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue(); 5329 } 5330 5331 /** 5332 * @param value A Boolean value to indicate that this capability statement2 is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage. 5333 */ 5334 public CapabilityStatement2 setExperimental(boolean value) { 5335 if (this.experimental == null) 5336 this.experimental = new BooleanType(); 5337 this.experimental.setValue(value); 5338 return this; 5339 } 5340 5341 /** 5342 * @return {@link #date} (The date (and optionally time) when the capability statement2 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 statement2 changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value 5343 */ 5344 public DateTimeType getDateElement() { 5345 if (this.date == null) 5346 if (Configuration.errorOnAutoCreate()) 5347 throw new Error("Attempt to auto-create CapabilityStatement2.date"); 5348 else if (Configuration.doAutoCreate()) 5349 this.date = new DateTimeType(); // bb 5350 return this.date; 5351 } 5352 5353 public boolean hasDateElement() { 5354 return this.date != null && !this.date.isEmpty(); 5355 } 5356 5357 public boolean hasDate() { 5358 return this.date != null && !this.date.isEmpty(); 5359 } 5360 5361 /** 5362 * @param value {@link #date} (The date (and optionally time) when the capability statement2 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 statement2 changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value 5363 */ 5364 public CapabilityStatement2 setDateElement(DateTimeType value) { 5365 this.date = value; 5366 return this; 5367 } 5368 5369 /** 5370 * @return The date (and optionally time) when the capability statement2 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 statement2 changes. 5371 */ 5372 public Date getDate() { 5373 return this.date == null ? null : this.date.getValue(); 5374 } 5375 5376 /** 5377 * @param value The date (and optionally time) when the capability statement2 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 statement2 changes. 5378 */ 5379 public CapabilityStatement2 setDate(Date value) { 5380 if (this.date == null) 5381 this.date = new DateTimeType(); 5382 this.date.setValue(value); 5383 return this; 5384 } 5385 5386 /** 5387 * @return {@link #publisher} (The name of the organization or individual that published the capability statement2.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value 5388 */ 5389 public StringType getPublisherElement() { 5390 if (this.publisher == null) 5391 if (Configuration.errorOnAutoCreate()) 5392 throw new Error("Attempt to auto-create CapabilityStatement2.publisher"); 5393 else if (Configuration.doAutoCreate()) 5394 this.publisher = new StringType(); // bb 5395 return this.publisher; 5396 } 5397 5398 public boolean hasPublisherElement() { 5399 return this.publisher != null && !this.publisher.isEmpty(); 5400 } 5401 5402 public boolean hasPublisher() { 5403 return this.publisher != null && !this.publisher.isEmpty(); 5404 } 5405 5406 /** 5407 * @param value {@link #publisher} (The name of the organization or individual that published the capability statement2.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value 5408 */ 5409 public CapabilityStatement2 setPublisherElement(StringType value) { 5410 this.publisher = value; 5411 return this; 5412 } 5413 5414 /** 5415 * @return The name of the organization or individual that published the capability statement2. 5416 */ 5417 public String getPublisher() { 5418 return this.publisher == null ? null : this.publisher.getValue(); 5419 } 5420 5421 /** 5422 * @param value The name of the organization or individual that published the capability statement2. 5423 */ 5424 public CapabilityStatement2 setPublisher(String value) { 5425 if (Utilities.noString(value)) 5426 this.publisher = null; 5427 else { 5428 if (this.publisher == null) 5429 this.publisher = new StringType(); 5430 this.publisher.setValue(value); 5431 } 5432 return this; 5433 } 5434 5435 /** 5436 * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.) 5437 */ 5438 public List<ContactDetail> getContact() { 5439 if (this.contact == null) 5440 this.contact = new ArrayList<ContactDetail>(); 5441 return this.contact; 5442 } 5443 5444 /** 5445 * @return Returns a reference to <code>this</code> for easy method chaining 5446 */ 5447 public CapabilityStatement2 setContact(List<ContactDetail> theContact) { 5448 this.contact = theContact; 5449 return this; 5450 } 5451 5452 public boolean hasContact() { 5453 if (this.contact == null) 5454 return false; 5455 for (ContactDetail item : this.contact) 5456 if (!item.isEmpty()) 5457 return true; 5458 return false; 5459 } 5460 5461 public ContactDetail addContact() { //3 5462 ContactDetail t = new ContactDetail(); 5463 if (this.contact == null) 5464 this.contact = new ArrayList<ContactDetail>(); 5465 this.contact.add(t); 5466 return t; 5467 } 5468 5469 public CapabilityStatement2 addContact(ContactDetail t) { //3 5470 if (t == null) 5471 return this; 5472 if (this.contact == null) 5473 this.contact = new ArrayList<ContactDetail>(); 5474 this.contact.add(t); 5475 return this; 5476 } 5477 5478 /** 5479 * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist {3} 5480 */ 5481 public ContactDetail getContactFirstRep() { 5482 if (getContact().isEmpty()) { 5483 addContact(); 5484 } 5485 return getContact().get(0); 5486 } 5487 5488 /** 5489 * @return {@link #description} (A free text natural language description of the capability statement2 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 5490 */ 5491 public MarkdownType getDescriptionElement() { 5492 if (this.description == null) 5493 if (Configuration.errorOnAutoCreate()) 5494 throw new Error("Attempt to auto-create CapabilityStatement2.description"); 5495 else if (Configuration.doAutoCreate()) 5496 this.description = new MarkdownType(); // bb 5497 return this.description; 5498 } 5499 5500 public boolean hasDescriptionElement() { 5501 return this.description != null && !this.description.isEmpty(); 5502 } 5503 5504 public boolean hasDescription() { 5505 return this.description != null && !this.description.isEmpty(); 5506 } 5507 5508 /** 5509 * @param value {@link #description} (A free text natural language description of the capability statement2 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 5510 */ 5511 public CapabilityStatement2 setDescriptionElement(MarkdownType value) { 5512 this.description = value; 5513 return this; 5514 } 5515 5516 /** 5517 * @return A free text natural language description of the capability statement2 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. 5518 */ 5519 public String getDescription() { 5520 return this.description == null ? null : this.description.getValue(); 5521 } 5522 5523 /** 5524 * @param value A free text natural language description of the capability statement2 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. 5525 */ 5526 public CapabilityStatement2 setDescription(String value) { 5527 if (value == null) 5528 this.description = null; 5529 else { 5530 if (this.description == null) 5531 this.description = new MarkdownType(); 5532 this.description.setValue(value); 5533 } 5534 return this; 5535 } 5536 5537 /** 5538 * @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 statement2 instances.) 5539 */ 5540 public List<UsageContext> getUseContext() { 5541 if (this.useContext == null) 5542 this.useContext = new ArrayList<UsageContext>(); 5543 return this.useContext; 5544 } 5545 5546 /** 5547 * @return Returns a reference to <code>this</code> for easy method chaining 5548 */ 5549 public CapabilityStatement2 setUseContext(List<UsageContext> theUseContext) { 5550 this.useContext = theUseContext; 5551 return this; 5552 } 5553 5554 public boolean hasUseContext() { 5555 if (this.useContext == null) 5556 return false; 5557 for (UsageContext item : this.useContext) 5558 if (!item.isEmpty()) 5559 return true; 5560 return false; 5561 } 5562 5563 public UsageContext addUseContext() { //3 5564 UsageContext t = new UsageContext(); 5565 if (this.useContext == null) 5566 this.useContext = new ArrayList<UsageContext>(); 5567 this.useContext.add(t); 5568 return t; 5569 } 5570 5571 public CapabilityStatement2 addUseContext(UsageContext t) { //3 5572 if (t == null) 5573 return this; 5574 if (this.useContext == null) 5575 this.useContext = new ArrayList<UsageContext>(); 5576 this.useContext.add(t); 5577 return this; 5578 } 5579 5580 /** 5581 * @return The first repetition of repeating field {@link #useContext}, creating it if it does not already exist {3} 5582 */ 5583 public UsageContext getUseContextFirstRep() { 5584 if (getUseContext().isEmpty()) { 5585 addUseContext(); 5586 } 5587 return getUseContext().get(0); 5588 } 5589 5590 /** 5591 * @return {@link #jurisdiction} (A legal or geographic region in which the capability statement2 is intended to be used.) 5592 */ 5593 public List<CodeableConcept> getJurisdiction() { 5594 if (this.jurisdiction == null) 5595 this.jurisdiction = new ArrayList<CodeableConcept>(); 5596 return this.jurisdiction; 5597 } 5598 5599 /** 5600 * @return Returns a reference to <code>this</code> for easy method chaining 5601 */ 5602 public CapabilityStatement2 setJurisdiction(List<CodeableConcept> theJurisdiction) { 5603 this.jurisdiction = theJurisdiction; 5604 return this; 5605 } 5606 5607 public boolean hasJurisdiction() { 5608 if (this.jurisdiction == null) 5609 return false; 5610 for (CodeableConcept item : this.jurisdiction) 5611 if (!item.isEmpty()) 5612 return true; 5613 return false; 5614 } 5615 5616 public CodeableConcept addJurisdiction() { //3 5617 CodeableConcept t = new CodeableConcept(); 5618 if (this.jurisdiction == null) 5619 this.jurisdiction = new ArrayList<CodeableConcept>(); 5620 this.jurisdiction.add(t); 5621 return t; 5622 } 5623 5624 public CapabilityStatement2 addJurisdiction(CodeableConcept t) { //3 5625 if (t == null) 5626 return this; 5627 if (this.jurisdiction == null) 5628 this.jurisdiction = new ArrayList<CodeableConcept>(); 5629 this.jurisdiction.add(t); 5630 return this; 5631 } 5632 5633 /** 5634 * @return The first repetition of repeating field {@link #jurisdiction}, creating it if it does not already exist {3} 5635 */ 5636 public CodeableConcept getJurisdictionFirstRep() { 5637 if (getJurisdiction().isEmpty()) { 5638 addJurisdiction(); 5639 } 5640 return getJurisdiction().get(0); 5641 } 5642 5643 /** 5644 * @return {@link #purpose} (Explanation of why this capability statement2 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 5645 */ 5646 public MarkdownType getPurposeElement() { 5647 if (this.purpose == null) 5648 if (Configuration.errorOnAutoCreate()) 5649 throw new Error("Attempt to auto-create CapabilityStatement2.purpose"); 5650 else if (Configuration.doAutoCreate()) 5651 this.purpose = new MarkdownType(); // bb 5652 return this.purpose; 5653 } 5654 5655 public boolean hasPurposeElement() { 5656 return this.purpose != null && !this.purpose.isEmpty(); 5657 } 5658 5659 public boolean hasPurpose() { 5660 return this.purpose != null && !this.purpose.isEmpty(); 5661 } 5662 5663 /** 5664 * @param value {@link #purpose} (Explanation of why this capability statement2 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 5665 */ 5666 public CapabilityStatement2 setPurposeElement(MarkdownType value) { 5667 this.purpose = value; 5668 return this; 5669 } 5670 5671 /** 5672 * @return Explanation of why this capability statement2 is needed and why it has been designed as it has. 5673 */ 5674 public String getPurpose() { 5675 return this.purpose == null ? null : this.purpose.getValue(); 5676 } 5677 5678 /** 5679 * @param value Explanation of why this capability statement2 is needed and why it has been designed as it has. 5680 */ 5681 public CapabilityStatement2 setPurpose(String value) { 5682 if (value == null) 5683 this.purpose = null; 5684 else { 5685 if (this.purpose == null) 5686 this.purpose = new MarkdownType(); 5687 this.purpose.setValue(value); 5688 } 5689 return this; 5690 } 5691 5692 /** 5693 * @return {@link #copyright} (A copyright statement relating to the capability statement2 and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement2.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value 5694 */ 5695 public MarkdownType getCopyrightElement() { 5696 if (this.copyright == null) 5697 if (Configuration.errorOnAutoCreate()) 5698 throw new Error("Attempt to auto-create CapabilityStatement2.copyright"); 5699 else if (Configuration.doAutoCreate()) 5700 this.copyright = new MarkdownType(); // bb 5701 return this.copyright; 5702 } 5703 5704 public boolean hasCopyrightElement() { 5705 return this.copyright != null && !this.copyright.isEmpty(); 5706 } 5707 5708 public boolean hasCopyright() { 5709 return this.copyright != null && !this.copyright.isEmpty(); 5710 } 5711 5712 /** 5713 * @param value {@link #copyright} (A copyright statement relating to the capability statement2 and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement2.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value 5714 */ 5715 public CapabilityStatement2 setCopyrightElement(MarkdownType value) { 5716 this.copyright = value; 5717 return this; 5718 } 5719 5720 /** 5721 * @return A copyright statement relating to the capability statement2 and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement2. 5722 */ 5723 public String getCopyright() { 5724 return this.copyright == null ? null : this.copyright.getValue(); 5725 } 5726 5727 /** 5728 * @param value A copyright statement relating to the capability statement2 and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement2. 5729 */ 5730 public CapabilityStatement2 setCopyright(String value) { 5731 if (value == null) 5732 this.copyright = null; 5733 else { 5734 if (this.copyright == null) 5735 this.copyright = new MarkdownType(); 5736 this.copyright.setValue(value); 5737 } 5738 return this; 5739 } 5740 5741 /** 5742 * @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 5743 */ 5744 public Enumeration<CapabilityStatementKind> getKindElement() { 5745 if (this.kind == null) 5746 if (Configuration.errorOnAutoCreate()) 5747 throw new Error("Attempt to auto-create CapabilityStatement2.kind"); 5748 else if (Configuration.doAutoCreate()) 5749 this.kind = new Enumeration<CapabilityStatementKind>(new CapabilityStatementKindEnumFactory()); // bb 5750 return this.kind; 5751 } 5752 5753 public boolean hasKindElement() { 5754 return this.kind != null && !this.kind.isEmpty(); 5755 } 5756 5757 public boolean hasKind() { 5758 return this.kind != null && !this.kind.isEmpty(); 5759 } 5760 5761 /** 5762 * @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 5763 */ 5764 public CapabilityStatement2 setKindElement(Enumeration<CapabilityStatementKind> value) { 5765 this.kind = value; 5766 return this; 5767 } 5768 5769 /** 5770 * @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). 5771 */ 5772 public CapabilityStatementKind getKind() { 5773 return this.kind == null ? null : this.kind.getValue(); 5774 } 5775 5776 /** 5777 * @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). 5778 */ 5779 public CapabilityStatement2 setKind(CapabilityStatementKind value) { 5780 if (this.kind == null) 5781 this.kind = new Enumeration<CapabilityStatementKind>(new CapabilityStatementKindEnumFactory()); 5782 this.kind.setValue(value); 5783 return this; 5784 } 5785 5786 /** 5787 * @return {@link #instantiates} (Reference to a canonical URL of another CapabilityStatement2 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.) 5788 */ 5789 public List<CanonicalType> getInstantiates() { 5790 if (this.instantiates == null) 5791 this.instantiates = new ArrayList<CanonicalType>(); 5792 return this.instantiates; 5793 } 5794 5795 /** 5796 * @return Returns a reference to <code>this</code> for easy method chaining 5797 */ 5798 public CapabilityStatement2 setInstantiates(List<CanonicalType> theInstantiates) { 5799 this.instantiates = theInstantiates; 5800 return this; 5801 } 5802 5803 public boolean hasInstantiates() { 5804 if (this.instantiates == null) 5805 return false; 5806 for (CanonicalType item : this.instantiates) 5807 if (!item.isEmpty()) 5808 return true; 5809 return false; 5810 } 5811 5812 /** 5813 * @return {@link #instantiates} (Reference to a canonical URL of another CapabilityStatement2 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.) 5814 */ 5815 public CanonicalType addInstantiatesElement() {//2 5816 CanonicalType t = new CanonicalType(); 5817 if (this.instantiates == null) 5818 this.instantiates = new ArrayList<CanonicalType>(); 5819 this.instantiates.add(t); 5820 return t; 5821 } 5822 5823 /** 5824 * @param value {@link #instantiates} (Reference to a canonical URL of another CapabilityStatement2 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.) 5825 */ 5826 public CapabilityStatement2 addInstantiates(String value) { //1 5827 CanonicalType t = new CanonicalType(); 5828 t.setValue(value); 5829 if (this.instantiates == null) 5830 this.instantiates = new ArrayList<CanonicalType>(); 5831 this.instantiates.add(t); 5832 return this; 5833 } 5834 5835 /** 5836 * @param value {@link #instantiates} (Reference to a canonical URL of another CapabilityStatement2 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.) 5837 */ 5838 public boolean hasInstantiates(String value) { 5839 if (this.instantiates == null) 5840 return false; 5841 for (CanonicalType v : this.instantiates) 5842 if (v.getValue().equals(value)) // canonical 5843 return true; 5844 return false; 5845 } 5846 5847 /** 5848 * @return {@link #imports} (Reference to a canonical URL of another CapabilityStatement2 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.) 5849 */ 5850 public List<CanonicalType> getImports() { 5851 if (this.imports == null) 5852 this.imports = new ArrayList<CanonicalType>(); 5853 return this.imports; 5854 } 5855 5856 /** 5857 * @return Returns a reference to <code>this</code> for easy method chaining 5858 */ 5859 public CapabilityStatement2 setImports(List<CanonicalType> theImports) { 5860 this.imports = theImports; 5861 return this; 5862 } 5863 5864 public boolean hasImports() { 5865 if (this.imports == null) 5866 return false; 5867 for (CanonicalType item : this.imports) 5868 if (!item.isEmpty()) 5869 return true; 5870 return false; 5871 } 5872 5873 /** 5874 * @return {@link #imports} (Reference to a canonical URL of another CapabilityStatement2 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.) 5875 */ 5876 public CanonicalType addImportsElement() {//2 5877 CanonicalType t = new CanonicalType(); 5878 if (this.imports == null) 5879 this.imports = new ArrayList<CanonicalType>(); 5880 this.imports.add(t); 5881 return t; 5882 } 5883 5884 /** 5885 * @param value {@link #imports} (Reference to a canonical URL of another CapabilityStatement2 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.) 5886 */ 5887 public CapabilityStatement2 addImports(String value) { //1 5888 CanonicalType t = new CanonicalType(); 5889 t.setValue(value); 5890 if (this.imports == null) 5891 this.imports = new ArrayList<CanonicalType>(); 5892 this.imports.add(t); 5893 return this; 5894 } 5895 5896 /** 5897 * @param value {@link #imports} (Reference to a canonical URL of another CapabilityStatement2 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.) 5898 */ 5899 public boolean hasImports(String value) { 5900 if (this.imports == null) 5901 return false; 5902 for (CanonicalType v : this.imports) 5903 if (v.getValue().equals(value)) // canonical 5904 return true; 5905 return false; 5906 } 5907 5908 /** 5909 * @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.) 5910 */ 5911 public CapabilityStatement2SoftwareComponent getSoftware() { 5912 if (this.software == null) 5913 if (Configuration.errorOnAutoCreate()) 5914 throw new Error("Attempt to auto-create CapabilityStatement2.software"); 5915 else if (Configuration.doAutoCreate()) 5916 this.software = new CapabilityStatement2SoftwareComponent(); // cc 5917 return this.software; 5918 } 5919 5920 public boolean hasSoftware() { 5921 return this.software != null && !this.software.isEmpty(); 5922 } 5923 5924 /** 5925 * @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.) 5926 */ 5927 public CapabilityStatement2 setSoftware(CapabilityStatement2SoftwareComponent value) { 5928 this.software = value; 5929 return this; 5930 } 5931 5932 /** 5933 * @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.) 5934 */ 5935 public CapabilityStatement2ImplementationComponent getImplementation() { 5936 if (this.implementation == null) 5937 if (Configuration.errorOnAutoCreate()) 5938 throw new Error("Attempt to auto-create CapabilityStatement2.implementation"); 5939 else if (Configuration.doAutoCreate()) 5940 this.implementation = new CapabilityStatement2ImplementationComponent(); // cc 5941 return this.implementation; 5942 } 5943 5944 public boolean hasImplementation() { 5945 return this.implementation != null && !this.implementation.isEmpty(); 5946 } 5947 5948 /** 5949 * @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.) 5950 */ 5951 public CapabilityStatement2 setImplementation(CapabilityStatement2ImplementationComponent value) { 5952 this.implementation = value; 5953 return this; 5954 } 5955 5956 /** 5957 * @return {@link #fhirVersion} (The version of the FHIR specification that this CapabilityStatement2 describes (which SHALL be the same as the FHIR version of the CapabilityStatement2 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 5958 */ 5959 public Enumeration<FHIRVersion> getFhirVersionElement() { 5960 if (this.fhirVersion == null) 5961 if (Configuration.errorOnAutoCreate()) 5962 throw new Error("Attempt to auto-create CapabilityStatement2.fhirVersion"); 5963 else if (Configuration.doAutoCreate()) 5964 this.fhirVersion = new Enumeration<FHIRVersion>(new FHIRVersionEnumFactory()); // bb 5965 return this.fhirVersion; 5966 } 5967 5968 public boolean hasFhirVersionElement() { 5969 return this.fhirVersion != null && !this.fhirVersion.isEmpty(); 5970 } 5971 5972 public boolean hasFhirVersion() { 5973 return this.fhirVersion != null && !this.fhirVersion.isEmpty(); 5974 } 5975 5976 /** 5977 * @param value {@link #fhirVersion} (The version of the FHIR specification that this CapabilityStatement2 describes (which SHALL be the same as the FHIR version of the CapabilityStatement2 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 5978 */ 5979 public CapabilityStatement2 setFhirVersionElement(Enumeration<FHIRVersion> value) { 5980 this.fhirVersion = value; 5981 return this; 5982 } 5983 5984 /** 5985 * @return The version of the FHIR specification that this CapabilityStatement2 describes (which SHALL be the same as the FHIR version of the CapabilityStatement2 itself). There is no default value. 5986 */ 5987 public FHIRVersion getFhirVersion() { 5988 return this.fhirVersion == null ? null : this.fhirVersion.getValue(); 5989 } 5990 5991 /** 5992 * @param value The version of the FHIR specification that this CapabilityStatement2 describes (which SHALL be the same as the FHIR version of the CapabilityStatement2 itself). There is no default value. 5993 */ 5994 public CapabilityStatement2 setFhirVersion(FHIRVersion value) { 5995 if (this.fhirVersion == null) 5996 this.fhirVersion = new Enumeration<FHIRVersion>(new FHIRVersionEnumFactory()); 5997 this.fhirVersion.setValue(value); 5998 return this; 5999 } 6000 6001 /** 6002 * @return {@link #format} (A list of the formats supported by this implementation using their content types.) 6003 */ 6004 public List<CodeType> getFormat() { 6005 if (this.format == null) 6006 this.format = new ArrayList<CodeType>(); 6007 return this.format; 6008 } 6009 6010 /** 6011 * @return Returns a reference to <code>this</code> for easy method chaining 6012 */ 6013 public CapabilityStatement2 setFormat(List<CodeType> theFormat) { 6014 this.format = theFormat; 6015 return this; 6016 } 6017 6018 public boolean hasFormat() { 6019 if (this.format == null) 6020 return false; 6021 for (CodeType item : this.format) 6022 if (!item.isEmpty()) 6023 return true; 6024 return false; 6025 } 6026 6027 /** 6028 * @return {@link #format} (A list of the formats supported by this implementation using their content types.) 6029 */ 6030 public CodeType addFormatElement() {//2 6031 CodeType t = new CodeType(); 6032 if (this.format == null) 6033 this.format = new ArrayList<CodeType>(); 6034 this.format.add(t); 6035 return t; 6036 } 6037 6038 /** 6039 * @param value {@link #format} (A list of the formats supported by this implementation using their content types.) 6040 */ 6041 public CapabilityStatement2 addFormat(String value) { //1 6042 CodeType t = new CodeType(); 6043 t.setValue(value); 6044 if (this.format == null) 6045 this.format = new ArrayList<CodeType>(); 6046 this.format.add(t); 6047 return this; 6048 } 6049 6050 /** 6051 * @param value {@link #format} (A list of the formats supported by this implementation using their content types.) 6052 */ 6053 public boolean hasFormat(String value) { 6054 if (this.format == null) 6055 return false; 6056 for (CodeType v : this.format) 6057 if (v.getValue().equals(value)) // code 6058 return true; 6059 return false; 6060 } 6061 6062 /** 6063 * @return {@link #patchFormat} (A list of the patch formats supported by this implementation using their content types.) 6064 */ 6065 public List<CodeType> getPatchFormat() { 6066 if (this.patchFormat == null) 6067 this.patchFormat = new ArrayList<CodeType>(); 6068 return this.patchFormat; 6069 } 6070 6071 /** 6072 * @return Returns a reference to <code>this</code> for easy method chaining 6073 */ 6074 public CapabilityStatement2 setPatchFormat(List<CodeType> thePatchFormat) { 6075 this.patchFormat = thePatchFormat; 6076 return this; 6077 } 6078 6079 public boolean hasPatchFormat() { 6080 if (this.patchFormat == null) 6081 return false; 6082 for (CodeType item : this.patchFormat) 6083 if (!item.isEmpty()) 6084 return true; 6085 return false; 6086 } 6087 6088 /** 6089 * @return {@link #patchFormat} (A list of the patch formats supported by this implementation using their content types.) 6090 */ 6091 public CodeType addPatchFormatElement() {//2 6092 CodeType t = new CodeType(); 6093 if (this.patchFormat == null) 6094 this.patchFormat = new ArrayList<CodeType>(); 6095 this.patchFormat.add(t); 6096 return t; 6097 } 6098 6099 /** 6100 * @param value {@link #patchFormat} (A list of the patch formats supported by this implementation using their content types.) 6101 */ 6102 public CapabilityStatement2 addPatchFormat(String value) { //1 6103 CodeType t = new CodeType(); 6104 t.setValue(value); 6105 if (this.patchFormat == null) 6106 this.patchFormat = new ArrayList<CodeType>(); 6107 this.patchFormat.add(t); 6108 return this; 6109 } 6110 6111 /** 6112 * @param value {@link #patchFormat} (A list of the patch formats supported by this implementation using their content types.) 6113 */ 6114 public boolean hasPatchFormat(String value) { 6115 if (this.patchFormat == null) 6116 return false; 6117 for (CodeType v : this.patchFormat) 6118 if (v.getValue().equals(value)) // code 6119 return true; 6120 return false; 6121 } 6122 6123 /** 6124 * @return {@link #implementationGuide} (A list of implementation guides that the server does (or should) support in their entirety.) 6125 */ 6126 public List<CanonicalType> getImplementationGuide() { 6127 if (this.implementationGuide == null) 6128 this.implementationGuide = new ArrayList<CanonicalType>(); 6129 return this.implementationGuide; 6130 } 6131 6132 /** 6133 * @return Returns a reference to <code>this</code> for easy method chaining 6134 */ 6135 public CapabilityStatement2 setImplementationGuide(List<CanonicalType> theImplementationGuide) { 6136 this.implementationGuide = theImplementationGuide; 6137 return this; 6138 } 6139 6140 public boolean hasImplementationGuide() { 6141 if (this.implementationGuide == null) 6142 return false; 6143 for (CanonicalType item : this.implementationGuide) 6144 if (!item.isEmpty()) 6145 return true; 6146 return false; 6147 } 6148 6149 /** 6150 * @return {@link #implementationGuide} (A list of implementation guides that the server does (or should) support in their entirety.) 6151 */ 6152 public CanonicalType addImplementationGuideElement() {//2 6153 CanonicalType t = new CanonicalType(); 6154 if (this.implementationGuide == null) 6155 this.implementationGuide = new ArrayList<CanonicalType>(); 6156 this.implementationGuide.add(t); 6157 return t; 6158 } 6159 6160 /** 6161 * @param value {@link #implementationGuide} (A list of implementation guides that the server does (or should) support in their entirety.) 6162 */ 6163 public CapabilityStatement2 addImplementationGuide(String value) { //1 6164 CanonicalType t = new CanonicalType(); 6165 t.setValue(value); 6166 if (this.implementationGuide == null) 6167 this.implementationGuide = new ArrayList<CanonicalType>(); 6168 this.implementationGuide.add(t); 6169 return this; 6170 } 6171 6172 /** 6173 * @param value {@link #implementationGuide} (A list of implementation guides that the server does (or should) support in their entirety.) 6174 */ 6175 public boolean hasImplementationGuide(String value) { 6176 if (this.implementationGuide == null) 6177 return false; 6178 for (CanonicalType v : this.implementationGuide) 6179 if (v.getValue().equals(value)) // canonical 6180 return true; 6181 return false; 6182 } 6183 6184 /** 6185 * @return {@link #rest} (A definition of the restful capabilities of the solution, if any.) 6186 */ 6187 public List<CapabilityStatement2RestComponent> getRest() { 6188 if (this.rest == null) 6189 this.rest = new ArrayList<CapabilityStatement2RestComponent>(); 6190 return this.rest; 6191 } 6192 6193 /** 6194 * @return Returns a reference to <code>this</code> for easy method chaining 6195 */ 6196 public CapabilityStatement2 setRest(List<CapabilityStatement2RestComponent> theRest) { 6197 this.rest = theRest; 6198 return this; 6199 } 6200 6201 public boolean hasRest() { 6202 if (this.rest == null) 6203 return false; 6204 for (CapabilityStatement2RestComponent item : this.rest) 6205 if (!item.isEmpty()) 6206 return true; 6207 return false; 6208 } 6209 6210 public CapabilityStatement2RestComponent addRest() { //3 6211 CapabilityStatement2RestComponent t = new CapabilityStatement2RestComponent(); 6212 if (this.rest == null) 6213 this.rest = new ArrayList<CapabilityStatement2RestComponent>(); 6214 this.rest.add(t); 6215 return t; 6216 } 6217 6218 public CapabilityStatement2 addRest(CapabilityStatement2RestComponent t) { //3 6219 if (t == null) 6220 return this; 6221 if (this.rest == null) 6222 this.rest = new ArrayList<CapabilityStatement2RestComponent>(); 6223 this.rest.add(t); 6224 return this; 6225 } 6226 6227 /** 6228 * @return The first repetition of repeating field {@link #rest}, creating it if it does not already exist {3} 6229 */ 6230 public CapabilityStatement2RestComponent getRestFirstRep() { 6231 if (getRest().isEmpty()) { 6232 addRest(); 6233 } 6234 return getRest().get(0); 6235 } 6236 6237 /** 6238 * not supported on this implementation 6239 */ 6240 @Override 6241 public int getIdentifierMax() { 6242 return 0; 6243 } 6244 /** 6245 * @return {@link #identifier} (A formal identifier that is used to identify this capability statement2 when it is represented in other formats, or referenced in a specification, model, design or an instance.) 6246 */ 6247 public List<Identifier> getIdentifier() { 6248 return new ArrayList<>(); 6249 } 6250 /** 6251 * @return Returns a reference to <code>this</code> for easy method chaining 6252 */ 6253 public CapabilityStatement2 setIdentifier(List<Identifier> theIdentifier) { 6254 throw new Error("The resource type \"CapabilityStatement2\" does not implement the property \"identifier\""); 6255 } 6256 public boolean hasIdentifier() { 6257 return false; 6258 } 6259 6260 public Identifier addIdentifier() { //3 6261 throw new Error("The resource type \"CapabilityStatement2\" does not implement the property \"identifier\""); 6262 } 6263 public CapabilityStatement2 addIdentifier(Identifier t) { //3 6264 throw new Error("The resource type \"CapabilityStatement2\" does not implement the property \"identifier\""); 6265 } 6266 /** 6267 * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist {2} 6268 */ 6269 public Identifier getIdentifierFirstRep() { 6270 throw new Error("The resource type \"CapabilityStatement2\" does not implement the property \"identifier\""); 6271 } 6272 protected void listChildren(List<Property> children) { 6273 super.listChildren(children); 6274 children.add(new Property("url", "uri", "An absolute URI that is used to identify this capability statement2 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 statement2 is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement2 is stored on different servers.", 0, 1, url)); 6275 children.add(new Property("version", "string", "The identifier that is used to identify this version of the capability statement2 when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement2 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)); 6276 children.add(new Property("name", "string", "A natural language name identifying the capability statement2. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name)); 6277 children.add(new Property("title", "string", "A short, descriptive, user-friendly title for the capability statement2.", 0, 1, title)); 6278 children.add(new Property("status", "code", "The status of this capability statement2. Enables tracking the life-cycle of the content.", 0, 1, status)); 6279 children.add(new Property("experimental", "boolean", "A Boolean value to indicate that this capability statement2 is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.", 0, 1, experimental)); 6280 children.add(new Property("date", "dateTime", "The date (and optionally time) when the capability statement2 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 statement2 changes.", 0, 1, date)); 6281 children.add(new Property("publisher", "string", "The name of the organization or individual that published the capability statement2.", 0, 1, publisher)); 6282 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)); 6283 children.add(new Property("description", "markdown", "A free text natural language description of the capability statement2 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)); 6284 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 statement2 instances.", 0, java.lang.Integer.MAX_VALUE, useContext)); 6285 children.add(new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the capability statement2 is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction)); 6286 children.add(new Property("purpose", "markdown", "Explanation of why this capability statement2 is needed and why it has been designed as it has.", 0, 1, purpose)); 6287 children.add(new Property("copyright", "markdown", "A copyright statement relating to the capability statement2 and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement2.", 0, 1, copyright)); 6288 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)); 6289 children.add(new Property("instantiates", "canonical(CapabilityStatement2)", "Reference to a canonical URL of another CapabilityStatement2 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)); 6290 children.add(new Property("imports", "canonical(CapabilityStatement2)", "Reference to a canonical URL of another CapabilityStatement2 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)); 6291 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)); 6292 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)); 6293 children.add(new Property("fhirVersion", "code", "The version of the FHIR specification that this CapabilityStatement2 describes (which SHALL be the same as the FHIR version of the CapabilityStatement2 itself). There is no default value.", 0, 1, fhirVersion)); 6294 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)); 6295 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)); 6296 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)); 6297 children.add(new Property("rest", "", "A definition of the restful capabilities of the solution, if any.", 0, java.lang.Integer.MAX_VALUE, rest)); 6298 } 6299 6300 @Override 6301 public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException { 6302 switch (_hash) { 6303 case 116079: /*url*/ return new Property("url", "uri", "An absolute URI that is used to identify this capability statement2 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 statement2 is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement2 is stored on different servers.", 0, 1, url); 6304 case 351608024: /*version*/ return new Property("version", "string", "The identifier that is used to identify this version of the capability statement2 when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement2 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); 6305 case 3373707: /*name*/ return new Property("name", "string", "A natural language name identifying the capability statement2. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name); 6306 case 110371416: /*title*/ return new Property("title", "string", "A short, descriptive, user-friendly title for the capability statement2.", 0, 1, title); 6307 case -892481550: /*status*/ return new Property("status", "code", "The status of this capability statement2. Enables tracking the life-cycle of the content.", 0, 1, status); 6308 case -404562712: /*experimental*/ return new Property("experimental", "boolean", "A Boolean value to indicate that this capability statement2 is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.", 0, 1, experimental); 6309 case 3076014: /*date*/ return new Property("date", "dateTime", "The date (and optionally time) when the capability statement2 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 statement2 changes.", 0, 1, date); 6310 case 1447404028: /*publisher*/ return new Property("publisher", "string", "The name of the organization or individual that published the capability statement2.", 0, 1, publisher); 6311 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); 6312 case -1724546052: /*description*/ return new Property("description", "markdown", "A free text natural language description of the capability statement2 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); 6313 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 statement2 instances.", 0, java.lang.Integer.MAX_VALUE, useContext); 6314 case -507075711: /*jurisdiction*/ return new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the capability statement2 is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction); 6315 case -220463842: /*purpose*/ return new Property("purpose", "markdown", "Explanation of why this capability statement2 is needed and why it has been designed as it has.", 0, 1, purpose); 6316 case 1522889671: /*copyright*/ return new Property("copyright", "markdown", "A copyright statement relating to the capability statement2 and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement2.", 0, 1, copyright); 6317 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); 6318 case -246883639: /*instantiates*/ return new Property("instantiates", "canonical(CapabilityStatement2)", "Reference to a canonical URL of another CapabilityStatement2 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); 6319 case 1926037870: /*imports*/ return new Property("imports", "canonical(CapabilityStatement2)", "Reference to a canonical URL of another CapabilityStatement2 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); 6320 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); 6321 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); 6322 case 461006061: /*fhirVersion*/ return new Property("fhirVersion", "code", "The version of the FHIR specification that this CapabilityStatement2 describes (which SHALL be the same as the FHIR version of the CapabilityStatement2 itself). There is no default value.", 0, 1, fhirVersion); 6323 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); 6324 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); 6325 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); 6326 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); 6327 default: return super.getNamedProperty(_hash, _name, _checkValid); 6328 } 6329 6330 } 6331 6332 @Override 6333 public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException { 6334 switch (hash) { 6335 case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType 6336 case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType 6337 case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType 6338 case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType 6339 case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<PublicationStatus> 6340 case -404562712: /*experimental*/ return this.experimental == null ? new Base[0] : new Base[] {this.experimental}; // BooleanType 6341 case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType 6342 case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType 6343 case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail 6344 case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType 6345 case -669707736: /*useContext*/ return this.useContext == null ? new Base[0] : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext 6346 case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept 6347 case -220463842: /*purpose*/ return this.purpose == null ? new Base[0] : new Base[] {this.purpose}; // MarkdownType 6348 case 1522889671: /*copyright*/ return this.copyright == null ? new Base[0] : new Base[] {this.copyright}; // MarkdownType 6349 case 3292052: /*kind*/ return this.kind == null ? new Base[0] : new Base[] {this.kind}; // Enumeration<CapabilityStatementKind> 6350 case -246883639: /*instantiates*/ return this.instantiates == null ? new Base[0] : this.instantiates.toArray(new Base[this.instantiates.size()]); // CanonicalType 6351 case 1926037870: /*imports*/ return this.imports == null ? new Base[0] : this.imports.toArray(new Base[this.imports.size()]); // CanonicalType 6352 case 1319330215: /*software*/ return this.software == null ? new Base[0] : new Base[] {this.software}; // CapabilityStatement2SoftwareComponent 6353 case 1683336114: /*implementation*/ return this.implementation == null ? new Base[0] : new Base[] {this.implementation}; // CapabilityStatement2ImplementationComponent 6354 case 461006061: /*fhirVersion*/ return this.fhirVersion == null ? new Base[0] : new Base[] {this.fhirVersion}; // Enumeration<FHIRVersion> 6355 case -1268779017: /*format*/ return this.format == null ? new Base[0] : this.format.toArray(new Base[this.format.size()]); // CodeType 6356 case 172338783: /*patchFormat*/ return this.patchFormat == null ? new Base[0] : this.patchFormat.toArray(new Base[this.patchFormat.size()]); // CodeType 6357 case 156966506: /*implementationGuide*/ return this.implementationGuide == null ? new Base[0] : this.implementationGuide.toArray(new Base[this.implementationGuide.size()]); // CanonicalType 6358 case 3496916: /*rest*/ return this.rest == null ? new Base[0] : this.rest.toArray(new Base[this.rest.size()]); // CapabilityStatement2RestComponent 6359 default: return super.getProperty(hash, name, checkValid); 6360 } 6361 6362 } 6363 6364 @Override 6365 public Base setProperty(int hash, String name, Base value) throws FHIRException { 6366 switch (hash) { 6367 case 116079: // url 6368 this.url = TypeConvertor.castToUri(value); // UriType 6369 return value; 6370 case 351608024: // version 6371 this.version = TypeConvertor.castToString(value); // StringType 6372 return value; 6373 case 3373707: // name 6374 this.name = TypeConvertor.castToString(value); // StringType 6375 return value; 6376 case 110371416: // title 6377 this.title = TypeConvertor.castToString(value); // StringType 6378 return value; 6379 case -892481550: // status 6380 value = new PublicationStatusEnumFactory().fromType(TypeConvertor.castToCode(value)); 6381 this.status = (Enumeration) value; // Enumeration<PublicationStatus> 6382 return value; 6383 case -404562712: // experimental 6384 this.experimental = TypeConvertor.castToBoolean(value); // BooleanType 6385 return value; 6386 case 3076014: // date 6387 this.date = TypeConvertor.castToDateTime(value); // DateTimeType 6388 return value; 6389 case 1447404028: // publisher 6390 this.publisher = TypeConvertor.castToString(value); // StringType 6391 return value; 6392 case 951526432: // contact 6393 this.getContact().add(TypeConvertor.castToContactDetail(value)); // ContactDetail 6394 return value; 6395 case -1724546052: // description 6396 this.description = TypeConvertor.castToMarkdown(value); // MarkdownType 6397 return value; 6398 case -669707736: // useContext 6399 this.getUseContext().add(TypeConvertor.castToUsageContext(value)); // UsageContext 6400 return value; 6401 case -507075711: // jurisdiction 6402 this.getJurisdiction().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept 6403 return value; 6404 case -220463842: // purpose 6405 this.purpose = TypeConvertor.castToMarkdown(value); // MarkdownType 6406 return value; 6407 case 1522889671: // copyright 6408 this.copyright = TypeConvertor.castToMarkdown(value); // MarkdownType 6409 return value; 6410 case 3292052: // kind 6411 value = new CapabilityStatementKindEnumFactory().fromType(TypeConvertor.castToCode(value)); 6412 this.kind = (Enumeration) value; // Enumeration<CapabilityStatementKind> 6413 return value; 6414 case -246883639: // instantiates 6415 this.getInstantiates().add(TypeConvertor.castToCanonical(value)); // CanonicalType 6416 return value; 6417 case 1926037870: // imports 6418 this.getImports().add(TypeConvertor.castToCanonical(value)); // CanonicalType 6419 return value; 6420 case 1319330215: // software 6421 this.software = (CapabilityStatement2SoftwareComponent) value; // CapabilityStatement2SoftwareComponent 6422 return value; 6423 case 1683336114: // implementation 6424 this.implementation = (CapabilityStatement2ImplementationComponent) value; // CapabilityStatement2ImplementationComponent 6425 return value; 6426 case 461006061: // fhirVersion 6427 value = new FHIRVersionEnumFactory().fromType(TypeConvertor.castToCode(value)); 6428 this.fhirVersion = (Enumeration) value; // Enumeration<FHIRVersion> 6429 return value; 6430 case -1268779017: // format 6431 this.getFormat().add(TypeConvertor.castToCode(value)); // CodeType 6432 return value; 6433 case 172338783: // patchFormat 6434 this.getPatchFormat().add(TypeConvertor.castToCode(value)); // CodeType 6435 return value; 6436 case 156966506: // implementationGuide 6437 this.getImplementationGuide().add(TypeConvertor.castToCanonical(value)); // CanonicalType 6438 return value; 6439 case 3496916: // rest 6440 this.getRest().add((CapabilityStatement2RestComponent) value); // CapabilityStatement2RestComponent 6441 return value; 6442 default: return super.setProperty(hash, name, value); 6443 } 6444 6445 } 6446 6447 @Override 6448 public Base setProperty(String name, Base value) throws FHIRException { 6449 if (name.equals("url")) { 6450 this.url = TypeConvertor.castToUri(value); // UriType 6451 } else if (name.equals("version")) { 6452 this.version = TypeConvertor.castToString(value); // StringType 6453 } else if (name.equals("name")) { 6454 this.name = TypeConvertor.castToString(value); // StringType 6455 } else if (name.equals("title")) { 6456 this.title = TypeConvertor.castToString(value); // StringType 6457 } else if (name.equals("status")) { 6458 value = new PublicationStatusEnumFactory().fromType(TypeConvertor.castToCode(value)); 6459 this.status = (Enumeration) value; // Enumeration<PublicationStatus> 6460 } else if (name.equals("experimental")) { 6461 this.experimental = TypeConvertor.castToBoolean(value); // BooleanType 6462 } else if (name.equals("date")) { 6463 this.date = TypeConvertor.castToDateTime(value); // DateTimeType 6464 } else if (name.equals("publisher")) { 6465 this.publisher = TypeConvertor.castToString(value); // StringType 6466 } else if (name.equals("contact")) { 6467 this.getContact().add(TypeConvertor.castToContactDetail(value)); 6468 } else if (name.equals("description")) { 6469 this.description = TypeConvertor.castToMarkdown(value); // MarkdownType 6470 } else if (name.equals("useContext")) { 6471 this.getUseContext().add(TypeConvertor.castToUsageContext(value)); 6472 } else if (name.equals("jurisdiction")) { 6473 this.getJurisdiction().add(TypeConvertor.castToCodeableConcept(value)); 6474 } else if (name.equals("purpose")) { 6475 this.purpose = TypeConvertor.castToMarkdown(value); // MarkdownType 6476 } else if (name.equals("copyright")) { 6477 this.copyright = TypeConvertor.castToMarkdown(value); // MarkdownType 6478 } else if (name.equals("kind")) { 6479 value = new CapabilityStatementKindEnumFactory().fromType(TypeConvertor.castToCode(value)); 6480 this.kind = (Enumeration) value; // Enumeration<CapabilityStatementKind> 6481 } else if (name.equals("instantiates")) { 6482 this.getInstantiates().add(TypeConvertor.castToCanonical(value)); 6483 } else if (name.equals("imports")) { 6484 this.getImports().add(TypeConvertor.castToCanonical(value)); 6485 } else if (name.equals("software")) { 6486 this.software = (CapabilityStatement2SoftwareComponent) value; // CapabilityStatement2SoftwareComponent 6487 } else if (name.equals("implementation")) { 6488 this.implementation = (CapabilityStatement2ImplementationComponent) value; // CapabilityStatement2ImplementationComponent 6489 } else if (name.equals("fhirVersion")) { 6490 value = new FHIRVersionEnumFactory().fromType(TypeConvertor.castToCode(value)); 6491 this.fhirVersion = (Enumeration) value; // Enumeration<FHIRVersion> 6492 } else if (name.equals("format")) { 6493 this.getFormat().add(TypeConvertor.castToCode(value)); 6494 } else if (name.equals("patchFormat")) { 6495 this.getPatchFormat().add(TypeConvertor.castToCode(value)); 6496 } else if (name.equals("implementationGuide")) { 6497 this.getImplementationGuide().add(TypeConvertor.castToCanonical(value)); 6498 } else if (name.equals("rest")) { 6499 this.getRest().add((CapabilityStatement2RestComponent) value); 6500 } else 6501 return super.setProperty(name, value); 6502 return value; 6503 } 6504 6505 @Override 6506 public Base makeProperty(int hash, String name) throws FHIRException { 6507 switch (hash) { 6508 case 116079: return getUrlElement(); 6509 case 351608024: return getVersionElement(); 6510 case 3373707: return getNameElement(); 6511 case 110371416: return getTitleElement(); 6512 case -892481550: return getStatusElement(); 6513 case -404562712: return getExperimentalElement(); 6514 case 3076014: return getDateElement(); 6515 case 1447404028: return getPublisherElement(); 6516 case 951526432: return addContact(); 6517 case -1724546052: return getDescriptionElement(); 6518 case -669707736: return addUseContext(); 6519 case -507075711: return addJurisdiction(); 6520 case -220463842: return getPurposeElement(); 6521 case 1522889671: return getCopyrightElement(); 6522 case 3292052: return getKindElement(); 6523 case -246883639: return addInstantiatesElement(); 6524 case 1926037870: return addImportsElement(); 6525 case 1319330215: return getSoftware(); 6526 case 1683336114: return getImplementation(); 6527 case 461006061: return getFhirVersionElement(); 6528 case -1268779017: return addFormatElement(); 6529 case 172338783: return addPatchFormatElement(); 6530 case 156966506: return addImplementationGuideElement(); 6531 case 3496916: return addRest(); 6532 default: return super.makeProperty(hash, name); 6533 } 6534 6535 } 6536 6537 @Override 6538 public String[] getTypesForProperty(int hash, String name) throws FHIRException { 6539 switch (hash) { 6540 case 116079: /*url*/ return new String[] {"uri"}; 6541 case 351608024: /*version*/ return new String[] {"string"}; 6542 case 3373707: /*name*/ return new String[] {"string"}; 6543 case 110371416: /*title*/ return new String[] {"string"}; 6544 case -892481550: /*status*/ return new String[] {"code"}; 6545 case -404562712: /*experimental*/ return new String[] {"boolean"}; 6546 case 3076014: /*date*/ return new String[] {"dateTime"}; 6547 case 1447404028: /*publisher*/ return new String[] {"string"}; 6548 case 951526432: /*contact*/ return new String[] {"ContactDetail"}; 6549 case -1724546052: /*description*/ return new String[] {"markdown"}; 6550 case -669707736: /*useContext*/ return new String[] {"UsageContext"}; 6551 case -507075711: /*jurisdiction*/ return new String[] {"CodeableConcept"}; 6552 case -220463842: /*purpose*/ return new String[] {"markdown"}; 6553 case 1522889671: /*copyright*/ return new String[] {"markdown"}; 6554 case 3292052: /*kind*/ return new String[] {"code"}; 6555 case -246883639: /*instantiates*/ return new String[] {"canonical"}; 6556 case 1926037870: /*imports*/ return new String[] {"canonical"}; 6557 case 1319330215: /*software*/ return new String[] {}; 6558 case 1683336114: /*implementation*/ return new String[] {}; 6559 case 461006061: /*fhirVersion*/ return new String[] {"code"}; 6560 case -1268779017: /*format*/ return new String[] {"code"}; 6561 case 172338783: /*patchFormat*/ return new String[] {"code"}; 6562 case 156966506: /*implementationGuide*/ return new String[] {"canonical"}; 6563 case 3496916: /*rest*/ return new String[] {}; 6564 default: return super.getTypesForProperty(hash, name); 6565 } 6566 6567 } 6568 6569 @Override 6570 public Base addChild(String name) throws FHIRException { 6571 if (name.equals("url")) { 6572 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.url"); 6573 } 6574 else if (name.equals("version")) { 6575 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.version"); 6576 } 6577 else if (name.equals("name")) { 6578 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.name"); 6579 } 6580 else if (name.equals("title")) { 6581 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.title"); 6582 } 6583 else if (name.equals("status")) { 6584 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.status"); 6585 } 6586 else if (name.equals("experimental")) { 6587 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.experimental"); 6588 } 6589 else if (name.equals("date")) { 6590 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.date"); 6591 } 6592 else if (name.equals("publisher")) { 6593 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.publisher"); 6594 } 6595 else if (name.equals("contact")) { 6596 return addContact(); 6597 } 6598 else if (name.equals("description")) { 6599 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.description"); 6600 } 6601 else if (name.equals("useContext")) { 6602 return addUseContext(); 6603 } 6604 else if (name.equals("jurisdiction")) { 6605 return addJurisdiction(); 6606 } 6607 else if (name.equals("purpose")) { 6608 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.purpose"); 6609 } 6610 else if (name.equals("copyright")) { 6611 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.copyright"); 6612 } 6613 else if (name.equals("kind")) { 6614 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.kind"); 6615 } 6616 else if (name.equals("instantiates")) { 6617 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.instantiates"); 6618 } 6619 else if (name.equals("imports")) { 6620 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.imports"); 6621 } 6622 else if (name.equals("software")) { 6623 this.software = new CapabilityStatement2SoftwareComponent(); 6624 return this.software; 6625 } 6626 else if (name.equals("implementation")) { 6627 this.implementation = new CapabilityStatement2ImplementationComponent(); 6628 return this.implementation; 6629 } 6630 else if (name.equals("fhirVersion")) { 6631 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.fhirVersion"); 6632 } 6633 else if (name.equals("format")) { 6634 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.format"); 6635 } 6636 else if (name.equals("patchFormat")) { 6637 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.patchFormat"); 6638 } 6639 else if (name.equals("implementationGuide")) { 6640 throw new FHIRException("Cannot call addChild on a primitive type CapabilityStatement2.implementationGuide"); 6641 } 6642 else if (name.equals("rest")) { 6643 return addRest(); 6644 } 6645 else 6646 return super.addChild(name); 6647 } 6648 6649 public String fhirType() { 6650 return "CapabilityStatement2"; 6651 6652 } 6653 6654 public CapabilityStatement2 copy() { 6655 CapabilityStatement2 dst = new CapabilityStatement2(); 6656 copyValues(dst); 6657 return dst; 6658 } 6659 6660 public void copyValues(CapabilityStatement2 dst) { 6661 super.copyValues(dst); 6662 dst.url = url == null ? null : url.copy(); 6663 dst.version = version == null ? null : version.copy(); 6664 dst.name = name == null ? null : name.copy(); 6665 dst.title = title == null ? null : title.copy(); 6666 dst.status = status == null ? null : status.copy(); 6667 dst.experimental = experimental == null ? null : experimental.copy(); 6668 dst.date = date == null ? null : date.copy(); 6669 dst.publisher = publisher == null ? null : publisher.copy(); 6670 if (contact != null) { 6671 dst.contact = new ArrayList<ContactDetail>(); 6672 for (ContactDetail i : contact) 6673 dst.contact.add(i.copy()); 6674 }; 6675 dst.description = description == null ? null : description.copy(); 6676 if (useContext != null) { 6677 dst.useContext = new ArrayList<UsageContext>(); 6678 for (UsageContext i : useContext) 6679 dst.useContext.add(i.copy()); 6680 }; 6681 if (jurisdiction != null) { 6682 dst.jurisdiction = new ArrayList<CodeableConcept>(); 6683 for (CodeableConcept i : jurisdiction) 6684 dst.jurisdiction.add(i.copy()); 6685 }; 6686 dst.purpose = purpose == null ? null : purpose.copy(); 6687 dst.copyright = copyright == null ? null : copyright.copy(); 6688 dst.kind = kind == null ? null : kind.copy(); 6689 if (instantiates != null) { 6690 dst.instantiates = new ArrayList<CanonicalType>(); 6691 for (CanonicalType i : instantiates) 6692 dst.instantiates.add(i.copy()); 6693 }; 6694 if (imports != null) { 6695 dst.imports = new ArrayList<CanonicalType>(); 6696 for (CanonicalType i : imports) 6697 dst.imports.add(i.copy()); 6698 }; 6699 dst.software = software == null ? null : software.copy(); 6700 dst.implementation = implementation == null ? null : implementation.copy(); 6701 dst.fhirVersion = fhirVersion == null ? null : fhirVersion.copy(); 6702 if (format != null) { 6703 dst.format = new ArrayList<CodeType>(); 6704 for (CodeType i : format) 6705 dst.format.add(i.copy()); 6706 }; 6707 if (patchFormat != null) { 6708 dst.patchFormat = new ArrayList<CodeType>(); 6709 for (CodeType i : patchFormat) 6710 dst.patchFormat.add(i.copy()); 6711 }; 6712 if (implementationGuide != null) { 6713 dst.implementationGuide = new ArrayList<CanonicalType>(); 6714 for (CanonicalType i : implementationGuide) 6715 dst.implementationGuide.add(i.copy()); 6716 }; 6717 if (rest != null) { 6718 dst.rest = new ArrayList<CapabilityStatement2RestComponent>(); 6719 for (CapabilityStatement2RestComponent i : rest) 6720 dst.rest.add(i.copy()); 6721 }; 6722 } 6723 6724 protected CapabilityStatement2 typedCopy() { 6725 return copy(); 6726 } 6727 6728 @Override 6729 public boolean equalsDeep(Base other_) { 6730 if (!super.equalsDeep(other_)) 6731 return false; 6732 if (!(other_ instanceof CapabilityStatement2)) 6733 return false; 6734 CapabilityStatement2 o = (CapabilityStatement2) other_; 6735 return compareDeep(url, o.url, true) && compareDeep(version, o.version, true) && compareDeep(name, o.name, true) 6736 && compareDeep(title, o.title, true) && compareDeep(status, o.status, true) && compareDeep(experimental, o.experimental, true) 6737 && compareDeep(date, o.date, true) && compareDeep(publisher, o.publisher, true) && compareDeep(contact, o.contact, true) 6738 && compareDeep(description, o.description, true) && compareDeep(useContext, o.useContext, true) 6739 && compareDeep(jurisdiction, o.jurisdiction, true) && compareDeep(purpose, o.purpose, true) && compareDeep(copyright, o.copyright, true) 6740 && compareDeep(kind, o.kind, true) && compareDeep(instantiates, o.instantiates, true) && compareDeep(imports, o.imports, true) 6741 && compareDeep(software, o.software, true) && compareDeep(implementation, o.implementation, true) 6742 && compareDeep(fhirVersion, o.fhirVersion, true) && compareDeep(format, o.format, true) && compareDeep(patchFormat, o.patchFormat, true) 6743 && compareDeep(implementationGuide, o.implementationGuide, true) && compareDeep(rest, o.rest, true) 6744 ; 6745 } 6746 6747 @Override 6748 public boolean equalsShallow(Base other_) { 6749 if (!super.equalsShallow(other_)) 6750 return false; 6751 if (!(other_ instanceof CapabilityStatement2)) 6752 return false; 6753 CapabilityStatement2 o = (CapabilityStatement2) other_; 6754 return compareValues(url, o.url, true) && compareValues(version, o.version, true) && compareValues(name, o.name, true) 6755 && compareValues(title, o.title, true) && compareValues(status, o.status, true) && compareValues(experimental, o.experimental, true) 6756 && compareValues(date, o.date, true) && compareValues(publisher, o.publisher, true) && compareValues(description, o.description, true) 6757 && compareValues(purpose, o.purpose, true) && compareValues(copyright, o.copyright, true) && compareValues(kind, o.kind, true) 6758 && compareValues(instantiates, o.instantiates, true) && compareValues(imports, o.imports, true) && compareValues(fhirVersion, o.fhirVersion, true) 6759 && compareValues(format, o.format, true) && compareValues(patchFormat, o.patchFormat, true) && compareValues(implementationGuide, o.implementationGuide, true) 6760 ; 6761 } 6762 6763 public boolean isEmpty() { 6764 return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(url, version, name, title 6765 , status, experimental, date, publisher, contact, description, useContext, jurisdiction 6766 , purpose, copyright, kind, instantiates, imports, software, implementation, fhirVersion 6767 , format, patchFormat, implementationGuide, rest); 6768 } 6769 6770 @Override 6771 public ResourceType getResourceType() { 6772 return ResourceType.CapabilityStatement2; 6773 } 6774 6775 /** 6776 * Search parameter: <b>context-quantity</b> 6777 * <p> 6778 * Description: <b>A quantity- or range-valued use context assigned to the capability statement2</b><br> 6779 * Type: <b>quantity</b><br> 6780 * Path: <b>(CapabilityStatement2.useContext.value as Quantity) | (CapabilityStatement2.useContext.value as Range)</b><br> 6781 * </p> 6782 */ 6783 @SearchParamDefinition(name="context-quantity", path="(CapabilityStatement2.useContext.value as Quantity) | (CapabilityStatement2.useContext.value as Range)", description="A quantity- or range-valued use context assigned to the capability statement2", type="quantity" ) 6784 public static final String SP_CONTEXT_QUANTITY = "context-quantity"; 6785 /** 6786 * <b>Fluent Client</b> search parameter constant for <b>context-quantity</b> 6787 * <p> 6788 * Description: <b>A quantity- or range-valued use context assigned to the capability statement2</b><br> 6789 * Type: <b>quantity</b><br> 6790 * Path: <b>(CapabilityStatement2.useContext.value as Quantity) | (CapabilityStatement2.useContext.value as Range)</b><br> 6791 * </p> 6792 */ 6793 public static final ca.uhn.fhir.rest.gclient.QuantityClientParam CONTEXT_QUANTITY = new ca.uhn.fhir.rest.gclient.QuantityClientParam(SP_CONTEXT_QUANTITY); 6794 6795 /** 6796 * Search parameter: <b>context-type-quantity</b> 6797 * <p> 6798 * Description: <b>A use context type and quantity- or range-based value assigned to the capability statement2</b><br> 6799 * Type: <b>composite</b><br> 6800 * Path: <b>CapabilityStatement2.useContext</b><br> 6801 * </p> 6802 */ 6803 @SearchParamDefinition(name="context-type-quantity", path="CapabilityStatement2.useContext", description="A use context type and quantity- or range-based value assigned to the capability statement2", type="composite", compositeOf={"context-type", "context-quantity"} ) 6804 public static final String SP_CONTEXT_TYPE_QUANTITY = "context-type-quantity"; 6805 /** 6806 * <b>Fluent Client</b> search parameter constant for <b>context-type-quantity</b> 6807 * <p> 6808 * Description: <b>A use context type and quantity- or range-based value assigned to the capability statement2</b><br> 6809 * Type: <b>composite</b><br> 6810 * Path: <b>CapabilityStatement2.useContext</b><br> 6811 * </p> 6812 */ 6813 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); 6814 6815 /** 6816 * Search parameter: <b>context-type-value</b> 6817 * <p> 6818 * Description: <b>A use context type and value assigned to the capability statement2</b><br> 6819 * Type: <b>composite</b><br> 6820 * Path: <b>CapabilityStatement2.useContext</b><br> 6821 * </p> 6822 */ 6823 @SearchParamDefinition(name="context-type-value", path="CapabilityStatement2.useContext", description="A use context type and value assigned to the capability statement2", type="composite", compositeOf={"context-type", "context"} ) 6824 public static final String SP_CONTEXT_TYPE_VALUE = "context-type-value"; 6825 /** 6826 * <b>Fluent Client</b> search parameter constant for <b>context-type-value</b> 6827 * <p> 6828 * Description: <b>A use context type and value assigned to the capability statement2</b><br> 6829 * Type: <b>composite</b><br> 6830 * Path: <b>CapabilityStatement2.useContext</b><br> 6831 * </p> 6832 */ 6833 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); 6834 6835 /** 6836 * Search parameter: <b>context-type</b> 6837 * <p> 6838 * Description: <b>A type of use context assigned to the capability statement2</b><br> 6839 * Type: <b>token</b><br> 6840 * Path: <b>CapabilityStatement2.useContext.code</b><br> 6841 * </p> 6842 */ 6843 @SearchParamDefinition(name="context-type", path="CapabilityStatement2.useContext.code", description="A type of use context assigned to the capability statement2", type="token" ) 6844 public static final String SP_CONTEXT_TYPE = "context-type"; 6845 /** 6846 * <b>Fluent Client</b> search parameter constant for <b>context-type</b> 6847 * <p> 6848 * Description: <b>A type of use context assigned to the capability statement2</b><br> 6849 * Type: <b>token</b><br> 6850 * Path: <b>CapabilityStatement2.useContext.code</b><br> 6851 * </p> 6852 */ 6853 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT_TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT_TYPE); 6854 6855 /** 6856 * Search parameter: <b>context</b> 6857 * <p> 6858 * Description: <b>A use context assigned to the capability statement2</b><br> 6859 * Type: <b>token</b><br> 6860 * Path: <b>(CapabilityStatement2.useContext.value as CodeableConcept)</b><br> 6861 * </p> 6862 */ 6863 @SearchParamDefinition(name="context", path="(CapabilityStatement2.useContext.value as CodeableConcept)", description="A use context assigned to the capability statement2", type="token" ) 6864 public static final String SP_CONTEXT = "context"; 6865 /** 6866 * <b>Fluent Client</b> search parameter constant for <b>context</b> 6867 * <p> 6868 * Description: <b>A use context assigned to the capability statement2</b><br> 6869 * Type: <b>token</b><br> 6870 * Path: <b>(CapabilityStatement2.useContext.value as CodeableConcept)</b><br> 6871 * </p> 6872 */ 6873 public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT); 6874 6875 /** 6876 * Search parameter: <b>date</b> 6877 * <p> 6878 * Description: <b>The capability statement2 publication date</b><br> 6879 * Type: <b>date</b><br> 6880 * Path: <b>CapabilityStatement2.date</b><br> 6881 * </p> 6882 */ 6883 @SearchParamDefinition(name="date", path="CapabilityStatement2.date", description="The capability statement2 publication date", type="date" ) 6884 public static final String SP_DATE = "date"; 6885 /** 6886 * <b>Fluent Client</b> search parameter constant for <b>date</b> 6887 * <p> 6888 * Description: <b>The capability statement2 publication date</b><br> 6889 * Type: <b>date</b><br> 6890 * Path: <b>CapabilityStatement2.date</b><br> 6891 * </p> 6892 */ 6893 public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE); 6894 6895 /** 6896 * Search parameter: <b>description</b> 6897 * <p> 6898 * Description: <b>The description of the capability statement2</b><br> 6899 * Type: <b>string</b><br> 6900 * Path: <b>CapabilityStatement2.description</b><br> 6901 * </p> 6902 */ 6903 @SearchParamDefinition(name="description", path="CapabilityStatement2.description", description="The description of the capability statement2", type="string" ) 6904 public static final String SP_DESCRIPTION = "description"; 6905 /** 6906 * <b>Fluent Client</b> search parameter constant for <b>description</b> 6907 * <p> 6908 * Description: <b>The description of the capability statement2</b><br> 6909 * Type: <b>string</b><br> 6910 * Path: <b>CapabilityStatement2.description</b><br> 6911 * </p> 6912 */ 6913 public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION); 6914 6915 /** 6916 * Search parameter: <b>fhirversion</b> 6917 * <p> 6918 * Description: <b>The version of FHIR</b><br> 6919 * Type: <b>token</b><br> 6920 * Path: <b>CapabilityStatement2.version</b><br> 6921 * </p> 6922 */ 6923 @SearchParamDefinition(name="fhirversion", path="CapabilityStatement2.version", description="The version of FHIR", type="token" ) 6924 public static final String SP_FHIRVERSION = "fhirversion"; 6925 /** 6926 * <b>Fluent Client</b> search parameter constant for <b>fhirversion</b> 6927 * <p> 6928 * Description: <b>The version of FHIR</b><br> 6929 * Type: <b>token</b><br> 6930 * Path: <b>CapabilityStatement2.version</b><br> 6931 * </p> 6932 */ 6933 public static final ca.uhn.fhir.rest.gclient.TokenClientParam FHIRVERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_FHIRVERSION); 6934 6935 /** 6936 * Search parameter: <b>format</b> 6937 * <p> 6938 * Description: <b>formats supported (xml | json | ttl | mime type)</b><br> 6939 * Type: <b>token</b><br> 6940 * Path: <b>CapabilityStatement2.format</b><br> 6941 * </p> 6942 */ 6943 @SearchParamDefinition(name="format", path="CapabilityStatement2.format", description="formats supported (xml | json | ttl | mime type)", type="token" ) 6944 public static final String SP_FORMAT = "format"; 6945 /** 6946 * <b>Fluent Client</b> search parameter constant for <b>format</b> 6947 * <p> 6948 * Description: <b>formats supported (xml | json | ttl | mime type)</b><br> 6949 * Type: <b>token</b><br> 6950 * Path: <b>CapabilityStatement2.format</b><br> 6951 * </p> 6952 */ 6953 public static final ca.uhn.fhir.rest.gclient.TokenClientParam FORMAT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_FORMAT); 6954 6955 /** 6956 * Search parameter: <b>guide</b> 6957 * <p> 6958 * Description: <b>Implementation guides supported</b><br> 6959 * Type: <b>reference</b><br> 6960 * Path: <b>CapabilityStatement2.implementationGuide</b><br> 6961 * </p> 6962 */ 6963 @SearchParamDefinition(name="guide", path="CapabilityStatement2.implementationGuide", description="Implementation guides supported", type="reference", target={ImplementationGuide.class } ) 6964 public static final String SP_GUIDE = "guide"; 6965 /** 6966 * <b>Fluent Client</b> search parameter constant for <b>guide</b> 6967 * <p> 6968 * Description: <b>Implementation guides supported</b><br> 6969 * Type: <b>reference</b><br> 6970 * Path: <b>CapabilityStatement2.implementationGuide</b><br> 6971 * </p> 6972 */ 6973 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam GUIDE = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_GUIDE); 6974 6975/** 6976 * Constant for fluent queries to be used to add include statements. Specifies 6977 * the path value of "<b>CapabilityStatement2:guide</b>". 6978 */ 6979 public static final ca.uhn.fhir.model.api.Include INCLUDE_GUIDE = new ca.uhn.fhir.model.api.Include("CapabilityStatement2:guide").toLocked(); 6980 6981 /** 6982 * Search parameter: <b>jurisdiction</b> 6983 * <p> 6984 * Description: <b>Intended jurisdiction for the capability statement2</b><br> 6985 * Type: <b>token</b><br> 6986 * Path: <b>CapabilityStatement2.jurisdiction</b><br> 6987 * </p> 6988 */ 6989 @SearchParamDefinition(name="jurisdiction", path="CapabilityStatement2.jurisdiction", description="Intended jurisdiction for the capability statement2", type="token" ) 6990 public static final String SP_JURISDICTION = "jurisdiction"; 6991 /** 6992 * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b> 6993 * <p> 6994 * Description: <b>Intended jurisdiction for the capability statement2</b><br> 6995 * Type: <b>token</b><br> 6996 * Path: <b>CapabilityStatement2.jurisdiction</b><br> 6997 * </p> 6998 */ 6999 public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_JURISDICTION); 7000 7001 /** 7002 * Search parameter: <b>mode</b> 7003 * <p> 7004 * Description: <b>Mode - restful (server/client) or messaging (sender/receiver)</b><br> 7005 * Type: <b>token</b><br> 7006 * Path: <b>CapabilityStatement2.rest.mode</b><br> 7007 * </p> 7008 */ 7009 @SearchParamDefinition(name="mode", path="CapabilityStatement2.rest.mode", description="Mode - restful (server/client) or messaging (sender/receiver)", type="token" ) 7010 public static final String SP_MODE = "mode"; 7011 /** 7012 * <b>Fluent Client</b> search parameter constant for <b>mode</b> 7013 * <p> 7014 * Description: <b>Mode - restful (server/client) or messaging (sender/receiver)</b><br> 7015 * Type: <b>token</b><br> 7016 * Path: <b>CapabilityStatement2.rest.mode</b><br> 7017 * </p> 7018 */ 7019 public static final ca.uhn.fhir.rest.gclient.TokenClientParam MODE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_MODE); 7020 7021 /** 7022 * Search parameter: <b>name</b> 7023 * <p> 7024 * Description: <b>Computationally friendly name of the capability statement2</b><br> 7025 * Type: <b>string</b><br> 7026 * Path: <b>CapabilityStatement2.name</b><br> 7027 * </p> 7028 */ 7029 @SearchParamDefinition(name="name", path="CapabilityStatement2.name", description="Computationally friendly name of the capability statement2", type="string" ) 7030 public static final String SP_NAME = "name"; 7031 /** 7032 * <b>Fluent Client</b> search parameter constant for <b>name</b> 7033 * <p> 7034 * Description: <b>Computationally friendly name of the capability statement2</b><br> 7035 * Type: <b>string</b><br> 7036 * Path: <b>CapabilityStatement2.name</b><br> 7037 * </p> 7038 */ 7039 public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME); 7040 7041 /** 7042 * Search parameter: <b>publisher</b> 7043 * <p> 7044 * Description: <b>Name of the publisher of the capability statement2</b><br> 7045 * Type: <b>string</b><br> 7046 * Path: <b>CapabilityStatement2.publisher</b><br> 7047 * </p> 7048 */ 7049 @SearchParamDefinition(name="publisher", path="CapabilityStatement2.publisher", description="Name of the publisher of the capability statement2", type="string" ) 7050 public static final String SP_PUBLISHER = "publisher"; 7051 /** 7052 * <b>Fluent Client</b> search parameter constant for <b>publisher</b> 7053 * <p> 7054 * Description: <b>Name of the publisher of the capability statement2</b><br> 7055 * Type: <b>string</b><br> 7056 * Path: <b>CapabilityStatement2.publisher</b><br> 7057 * </p> 7058 */ 7059 public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_PUBLISHER); 7060 7061 /** 7062 * Search parameter: <b>resource-profile</b> 7063 * <p> 7064 * Description: <b>A profile id invoked in a capability statement</b><br> 7065 * Type: <b>reference</b><br> 7066 * Path: <b>CapabilityStatement2.rest.resource.profile</b><br> 7067 * </p> 7068 */ 7069 @SearchParamDefinition(name="resource-profile", path="CapabilityStatement2.rest.resource.profile", description="A profile id invoked in a capability statement", type="reference", target={StructureDefinition.class } ) 7070 public static final String SP_RESOURCE_PROFILE = "resource-profile"; 7071 /** 7072 * <b>Fluent Client</b> search parameter constant for <b>resource-profile</b> 7073 * <p> 7074 * Description: <b>A profile id invoked in a capability statement</b><br> 7075 * Type: <b>reference</b><br> 7076 * Path: <b>CapabilityStatement2.rest.resource.profile</b><br> 7077 * </p> 7078 */ 7079 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam RESOURCE_PROFILE = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_RESOURCE_PROFILE); 7080 7081/** 7082 * Constant for fluent queries to be used to add include statements. Specifies 7083 * the path value of "<b>CapabilityStatement2:resource-profile</b>". 7084 */ 7085 public static final ca.uhn.fhir.model.api.Include INCLUDE_RESOURCE_PROFILE = new ca.uhn.fhir.model.api.Include("CapabilityStatement2:resource-profile").toLocked(); 7086 7087 /** 7088 * Search parameter: <b>resource</b> 7089 * <p> 7090 * Description: <b>Name of a resource mentioned in a capability statement</b><br> 7091 * Type: <b>token</b><br> 7092 * Path: <b>CapabilityStatement2.rest.resource.type</b><br> 7093 * </p> 7094 */ 7095 @SearchParamDefinition(name="resource", path="CapabilityStatement2.rest.resource.type", description="Name of a resource mentioned in a capability statement", type="token" ) 7096 public static final String SP_RESOURCE = "resource"; 7097 /** 7098 * <b>Fluent Client</b> search parameter constant for <b>resource</b> 7099 * <p> 7100 * Description: <b>Name of a resource mentioned in a capability statement</b><br> 7101 * Type: <b>token</b><br> 7102 * Path: <b>CapabilityStatement2.rest.resource.type</b><br> 7103 * </p> 7104 */ 7105 public static final ca.uhn.fhir.rest.gclient.TokenClientParam RESOURCE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_RESOURCE); 7106 7107 /** 7108 * Search parameter: <b>software</b> 7109 * <p> 7110 * Description: <b>Part of the name of a software application</b><br> 7111 * Type: <b>string</b><br> 7112 * Path: <b>CapabilityStatement2.software.name</b><br> 7113 * </p> 7114 */ 7115 @SearchParamDefinition(name="software", path="CapabilityStatement2.software.name", description="Part of the name of a software application", type="string" ) 7116 public static final String SP_SOFTWARE = "software"; 7117 /** 7118 * <b>Fluent Client</b> search parameter constant for <b>software</b> 7119 * <p> 7120 * Description: <b>Part of the name of a software application</b><br> 7121 * Type: <b>string</b><br> 7122 * Path: <b>CapabilityStatement2.software.name</b><br> 7123 * </p> 7124 */ 7125 public static final ca.uhn.fhir.rest.gclient.StringClientParam SOFTWARE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_SOFTWARE); 7126 7127 /** 7128 * Search parameter: <b>status</b> 7129 * <p> 7130 * Description: <b>The current status of the capability statement2</b><br> 7131 * Type: <b>token</b><br> 7132 * Path: <b>CapabilityStatement2.status</b><br> 7133 * </p> 7134 */ 7135 @SearchParamDefinition(name="status", path="CapabilityStatement2.status", description="The current status of the capability statement2", type="token" ) 7136 public static final String SP_STATUS = "status"; 7137 /** 7138 * <b>Fluent Client</b> search parameter constant for <b>status</b> 7139 * <p> 7140 * Description: <b>The current status of the capability statement2</b><br> 7141 * Type: <b>token</b><br> 7142 * Path: <b>CapabilityStatement2.status</b><br> 7143 * </p> 7144 */ 7145 public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS); 7146 7147 /** 7148 * Search parameter: <b>supported-profile</b> 7149 * <p> 7150 * Description: <b>Profiles for use cases supported</b><br> 7151 * Type: <b>reference</b><br> 7152 * Path: <b>CapabilityStatement2.rest.resource.supportedProfile</b><br> 7153 * </p> 7154 */ 7155 @SearchParamDefinition(name="supported-profile", path="CapabilityStatement2.rest.resource.supportedProfile", description="Profiles for use cases supported", type="reference", target={StructureDefinition.class } ) 7156 public static final String SP_SUPPORTED_PROFILE = "supported-profile"; 7157 /** 7158 * <b>Fluent Client</b> search parameter constant for <b>supported-profile</b> 7159 * <p> 7160 * Description: <b>Profiles for use cases supported</b><br> 7161 * Type: <b>reference</b><br> 7162 * Path: <b>CapabilityStatement2.rest.resource.supportedProfile</b><br> 7163 * </p> 7164 */ 7165 public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SUPPORTED_PROFILE = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_SUPPORTED_PROFILE); 7166 7167/** 7168 * Constant for fluent queries to be used to add include statements. Specifies 7169 * the path value of "<b>CapabilityStatement2:supported-profile</b>". 7170 */ 7171 public static final ca.uhn.fhir.model.api.Include INCLUDE_SUPPORTED_PROFILE = new ca.uhn.fhir.model.api.Include("CapabilityStatement2:supported-profile").toLocked(); 7172 7173 /** 7174 * Search parameter: <b>title</b> 7175 * <p> 7176 * Description: <b>The human-friendly name of the capability statement2</b><br> 7177 * Type: <b>string</b><br> 7178 * Path: <b>CapabilityStatement2.title</b><br> 7179 * </p> 7180 */ 7181 @SearchParamDefinition(name="title", path="CapabilityStatement2.title", description="The human-friendly name of the capability statement2", type="string" ) 7182 public static final String SP_TITLE = "title"; 7183 /** 7184 * <b>Fluent Client</b> search parameter constant for <b>title</b> 7185 * <p> 7186 * Description: <b>The human-friendly name of the capability statement2</b><br> 7187 * Type: <b>string</b><br> 7188 * Path: <b>CapabilityStatement2.title</b><br> 7189 * </p> 7190 */ 7191 public static final ca.uhn.fhir.rest.gclient.StringClientParam TITLE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_TITLE); 7192 7193 /** 7194 * Search parameter: <b>url</b> 7195 * <p> 7196 * Description: <b>The uri that identifies the capability statement2</b><br> 7197 * Type: <b>uri</b><br> 7198 * Path: <b>CapabilityStatement2.url</b><br> 7199 * </p> 7200 */ 7201 @SearchParamDefinition(name="url", path="CapabilityStatement2.url", description="The uri that identifies the capability statement2", type="uri" ) 7202 public static final String SP_URL = "url"; 7203 /** 7204 * <b>Fluent Client</b> search parameter constant for <b>url</b> 7205 * <p> 7206 * Description: <b>The uri that identifies the capability statement2</b><br> 7207 * Type: <b>uri</b><br> 7208 * Path: <b>CapabilityStatement2.url</b><br> 7209 * </p> 7210 */ 7211 public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL); 7212 7213 /** 7214 * Search parameter: <b>version</b> 7215 * <p> 7216 * Description: <b>The business version of the capability statement2</b><br> 7217 * Type: <b>token</b><br> 7218 * Path: <b>CapabilityStatement2.version</b><br> 7219 * </p> 7220 */ 7221 @SearchParamDefinition(name="version", path="CapabilityStatement2.version", description="The business version of the capability statement2", type="token" ) 7222 public static final String SP_VERSION = "version"; 7223 /** 7224 * <b>Fluent Client</b> search parameter constant for <b>version</b> 7225 * <p> 7226 * Description: <b>The business version of the capability statement2</b><br> 7227 * Type: <b>token</b><br> 7228 * Path: <b>CapabilityStatement2.version</b><br> 7229 * </p> 7230 */ 7231 public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VERSION); 7232 7233 7234} 7235