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