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