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.r4.model.Enumerations.PublicationStatus;
040import org.hl7.fhir.r4.model.Enumerations.PublicationStatusEnumFactory;
041import org.hl7.fhir.utilities.Utilities;
042
043import ca.uhn.fhir.model.api.annotation.Block;
044import ca.uhn.fhir.model.api.annotation.Child;
045import ca.uhn.fhir.model.api.annotation.ChildOrder;
046import ca.uhn.fhir.model.api.annotation.Description;
047import ca.uhn.fhir.model.api.annotation.ResourceDef;
048import ca.uhn.fhir.model.api.annotation.SearchParamDefinition;
049
050/**
051 * A TerminologyCapabilities resource documents a set of capabilities
052 * (behaviors) of a FHIR Terminology Server that may be used as a statement of
053 * actual server functionality or a statement of required or desired server
054 * implementation.
055 */
056@ResourceDef(name = "TerminologyCapabilities", profile = "http://hl7.org/fhir/StructureDefinition/TerminologyCapabilities")
057@ChildOrder(names = { "url", "version", "name", "title", "status", "experimental", "date", "publisher", "contact",
058    "description", "useContext", "jurisdiction", "purpose", "copyright", "kind", "software", "implementation",
059    "lockedDate", "codeSystem", "expansion", "codeSearch", "validateCode", "translation", "closure" })
060public class TerminologyCapabilities extends MetadataResource {
061
062  public enum CapabilityStatementKind {
063    /**
064     * The CapabilityStatement instance represents the present capabilities of a
065     * specific system instance. This is the kind returned by /metadata for a FHIR
066     * server end-point.
067     */
068    INSTANCE,
069    /**
070     * The CapabilityStatement instance represents the capabilities of a system or
071     * piece of software, independent of a particular installation.
072     */
073    CAPABILITY,
074    /**
075     * The CapabilityStatement instance represents a set of requirements for other
076     * systems to meet; e.g. as part of an implementation guide or 'request for
077     * proposal'.
078     */
079    REQUIREMENTS,
080    /**
081     * added to help the parsers with the generic types
082     */
083    NULL;
084
085    public static CapabilityStatementKind fromCode(String codeString) throws FHIRException {
086      if (codeString == null || "".equals(codeString))
087        return null;
088      if ("instance".equals(codeString))
089        return INSTANCE;
090      if ("capability".equals(codeString))
091        return CAPABILITY;
092      if ("requirements".equals(codeString))
093        return REQUIREMENTS;
094      if (Configuration.isAcceptInvalidEnums())
095        return null;
096      else
097        throw new FHIRException("Unknown CapabilityStatementKind code '" + codeString + "'");
098    }
099
100    public String toCode() {
101      switch (this) {
102      case INSTANCE:
103        return "instance";
104      case CAPABILITY:
105        return "capability";
106      case REQUIREMENTS:
107        return "requirements";
108      case NULL:
109        return null;
110      default:
111        return "?";
112      }
113    }
114
115    public String getSystem() {
116      switch (this) {
117      case INSTANCE:
118        return "http://hl7.org/fhir/capability-statement-kind";
119      case CAPABILITY:
120        return "http://hl7.org/fhir/capability-statement-kind";
121      case REQUIREMENTS:
122        return "http://hl7.org/fhir/capability-statement-kind";
123      case NULL:
124        return null;
125      default:
126        return "?";
127      }
128    }
129
130    public String getDefinition() {
131      switch (this) {
132      case INSTANCE:
133        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.";
134      case CAPABILITY:
135        return "The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation.";
136      case REQUIREMENTS:
137        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'.";
138      case NULL:
139        return null;
140      default:
141        return "?";
142      }
143    }
144
145    public String getDisplay() {
146      switch (this) {
147      case INSTANCE:
148        return "Instance";
149      case CAPABILITY:
150        return "Capability";
151      case REQUIREMENTS:
152        return "Requirements";
153      case NULL:
154        return null;
155      default:
156        return "?";
157      }
158    }
159  }
160
161  public static class CapabilityStatementKindEnumFactory implements EnumFactory<CapabilityStatementKind> {
162    public CapabilityStatementKind fromCode(String codeString) throws IllegalArgumentException {
163      if (codeString == null || "".equals(codeString))
164        if (codeString == null || "".equals(codeString))
165          return null;
166      if ("instance".equals(codeString))
167        return CapabilityStatementKind.INSTANCE;
168      if ("capability".equals(codeString))
169        return CapabilityStatementKind.CAPABILITY;
170      if ("requirements".equals(codeString))
171        return CapabilityStatementKind.REQUIREMENTS;
172      throw new IllegalArgumentException("Unknown CapabilityStatementKind code '" + codeString + "'");
173    }
174
175    public Enumeration<CapabilityStatementKind> fromType(PrimitiveType<?> code) throws FHIRException {
176      if (code == null)
177        return null;
178      if (code.isEmpty())
179        return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.NULL, code);
180      String codeString = code.asStringValue();
181      if (codeString == null || "".equals(codeString))
182        return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.NULL, code);
183      if ("instance".equals(codeString))
184        return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.INSTANCE, code);
185      if ("capability".equals(codeString))
186        return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.CAPABILITY, code);
187      if ("requirements".equals(codeString))
188        return new Enumeration<CapabilityStatementKind>(this, CapabilityStatementKind.REQUIREMENTS, code);
189      throw new FHIRException("Unknown CapabilityStatementKind code '" + codeString + "'");
190    }
191
192    public String toCode(CapabilityStatementKind code) {
193      if (code == CapabilityStatementKind.INSTANCE)
194        return "instance";
195      if (code == CapabilityStatementKind.CAPABILITY)
196        return "capability";
197      if (code == CapabilityStatementKind.REQUIREMENTS)
198        return "requirements";
199      return "?";
200    }
201
202    public String toSystem(CapabilityStatementKind code) {
203      return code.getSystem();
204    }
205  }
206
207  public enum CodeSearchSupport {
208    /**
209     * The search for code on ValueSet only includes codes explicitly detailed on
210     * includes or expansions.
211     */
212    EXPLICIT,
213    /**
214     * The search for code on ValueSet only includes all codes based on the
215     * expansion of the value set.
216     */
217    ALL,
218    /**
219     * added to help the parsers with the generic types
220     */
221    NULL;
222
223    public static CodeSearchSupport fromCode(String codeString) throws FHIRException {
224      if (codeString == null || "".equals(codeString))
225        return null;
226      if ("explicit".equals(codeString))
227        return EXPLICIT;
228      if ("all".equals(codeString))
229        return ALL;
230      if (Configuration.isAcceptInvalidEnums())
231        return null;
232      else
233        throw new FHIRException("Unknown CodeSearchSupport code '" + codeString + "'");
234    }
235
236    public String toCode() {
237      switch (this) {
238      case EXPLICIT:
239        return "explicit";
240      case ALL:
241        return "all";
242      case NULL:
243        return null;
244      default:
245        return "?";
246      }
247    }
248
249    public String getSystem() {
250      switch (this) {
251      case EXPLICIT:
252        return "http://hl7.org/fhir/code-search-support";
253      case ALL:
254        return "http://hl7.org/fhir/code-search-support";
255      case NULL:
256        return null;
257      default:
258        return "?";
259      }
260    }
261
262    public String getDefinition() {
263      switch (this) {
264      case EXPLICIT:
265        return "The search for code on ValueSet only includes codes explicitly detailed on includes or expansions.";
266      case ALL:
267        return "The search for code on ValueSet only includes all codes based on the expansion of the value set.";
268      case NULL:
269        return null;
270      default:
271        return "?";
272      }
273    }
274
275    public String getDisplay() {
276      switch (this) {
277      case EXPLICIT:
278        return "Explicit Codes";
279      case ALL:
280        return "Implicit Codes";
281      case NULL:
282        return null;
283      default:
284        return "?";
285      }
286    }
287  }
288
289  public static class CodeSearchSupportEnumFactory implements EnumFactory<CodeSearchSupport> {
290    public CodeSearchSupport fromCode(String codeString) throws IllegalArgumentException {
291      if (codeString == null || "".equals(codeString))
292        if (codeString == null || "".equals(codeString))
293          return null;
294      if ("explicit".equals(codeString))
295        return CodeSearchSupport.EXPLICIT;
296      if ("all".equals(codeString))
297        return CodeSearchSupport.ALL;
298      throw new IllegalArgumentException("Unknown CodeSearchSupport code '" + codeString + "'");
299    }
300
301    public Enumeration<CodeSearchSupport> fromType(PrimitiveType<?> code) throws FHIRException {
302      if (code == null)
303        return null;
304      if (code.isEmpty())
305        return new Enumeration<CodeSearchSupport>(this, CodeSearchSupport.NULL, code);
306      String codeString = code.asStringValue();
307      if (codeString == null || "".equals(codeString))
308        return new Enumeration<CodeSearchSupport>(this, CodeSearchSupport.NULL, code);
309      if ("explicit".equals(codeString))
310        return new Enumeration<CodeSearchSupport>(this, CodeSearchSupport.EXPLICIT, code);
311      if ("all".equals(codeString))
312        return new Enumeration<CodeSearchSupport>(this, CodeSearchSupport.ALL, code);
313      throw new FHIRException("Unknown CodeSearchSupport code '" + codeString + "'");
314    }
315
316    public String toCode(CodeSearchSupport code) {
317      if (code == CodeSearchSupport.EXPLICIT)
318        return "explicit";
319      if (code == CodeSearchSupport.ALL)
320        return "all";
321      return "?";
322    }
323
324    public String toSystem(CodeSearchSupport code) {
325      return code.getSystem();
326    }
327  }
328
329  @Block()
330  public static class TerminologyCapabilitiesSoftwareComponent extends BackboneElement implements IBaseBackboneElement {
331    /**
332     * Name the software is known by.
333     */
334    @Child(name = "name", type = { StringType.class }, order = 1, min = 1, max = 1, modifier = false, summary = true)
335    @Description(shortDefinition = "A name the software is known by", formalDefinition = "Name the software is known by.")
336    protected StringType name;
337
338    /**
339     * The version identifier for the software covered by this statement.
340     */
341    @Child(name = "version", type = { StringType.class }, order = 2, min = 0, max = 1, modifier = false, summary = true)
342    @Description(shortDefinition = "Version covered by this statement", formalDefinition = "The version identifier for the software covered by this statement.")
343    protected StringType version;
344
345    private static final long serialVersionUID = -790299911L;
346
347    /**
348     * Constructor
349     */
350    public TerminologyCapabilitiesSoftwareComponent() {
351      super();
352    }
353
354    /**
355     * Constructor
356     */
357    public TerminologyCapabilitiesSoftwareComponent(StringType name) {
358      super();
359      this.name = name;
360    }
361
362    /**
363     * @return {@link #name} (Name the software is known by.). This is the
364     *         underlying object with id, value and extensions. The accessor
365     *         "getName" gives direct access to the value
366     */
367    public StringType getNameElement() {
368      if (this.name == null)
369        if (Configuration.errorOnAutoCreate())
370          throw new Error("Attempt to auto-create TerminologyCapabilitiesSoftwareComponent.name");
371        else if (Configuration.doAutoCreate())
372          this.name = new StringType(); // bb
373      return this.name;
374    }
375
376    public boolean hasNameElement() {
377      return this.name != null && !this.name.isEmpty();
378    }
379
380    public boolean hasName() {
381      return this.name != null && !this.name.isEmpty();
382    }
383
384    /**
385     * @param value {@link #name} (Name the software is known by.). This is the
386     *              underlying object with id, value and extensions. The accessor
387     *              "getName" gives direct access to the value
388     */
389    public TerminologyCapabilitiesSoftwareComponent setNameElement(StringType value) {
390      this.name = value;
391      return this;
392    }
393
394    /**
395     * @return Name the software is known by.
396     */
397    public String getName() {
398      return this.name == null ? null : this.name.getValue();
399    }
400
401    /**
402     * @param value Name the software is known by.
403     */
404    public TerminologyCapabilitiesSoftwareComponent setName(String value) {
405      if (this.name == null)
406        this.name = new StringType();
407      this.name.setValue(value);
408      return this;
409    }
410
411    /**
412     * @return {@link #version} (The version identifier for the software covered by
413     *         this statement.). This is the underlying object with id, value and
414     *         extensions. The accessor "getVersion" gives direct access to the
415     *         value
416     */
417    public StringType getVersionElement() {
418      if (this.version == null)
419        if (Configuration.errorOnAutoCreate())
420          throw new Error("Attempt to auto-create TerminologyCapabilitiesSoftwareComponent.version");
421        else if (Configuration.doAutoCreate())
422          this.version = new StringType(); // bb
423      return this.version;
424    }
425
426    public boolean hasVersionElement() {
427      return this.version != null && !this.version.isEmpty();
428    }
429
430    public boolean hasVersion() {
431      return this.version != null && !this.version.isEmpty();
432    }
433
434    /**
435     * @param value {@link #version} (The version identifier for the software
436     *              covered by this statement.). This is the underlying object with
437     *              id, value and extensions. The accessor "getVersion" gives direct
438     *              access to the value
439     */
440    public TerminologyCapabilitiesSoftwareComponent setVersionElement(StringType value) {
441      this.version = value;
442      return this;
443    }
444
445    /**
446     * @return The version identifier for the software covered by this statement.
447     */
448    public String getVersion() {
449      return this.version == null ? null : this.version.getValue();
450    }
451
452    /**
453     * @param value The version identifier for the software covered by this
454     *              statement.
455     */
456    public TerminologyCapabilitiesSoftwareComponent setVersion(String value) {
457      if (Utilities.noString(value))
458        this.version = null;
459      else {
460        if (this.version == null)
461          this.version = new StringType();
462        this.version.setValue(value);
463      }
464      return this;
465    }
466
467    protected void listChildren(List<Property> children) {
468      super.listChildren(children);
469      children.add(new Property("name", "string", "Name the software is known by.", 0, 1, name));
470      children.add(new Property("version", "string",
471          "The version identifier for the software covered by this statement.", 0, 1, version));
472    }
473
474    @Override
475    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
476      switch (_hash) {
477      case 3373707:
478        /* name */ return new Property("name", "string", "Name the software is known by.", 0, 1, name);
479      case 351608024:
480        /* version */ return new Property("version", "string",
481            "The version identifier for the software covered by this statement.", 0, 1, version);
482      default:
483        return super.getNamedProperty(_hash, _name, _checkValid);
484      }
485
486    }
487
488    @Override
489    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
490      switch (hash) {
491      case 3373707:
492        /* name */ return this.name == null ? new Base[0] : new Base[] { this.name }; // StringType
493      case 351608024:
494        /* version */ return this.version == null ? new Base[0] : new Base[] { this.version }; // StringType
495      default:
496        return super.getProperty(hash, name, checkValid);
497      }
498
499    }
500
501    @Override
502    public Base setProperty(int hash, String name, Base value) throws FHIRException {
503      switch (hash) {
504      case 3373707: // name
505        this.name = castToString(value); // StringType
506        return value;
507      case 351608024: // version
508        this.version = castToString(value); // StringType
509        return value;
510      default:
511        return super.setProperty(hash, name, value);
512      }
513
514    }
515
516    @Override
517    public Base setProperty(String name, Base value) throws FHIRException {
518      if (name.equals("name")) {
519        this.name = castToString(value); // StringType
520      } else if (name.equals("version")) {
521        this.version = castToString(value); // StringType
522      } else
523        return super.setProperty(name, value);
524      return value;
525    }
526
527    @Override
528    public Base makeProperty(int hash, String name) throws FHIRException {
529      switch (hash) {
530      case 3373707:
531        return getNameElement();
532      case 351608024:
533        return getVersionElement();
534      default:
535        return super.makeProperty(hash, name);
536      }
537
538    }
539
540    @Override
541    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
542      switch (hash) {
543      case 3373707:
544        /* name */ return new String[] { "string" };
545      case 351608024:
546        /* version */ return new String[] { "string" };
547      default:
548        return super.getTypesForProperty(hash, name);
549      }
550
551    }
552
553    @Override
554    public Base addChild(String name) throws FHIRException {
555      if (name.equals("name")) {
556        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.name");
557      } else if (name.equals("version")) {
558        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.version");
559      } else
560        return super.addChild(name);
561    }
562
563    public TerminologyCapabilitiesSoftwareComponent copy() {
564      TerminologyCapabilitiesSoftwareComponent dst = new TerminologyCapabilitiesSoftwareComponent();
565      copyValues(dst);
566      return dst;
567    }
568
569    public void copyValues(TerminologyCapabilitiesSoftwareComponent dst) {
570      super.copyValues(dst);
571      dst.name = name == null ? null : name.copy();
572      dst.version = version == null ? null : version.copy();
573    }
574
575    @Override
576    public boolean equalsDeep(Base other_) {
577      if (!super.equalsDeep(other_))
578        return false;
579      if (!(other_ instanceof TerminologyCapabilitiesSoftwareComponent))
580        return false;
581      TerminologyCapabilitiesSoftwareComponent o = (TerminologyCapabilitiesSoftwareComponent) other_;
582      return compareDeep(name, o.name, true) && compareDeep(version, o.version, true);
583    }
584
585    @Override
586    public boolean equalsShallow(Base other_) {
587      if (!super.equalsShallow(other_))
588        return false;
589      if (!(other_ instanceof TerminologyCapabilitiesSoftwareComponent))
590        return false;
591      TerminologyCapabilitiesSoftwareComponent o = (TerminologyCapabilitiesSoftwareComponent) other_;
592      return compareValues(name, o.name, true) && compareValues(version, o.version, true);
593    }
594
595    public boolean isEmpty() {
596      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, version);
597    }
598
599    public String fhirType() {
600      return "TerminologyCapabilities.software";
601
602    }
603
604  }
605
606  @Block()
607  public static class TerminologyCapabilitiesImplementationComponent extends BackboneElement
608      implements IBaseBackboneElement {
609    /**
610     * Information about the specific installation that this terminology capability
611     * statement relates to.
612     */
613    @Child(name = "description", type = {
614        StringType.class }, order = 1, min = 1, max = 1, modifier = false, summary = true)
615    @Description(shortDefinition = "Describes this specific instance", formalDefinition = "Information about the specific installation that this terminology capability statement relates to.")
616    protected StringType description;
617
618    /**
619     * An absolute base URL for the implementation.
620     */
621    @Child(name = "url", type = { UrlType.class }, order = 2, min = 0, max = 1, modifier = false, summary = true)
622    @Description(shortDefinition = "Base URL for the implementation", formalDefinition = "An absolute base URL for the implementation.")
623    protected UrlType url;
624
625    private static final long serialVersionUID = 98009649L;
626
627    /**
628     * Constructor
629     */
630    public TerminologyCapabilitiesImplementationComponent() {
631      super();
632    }
633
634    /**
635     * Constructor
636     */
637    public TerminologyCapabilitiesImplementationComponent(StringType description) {
638      super();
639      this.description = description;
640    }
641
642    /**
643     * @return {@link #description} (Information about the specific installation
644     *         that this terminology capability statement relates to.). This is the
645     *         underlying object with id, value and extensions. The accessor
646     *         "getDescription" gives direct access to the value
647     */
648    public StringType getDescriptionElement() {
649      if (this.description == null)
650        if (Configuration.errorOnAutoCreate())
651          throw new Error("Attempt to auto-create TerminologyCapabilitiesImplementationComponent.description");
652        else if (Configuration.doAutoCreate())
653          this.description = new StringType(); // bb
654      return this.description;
655    }
656
657    public boolean hasDescriptionElement() {
658      return this.description != null && !this.description.isEmpty();
659    }
660
661    public boolean hasDescription() {
662      return this.description != null && !this.description.isEmpty();
663    }
664
665    /**
666     * @param value {@link #description} (Information about the specific
667     *              installation that this terminology capability statement relates
668     *              to.). This is the underlying object with id, value and
669     *              extensions. The accessor "getDescription" gives direct access to
670     *              the value
671     */
672    public TerminologyCapabilitiesImplementationComponent setDescriptionElement(StringType value) {
673      this.description = value;
674      return this;
675    }
676
677    /**
678     * @return Information about the specific installation that this terminology
679     *         capability statement relates to.
680     */
681    public String getDescription() {
682      return this.description == null ? null : this.description.getValue();
683    }
684
685    /**
686     * @param value Information about the specific installation that this
687     *              terminology capability statement relates to.
688     */
689    public TerminologyCapabilitiesImplementationComponent setDescription(String value) {
690      if (this.description == null)
691        this.description = new StringType();
692      this.description.setValue(value);
693      return this;
694    }
695
696    /**
697     * @return {@link #url} (An absolute base URL for the implementation.). This is
698     *         the underlying object with id, value and extensions. The accessor
699     *         "getUrl" gives direct access to the value
700     */
701    public UrlType getUrlElement() {
702      if (this.url == null)
703        if (Configuration.errorOnAutoCreate())
704          throw new Error("Attempt to auto-create TerminologyCapabilitiesImplementationComponent.url");
705        else if (Configuration.doAutoCreate())
706          this.url = new UrlType(); // bb
707      return this.url;
708    }
709
710    public boolean hasUrlElement() {
711      return this.url != null && !this.url.isEmpty();
712    }
713
714    public boolean hasUrl() {
715      return this.url != null && !this.url.isEmpty();
716    }
717
718    /**
719     * @param value {@link #url} (An absolute base URL for the implementation.).
720     *              This is the underlying object with id, value and extensions. The
721     *              accessor "getUrl" gives direct access to the value
722     */
723    public TerminologyCapabilitiesImplementationComponent setUrlElement(UrlType value) {
724      this.url = value;
725      return this;
726    }
727
728    /**
729     * @return An absolute base URL for the implementation.
730     */
731    public String getUrl() {
732      return this.url == null ? null : this.url.getValue();
733    }
734
735    /**
736     * @param value An absolute base URL for the implementation.
737     */
738    public TerminologyCapabilitiesImplementationComponent setUrl(String value) {
739      if (Utilities.noString(value))
740        this.url = null;
741      else {
742        if (this.url == null)
743          this.url = new UrlType();
744        this.url.setValue(value);
745      }
746      return this;
747    }
748
749    protected void listChildren(List<Property> children) {
750      super.listChildren(children);
751      children.add(new Property("description", "string",
752          "Information about the specific installation that this terminology capability statement relates to.", 0, 1,
753          description));
754      children.add(new Property("url", "url", "An absolute base URL for the implementation.", 0, 1, url));
755    }
756
757    @Override
758    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
759      switch (_hash) {
760      case -1724546052:
761        /* description */ return new Property("description", "string",
762            "Information about the specific installation that this terminology capability statement relates to.", 0, 1,
763            description);
764      case 116079:
765        /* url */ return new Property("url", "url", "An absolute base URL for the implementation.", 0, 1, url);
766      default:
767        return super.getNamedProperty(_hash, _name, _checkValid);
768      }
769
770    }
771
772    @Override
773    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
774      switch (hash) {
775      case -1724546052:
776        /* description */ return this.description == null ? new Base[0] : new Base[] { this.description }; // StringType
777      case 116079:
778        /* url */ return this.url == null ? new Base[0] : new Base[] { this.url }; // UrlType
779      default:
780        return super.getProperty(hash, name, checkValid);
781      }
782
783    }
784
785    @Override
786    public Base setProperty(int hash, String name, Base value) throws FHIRException {
787      switch (hash) {
788      case -1724546052: // description
789        this.description = castToString(value); // StringType
790        return value;
791      case 116079: // url
792        this.url = castToUrl(value); // UrlType
793        return value;
794      default:
795        return super.setProperty(hash, name, value);
796      }
797
798    }
799
800    @Override
801    public Base setProperty(String name, Base value) throws FHIRException {
802      if (name.equals("description")) {
803        this.description = castToString(value); // StringType
804      } else if (name.equals("url")) {
805        this.url = castToUrl(value); // UrlType
806      } else
807        return super.setProperty(name, value);
808      return value;
809    }
810
811    @Override
812    public Base makeProperty(int hash, String name) throws FHIRException {
813      switch (hash) {
814      case -1724546052:
815        return getDescriptionElement();
816      case 116079:
817        return getUrlElement();
818      default:
819        return super.makeProperty(hash, name);
820      }
821
822    }
823
824    @Override
825    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
826      switch (hash) {
827      case -1724546052:
828        /* description */ return new String[] { "string" };
829      case 116079:
830        /* url */ return new String[] { "url" };
831      default:
832        return super.getTypesForProperty(hash, name);
833      }
834
835    }
836
837    @Override
838    public Base addChild(String name) throws FHIRException {
839      if (name.equals("description")) {
840        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.description");
841      } else if (name.equals("url")) {
842        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.url");
843      } else
844        return super.addChild(name);
845    }
846
847    public TerminologyCapabilitiesImplementationComponent copy() {
848      TerminologyCapabilitiesImplementationComponent dst = new TerminologyCapabilitiesImplementationComponent();
849      copyValues(dst);
850      return dst;
851    }
852
853    public void copyValues(TerminologyCapabilitiesImplementationComponent dst) {
854      super.copyValues(dst);
855      dst.description = description == null ? null : description.copy();
856      dst.url = url == null ? null : url.copy();
857    }
858
859    @Override
860    public boolean equalsDeep(Base other_) {
861      if (!super.equalsDeep(other_))
862        return false;
863      if (!(other_ instanceof TerminologyCapabilitiesImplementationComponent))
864        return false;
865      TerminologyCapabilitiesImplementationComponent o = (TerminologyCapabilitiesImplementationComponent) other_;
866      return compareDeep(description, o.description, true) && compareDeep(url, o.url, true);
867    }
868
869    @Override
870    public boolean equalsShallow(Base other_) {
871      if (!super.equalsShallow(other_))
872        return false;
873      if (!(other_ instanceof TerminologyCapabilitiesImplementationComponent))
874        return false;
875      TerminologyCapabilitiesImplementationComponent o = (TerminologyCapabilitiesImplementationComponent) other_;
876      return compareValues(description, o.description, true) && compareValues(url, o.url, true);
877    }
878
879    public boolean isEmpty() {
880      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(description, url);
881    }
882
883    public String fhirType() {
884      return "TerminologyCapabilities.implementation";
885
886    }
887
888  }
889
890  @Block()
891  public static class TerminologyCapabilitiesCodeSystemComponent extends BackboneElement
892      implements IBaseBackboneElement {
893    /**
894     * URI for the Code System.
895     */
896    @Child(name = "uri", type = { CanonicalType.class }, order = 1, min = 0, max = 1, modifier = false, summary = false)
897    @Description(shortDefinition = "URI for the Code System", formalDefinition = "URI for the Code System.")
898    protected CanonicalType uri;
899
900    /**
901     * For the code system, a list of versions that are supported by the server.
902     */
903    @Child(name = "version", type = {}, order = 2, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
904    @Description(shortDefinition = "Version of Code System supported", formalDefinition = "For the code system, a list of versions that are supported by the server.")
905    protected List<TerminologyCapabilitiesCodeSystemVersionComponent> version;
906
907    /**
908     * True if subsumption is supported for this version of the code system.
909     */
910    @Child(name = "subsumption", type = {
911        BooleanType.class }, order = 3, min = 0, max = 1, modifier = false, summary = false)
912    @Description(shortDefinition = "Whether subsumption is supported", formalDefinition = "True if subsumption is supported for this version of the code system.")
913    protected BooleanType subsumption;
914
915    private static final long serialVersionUID = -1593622817L;
916
917    /**
918     * Constructor
919     */
920    public TerminologyCapabilitiesCodeSystemComponent() {
921      super();
922    }
923
924    /**
925     * @return {@link #uri} (URI for the Code System.). This is the underlying
926     *         object with id, value and extensions. The accessor "getUri" gives
927     *         direct access to the value
928     */
929    public CanonicalType getUriElement() {
930      if (this.uri == null)
931        if (Configuration.errorOnAutoCreate())
932          throw new Error("Attempt to auto-create TerminologyCapabilitiesCodeSystemComponent.uri");
933        else if (Configuration.doAutoCreate())
934          this.uri = new CanonicalType(); // bb
935      return this.uri;
936    }
937
938    public boolean hasUriElement() {
939      return this.uri != null && !this.uri.isEmpty();
940    }
941
942    public boolean hasUri() {
943      return this.uri != null && !this.uri.isEmpty();
944    }
945
946    /**
947     * @param value {@link #uri} (URI for the Code System.). This is the underlying
948     *              object with id, value and extensions. The accessor "getUri"
949     *              gives direct access to the value
950     */
951    public TerminologyCapabilitiesCodeSystemComponent setUriElement(CanonicalType value) {
952      this.uri = value;
953      return this;
954    }
955
956    /**
957     * @return URI for the Code System.
958     */
959    public String getUri() {
960      return this.uri == null ? null : this.uri.getValue();
961    }
962
963    /**
964     * @param value URI for the Code System.
965     */
966    public TerminologyCapabilitiesCodeSystemComponent setUri(String value) {
967      if (Utilities.noString(value))
968        this.uri = null;
969      else {
970        if (this.uri == null)
971          this.uri = new CanonicalType();
972        this.uri.setValue(value);
973      }
974      return this;
975    }
976
977    /**
978     * @return {@link #version} (For the code system, a list of versions that are
979     *         supported by the server.)
980     */
981    public List<TerminologyCapabilitiesCodeSystemVersionComponent> getVersion() {
982      if (this.version == null)
983        this.version = new ArrayList<TerminologyCapabilitiesCodeSystemVersionComponent>();
984      return this.version;
985    }
986
987    /**
988     * @return Returns a reference to <code>this</code> for easy method chaining
989     */
990    public TerminologyCapabilitiesCodeSystemComponent setVersion(
991        List<TerminologyCapabilitiesCodeSystemVersionComponent> theVersion) {
992      this.version = theVersion;
993      return this;
994    }
995
996    public boolean hasVersion() {
997      if (this.version == null)
998        return false;
999      for (TerminologyCapabilitiesCodeSystemVersionComponent item : this.version)
1000        if (!item.isEmpty())
1001          return true;
1002      return false;
1003    }
1004
1005    public TerminologyCapabilitiesCodeSystemVersionComponent addVersion() { // 3
1006      TerminologyCapabilitiesCodeSystemVersionComponent t = new TerminologyCapabilitiesCodeSystemVersionComponent();
1007      if (this.version == null)
1008        this.version = new ArrayList<TerminologyCapabilitiesCodeSystemVersionComponent>();
1009      this.version.add(t);
1010      return t;
1011    }
1012
1013    public TerminologyCapabilitiesCodeSystemComponent addVersion(TerminologyCapabilitiesCodeSystemVersionComponent t) { // 3
1014      if (t == null)
1015        return this;
1016      if (this.version == null)
1017        this.version = new ArrayList<TerminologyCapabilitiesCodeSystemVersionComponent>();
1018      this.version.add(t);
1019      return this;
1020    }
1021
1022    /**
1023     * @return The first repetition of repeating field {@link #version}, creating it
1024     *         if it does not already exist
1025     */
1026    public TerminologyCapabilitiesCodeSystemVersionComponent getVersionFirstRep() {
1027      if (getVersion().isEmpty()) {
1028        addVersion();
1029      }
1030      return getVersion().get(0);
1031    }
1032
1033    /**
1034     * @return {@link #subsumption} (True if subsumption is supported for this
1035     *         version of the code system.). This is the underlying object with id,
1036     *         value and extensions. The accessor "getSubsumption" gives direct
1037     *         access to the value
1038     */
1039    public BooleanType getSubsumptionElement() {
1040      if (this.subsumption == null)
1041        if (Configuration.errorOnAutoCreate())
1042          throw new Error("Attempt to auto-create TerminologyCapabilitiesCodeSystemComponent.subsumption");
1043        else if (Configuration.doAutoCreate())
1044          this.subsumption = new BooleanType(); // bb
1045      return this.subsumption;
1046    }
1047
1048    public boolean hasSubsumptionElement() {
1049      return this.subsumption != null && !this.subsumption.isEmpty();
1050    }
1051
1052    public boolean hasSubsumption() {
1053      return this.subsumption != null && !this.subsumption.isEmpty();
1054    }
1055
1056    /**
1057     * @param value {@link #subsumption} (True if subsumption is supported for this
1058     *              version of the code system.). This is the underlying object with
1059     *              id, value and extensions. The accessor "getSubsumption" gives
1060     *              direct access to the value
1061     */
1062    public TerminologyCapabilitiesCodeSystemComponent setSubsumptionElement(BooleanType value) {
1063      this.subsumption = value;
1064      return this;
1065    }
1066
1067    /**
1068     * @return True if subsumption is supported for this version of the code system.
1069     */
1070    public boolean getSubsumption() {
1071      return this.subsumption == null || this.subsumption.isEmpty() ? false : this.subsumption.getValue();
1072    }
1073
1074    /**
1075     * @param value True if subsumption is supported for this version of the code
1076     *              system.
1077     */
1078    public TerminologyCapabilitiesCodeSystemComponent setSubsumption(boolean value) {
1079      if (this.subsumption == null)
1080        this.subsumption = new BooleanType();
1081      this.subsumption.setValue(value);
1082      return this;
1083    }
1084
1085    protected void listChildren(List<Property> children) {
1086      super.listChildren(children);
1087      children.add(new Property("uri", "canonical(CodeSystem)", "URI for the Code System.", 0, 1, uri));
1088      children
1089          .add(new Property("version", "", "For the code system, a list of versions that are supported by the server.",
1090              0, java.lang.Integer.MAX_VALUE, version));
1091      children.add(new Property("subsumption", "boolean",
1092          "True if subsumption is supported for this version of the code system.", 0, 1, subsumption));
1093    }
1094
1095    @Override
1096    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1097      switch (_hash) {
1098      case 116076:
1099        /* uri */ return new Property("uri", "canonical(CodeSystem)", "URI for the Code System.", 0, 1, uri);
1100      case 351608024:
1101        /* version */ return new Property("version", "",
1102            "For the code system, a list of versions that are supported by the server.", 0, java.lang.Integer.MAX_VALUE,
1103            version);
1104      case -499084711:
1105        /* subsumption */ return new Property("subsumption", "boolean",
1106            "True if subsumption is supported for this version of the code system.", 0, 1, subsumption);
1107      default:
1108        return super.getNamedProperty(_hash, _name, _checkValid);
1109      }
1110
1111    }
1112
1113    @Override
1114    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1115      switch (hash) {
1116      case 116076:
1117        /* uri */ return this.uri == null ? new Base[0] : new Base[] { this.uri }; // CanonicalType
1118      case 351608024:
1119        /* version */ return this.version == null ? new Base[0] : this.version.toArray(new Base[this.version.size()]); // TerminologyCapabilitiesCodeSystemVersionComponent
1120      case -499084711:
1121        /* subsumption */ return this.subsumption == null ? new Base[0] : new Base[] { this.subsumption }; // BooleanType
1122      default:
1123        return super.getProperty(hash, name, checkValid);
1124      }
1125
1126    }
1127
1128    @Override
1129    public Base setProperty(int hash, String name, Base value) throws FHIRException {
1130      switch (hash) {
1131      case 116076: // uri
1132        this.uri = castToCanonical(value); // CanonicalType
1133        return value;
1134      case 351608024: // version
1135        this.getVersion().add((TerminologyCapabilitiesCodeSystemVersionComponent) value); // TerminologyCapabilitiesCodeSystemVersionComponent
1136        return value;
1137      case -499084711: // subsumption
1138        this.subsumption = castToBoolean(value); // BooleanType
1139        return value;
1140      default:
1141        return super.setProperty(hash, name, value);
1142      }
1143
1144    }
1145
1146    @Override
1147    public Base setProperty(String name, Base value) throws FHIRException {
1148      if (name.equals("uri")) {
1149        this.uri = castToCanonical(value); // CanonicalType
1150      } else if (name.equals("version")) {
1151        this.getVersion().add((TerminologyCapabilitiesCodeSystemVersionComponent) value);
1152      } else if (name.equals("subsumption")) {
1153        this.subsumption = castToBoolean(value); // BooleanType
1154      } else
1155        return super.setProperty(name, value);
1156      return value;
1157    }
1158
1159    @Override
1160    public Base makeProperty(int hash, String name) throws FHIRException {
1161      switch (hash) {
1162      case 116076:
1163        return getUriElement();
1164      case 351608024:
1165        return addVersion();
1166      case -499084711:
1167        return getSubsumptionElement();
1168      default:
1169        return super.makeProperty(hash, name);
1170      }
1171
1172    }
1173
1174    @Override
1175    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1176      switch (hash) {
1177      case 116076:
1178        /* uri */ return new String[] { "canonical" };
1179      case 351608024:
1180        /* version */ return new String[] {};
1181      case -499084711:
1182        /* subsumption */ return new String[] { "boolean" };
1183      default:
1184        return super.getTypesForProperty(hash, name);
1185      }
1186
1187    }
1188
1189    @Override
1190    public Base addChild(String name) throws FHIRException {
1191      if (name.equals("uri")) {
1192        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.uri");
1193      } else if (name.equals("version")) {
1194        return addVersion();
1195      } else if (name.equals("subsumption")) {
1196        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.subsumption");
1197      } else
1198        return super.addChild(name);
1199    }
1200
1201    public TerminologyCapabilitiesCodeSystemComponent copy() {
1202      TerminologyCapabilitiesCodeSystemComponent dst = new TerminologyCapabilitiesCodeSystemComponent();
1203      copyValues(dst);
1204      return dst;
1205    }
1206
1207    public void copyValues(TerminologyCapabilitiesCodeSystemComponent dst) {
1208      super.copyValues(dst);
1209      dst.uri = uri == null ? null : uri.copy();
1210      if (version != null) {
1211        dst.version = new ArrayList<TerminologyCapabilitiesCodeSystemVersionComponent>();
1212        for (TerminologyCapabilitiesCodeSystemVersionComponent i : version)
1213          dst.version.add(i.copy());
1214      }
1215      ;
1216      dst.subsumption = subsumption == null ? null : subsumption.copy();
1217    }
1218
1219    @Override
1220    public boolean equalsDeep(Base other_) {
1221      if (!super.equalsDeep(other_))
1222        return false;
1223      if (!(other_ instanceof TerminologyCapabilitiesCodeSystemComponent))
1224        return false;
1225      TerminologyCapabilitiesCodeSystemComponent o = (TerminologyCapabilitiesCodeSystemComponent) other_;
1226      return compareDeep(uri, o.uri, true) && compareDeep(version, o.version, true)
1227          && compareDeep(subsumption, o.subsumption, true);
1228    }
1229
1230    @Override
1231    public boolean equalsShallow(Base other_) {
1232      if (!super.equalsShallow(other_))
1233        return false;
1234      if (!(other_ instanceof TerminologyCapabilitiesCodeSystemComponent))
1235        return false;
1236      TerminologyCapabilitiesCodeSystemComponent o = (TerminologyCapabilitiesCodeSystemComponent) other_;
1237      return compareValues(subsumption, o.subsumption, true);
1238    }
1239
1240    public boolean isEmpty() {
1241      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(uri, version, subsumption);
1242    }
1243
1244    public String fhirType() {
1245      return "TerminologyCapabilities.codeSystem";
1246
1247    }
1248
1249  }
1250
1251  @Block()
1252  public static class TerminologyCapabilitiesCodeSystemVersionComponent extends BackboneElement
1253      implements IBaseBackboneElement {
1254    /**
1255     * For version-less code systems, there should be a single version with no
1256     * identifier.
1257     */
1258    @Child(name = "code", type = { StringType.class }, order = 1, min = 0, max = 1, modifier = false, summary = true)
1259    @Description(shortDefinition = "Version identifier for this version", formalDefinition = "For version-less code systems, there should be a single version with no identifier.")
1260    protected StringType code;
1261
1262    /**
1263     * If this is the default version for this code system.
1264     */
1265    @Child(name = "isDefault", type = {
1266        BooleanType.class }, order = 2, min = 0, max = 1, modifier = false, summary = true)
1267    @Description(shortDefinition = "If this is the default version for this code system", formalDefinition = "If this is the default version for this code system.")
1268    protected BooleanType isDefault;
1269
1270    /**
1271     * If the compositional grammar defined by the code system is supported.
1272     */
1273    @Child(name = "compositional", type = {
1274        BooleanType.class }, order = 3, min = 0, max = 1, modifier = false, summary = false)
1275    @Description(shortDefinition = "If compositional grammar is supported", formalDefinition = "If the compositional grammar defined by the code system is supported.")
1276    protected BooleanType compositional;
1277
1278    /**
1279     * Language Displays supported.
1280     */
1281    @Child(name = "language", type = {
1282        CodeType.class }, order = 4, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
1283    @Description(shortDefinition = "Language Displays supported", formalDefinition = "Language Displays supported.")
1284    protected List<CodeType> language;
1285
1286    /**
1287     * Filter Properties supported.
1288     */
1289    @Child(name = "filter", type = {}, order = 5, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
1290    @Description(shortDefinition = "Filter Properties supported", formalDefinition = "Filter Properties supported.")
1291    protected List<TerminologyCapabilitiesCodeSystemVersionFilterComponent> filter;
1292
1293    /**
1294     * Properties supported for $lookup.
1295     */
1296    @Child(name = "property", type = {
1297        CodeType.class }, order = 6, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
1298    @Description(shortDefinition = "Properties supported for $lookup", formalDefinition = "Properties supported for $lookup.")
1299    protected List<CodeType> property;
1300
1301    private static final long serialVersionUID = 1857571343L;
1302
1303    /**
1304     * Constructor
1305     */
1306    public TerminologyCapabilitiesCodeSystemVersionComponent() {
1307      super();
1308    }
1309
1310    /**
1311     * @return {@link #code} (For version-less code systems, there should be a
1312     *         single version with no identifier.). This is the underlying object
1313     *         with id, value and extensions. The accessor "getCode" gives direct
1314     *         access to the value
1315     */
1316    public StringType getCodeElement() {
1317      if (this.code == null)
1318        if (Configuration.errorOnAutoCreate())
1319          throw new Error("Attempt to auto-create TerminologyCapabilitiesCodeSystemVersionComponent.code");
1320        else if (Configuration.doAutoCreate())
1321          this.code = new StringType(); // bb
1322      return this.code;
1323    }
1324
1325    public boolean hasCodeElement() {
1326      return this.code != null && !this.code.isEmpty();
1327    }
1328
1329    public boolean hasCode() {
1330      return this.code != null && !this.code.isEmpty();
1331    }
1332
1333    /**
1334     * @param value {@link #code} (For version-less code systems, there should be a
1335     *              single version with no identifier.). This is the underlying
1336     *              object with id, value and extensions. The accessor "getCode"
1337     *              gives direct access to the value
1338     */
1339    public TerminologyCapabilitiesCodeSystemVersionComponent setCodeElement(StringType value) {
1340      this.code = value;
1341      return this;
1342    }
1343
1344    /**
1345     * @return For version-less code systems, there should be a single version with
1346     *         no identifier.
1347     */
1348    public String getCode() {
1349      return this.code == null ? null : this.code.getValue();
1350    }
1351
1352    /**
1353     * @param value For version-less code systems, there should be a single version
1354     *              with no identifier.
1355     */
1356    public TerminologyCapabilitiesCodeSystemVersionComponent setCode(String value) {
1357      if (Utilities.noString(value))
1358        this.code = null;
1359      else {
1360        if (this.code == null)
1361          this.code = new StringType();
1362        this.code.setValue(value);
1363      }
1364      return this;
1365    }
1366
1367    /**
1368     * @return {@link #isDefault} (If this is the default version for this code
1369     *         system.). This is the underlying object with id, value and
1370     *         extensions. The accessor "getIsDefault" gives direct access to the
1371     *         value
1372     */
1373    public BooleanType getIsDefaultElement() {
1374      if (this.isDefault == null)
1375        if (Configuration.errorOnAutoCreate())
1376          throw new Error("Attempt to auto-create TerminologyCapabilitiesCodeSystemVersionComponent.isDefault");
1377        else if (Configuration.doAutoCreate())
1378          this.isDefault = new BooleanType(); // bb
1379      return this.isDefault;
1380    }
1381
1382    public boolean hasIsDefaultElement() {
1383      return this.isDefault != null && !this.isDefault.isEmpty();
1384    }
1385
1386    public boolean hasIsDefault() {
1387      return this.isDefault != null && !this.isDefault.isEmpty();
1388    }
1389
1390    /**
1391     * @param value {@link #isDefault} (If this is the default version for this code
1392     *              system.). This is the underlying object with id, value and
1393     *              extensions. The accessor "getIsDefault" gives direct access to
1394     *              the value
1395     */
1396    public TerminologyCapabilitiesCodeSystemVersionComponent setIsDefaultElement(BooleanType value) {
1397      this.isDefault = value;
1398      return this;
1399    }
1400
1401    /**
1402     * @return If this is the default version for this code system.
1403     */
1404    public boolean getIsDefault() {
1405      return this.isDefault == null || this.isDefault.isEmpty() ? false : this.isDefault.getValue();
1406    }
1407
1408    /**
1409     * @param value If this is the default version for this code system.
1410     */
1411    public TerminologyCapabilitiesCodeSystemVersionComponent setIsDefault(boolean value) {
1412      if (this.isDefault == null)
1413        this.isDefault = new BooleanType();
1414      this.isDefault.setValue(value);
1415      return this;
1416    }
1417
1418    /**
1419     * @return {@link #compositional} (If the compositional grammar defined by the
1420     *         code system is supported.). This is the underlying object with id,
1421     *         value and extensions. The accessor "getCompositional" gives direct
1422     *         access to the value
1423     */
1424    public BooleanType getCompositionalElement() {
1425      if (this.compositional == null)
1426        if (Configuration.errorOnAutoCreate())
1427          throw new Error("Attempt to auto-create TerminologyCapabilitiesCodeSystemVersionComponent.compositional");
1428        else if (Configuration.doAutoCreate())
1429          this.compositional = new BooleanType(); // bb
1430      return this.compositional;
1431    }
1432
1433    public boolean hasCompositionalElement() {
1434      return this.compositional != null && !this.compositional.isEmpty();
1435    }
1436
1437    public boolean hasCompositional() {
1438      return this.compositional != null && !this.compositional.isEmpty();
1439    }
1440
1441    /**
1442     * @param value {@link #compositional} (If the compositional grammar defined by
1443     *              the code system is supported.). This is the underlying object
1444     *              with id, value and extensions. The accessor "getCompositional"
1445     *              gives direct access to the value
1446     */
1447    public TerminologyCapabilitiesCodeSystemVersionComponent setCompositionalElement(BooleanType value) {
1448      this.compositional = value;
1449      return this;
1450    }
1451
1452    /**
1453     * @return If the compositional grammar defined by the code system is supported.
1454     */
1455    public boolean getCompositional() {
1456      return this.compositional == null || this.compositional.isEmpty() ? false : this.compositional.getValue();
1457    }
1458
1459    /**
1460     * @param value If the compositional grammar defined by the code system is
1461     *              supported.
1462     */
1463    public TerminologyCapabilitiesCodeSystemVersionComponent setCompositional(boolean value) {
1464      if (this.compositional == null)
1465        this.compositional = new BooleanType();
1466      this.compositional.setValue(value);
1467      return this;
1468    }
1469
1470    /**
1471     * @return {@link #language} (Language Displays supported.)
1472     */
1473    public List<CodeType> getLanguage() {
1474      if (this.language == null)
1475        this.language = new ArrayList<CodeType>();
1476      return this.language;
1477    }
1478
1479    /**
1480     * @return Returns a reference to <code>this</code> for easy method chaining
1481     */
1482    public TerminologyCapabilitiesCodeSystemVersionComponent setLanguage(List<CodeType> theLanguage) {
1483      this.language = theLanguage;
1484      return this;
1485    }
1486
1487    public boolean hasLanguage() {
1488      if (this.language == null)
1489        return false;
1490      for (CodeType item : this.language)
1491        if (!item.isEmpty())
1492          return true;
1493      return false;
1494    }
1495
1496    /**
1497     * @return {@link #language} (Language Displays supported.)
1498     */
1499    public CodeType addLanguageElement() {// 2
1500      CodeType t = new CodeType();
1501      if (this.language == null)
1502        this.language = new ArrayList<CodeType>();
1503      this.language.add(t);
1504      return t;
1505    }
1506
1507    /**
1508     * @param value {@link #language} (Language Displays supported.)
1509     */
1510    public TerminologyCapabilitiesCodeSystemVersionComponent addLanguage(String value) { // 1
1511      CodeType t = new CodeType();
1512      t.setValue(value);
1513      if (this.language == null)
1514        this.language = new ArrayList<CodeType>();
1515      this.language.add(t);
1516      return this;
1517    }
1518
1519    /**
1520     * @param value {@link #language} (Language Displays supported.)
1521     */
1522    public boolean hasLanguage(String value) {
1523      if (this.language == null)
1524        return false;
1525      for (CodeType v : this.language)
1526        if (v.getValue().equals(value)) // code
1527          return true;
1528      return false;
1529    }
1530
1531    /**
1532     * @return {@link #filter} (Filter Properties supported.)
1533     */
1534    public List<TerminologyCapabilitiesCodeSystemVersionFilterComponent> getFilter() {
1535      if (this.filter == null)
1536        this.filter = new ArrayList<TerminologyCapabilitiesCodeSystemVersionFilterComponent>();
1537      return this.filter;
1538    }
1539
1540    /**
1541     * @return Returns a reference to <code>this</code> for easy method chaining
1542     */
1543    public TerminologyCapabilitiesCodeSystemVersionComponent setFilter(
1544        List<TerminologyCapabilitiesCodeSystemVersionFilterComponent> theFilter) {
1545      this.filter = theFilter;
1546      return this;
1547    }
1548
1549    public boolean hasFilter() {
1550      if (this.filter == null)
1551        return false;
1552      for (TerminologyCapabilitiesCodeSystemVersionFilterComponent item : this.filter)
1553        if (!item.isEmpty())
1554          return true;
1555      return false;
1556    }
1557
1558    public TerminologyCapabilitiesCodeSystemVersionFilterComponent addFilter() { // 3
1559      TerminologyCapabilitiesCodeSystemVersionFilterComponent t = new TerminologyCapabilitiesCodeSystemVersionFilterComponent();
1560      if (this.filter == null)
1561        this.filter = new ArrayList<TerminologyCapabilitiesCodeSystemVersionFilterComponent>();
1562      this.filter.add(t);
1563      return t;
1564    }
1565
1566    public TerminologyCapabilitiesCodeSystemVersionComponent addFilter(
1567        TerminologyCapabilitiesCodeSystemVersionFilterComponent t) { // 3
1568      if (t == null)
1569        return this;
1570      if (this.filter == null)
1571        this.filter = new ArrayList<TerminologyCapabilitiesCodeSystemVersionFilterComponent>();
1572      this.filter.add(t);
1573      return this;
1574    }
1575
1576    /**
1577     * @return The first repetition of repeating field {@link #filter}, creating it
1578     *         if it does not already exist
1579     */
1580    public TerminologyCapabilitiesCodeSystemVersionFilterComponent getFilterFirstRep() {
1581      if (getFilter().isEmpty()) {
1582        addFilter();
1583      }
1584      return getFilter().get(0);
1585    }
1586
1587    /**
1588     * @return {@link #property} (Properties supported for $lookup.)
1589     */
1590    public List<CodeType> getProperty() {
1591      if (this.property == null)
1592        this.property = new ArrayList<CodeType>();
1593      return this.property;
1594    }
1595
1596    /**
1597     * @return Returns a reference to <code>this</code> for easy method chaining
1598     */
1599    public TerminologyCapabilitiesCodeSystemVersionComponent setProperty(List<CodeType> theProperty) {
1600      this.property = theProperty;
1601      return this;
1602    }
1603
1604    public boolean hasProperty() {
1605      if (this.property == null)
1606        return false;
1607      for (CodeType item : this.property)
1608        if (!item.isEmpty())
1609          return true;
1610      return false;
1611    }
1612
1613    /**
1614     * @return {@link #property} (Properties supported for $lookup.)
1615     */
1616    public CodeType addPropertyElement() {// 2
1617      CodeType t = new CodeType();
1618      if (this.property == null)
1619        this.property = new ArrayList<CodeType>();
1620      this.property.add(t);
1621      return t;
1622    }
1623
1624    /**
1625     * @param value {@link #property} (Properties supported for $lookup.)
1626     */
1627    public TerminologyCapabilitiesCodeSystemVersionComponent addProperty(String value) { // 1
1628      CodeType t = new CodeType();
1629      t.setValue(value);
1630      if (this.property == null)
1631        this.property = new ArrayList<CodeType>();
1632      this.property.add(t);
1633      return this;
1634    }
1635
1636    /**
1637     * @param value {@link #property} (Properties supported for $lookup.)
1638     */
1639    public boolean hasProperty(String value) {
1640      if (this.property == null)
1641        return false;
1642      for (CodeType v : this.property)
1643        if (v.getValue().equals(value)) // code
1644          return true;
1645      return false;
1646    }
1647
1648    protected void listChildren(List<Property> children) {
1649      super.listChildren(children);
1650      children.add(new Property("code", "string",
1651          "For version-less code systems, there should be a single version with no identifier.", 0, 1, code));
1652      children.add(new Property("isDefault", "boolean", "If this is the default version for this code system.", 0, 1,
1653          isDefault));
1654      children.add(new Property("compositional", "boolean",
1655          "If the compositional grammar defined by the code system is supported.", 0, 1, compositional));
1656      children.add(
1657          new Property("language", "code", "Language Displays supported.", 0, java.lang.Integer.MAX_VALUE, language));
1658      children.add(new Property("filter", "", "Filter Properties supported.", 0, java.lang.Integer.MAX_VALUE, filter));
1659      children.add(new Property("property", "code", "Properties supported for $lookup.", 0, java.lang.Integer.MAX_VALUE,
1660          property));
1661    }
1662
1663    @Override
1664    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1665      switch (_hash) {
1666      case 3059181:
1667        /* code */ return new Property("code", "string",
1668            "For version-less code systems, there should be a single version with no identifier.", 0, 1, code);
1669      case 965025207:
1670        /* isDefault */ return new Property("isDefault", "boolean",
1671            "If this is the default version for this code system.", 0, 1, isDefault);
1672      case 1248023381:
1673        /* compositional */ return new Property("compositional", "boolean",
1674            "If the compositional grammar defined by the code system is supported.", 0, 1, compositional);
1675      case -1613589672:
1676        /* language */ return new Property("language", "code", "Language Displays supported.", 0,
1677            java.lang.Integer.MAX_VALUE, language);
1678      case -1274492040:
1679        /* filter */ return new Property("filter", "", "Filter Properties supported.", 0, java.lang.Integer.MAX_VALUE,
1680            filter);
1681      case -993141291:
1682        /* property */ return new Property("property", "code", "Properties supported for $lookup.", 0,
1683            java.lang.Integer.MAX_VALUE, property);
1684      default:
1685        return super.getNamedProperty(_hash, _name, _checkValid);
1686      }
1687
1688    }
1689
1690    @Override
1691    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1692      switch (hash) {
1693      case 3059181:
1694        /* code */ return this.code == null ? new Base[0] : new Base[] { this.code }; // StringType
1695      case 965025207:
1696        /* isDefault */ return this.isDefault == null ? new Base[0] : new Base[] { this.isDefault }; // BooleanType
1697      case 1248023381:
1698        /* compositional */ return this.compositional == null ? new Base[0] : new Base[] { this.compositional }; // BooleanType
1699      case -1613589672:
1700        /* language */ return this.language == null ? new Base[0]
1701            : this.language.toArray(new Base[this.language.size()]); // CodeType
1702      case -1274492040:
1703        /* filter */ return this.filter == null ? new Base[0] : this.filter.toArray(new Base[this.filter.size()]); // TerminologyCapabilitiesCodeSystemVersionFilterComponent
1704      case -993141291:
1705        /* property */ return this.property == null ? new Base[0]
1706            : this.property.toArray(new Base[this.property.size()]); // CodeType
1707      default:
1708        return super.getProperty(hash, name, checkValid);
1709      }
1710
1711    }
1712
1713    @Override
1714    public Base setProperty(int hash, String name, Base value) throws FHIRException {
1715      switch (hash) {
1716      case 3059181: // code
1717        this.code = castToString(value); // StringType
1718        return value;
1719      case 965025207: // isDefault
1720        this.isDefault = castToBoolean(value); // BooleanType
1721        return value;
1722      case 1248023381: // compositional
1723        this.compositional = castToBoolean(value); // BooleanType
1724        return value;
1725      case -1613589672: // language
1726        this.getLanguage().add(castToCode(value)); // CodeType
1727        return value;
1728      case -1274492040: // filter
1729        this.getFilter().add((TerminologyCapabilitiesCodeSystemVersionFilterComponent) value); // TerminologyCapabilitiesCodeSystemVersionFilterComponent
1730        return value;
1731      case -993141291: // property
1732        this.getProperty().add(castToCode(value)); // CodeType
1733        return value;
1734      default:
1735        return super.setProperty(hash, name, value);
1736      }
1737
1738    }
1739
1740    @Override
1741    public Base setProperty(String name, Base value) throws FHIRException {
1742      if (name.equals("code")) {
1743        this.code = castToString(value); // StringType
1744      } else if (name.equals("isDefault")) {
1745        this.isDefault = castToBoolean(value); // BooleanType
1746      } else if (name.equals("compositional")) {
1747        this.compositional = castToBoolean(value); // BooleanType
1748      } else if (name.equals("language")) {
1749        this.getLanguage().add(castToCode(value));
1750      } else if (name.equals("filter")) {
1751        this.getFilter().add((TerminologyCapabilitiesCodeSystemVersionFilterComponent) value);
1752      } else if (name.equals("property")) {
1753        this.getProperty().add(castToCode(value));
1754      } else
1755        return super.setProperty(name, value);
1756      return value;
1757    }
1758
1759    @Override
1760    public Base makeProperty(int hash, String name) throws FHIRException {
1761      switch (hash) {
1762      case 3059181:
1763        return getCodeElement();
1764      case 965025207:
1765        return getIsDefaultElement();
1766      case 1248023381:
1767        return getCompositionalElement();
1768      case -1613589672:
1769        return addLanguageElement();
1770      case -1274492040:
1771        return addFilter();
1772      case -993141291:
1773        return addPropertyElement();
1774      default:
1775        return super.makeProperty(hash, name);
1776      }
1777
1778    }
1779
1780    @Override
1781    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1782      switch (hash) {
1783      case 3059181:
1784        /* code */ return new String[] { "string" };
1785      case 965025207:
1786        /* isDefault */ return new String[] { "boolean" };
1787      case 1248023381:
1788        /* compositional */ return new String[] { "boolean" };
1789      case -1613589672:
1790        /* language */ return new String[] { "code" };
1791      case -1274492040:
1792        /* filter */ return new String[] {};
1793      case -993141291:
1794        /* property */ return new String[] { "code" };
1795      default:
1796        return super.getTypesForProperty(hash, name);
1797      }
1798
1799    }
1800
1801    @Override
1802    public Base addChild(String name) throws FHIRException {
1803      if (name.equals("code")) {
1804        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.code");
1805      } else if (name.equals("isDefault")) {
1806        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.isDefault");
1807      } else if (name.equals("compositional")) {
1808        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.compositional");
1809      } else if (name.equals("language")) {
1810        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.language");
1811      } else if (name.equals("filter")) {
1812        return addFilter();
1813      } else if (name.equals("property")) {
1814        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.property");
1815      } else
1816        return super.addChild(name);
1817    }
1818
1819    public TerminologyCapabilitiesCodeSystemVersionComponent copy() {
1820      TerminologyCapabilitiesCodeSystemVersionComponent dst = new TerminologyCapabilitiesCodeSystemVersionComponent();
1821      copyValues(dst);
1822      return dst;
1823    }
1824
1825    public void copyValues(TerminologyCapabilitiesCodeSystemVersionComponent dst) {
1826      super.copyValues(dst);
1827      dst.code = code == null ? null : code.copy();
1828      dst.isDefault = isDefault == null ? null : isDefault.copy();
1829      dst.compositional = compositional == null ? null : compositional.copy();
1830      if (language != null) {
1831        dst.language = new ArrayList<CodeType>();
1832        for (CodeType i : language)
1833          dst.language.add(i.copy());
1834      }
1835      ;
1836      if (filter != null) {
1837        dst.filter = new ArrayList<TerminologyCapabilitiesCodeSystemVersionFilterComponent>();
1838        for (TerminologyCapabilitiesCodeSystemVersionFilterComponent i : filter)
1839          dst.filter.add(i.copy());
1840      }
1841      ;
1842      if (property != null) {
1843        dst.property = new ArrayList<CodeType>();
1844        for (CodeType i : property)
1845          dst.property.add(i.copy());
1846      }
1847      ;
1848    }
1849
1850    @Override
1851    public boolean equalsDeep(Base other_) {
1852      if (!super.equalsDeep(other_))
1853        return false;
1854      if (!(other_ instanceof TerminologyCapabilitiesCodeSystemVersionComponent))
1855        return false;
1856      TerminologyCapabilitiesCodeSystemVersionComponent o = (TerminologyCapabilitiesCodeSystemVersionComponent) other_;
1857      return compareDeep(code, o.code, true) && compareDeep(isDefault, o.isDefault, true)
1858          && compareDeep(compositional, o.compositional, true) && compareDeep(language, o.language, true)
1859          && compareDeep(filter, o.filter, true) && compareDeep(property, o.property, true);
1860    }
1861
1862    @Override
1863    public boolean equalsShallow(Base other_) {
1864      if (!super.equalsShallow(other_))
1865        return false;
1866      if (!(other_ instanceof TerminologyCapabilitiesCodeSystemVersionComponent))
1867        return false;
1868      TerminologyCapabilitiesCodeSystemVersionComponent o = (TerminologyCapabilitiesCodeSystemVersionComponent) other_;
1869      return compareValues(code, o.code, true) && compareValues(isDefault, o.isDefault, true)
1870          && compareValues(compositional, o.compositional, true) && compareValues(language, o.language, true)
1871          && compareValues(property, o.property, true);
1872    }
1873
1874    public boolean isEmpty() {
1875      return super.isEmpty()
1876          && ca.uhn.fhir.util.ElementUtil.isEmpty(code, isDefault, compositional, language, filter, property);
1877    }
1878
1879    public String fhirType() {
1880      return "TerminologyCapabilities.codeSystem.version";
1881
1882    }
1883
1884  }
1885
1886  @Block()
1887  public static class TerminologyCapabilitiesCodeSystemVersionFilterComponent extends BackboneElement
1888      implements IBaseBackboneElement {
1889    /**
1890     * Code of the property supported.
1891     */
1892    @Child(name = "code", type = { CodeType.class }, order = 1, min = 1, max = 1, modifier = false, summary = false)
1893    @Description(shortDefinition = "Code of the property supported", formalDefinition = "Code of the property supported.")
1894    protected CodeType code;
1895
1896    /**
1897     * Operations supported for the property.
1898     */
1899    @Child(name = "op", type = {
1900        CodeType.class }, order = 2, min = 1, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
1901    @Description(shortDefinition = "Operations supported for the property", formalDefinition = "Operations supported for the property.")
1902    protected List<CodeType> op;
1903
1904    private static final long serialVersionUID = -489160282L;
1905
1906    /**
1907     * Constructor
1908     */
1909    public TerminologyCapabilitiesCodeSystemVersionFilterComponent() {
1910      super();
1911    }
1912
1913    /**
1914     * Constructor
1915     */
1916    public TerminologyCapabilitiesCodeSystemVersionFilterComponent(CodeType code) {
1917      super();
1918      this.code = code;
1919    }
1920
1921    /**
1922     * @return {@link #code} (Code of the property supported.). This is the
1923     *         underlying object with id, value and extensions. The accessor
1924     *         "getCode" gives direct access to the value
1925     */
1926    public CodeType getCodeElement() {
1927      if (this.code == null)
1928        if (Configuration.errorOnAutoCreate())
1929          throw new Error("Attempt to auto-create TerminologyCapabilitiesCodeSystemVersionFilterComponent.code");
1930        else if (Configuration.doAutoCreate())
1931          this.code = new CodeType(); // bb
1932      return this.code;
1933    }
1934
1935    public boolean hasCodeElement() {
1936      return this.code != null && !this.code.isEmpty();
1937    }
1938
1939    public boolean hasCode() {
1940      return this.code != null && !this.code.isEmpty();
1941    }
1942
1943    /**
1944     * @param value {@link #code} (Code of the property supported.). This is the
1945     *              underlying object with id, value and extensions. The accessor
1946     *              "getCode" gives direct access to the value
1947     */
1948    public TerminologyCapabilitiesCodeSystemVersionFilterComponent setCodeElement(CodeType value) {
1949      this.code = value;
1950      return this;
1951    }
1952
1953    /**
1954     * @return Code of the property supported.
1955     */
1956    public String getCode() {
1957      return this.code == null ? null : this.code.getValue();
1958    }
1959
1960    /**
1961     * @param value Code of the property supported.
1962     */
1963    public TerminologyCapabilitiesCodeSystemVersionFilterComponent setCode(String value) {
1964      if (this.code == null)
1965        this.code = new CodeType();
1966      this.code.setValue(value);
1967      return this;
1968    }
1969
1970    /**
1971     * @return {@link #op} (Operations supported for the property.)
1972     */
1973    public List<CodeType> getOp() {
1974      if (this.op == null)
1975        this.op = new ArrayList<CodeType>();
1976      return this.op;
1977    }
1978
1979    /**
1980     * @return Returns a reference to <code>this</code> for easy method chaining
1981     */
1982    public TerminologyCapabilitiesCodeSystemVersionFilterComponent setOp(List<CodeType> theOp) {
1983      this.op = theOp;
1984      return this;
1985    }
1986
1987    public boolean hasOp() {
1988      if (this.op == null)
1989        return false;
1990      for (CodeType item : this.op)
1991        if (!item.isEmpty())
1992          return true;
1993      return false;
1994    }
1995
1996    /**
1997     * @return {@link #op} (Operations supported for the property.)
1998     */
1999    public CodeType addOpElement() {// 2
2000      CodeType t = new CodeType();
2001      if (this.op == null)
2002        this.op = new ArrayList<CodeType>();
2003      this.op.add(t);
2004      return t;
2005    }
2006
2007    /**
2008     * @param value {@link #op} (Operations supported for the property.)
2009     */
2010    public TerminologyCapabilitiesCodeSystemVersionFilterComponent addOp(String value) { // 1
2011      CodeType t = new CodeType();
2012      t.setValue(value);
2013      if (this.op == null)
2014        this.op = new ArrayList<CodeType>();
2015      this.op.add(t);
2016      return this;
2017    }
2018
2019    /**
2020     * @param value {@link #op} (Operations supported for the property.)
2021     */
2022    public boolean hasOp(String value) {
2023      if (this.op == null)
2024        return false;
2025      for (CodeType v : this.op)
2026        if (v.getValue().equals(value)) // code
2027          return true;
2028      return false;
2029    }
2030
2031    protected void listChildren(List<Property> children) {
2032      super.listChildren(children);
2033      children.add(new Property("code", "code", "Code of the property supported.", 0, 1, code));
2034      children.add(
2035          new Property("op", "code", "Operations supported for the property.", 0, java.lang.Integer.MAX_VALUE, op));
2036    }
2037
2038    @Override
2039    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2040      switch (_hash) {
2041      case 3059181:
2042        /* code */ return new Property("code", "code", "Code of the property supported.", 0, 1, code);
2043      case 3553:
2044        /* op */ return new Property("op", "code", "Operations supported for the property.", 0,
2045            java.lang.Integer.MAX_VALUE, op);
2046      default:
2047        return super.getNamedProperty(_hash, _name, _checkValid);
2048      }
2049
2050    }
2051
2052    @Override
2053    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2054      switch (hash) {
2055      case 3059181:
2056        /* code */ return this.code == null ? new Base[0] : new Base[] { this.code }; // CodeType
2057      case 3553:
2058        /* op */ return this.op == null ? new Base[0] : this.op.toArray(new Base[this.op.size()]); // CodeType
2059      default:
2060        return super.getProperty(hash, name, checkValid);
2061      }
2062
2063    }
2064
2065    @Override
2066    public Base setProperty(int hash, String name, Base value) throws FHIRException {
2067      switch (hash) {
2068      case 3059181: // code
2069        this.code = castToCode(value); // CodeType
2070        return value;
2071      case 3553: // op
2072        this.getOp().add(castToCode(value)); // CodeType
2073        return value;
2074      default:
2075        return super.setProperty(hash, name, value);
2076      }
2077
2078    }
2079
2080    @Override
2081    public Base setProperty(String name, Base value) throws FHIRException {
2082      if (name.equals("code")) {
2083        this.code = castToCode(value); // CodeType
2084      } else if (name.equals("op")) {
2085        this.getOp().add(castToCode(value));
2086      } else
2087        return super.setProperty(name, value);
2088      return value;
2089    }
2090
2091    @Override
2092    public Base makeProperty(int hash, String name) throws FHIRException {
2093      switch (hash) {
2094      case 3059181:
2095        return getCodeElement();
2096      case 3553:
2097        return addOpElement();
2098      default:
2099        return super.makeProperty(hash, name);
2100      }
2101
2102    }
2103
2104    @Override
2105    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2106      switch (hash) {
2107      case 3059181:
2108        /* code */ return new String[] { "code" };
2109      case 3553:
2110        /* op */ return new String[] { "code" };
2111      default:
2112        return super.getTypesForProperty(hash, name);
2113      }
2114
2115    }
2116
2117    @Override
2118    public Base addChild(String name) throws FHIRException {
2119      if (name.equals("code")) {
2120        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.code");
2121      } else if (name.equals("op")) {
2122        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.op");
2123      } else
2124        return super.addChild(name);
2125    }
2126
2127    public TerminologyCapabilitiesCodeSystemVersionFilterComponent copy() {
2128      TerminologyCapabilitiesCodeSystemVersionFilterComponent dst = new TerminologyCapabilitiesCodeSystemVersionFilterComponent();
2129      copyValues(dst);
2130      return dst;
2131    }
2132
2133    public void copyValues(TerminologyCapabilitiesCodeSystemVersionFilterComponent dst) {
2134      super.copyValues(dst);
2135      dst.code = code == null ? null : code.copy();
2136      if (op != null) {
2137        dst.op = new ArrayList<CodeType>();
2138        for (CodeType i : op)
2139          dst.op.add(i.copy());
2140      }
2141      ;
2142    }
2143
2144    @Override
2145    public boolean equalsDeep(Base other_) {
2146      if (!super.equalsDeep(other_))
2147        return false;
2148      if (!(other_ instanceof TerminologyCapabilitiesCodeSystemVersionFilterComponent))
2149        return false;
2150      TerminologyCapabilitiesCodeSystemVersionFilterComponent o = (TerminologyCapabilitiesCodeSystemVersionFilterComponent) other_;
2151      return compareDeep(code, o.code, true) && compareDeep(op, o.op, true);
2152    }
2153
2154    @Override
2155    public boolean equalsShallow(Base other_) {
2156      if (!super.equalsShallow(other_))
2157        return false;
2158      if (!(other_ instanceof TerminologyCapabilitiesCodeSystemVersionFilterComponent))
2159        return false;
2160      TerminologyCapabilitiesCodeSystemVersionFilterComponent o = (TerminologyCapabilitiesCodeSystemVersionFilterComponent) other_;
2161      return compareValues(code, o.code, true) && compareValues(op, o.op, true);
2162    }
2163
2164    public boolean isEmpty() {
2165      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, op);
2166    }
2167
2168    public String fhirType() {
2169      return "TerminologyCapabilities.codeSystem.version.filter";
2170
2171    }
2172
2173  }
2174
2175  @Block()
2176  public static class TerminologyCapabilitiesExpansionComponent extends BackboneElement
2177      implements IBaseBackboneElement {
2178    /**
2179     * Whether the server can return nested value sets.
2180     */
2181    @Child(name = "hierarchical", type = {
2182        BooleanType.class }, order = 1, min = 0, max = 1, modifier = false, summary = false)
2183    @Description(shortDefinition = "Whether the server can return nested value sets", formalDefinition = "Whether the server can return nested value sets.")
2184    protected BooleanType hierarchical;
2185
2186    /**
2187     * Whether the server supports paging on expansion.
2188     */
2189    @Child(name = "paging", type = {
2190        BooleanType.class }, order = 2, min = 0, max = 1, modifier = false, summary = false)
2191    @Description(shortDefinition = "Whether the server supports paging on expansion", formalDefinition = "Whether the server supports paging on expansion.")
2192    protected BooleanType paging;
2193
2194    /**
2195     * Allow request for incomplete expansions?
2196     */
2197    @Child(name = "incomplete", type = {
2198        BooleanType.class }, order = 3, min = 0, max = 1, modifier = false, summary = false)
2199    @Description(shortDefinition = "Allow request for incomplete expansions?", formalDefinition = "Allow request for incomplete expansions?")
2200    protected BooleanType incomplete;
2201
2202    /**
2203     * Supported expansion parameter.
2204     */
2205    @Child(name = "parameter", type = {}, order = 4, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
2206    @Description(shortDefinition = "Supported expansion parameter", formalDefinition = "Supported expansion parameter.")
2207    protected List<TerminologyCapabilitiesExpansionParameterComponent> parameter;
2208
2209    /**
2210     * Documentation about text searching works.
2211     */
2212    @Child(name = "textFilter", type = {
2213        MarkdownType.class }, order = 5, min = 0, max = 1, modifier = false, summary = false)
2214    @Description(shortDefinition = "Documentation about text searching works", formalDefinition = "Documentation about text searching works.")
2215    protected MarkdownType textFilter;
2216
2217    private static final long serialVersionUID = -1011350616L;
2218
2219    /**
2220     * Constructor
2221     */
2222    public TerminologyCapabilitiesExpansionComponent() {
2223      super();
2224    }
2225
2226    /**
2227     * @return {@link #hierarchical} (Whether the server can return nested value
2228     *         sets.). This is the underlying object with id, value and extensions.
2229     *         The accessor "getHierarchical" gives direct access to the value
2230     */
2231    public BooleanType getHierarchicalElement() {
2232      if (this.hierarchical == null)
2233        if (Configuration.errorOnAutoCreate())
2234          throw new Error("Attempt to auto-create TerminologyCapabilitiesExpansionComponent.hierarchical");
2235        else if (Configuration.doAutoCreate())
2236          this.hierarchical = new BooleanType(); // bb
2237      return this.hierarchical;
2238    }
2239
2240    public boolean hasHierarchicalElement() {
2241      return this.hierarchical != null && !this.hierarchical.isEmpty();
2242    }
2243
2244    public boolean hasHierarchical() {
2245      return this.hierarchical != null && !this.hierarchical.isEmpty();
2246    }
2247
2248    /**
2249     * @param value {@link #hierarchical} (Whether the server can return nested
2250     *              value sets.). This is the underlying object with id, value and
2251     *              extensions. The accessor "getHierarchical" gives direct access
2252     *              to the value
2253     */
2254    public TerminologyCapabilitiesExpansionComponent setHierarchicalElement(BooleanType value) {
2255      this.hierarchical = value;
2256      return this;
2257    }
2258
2259    /**
2260     * @return Whether the server can return nested value sets.
2261     */
2262    public boolean getHierarchical() {
2263      return this.hierarchical == null || this.hierarchical.isEmpty() ? false : this.hierarchical.getValue();
2264    }
2265
2266    /**
2267     * @param value Whether the server can return nested value sets.
2268     */
2269    public TerminologyCapabilitiesExpansionComponent setHierarchical(boolean value) {
2270      if (this.hierarchical == null)
2271        this.hierarchical = new BooleanType();
2272      this.hierarchical.setValue(value);
2273      return this;
2274    }
2275
2276    /**
2277     * @return {@link #paging} (Whether the server supports paging on expansion.).
2278     *         This is the underlying object with id, value and extensions. The
2279     *         accessor "getPaging" gives direct access to the value
2280     */
2281    public BooleanType getPagingElement() {
2282      if (this.paging == null)
2283        if (Configuration.errorOnAutoCreate())
2284          throw new Error("Attempt to auto-create TerminologyCapabilitiesExpansionComponent.paging");
2285        else if (Configuration.doAutoCreate())
2286          this.paging = new BooleanType(); // bb
2287      return this.paging;
2288    }
2289
2290    public boolean hasPagingElement() {
2291      return this.paging != null && !this.paging.isEmpty();
2292    }
2293
2294    public boolean hasPaging() {
2295      return this.paging != null && !this.paging.isEmpty();
2296    }
2297
2298    /**
2299     * @param value {@link #paging} (Whether the server supports paging on
2300     *              expansion.). This is the underlying object with id, value and
2301     *              extensions. The accessor "getPaging" gives direct access to the
2302     *              value
2303     */
2304    public TerminologyCapabilitiesExpansionComponent setPagingElement(BooleanType value) {
2305      this.paging = value;
2306      return this;
2307    }
2308
2309    /**
2310     * @return Whether the server supports paging on expansion.
2311     */
2312    public boolean getPaging() {
2313      return this.paging == null || this.paging.isEmpty() ? false : this.paging.getValue();
2314    }
2315
2316    /**
2317     * @param value Whether the server supports paging on expansion.
2318     */
2319    public TerminologyCapabilitiesExpansionComponent setPaging(boolean value) {
2320      if (this.paging == null)
2321        this.paging = new BooleanType();
2322      this.paging.setValue(value);
2323      return this;
2324    }
2325
2326    /**
2327     * @return {@link #incomplete} (Allow request for incomplete expansions?). This
2328     *         is the underlying object with id, value and extensions. The accessor
2329     *         "getIncomplete" gives direct access to the value
2330     */
2331    public BooleanType getIncompleteElement() {
2332      if (this.incomplete == null)
2333        if (Configuration.errorOnAutoCreate())
2334          throw new Error("Attempt to auto-create TerminologyCapabilitiesExpansionComponent.incomplete");
2335        else if (Configuration.doAutoCreate())
2336          this.incomplete = new BooleanType(); // bb
2337      return this.incomplete;
2338    }
2339
2340    public boolean hasIncompleteElement() {
2341      return this.incomplete != null && !this.incomplete.isEmpty();
2342    }
2343
2344    public boolean hasIncomplete() {
2345      return this.incomplete != null && !this.incomplete.isEmpty();
2346    }
2347
2348    /**
2349     * @param value {@link #incomplete} (Allow request for incomplete expansions?).
2350     *              This is the underlying object with id, value and extensions. The
2351     *              accessor "getIncomplete" gives direct access to the value
2352     */
2353    public TerminologyCapabilitiesExpansionComponent setIncompleteElement(BooleanType value) {
2354      this.incomplete = value;
2355      return this;
2356    }
2357
2358    /**
2359     * @return Allow request for incomplete expansions?
2360     */
2361    public boolean getIncomplete() {
2362      return this.incomplete == null || this.incomplete.isEmpty() ? false : this.incomplete.getValue();
2363    }
2364
2365    /**
2366     * @param value Allow request for incomplete expansions?
2367     */
2368    public TerminologyCapabilitiesExpansionComponent setIncomplete(boolean value) {
2369      if (this.incomplete == null)
2370        this.incomplete = new BooleanType();
2371      this.incomplete.setValue(value);
2372      return this;
2373    }
2374
2375    /**
2376     * @return {@link #parameter} (Supported expansion parameter.)
2377     */
2378    public List<TerminologyCapabilitiesExpansionParameterComponent> getParameter() {
2379      if (this.parameter == null)
2380        this.parameter = new ArrayList<TerminologyCapabilitiesExpansionParameterComponent>();
2381      return this.parameter;
2382    }
2383
2384    /**
2385     * @return Returns a reference to <code>this</code> for easy method chaining
2386     */
2387    public TerminologyCapabilitiesExpansionComponent setParameter(
2388        List<TerminologyCapabilitiesExpansionParameterComponent> theParameter) {
2389      this.parameter = theParameter;
2390      return this;
2391    }
2392
2393    public boolean hasParameter() {
2394      if (this.parameter == null)
2395        return false;
2396      for (TerminologyCapabilitiesExpansionParameterComponent item : this.parameter)
2397        if (!item.isEmpty())
2398          return true;
2399      return false;
2400    }
2401
2402    public TerminologyCapabilitiesExpansionParameterComponent addParameter() { // 3
2403      TerminologyCapabilitiesExpansionParameterComponent t = new TerminologyCapabilitiesExpansionParameterComponent();
2404      if (this.parameter == null)
2405        this.parameter = new ArrayList<TerminologyCapabilitiesExpansionParameterComponent>();
2406      this.parameter.add(t);
2407      return t;
2408    }
2409
2410    public TerminologyCapabilitiesExpansionComponent addParameter(
2411        TerminologyCapabilitiesExpansionParameterComponent t) { // 3
2412      if (t == null)
2413        return this;
2414      if (this.parameter == null)
2415        this.parameter = new ArrayList<TerminologyCapabilitiesExpansionParameterComponent>();
2416      this.parameter.add(t);
2417      return this;
2418    }
2419
2420    /**
2421     * @return The first repetition of repeating field {@link #parameter}, creating
2422     *         it if it does not already exist
2423     */
2424    public TerminologyCapabilitiesExpansionParameterComponent getParameterFirstRep() {
2425      if (getParameter().isEmpty()) {
2426        addParameter();
2427      }
2428      return getParameter().get(0);
2429    }
2430
2431    /**
2432     * @return {@link #textFilter} (Documentation about text searching works.). This
2433     *         is the underlying object with id, value and extensions. The accessor
2434     *         "getTextFilter" gives direct access to the value
2435     */
2436    public MarkdownType getTextFilterElement() {
2437      if (this.textFilter == null)
2438        if (Configuration.errorOnAutoCreate())
2439          throw new Error("Attempt to auto-create TerminologyCapabilitiesExpansionComponent.textFilter");
2440        else if (Configuration.doAutoCreate())
2441          this.textFilter = new MarkdownType(); // bb
2442      return this.textFilter;
2443    }
2444
2445    public boolean hasTextFilterElement() {
2446      return this.textFilter != null && !this.textFilter.isEmpty();
2447    }
2448
2449    public boolean hasTextFilter() {
2450      return this.textFilter != null && !this.textFilter.isEmpty();
2451    }
2452
2453    /**
2454     * @param value {@link #textFilter} (Documentation about text searching works.).
2455     *              This is the underlying object with id, value and extensions. The
2456     *              accessor "getTextFilter" gives direct access to the value
2457     */
2458    public TerminologyCapabilitiesExpansionComponent setTextFilterElement(MarkdownType value) {
2459      this.textFilter = value;
2460      return this;
2461    }
2462
2463    /**
2464     * @return Documentation about text searching works.
2465     */
2466    public String getTextFilter() {
2467      return this.textFilter == null ? null : this.textFilter.getValue();
2468    }
2469
2470    /**
2471     * @param value Documentation about text searching works.
2472     */
2473    public TerminologyCapabilitiesExpansionComponent setTextFilter(String value) {
2474      if (value == null)
2475        this.textFilter = null;
2476      else {
2477        if (this.textFilter == null)
2478          this.textFilter = new MarkdownType();
2479        this.textFilter.setValue(value);
2480      }
2481      return this;
2482    }
2483
2484    protected void listChildren(List<Property> children) {
2485      super.listChildren(children);
2486      children.add(new Property("hierarchical", "boolean", "Whether the server can return nested value sets.", 0, 1,
2487          hierarchical));
2488      children.add(new Property("paging", "boolean", "Whether the server supports paging on expansion.", 0, 1, paging));
2489      children.add(new Property("incomplete", "boolean", "Allow request for incomplete expansions?", 0, 1, incomplete));
2490      children.add(
2491          new Property("parameter", "", "Supported expansion parameter.", 0, java.lang.Integer.MAX_VALUE, parameter));
2492      children
2493          .add(new Property("textFilter", "markdown", "Documentation about text searching works.", 0, 1, textFilter));
2494    }
2495
2496    @Override
2497    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2498      switch (_hash) {
2499      case 857636745:
2500        /* hierarchical */ return new Property("hierarchical", "boolean",
2501            "Whether the server can return nested value sets.", 0, 1, hierarchical);
2502      case -995747956:
2503        /* paging */ return new Property("paging", "boolean", "Whether the server supports paging on expansion.", 0, 1,
2504            paging);
2505      case -1010022050:
2506        /* incomplete */ return new Property("incomplete", "boolean", "Allow request for incomplete expansions?", 0, 1,
2507            incomplete);
2508      case 1954460585:
2509        /* parameter */ return new Property("parameter", "", "Supported expansion parameter.", 0,
2510            java.lang.Integer.MAX_VALUE, parameter);
2511      case 1469359877:
2512        /* textFilter */ return new Property("textFilter", "markdown", "Documentation about text searching works.", 0,
2513            1, textFilter);
2514      default:
2515        return super.getNamedProperty(_hash, _name, _checkValid);
2516      }
2517
2518    }
2519
2520    @Override
2521    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2522      switch (hash) {
2523      case 857636745:
2524        /* hierarchical */ return this.hierarchical == null ? new Base[0] : new Base[] { this.hierarchical }; // BooleanType
2525      case -995747956:
2526        /* paging */ return this.paging == null ? new Base[0] : new Base[] { this.paging }; // BooleanType
2527      case -1010022050:
2528        /* incomplete */ return this.incomplete == null ? new Base[0] : new Base[] { this.incomplete }; // BooleanType
2529      case 1954460585:
2530        /* parameter */ return this.parameter == null ? new Base[0]
2531            : this.parameter.toArray(new Base[this.parameter.size()]); // TerminologyCapabilitiesExpansionParameterComponent
2532      case 1469359877:
2533        /* textFilter */ return this.textFilter == null ? new Base[0] : new Base[] { this.textFilter }; // MarkdownType
2534      default:
2535        return super.getProperty(hash, name, checkValid);
2536      }
2537
2538    }
2539
2540    @Override
2541    public Base setProperty(int hash, String name, Base value) throws FHIRException {
2542      switch (hash) {
2543      case 857636745: // hierarchical
2544        this.hierarchical = castToBoolean(value); // BooleanType
2545        return value;
2546      case -995747956: // paging
2547        this.paging = castToBoolean(value); // BooleanType
2548        return value;
2549      case -1010022050: // incomplete
2550        this.incomplete = castToBoolean(value); // BooleanType
2551        return value;
2552      case 1954460585: // parameter
2553        this.getParameter().add((TerminologyCapabilitiesExpansionParameterComponent) value); // TerminologyCapabilitiesExpansionParameterComponent
2554        return value;
2555      case 1469359877: // textFilter
2556        this.textFilter = castToMarkdown(value); // MarkdownType
2557        return value;
2558      default:
2559        return super.setProperty(hash, name, value);
2560      }
2561
2562    }
2563
2564    @Override
2565    public Base setProperty(String name, Base value) throws FHIRException {
2566      if (name.equals("hierarchical")) {
2567        this.hierarchical = castToBoolean(value); // BooleanType
2568      } else if (name.equals("paging")) {
2569        this.paging = castToBoolean(value); // BooleanType
2570      } else if (name.equals("incomplete")) {
2571        this.incomplete = castToBoolean(value); // BooleanType
2572      } else if (name.equals("parameter")) {
2573        this.getParameter().add((TerminologyCapabilitiesExpansionParameterComponent) value);
2574      } else if (name.equals("textFilter")) {
2575        this.textFilter = castToMarkdown(value); // MarkdownType
2576      } else
2577        return super.setProperty(name, value);
2578      return value;
2579    }
2580
2581    @Override
2582    public Base makeProperty(int hash, String name) throws FHIRException {
2583      switch (hash) {
2584      case 857636745:
2585        return getHierarchicalElement();
2586      case -995747956:
2587        return getPagingElement();
2588      case -1010022050:
2589        return getIncompleteElement();
2590      case 1954460585:
2591        return addParameter();
2592      case 1469359877:
2593        return getTextFilterElement();
2594      default:
2595        return super.makeProperty(hash, name);
2596      }
2597
2598    }
2599
2600    @Override
2601    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2602      switch (hash) {
2603      case 857636745:
2604        /* hierarchical */ return new String[] { "boolean" };
2605      case -995747956:
2606        /* paging */ return new String[] { "boolean" };
2607      case -1010022050:
2608        /* incomplete */ return new String[] { "boolean" };
2609      case 1954460585:
2610        /* parameter */ return new String[] {};
2611      case 1469359877:
2612        /* textFilter */ return new String[] { "markdown" };
2613      default:
2614        return super.getTypesForProperty(hash, name);
2615      }
2616
2617    }
2618
2619    @Override
2620    public Base addChild(String name) throws FHIRException {
2621      if (name.equals("hierarchical")) {
2622        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.hierarchical");
2623      } else if (name.equals("paging")) {
2624        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.paging");
2625      } else if (name.equals("incomplete")) {
2626        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.incomplete");
2627      } else if (name.equals("parameter")) {
2628        return addParameter();
2629      } else if (name.equals("textFilter")) {
2630        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.textFilter");
2631      } else
2632        return super.addChild(name);
2633    }
2634
2635    public TerminologyCapabilitiesExpansionComponent copy() {
2636      TerminologyCapabilitiesExpansionComponent dst = new TerminologyCapabilitiesExpansionComponent();
2637      copyValues(dst);
2638      return dst;
2639    }
2640
2641    public void copyValues(TerminologyCapabilitiesExpansionComponent dst) {
2642      super.copyValues(dst);
2643      dst.hierarchical = hierarchical == null ? null : hierarchical.copy();
2644      dst.paging = paging == null ? null : paging.copy();
2645      dst.incomplete = incomplete == null ? null : incomplete.copy();
2646      if (parameter != null) {
2647        dst.parameter = new ArrayList<TerminologyCapabilitiesExpansionParameterComponent>();
2648        for (TerminologyCapabilitiesExpansionParameterComponent i : parameter)
2649          dst.parameter.add(i.copy());
2650      }
2651      ;
2652      dst.textFilter = textFilter == null ? null : textFilter.copy();
2653    }
2654
2655    @Override
2656    public boolean equalsDeep(Base other_) {
2657      if (!super.equalsDeep(other_))
2658        return false;
2659      if (!(other_ instanceof TerminologyCapabilitiesExpansionComponent))
2660        return false;
2661      TerminologyCapabilitiesExpansionComponent o = (TerminologyCapabilitiesExpansionComponent) other_;
2662      return compareDeep(hierarchical, o.hierarchical, true) && compareDeep(paging, o.paging, true)
2663          && compareDeep(incomplete, o.incomplete, true) && compareDeep(parameter, o.parameter, true)
2664          && compareDeep(textFilter, o.textFilter, true);
2665    }
2666
2667    @Override
2668    public boolean equalsShallow(Base other_) {
2669      if (!super.equalsShallow(other_))
2670        return false;
2671      if (!(other_ instanceof TerminologyCapabilitiesExpansionComponent))
2672        return false;
2673      TerminologyCapabilitiesExpansionComponent o = (TerminologyCapabilitiesExpansionComponent) other_;
2674      return compareValues(hierarchical, o.hierarchical, true) && compareValues(paging, o.paging, true)
2675          && compareValues(incomplete, o.incomplete, true) && compareValues(textFilter, o.textFilter, true);
2676    }
2677
2678    public boolean isEmpty() {
2679      return super.isEmpty()
2680          && ca.uhn.fhir.util.ElementUtil.isEmpty(hierarchical, paging, incomplete, parameter, textFilter);
2681    }
2682
2683    public String fhirType() {
2684      return "TerminologyCapabilities.expansion";
2685
2686    }
2687
2688  }
2689
2690  @Block()
2691  public static class TerminologyCapabilitiesExpansionParameterComponent extends BackboneElement
2692      implements IBaseBackboneElement {
2693    /**
2694     * Expansion Parameter name.
2695     */
2696    @Child(name = "name", type = { CodeType.class }, order = 1, min = 1, max = 1, modifier = false, summary = false)
2697    @Description(shortDefinition = "Expansion Parameter name", formalDefinition = "Expansion Parameter name.")
2698    protected CodeType name;
2699
2700    /**
2701     * Description of support for parameter.
2702     */
2703    @Child(name = "documentation", type = {
2704        StringType.class }, order = 2, min = 0, max = 1, modifier = false, summary = false)
2705    @Description(shortDefinition = "Description of support for parameter", formalDefinition = "Description of support for parameter.")
2706    protected StringType documentation;
2707
2708    private static final long serialVersionUID = -1703372741L;
2709
2710    /**
2711     * Constructor
2712     */
2713    public TerminologyCapabilitiesExpansionParameterComponent() {
2714      super();
2715    }
2716
2717    /**
2718     * Constructor
2719     */
2720    public TerminologyCapabilitiesExpansionParameterComponent(CodeType name) {
2721      super();
2722      this.name = name;
2723    }
2724
2725    /**
2726     * @return {@link #name} (Expansion Parameter name.). This is the underlying
2727     *         object with id, value and extensions. The accessor "getName" gives
2728     *         direct access to the value
2729     */
2730    public CodeType getNameElement() {
2731      if (this.name == null)
2732        if (Configuration.errorOnAutoCreate())
2733          throw new Error("Attempt to auto-create TerminologyCapabilitiesExpansionParameterComponent.name");
2734        else if (Configuration.doAutoCreate())
2735          this.name = new CodeType(); // bb
2736      return this.name;
2737    }
2738
2739    public boolean hasNameElement() {
2740      return this.name != null && !this.name.isEmpty();
2741    }
2742
2743    public boolean hasName() {
2744      return this.name != null && !this.name.isEmpty();
2745    }
2746
2747    /**
2748     * @param value {@link #name} (Expansion Parameter name.). This is the
2749     *              underlying object with id, value and extensions. The accessor
2750     *              "getName" gives direct access to the value
2751     */
2752    public TerminologyCapabilitiesExpansionParameterComponent setNameElement(CodeType value) {
2753      this.name = value;
2754      return this;
2755    }
2756
2757    /**
2758     * @return Expansion Parameter name.
2759     */
2760    public String getName() {
2761      return this.name == null ? null : this.name.getValue();
2762    }
2763
2764    /**
2765     * @param value Expansion Parameter name.
2766     */
2767    public TerminologyCapabilitiesExpansionParameterComponent setName(String value) {
2768      if (this.name == null)
2769        this.name = new CodeType();
2770      this.name.setValue(value);
2771      return this;
2772    }
2773
2774    /**
2775     * @return {@link #documentation} (Description of support for parameter.). This
2776     *         is the underlying object with id, value and extensions. The accessor
2777     *         "getDocumentation" gives direct access to the value
2778     */
2779    public StringType getDocumentationElement() {
2780      if (this.documentation == null)
2781        if (Configuration.errorOnAutoCreate())
2782          throw new Error("Attempt to auto-create TerminologyCapabilitiesExpansionParameterComponent.documentation");
2783        else if (Configuration.doAutoCreate())
2784          this.documentation = new StringType(); // bb
2785      return this.documentation;
2786    }
2787
2788    public boolean hasDocumentationElement() {
2789      return this.documentation != null && !this.documentation.isEmpty();
2790    }
2791
2792    public boolean hasDocumentation() {
2793      return this.documentation != null && !this.documentation.isEmpty();
2794    }
2795
2796    /**
2797     * @param value {@link #documentation} (Description of support for parameter.).
2798     *              This is the underlying object with id, value and extensions. The
2799     *              accessor "getDocumentation" gives direct access to the value
2800     */
2801    public TerminologyCapabilitiesExpansionParameterComponent setDocumentationElement(StringType value) {
2802      this.documentation = value;
2803      return this;
2804    }
2805
2806    /**
2807     * @return Description of support for parameter.
2808     */
2809    public String getDocumentation() {
2810      return this.documentation == null ? null : this.documentation.getValue();
2811    }
2812
2813    /**
2814     * @param value Description of support for parameter.
2815     */
2816    public TerminologyCapabilitiesExpansionParameterComponent setDocumentation(String value) {
2817      if (Utilities.noString(value))
2818        this.documentation = null;
2819      else {
2820        if (this.documentation == null)
2821          this.documentation = new StringType();
2822        this.documentation.setValue(value);
2823      }
2824      return this;
2825    }
2826
2827    protected void listChildren(List<Property> children) {
2828      super.listChildren(children);
2829      children.add(new Property("name", "code", "Expansion Parameter name.", 0, 1, name));
2830      children
2831          .add(new Property("documentation", "string", "Description of support for parameter.", 0, 1, documentation));
2832    }
2833
2834    @Override
2835    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2836      switch (_hash) {
2837      case 3373707:
2838        /* name */ return new Property("name", "code", "Expansion Parameter name.", 0, 1, name);
2839      case 1587405498:
2840        /* documentation */ return new Property("documentation", "string", "Description of support for parameter.", 0,
2841            1, documentation);
2842      default:
2843        return super.getNamedProperty(_hash, _name, _checkValid);
2844      }
2845
2846    }
2847
2848    @Override
2849    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2850      switch (hash) {
2851      case 3373707:
2852        /* name */ return this.name == null ? new Base[0] : new Base[] { this.name }; // CodeType
2853      case 1587405498:
2854        /* documentation */ return this.documentation == null ? new Base[0] : new Base[] { this.documentation }; // StringType
2855      default:
2856        return super.getProperty(hash, name, checkValid);
2857      }
2858
2859    }
2860
2861    @Override
2862    public Base setProperty(int hash, String name, Base value) throws FHIRException {
2863      switch (hash) {
2864      case 3373707: // name
2865        this.name = castToCode(value); // CodeType
2866        return value;
2867      case 1587405498: // documentation
2868        this.documentation = castToString(value); // StringType
2869        return value;
2870      default:
2871        return super.setProperty(hash, name, value);
2872      }
2873
2874    }
2875
2876    @Override
2877    public Base setProperty(String name, Base value) throws FHIRException {
2878      if (name.equals("name")) {
2879        this.name = castToCode(value); // CodeType
2880      } else if (name.equals("documentation")) {
2881        this.documentation = castToString(value); // StringType
2882      } else
2883        return super.setProperty(name, value);
2884      return value;
2885    }
2886
2887    @Override
2888    public Base makeProperty(int hash, String name) throws FHIRException {
2889      switch (hash) {
2890      case 3373707:
2891        return getNameElement();
2892      case 1587405498:
2893        return getDocumentationElement();
2894      default:
2895        return super.makeProperty(hash, name);
2896      }
2897
2898    }
2899
2900    @Override
2901    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2902      switch (hash) {
2903      case 3373707:
2904        /* name */ return new String[] { "code" };
2905      case 1587405498:
2906        /* documentation */ return new String[] { "string" };
2907      default:
2908        return super.getTypesForProperty(hash, name);
2909      }
2910
2911    }
2912
2913    @Override
2914    public Base addChild(String name) throws FHIRException {
2915      if (name.equals("name")) {
2916        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.name");
2917      } else if (name.equals("documentation")) {
2918        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.documentation");
2919      } else
2920        return super.addChild(name);
2921    }
2922
2923    public TerminologyCapabilitiesExpansionParameterComponent copy() {
2924      TerminologyCapabilitiesExpansionParameterComponent dst = new TerminologyCapabilitiesExpansionParameterComponent();
2925      copyValues(dst);
2926      return dst;
2927    }
2928
2929    public void copyValues(TerminologyCapabilitiesExpansionParameterComponent dst) {
2930      super.copyValues(dst);
2931      dst.name = name == null ? null : name.copy();
2932      dst.documentation = documentation == null ? null : documentation.copy();
2933    }
2934
2935    @Override
2936    public boolean equalsDeep(Base other_) {
2937      if (!super.equalsDeep(other_))
2938        return false;
2939      if (!(other_ instanceof TerminologyCapabilitiesExpansionParameterComponent))
2940        return false;
2941      TerminologyCapabilitiesExpansionParameterComponent o = (TerminologyCapabilitiesExpansionParameterComponent) other_;
2942      return compareDeep(name, o.name, true) && compareDeep(documentation, o.documentation, true);
2943    }
2944
2945    @Override
2946    public boolean equalsShallow(Base other_) {
2947      if (!super.equalsShallow(other_))
2948        return false;
2949      if (!(other_ instanceof TerminologyCapabilitiesExpansionParameterComponent))
2950        return false;
2951      TerminologyCapabilitiesExpansionParameterComponent o = (TerminologyCapabilitiesExpansionParameterComponent) other_;
2952      return compareValues(name, o.name, true) && compareValues(documentation, o.documentation, true);
2953    }
2954
2955    public boolean isEmpty() {
2956      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, documentation);
2957    }
2958
2959    public String fhirType() {
2960      return "TerminologyCapabilities.expansion.parameter";
2961
2962    }
2963
2964  }
2965
2966  @Block()
2967  public static class TerminologyCapabilitiesValidateCodeComponent extends BackboneElement
2968      implements IBaseBackboneElement {
2969    /**
2970     * Whether translations are validated.
2971     */
2972    @Child(name = "translations", type = {
2973        BooleanType.class }, order = 1, min = 1, max = 1, modifier = false, summary = false)
2974    @Description(shortDefinition = "Whether translations are validated", formalDefinition = "Whether translations are validated.")
2975    protected BooleanType translations;
2976
2977    private static final long serialVersionUID = -1212814906L;
2978
2979    /**
2980     * Constructor
2981     */
2982    public TerminologyCapabilitiesValidateCodeComponent() {
2983      super();
2984    }
2985
2986    /**
2987     * Constructor
2988     */
2989    public TerminologyCapabilitiesValidateCodeComponent(BooleanType translations) {
2990      super();
2991      this.translations = translations;
2992    }
2993
2994    /**
2995     * @return {@link #translations} (Whether translations are validated.). This is
2996     *         the underlying object with id, value and extensions. The accessor
2997     *         "getTranslations" gives direct access to the value
2998     */
2999    public BooleanType getTranslationsElement() {
3000      if (this.translations == null)
3001        if (Configuration.errorOnAutoCreate())
3002          throw new Error("Attempt to auto-create TerminologyCapabilitiesValidateCodeComponent.translations");
3003        else if (Configuration.doAutoCreate())
3004          this.translations = new BooleanType(); // bb
3005      return this.translations;
3006    }
3007
3008    public boolean hasTranslationsElement() {
3009      return this.translations != null && !this.translations.isEmpty();
3010    }
3011
3012    public boolean hasTranslations() {
3013      return this.translations != null && !this.translations.isEmpty();
3014    }
3015
3016    /**
3017     * @param value {@link #translations} (Whether translations are validated.).
3018     *              This is the underlying object with id, value and extensions. The
3019     *              accessor "getTranslations" gives direct access to the value
3020     */
3021    public TerminologyCapabilitiesValidateCodeComponent setTranslationsElement(BooleanType value) {
3022      this.translations = value;
3023      return this;
3024    }
3025
3026    /**
3027     * @return Whether translations are validated.
3028     */
3029    public boolean getTranslations() {
3030      return this.translations == null || this.translations.isEmpty() ? false : this.translations.getValue();
3031    }
3032
3033    /**
3034     * @param value Whether translations are validated.
3035     */
3036    public TerminologyCapabilitiesValidateCodeComponent setTranslations(boolean value) {
3037      if (this.translations == null)
3038        this.translations = new BooleanType();
3039      this.translations.setValue(value);
3040      return this;
3041    }
3042
3043    protected void listChildren(List<Property> children) {
3044      super.listChildren(children);
3045      children.add(new Property("translations", "boolean", "Whether translations are validated.", 0, 1, translations));
3046    }
3047
3048    @Override
3049    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3050      switch (_hash) {
3051      case -1225497630:
3052        /* translations */ return new Property("translations", "boolean", "Whether translations are validated.", 0, 1,
3053            translations);
3054      default:
3055        return super.getNamedProperty(_hash, _name, _checkValid);
3056      }
3057
3058    }
3059
3060    @Override
3061    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3062      switch (hash) {
3063      case -1225497630:
3064        /* translations */ return this.translations == null ? new Base[0] : new Base[] { this.translations }; // BooleanType
3065      default:
3066        return super.getProperty(hash, name, checkValid);
3067      }
3068
3069    }
3070
3071    @Override
3072    public Base setProperty(int hash, String name, Base value) throws FHIRException {
3073      switch (hash) {
3074      case -1225497630: // translations
3075        this.translations = castToBoolean(value); // BooleanType
3076        return value;
3077      default:
3078        return super.setProperty(hash, name, value);
3079      }
3080
3081    }
3082
3083    @Override
3084    public Base setProperty(String name, Base value) throws FHIRException {
3085      if (name.equals("translations")) {
3086        this.translations = castToBoolean(value); // BooleanType
3087      } else
3088        return super.setProperty(name, value);
3089      return value;
3090    }
3091
3092    @Override
3093    public Base makeProperty(int hash, String name) throws FHIRException {
3094      switch (hash) {
3095      case -1225497630:
3096        return getTranslationsElement();
3097      default:
3098        return super.makeProperty(hash, name);
3099      }
3100
3101    }
3102
3103    @Override
3104    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3105      switch (hash) {
3106      case -1225497630:
3107        /* translations */ return new String[] { "boolean" };
3108      default:
3109        return super.getTypesForProperty(hash, name);
3110      }
3111
3112    }
3113
3114    @Override
3115    public Base addChild(String name) throws FHIRException {
3116      if (name.equals("translations")) {
3117        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.translations");
3118      } else
3119        return super.addChild(name);
3120    }
3121
3122    public TerminologyCapabilitiesValidateCodeComponent copy() {
3123      TerminologyCapabilitiesValidateCodeComponent dst = new TerminologyCapabilitiesValidateCodeComponent();
3124      copyValues(dst);
3125      return dst;
3126    }
3127
3128    public void copyValues(TerminologyCapabilitiesValidateCodeComponent dst) {
3129      super.copyValues(dst);
3130      dst.translations = translations == null ? null : translations.copy();
3131    }
3132
3133    @Override
3134    public boolean equalsDeep(Base other_) {
3135      if (!super.equalsDeep(other_))
3136        return false;
3137      if (!(other_ instanceof TerminologyCapabilitiesValidateCodeComponent))
3138        return false;
3139      TerminologyCapabilitiesValidateCodeComponent o = (TerminologyCapabilitiesValidateCodeComponent) other_;
3140      return compareDeep(translations, o.translations, true);
3141    }
3142
3143    @Override
3144    public boolean equalsShallow(Base other_) {
3145      if (!super.equalsShallow(other_))
3146        return false;
3147      if (!(other_ instanceof TerminologyCapabilitiesValidateCodeComponent))
3148        return false;
3149      TerminologyCapabilitiesValidateCodeComponent o = (TerminologyCapabilitiesValidateCodeComponent) other_;
3150      return compareValues(translations, o.translations, true);
3151    }
3152
3153    public boolean isEmpty() {
3154      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(translations);
3155    }
3156
3157    public String fhirType() {
3158      return "TerminologyCapabilities.validateCode";
3159
3160    }
3161
3162  }
3163
3164  @Block()
3165  public static class TerminologyCapabilitiesTranslationComponent extends BackboneElement
3166      implements IBaseBackboneElement {
3167    /**
3168     * Whether the client must identify the map.
3169     */
3170    @Child(name = "needsMap", type = {
3171        BooleanType.class }, order = 1, min = 1, max = 1, modifier = false, summary = false)
3172    @Description(shortDefinition = "Whether the client must identify the map", formalDefinition = "Whether the client must identify the map.")
3173    protected BooleanType needsMap;
3174
3175    private static final long serialVersionUID = -1727843575L;
3176
3177    /**
3178     * Constructor
3179     */
3180    public TerminologyCapabilitiesTranslationComponent() {
3181      super();
3182    }
3183
3184    /**
3185     * Constructor
3186     */
3187    public TerminologyCapabilitiesTranslationComponent(BooleanType needsMap) {
3188      super();
3189      this.needsMap = needsMap;
3190    }
3191
3192    /**
3193     * @return {@link #needsMap} (Whether the client must identify the map.). This
3194     *         is the underlying object with id, value and extensions. The accessor
3195     *         "getNeedsMap" gives direct access to the value
3196     */
3197    public BooleanType getNeedsMapElement() {
3198      if (this.needsMap == null)
3199        if (Configuration.errorOnAutoCreate())
3200          throw new Error("Attempt to auto-create TerminologyCapabilitiesTranslationComponent.needsMap");
3201        else if (Configuration.doAutoCreate())
3202          this.needsMap = new BooleanType(); // bb
3203      return this.needsMap;
3204    }
3205
3206    public boolean hasNeedsMapElement() {
3207      return this.needsMap != null && !this.needsMap.isEmpty();
3208    }
3209
3210    public boolean hasNeedsMap() {
3211      return this.needsMap != null && !this.needsMap.isEmpty();
3212    }
3213
3214    /**
3215     * @param value {@link #needsMap} (Whether the client must identify the map.).
3216     *              This is the underlying object with id, value and extensions. The
3217     *              accessor "getNeedsMap" gives direct access to the value
3218     */
3219    public TerminologyCapabilitiesTranslationComponent setNeedsMapElement(BooleanType value) {
3220      this.needsMap = value;
3221      return this;
3222    }
3223
3224    /**
3225     * @return Whether the client must identify the map.
3226     */
3227    public boolean getNeedsMap() {
3228      return this.needsMap == null || this.needsMap.isEmpty() ? false : this.needsMap.getValue();
3229    }
3230
3231    /**
3232     * @param value Whether the client must identify the map.
3233     */
3234    public TerminologyCapabilitiesTranslationComponent setNeedsMap(boolean value) {
3235      if (this.needsMap == null)
3236        this.needsMap = new BooleanType();
3237      this.needsMap.setValue(value);
3238      return this;
3239    }
3240
3241    protected void listChildren(List<Property> children) {
3242      super.listChildren(children);
3243      children.add(new Property("needsMap", "boolean", "Whether the client must identify the map.", 0, 1, needsMap));
3244    }
3245
3246    @Override
3247    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3248      switch (_hash) {
3249      case 866566527:
3250        /* needsMap */ return new Property("needsMap", "boolean", "Whether the client must identify the map.", 0, 1,
3251            needsMap);
3252      default:
3253        return super.getNamedProperty(_hash, _name, _checkValid);
3254      }
3255
3256    }
3257
3258    @Override
3259    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3260      switch (hash) {
3261      case 866566527:
3262        /* needsMap */ return this.needsMap == null ? new Base[0] : new Base[] { this.needsMap }; // BooleanType
3263      default:
3264        return super.getProperty(hash, name, checkValid);
3265      }
3266
3267    }
3268
3269    @Override
3270    public Base setProperty(int hash, String name, Base value) throws FHIRException {
3271      switch (hash) {
3272      case 866566527: // needsMap
3273        this.needsMap = castToBoolean(value); // BooleanType
3274        return value;
3275      default:
3276        return super.setProperty(hash, name, value);
3277      }
3278
3279    }
3280
3281    @Override
3282    public Base setProperty(String name, Base value) throws FHIRException {
3283      if (name.equals("needsMap")) {
3284        this.needsMap = castToBoolean(value); // BooleanType
3285      } else
3286        return super.setProperty(name, value);
3287      return value;
3288    }
3289
3290    @Override
3291    public Base makeProperty(int hash, String name) throws FHIRException {
3292      switch (hash) {
3293      case 866566527:
3294        return getNeedsMapElement();
3295      default:
3296        return super.makeProperty(hash, name);
3297      }
3298
3299    }
3300
3301    @Override
3302    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3303      switch (hash) {
3304      case 866566527:
3305        /* needsMap */ return new String[] { "boolean" };
3306      default:
3307        return super.getTypesForProperty(hash, name);
3308      }
3309
3310    }
3311
3312    @Override
3313    public Base addChild(String name) throws FHIRException {
3314      if (name.equals("needsMap")) {
3315        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.needsMap");
3316      } else
3317        return super.addChild(name);
3318    }
3319
3320    public TerminologyCapabilitiesTranslationComponent copy() {
3321      TerminologyCapabilitiesTranslationComponent dst = new TerminologyCapabilitiesTranslationComponent();
3322      copyValues(dst);
3323      return dst;
3324    }
3325
3326    public void copyValues(TerminologyCapabilitiesTranslationComponent dst) {
3327      super.copyValues(dst);
3328      dst.needsMap = needsMap == null ? null : needsMap.copy();
3329    }
3330
3331    @Override
3332    public boolean equalsDeep(Base other_) {
3333      if (!super.equalsDeep(other_))
3334        return false;
3335      if (!(other_ instanceof TerminologyCapabilitiesTranslationComponent))
3336        return false;
3337      TerminologyCapabilitiesTranslationComponent o = (TerminologyCapabilitiesTranslationComponent) other_;
3338      return compareDeep(needsMap, o.needsMap, true);
3339    }
3340
3341    @Override
3342    public boolean equalsShallow(Base other_) {
3343      if (!super.equalsShallow(other_))
3344        return false;
3345      if (!(other_ instanceof TerminologyCapabilitiesTranslationComponent))
3346        return false;
3347      TerminologyCapabilitiesTranslationComponent o = (TerminologyCapabilitiesTranslationComponent) other_;
3348      return compareValues(needsMap, o.needsMap, true);
3349    }
3350
3351    public boolean isEmpty() {
3352      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(needsMap);
3353    }
3354
3355    public String fhirType() {
3356      return "TerminologyCapabilities.translation";
3357
3358    }
3359
3360  }
3361
3362  @Block()
3363  public static class TerminologyCapabilitiesClosureComponent extends BackboneElement implements IBaseBackboneElement {
3364    /**
3365     * If cross-system closure is supported.
3366     */
3367    @Child(name = "translation", type = {
3368        BooleanType.class }, order = 1, min = 0, max = 1, modifier = false, summary = false)
3369    @Description(shortDefinition = "If cross-system closure is supported", formalDefinition = "If cross-system closure is supported.")
3370    protected BooleanType translation;
3371
3372    private static final long serialVersionUID = 1900484343L;
3373
3374    /**
3375     * Constructor
3376     */
3377    public TerminologyCapabilitiesClosureComponent() {
3378      super();
3379    }
3380
3381    /**
3382     * @return {@link #translation} (If cross-system closure is supported.). This is
3383     *         the underlying object with id, value and extensions. The accessor
3384     *         "getTranslation" gives direct access to the value
3385     */
3386    public BooleanType getTranslationElement() {
3387      if (this.translation == null)
3388        if (Configuration.errorOnAutoCreate())
3389          throw new Error("Attempt to auto-create TerminologyCapabilitiesClosureComponent.translation");
3390        else if (Configuration.doAutoCreate())
3391          this.translation = new BooleanType(); // bb
3392      return this.translation;
3393    }
3394
3395    public boolean hasTranslationElement() {
3396      return this.translation != null && !this.translation.isEmpty();
3397    }
3398
3399    public boolean hasTranslation() {
3400      return this.translation != null && !this.translation.isEmpty();
3401    }
3402
3403    /**
3404     * @param value {@link #translation} (If cross-system closure is supported.).
3405     *              This is the underlying object with id, value and extensions. The
3406     *              accessor "getTranslation" gives direct access to the value
3407     */
3408    public TerminologyCapabilitiesClosureComponent setTranslationElement(BooleanType value) {
3409      this.translation = value;
3410      return this;
3411    }
3412
3413    /**
3414     * @return If cross-system closure is supported.
3415     */
3416    public boolean getTranslation() {
3417      return this.translation == null || this.translation.isEmpty() ? false : this.translation.getValue();
3418    }
3419
3420    /**
3421     * @param value If cross-system closure is supported.
3422     */
3423    public TerminologyCapabilitiesClosureComponent setTranslation(boolean value) {
3424      if (this.translation == null)
3425        this.translation = new BooleanType();
3426      this.translation.setValue(value);
3427      return this;
3428    }
3429
3430    protected void listChildren(List<Property> children) {
3431      super.listChildren(children);
3432      children.add(new Property("translation", "boolean", "If cross-system closure is supported.", 0, 1, translation));
3433    }
3434
3435    @Override
3436    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3437      switch (_hash) {
3438      case -1840647503:
3439        /* translation */ return new Property("translation", "boolean", "If cross-system closure is supported.", 0, 1,
3440            translation);
3441      default:
3442        return super.getNamedProperty(_hash, _name, _checkValid);
3443      }
3444
3445    }
3446
3447    @Override
3448    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3449      switch (hash) {
3450      case -1840647503:
3451        /* translation */ return this.translation == null ? new Base[0] : new Base[] { this.translation }; // BooleanType
3452      default:
3453        return super.getProperty(hash, name, checkValid);
3454      }
3455
3456    }
3457
3458    @Override
3459    public Base setProperty(int hash, String name, Base value) throws FHIRException {
3460      switch (hash) {
3461      case -1840647503: // translation
3462        this.translation = castToBoolean(value); // BooleanType
3463        return value;
3464      default:
3465        return super.setProperty(hash, name, value);
3466      }
3467
3468    }
3469
3470    @Override
3471    public Base setProperty(String name, Base value) throws FHIRException {
3472      if (name.equals("translation")) {
3473        this.translation = castToBoolean(value); // BooleanType
3474      } else
3475        return super.setProperty(name, value);
3476      return value;
3477    }
3478
3479    @Override
3480    public Base makeProperty(int hash, String name) throws FHIRException {
3481      switch (hash) {
3482      case -1840647503:
3483        return getTranslationElement();
3484      default:
3485        return super.makeProperty(hash, name);
3486      }
3487
3488    }
3489
3490    @Override
3491    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3492      switch (hash) {
3493      case -1840647503:
3494        /* translation */ return new String[] { "boolean" };
3495      default:
3496        return super.getTypesForProperty(hash, name);
3497      }
3498
3499    }
3500
3501    @Override
3502    public Base addChild(String name) throws FHIRException {
3503      if (name.equals("translation")) {
3504        throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.translation");
3505      } else
3506        return super.addChild(name);
3507    }
3508
3509    public TerminologyCapabilitiesClosureComponent copy() {
3510      TerminologyCapabilitiesClosureComponent dst = new TerminologyCapabilitiesClosureComponent();
3511      copyValues(dst);
3512      return dst;
3513    }
3514
3515    public void copyValues(TerminologyCapabilitiesClosureComponent dst) {
3516      super.copyValues(dst);
3517      dst.translation = translation == null ? null : translation.copy();
3518    }
3519
3520    @Override
3521    public boolean equalsDeep(Base other_) {
3522      if (!super.equalsDeep(other_))
3523        return false;
3524      if (!(other_ instanceof TerminologyCapabilitiesClosureComponent))
3525        return false;
3526      TerminologyCapabilitiesClosureComponent o = (TerminologyCapabilitiesClosureComponent) other_;
3527      return compareDeep(translation, o.translation, true);
3528    }
3529
3530    @Override
3531    public boolean equalsShallow(Base other_) {
3532      if (!super.equalsShallow(other_))
3533        return false;
3534      if (!(other_ instanceof TerminologyCapabilitiesClosureComponent))
3535        return false;
3536      TerminologyCapabilitiesClosureComponent o = (TerminologyCapabilitiesClosureComponent) other_;
3537      return compareValues(translation, o.translation, true);
3538    }
3539
3540    public boolean isEmpty() {
3541      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(translation);
3542    }
3543
3544    public String fhirType() {
3545      return "TerminologyCapabilities.closure";
3546
3547    }
3548
3549  }
3550
3551  /**
3552   * Explanation of why this terminology capabilities is needed and why it has
3553   * been designed as it has.
3554   */
3555  @Child(name = "purpose", type = {
3556      MarkdownType.class }, order = 0, min = 0, max = 1, modifier = false, summary = false)
3557  @Description(shortDefinition = "Why this terminology capabilities is defined", formalDefinition = "Explanation of why this terminology capabilities is needed and why it has been designed as it has.")
3558  protected MarkdownType purpose;
3559
3560  /**
3561   * A copyright statement relating to the terminology capabilities and/or its
3562   * contents. Copyright statements are generally legal restrictions on the use
3563   * and publishing of the terminology capabilities.
3564   */
3565  @Child(name = "copyright", type = {
3566      MarkdownType.class }, order = 1, min = 0, max = 1, modifier = false, summary = true)
3567  @Description(shortDefinition = "Use and/or publishing restrictions", formalDefinition = "A copyright statement relating to the terminology capabilities and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the terminology capabilities.")
3568  protected MarkdownType copyright;
3569
3570  /**
3571   * The way that this statement is intended to be used, to describe an actual
3572   * running instance of software, a particular product (kind, not instance of
3573   * software) or a class of implementation (e.g. a desired purchase).
3574   */
3575  @Child(name = "kind", type = { CodeType.class }, order = 2, min = 1, max = 1, modifier = false, summary = true)
3576  @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).")
3577  @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/capability-statement-kind")
3578  protected Enumeration<CapabilityStatementKind> kind;
3579
3580  /**
3581   * Software that is covered by this terminology capability statement. It is used
3582   * when the statement describes the capabilities of a particular software
3583   * version, independent of an installation.
3584   */
3585  @Child(name = "software", type = {}, order = 3, min = 0, max = 1, modifier = false, summary = true)
3586  @Description(shortDefinition = "Software that is covered by this terminology capability statement", formalDefinition = "Software that is covered by this terminology capability statement.  It is used when the statement describes the capabilities of a particular software version, independent of an installation.")
3587  protected TerminologyCapabilitiesSoftwareComponent software;
3588
3589  /**
3590   * Identifies a specific implementation instance that is described by the
3591   * terminology capability statement - i.e. a particular installation, rather
3592   * than the capabilities of a software program.
3593   */
3594  @Child(name = "implementation", type = {}, order = 4, min = 0, max = 1, modifier = false, summary = true)
3595  @Description(shortDefinition = "If this describes a specific instance", formalDefinition = "Identifies a specific implementation instance that is described by the terminology capability statement - i.e. a particular installation, rather than the capabilities of a software program.")
3596  protected TerminologyCapabilitiesImplementationComponent implementation;
3597
3598  /**
3599   * Whether the server supports lockedDate.
3600   */
3601  @Child(name = "lockedDate", type = {
3602      BooleanType.class }, order = 5, min = 0, max = 1, modifier = false, summary = true)
3603  @Description(shortDefinition = "Whether lockedDate is supported", formalDefinition = "Whether the server supports lockedDate.")
3604  protected BooleanType lockedDate;
3605
3606  /**
3607   * Identifies a code system that is supported by the server. If there is a no
3608   * code system URL, then this declares the general assumptions a client can make
3609   * about support for any CodeSystem resource.
3610   */
3611  @Child(name = "codeSystem", type = {}, order = 6, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
3612  @Description(shortDefinition = "A code system supported by the server", formalDefinition = "Identifies a code system that is supported by the server. If there is a no code system URL, then this declares the general assumptions a client can make about support for any CodeSystem resource.")
3613  protected List<TerminologyCapabilitiesCodeSystemComponent> codeSystem;
3614
3615  /**
3616   * Information about the [ValueSet/$expand](valueset-operation-expand.html)
3617   * operation.
3618   */
3619  @Child(name = "expansion", type = {}, order = 7, min = 0, max = 1, modifier = false, summary = false)
3620  @Description(shortDefinition = "Information about the [ValueSet/$expand](valueset-operation-expand.html) operation", formalDefinition = "Information about the [ValueSet/$expand](valueset-operation-expand.html) operation.")
3621  protected TerminologyCapabilitiesExpansionComponent expansion;
3622
3623  /**
3624   * The degree to which the server supports the code search parameter on
3625   * ValueSet, if it is supported.
3626   */
3627  @Child(name = "codeSearch", type = { CodeType.class }, order = 8, min = 0, max = 1, modifier = false, summary = false)
3628  @Description(shortDefinition = "explicit | all", formalDefinition = "The degree to which the server supports the code search parameter on ValueSet, if it is supported.")
3629  @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/code-search-support")
3630  protected Enumeration<CodeSearchSupport> codeSearch;
3631
3632  /**
3633   * Information about the
3634   * [ValueSet/$validate-code](valueset-operation-validate-code.html) operation.
3635   */
3636  @Child(name = "validateCode", type = {}, order = 9, min = 0, max = 1, modifier = false, summary = false)
3637  @Description(shortDefinition = "Information about the [ValueSet/$validate-code](valueset-operation-validate-code.html) operation", formalDefinition = "Information about the [ValueSet/$validate-code](valueset-operation-validate-code.html) operation.")
3638  protected TerminologyCapabilitiesValidateCodeComponent validateCode;
3639
3640  /**
3641   * Information about the
3642   * [ConceptMap/$translate](conceptmap-operation-translate.html) operation.
3643   */
3644  @Child(name = "translation", type = {}, order = 10, min = 0, max = 1, modifier = false, summary = false)
3645  @Description(shortDefinition = "Information about the [ConceptMap/$translate](conceptmap-operation-translate.html) operation", formalDefinition = "Information about the [ConceptMap/$translate](conceptmap-operation-translate.html) operation.")
3646  protected TerminologyCapabilitiesTranslationComponent translation;
3647
3648  /**
3649   * Whether the $closure operation is supported.
3650   */
3651  @Child(name = "closure", type = {}, order = 11, min = 0, max = 1, modifier = false, summary = false)
3652  @Description(shortDefinition = "Information about the [ConceptMap/$closure](conceptmap-operation-closure.html) operation", formalDefinition = "Whether the $closure operation is supported.")
3653  protected TerminologyCapabilitiesClosureComponent closure;
3654
3655  private static final long serialVersionUID = -1899106119L;
3656
3657  /**
3658   * Constructor
3659   */
3660  public TerminologyCapabilities() {
3661    super();
3662  }
3663
3664  /**
3665   * Constructor
3666   */
3667  public TerminologyCapabilities(Enumeration<PublicationStatus> status, DateTimeType date,
3668      Enumeration<CapabilityStatementKind> kind) {
3669    super();
3670    this.status = status;
3671    this.date = date;
3672    this.kind = kind;
3673  }
3674
3675  /**
3676   * @return {@link #url} (An absolute URI that is used to identify this
3677   *         terminology capabilities when it is referenced in a specification,
3678   *         model, design or an instance; also called its canonical identifier.
3679   *         This SHOULD be globally unique and SHOULD be a literal address at
3680   *         which at which an authoritative instance of this terminology
3681   *         capabilities is (or will be) published. This URL can be the target of
3682   *         a canonical reference. It SHALL remain the same when the terminology
3683   *         capabilities is stored on different servers.). This is the underlying
3684   *         object with id, value and extensions. The accessor "getUrl" gives
3685   *         direct access to the value
3686   */
3687  public UriType getUrlElement() {
3688    if (this.url == null)
3689      if (Configuration.errorOnAutoCreate())
3690        throw new Error("Attempt to auto-create TerminologyCapabilities.url");
3691      else if (Configuration.doAutoCreate())
3692        this.url = new UriType(); // bb
3693    return this.url;
3694  }
3695
3696  public boolean hasUrlElement() {
3697    return this.url != null && !this.url.isEmpty();
3698  }
3699
3700  public boolean hasUrl() {
3701    return this.url != null && !this.url.isEmpty();
3702  }
3703
3704  /**
3705   * @param value {@link #url} (An absolute URI that is used to identify this
3706   *              terminology capabilities when it is referenced in a
3707   *              specification, model, design or an instance; also called its
3708   *              canonical identifier. This SHOULD be globally unique and SHOULD
3709   *              be a literal address at which at which an authoritative instance
3710   *              of this terminology capabilities is (or will be) published. This
3711   *              URL can be the target of a canonical reference. It SHALL remain
3712   *              the same when the terminology capabilities is stored on
3713   *              different servers.). This is the underlying object with id,
3714   *              value and extensions. The accessor "getUrl" gives direct access
3715   *              to the value
3716   */
3717  public TerminologyCapabilities setUrlElement(UriType value) {
3718    this.url = value;
3719    return this;
3720  }
3721
3722  /**
3723   * @return An absolute URI that is used to identify this terminology
3724   *         capabilities when it is referenced in a specification, model, design
3725   *         or an instance; also called its canonical identifier. This SHOULD be
3726   *         globally unique and SHOULD be a literal address at which at which an
3727   *         authoritative instance of this terminology capabilities is (or will
3728   *         be) published. This URL can be the target of a canonical reference.
3729   *         It SHALL remain the same when the terminology capabilities is stored
3730   *         on different servers.
3731   */
3732  public String getUrl() {
3733    return this.url == null ? null : this.url.getValue();
3734  }
3735
3736  /**
3737   * @param value An absolute URI that is used to identify this terminology
3738   *              capabilities when it is referenced in a specification, model,
3739   *              design or an instance; also called its canonical identifier.
3740   *              This SHOULD be globally unique and SHOULD be a literal address
3741   *              at which at which an authoritative instance of this terminology
3742   *              capabilities is (or will be) published. This URL can be the
3743   *              target of a canonical reference. It SHALL remain the same when
3744   *              the terminology capabilities is stored on different servers.
3745   */
3746  public TerminologyCapabilities setUrl(String value) {
3747    if (Utilities.noString(value))
3748      this.url = null;
3749    else {
3750      if (this.url == null)
3751        this.url = new UriType();
3752      this.url.setValue(value);
3753    }
3754    return this;
3755  }
3756
3757  /**
3758   * @return {@link #version} (The identifier that is used to identify this
3759   *         version of the terminology capabilities when it is referenced in a
3760   *         specification, model, design or instance. This is an arbitrary value
3761   *         managed by the terminology capabilities author and is not expected to
3762   *         be globally unique. For example, it might be a timestamp (e.g.
3763   *         yyyymmdd) if a managed version is not available. There is also no
3764   *         expectation that versions can be placed in a lexicographical
3765   *         sequence.). This is the underlying object with id, value and
3766   *         extensions. The accessor "getVersion" gives direct access to the
3767   *         value
3768   */
3769  public StringType getVersionElement() {
3770    if (this.version == null)
3771      if (Configuration.errorOnAutoCreate())
3772        throw new Error("Attempt to auto-create TerminologyCapabilities.version");
3773      else if (Configuration.doAutoCreate())
3774        this.version = new StringType(); // bb
3775    return this.version;
3776  }
3777
3778  public boolean hasVersionElement() {
3779    return this.version != null && !this.version.isEmpty();
3780  }
3781
3782  public boolean hasVersion() {
3783    return this.version != null && !this.version.isEmpty();
3784  }
3785
3786  /**
3787   * @param value {@link #version} (The identifier that is used to identify this
3788   *              version of the terminology capabilities when it is referenced in
3789   *              a specification, model, design or instance. This is an arbitrary
3790   *              value managed by the terminology capabilities author and is not
3791   *              expected to be globally unique. For example, it might be a
3792   *              timestamp (e.g. yyyymmdd) if a managed version is not available.
3793   *              There is also no expectation that versions can be placed in a
3794   *              lexicographical sequence.). This is the underlying object with
3795   *              id, value and extensions. The accessor "getVersion" gives direct
3796   *              access to the value
3797   */
3798  public TerminologyCapabilities setVersionElement(StringType value) {
3799    this.version = value;
3800    return this;
3801  }
3802
3803  /**
3804   * @return The identifier that is used to identify this version of the
3805   *         terminology capabilities when it is referenced in a specification,
3806   *         model, design or instance. This is an arbitrary value managed by the
3807   *         terminology capabilities author and is not expected to be globally
3808   *         unique. For example, it might be a timestamp (e.g. yyyymmdd) if a
3809   *         managed version is not available. There is also no expectation that
3810   *         versions can be placed in a lexicographical sequence.
3811   */
3812  public String getVersion() {
3813    return this.version == null ? null : this.version.getValue();
3814  }
3815
3816  /**
3817   * @param value The identifier that is used to identify this version of the
3818   *              terminology capabilities when it is referenced in a
3819   *              specification, model, design or instance. This is an arbitrary
3820   *              value managed by the terminology capabilities author and is not
3821   *              expected to be globally unique. For example, it might be a
3822   *              timestamp (e.g. yyyymmdd) if a managed version is not available.
3823   *              There is also no expectation that versions can be placed in a
3824   *              lexicographical sequence.
3825   */
3826  public TerminologyCapabilities setVersion(String value) {
3827    if (Utilities.noString(value))
3828      this.version = null;
3829    else {
3830      if (this.version == null)
3831        this.version = new StringType();
3832      this.version.setValue(value);
3833    }
3834    return this;
3835  }
3836
3837  /**
3838   * @return {@link #name} (A natural language name identifying the terminology
3839   *         capabilities. This name should be usable as an identifier for the
3840   *         module by machine processing applications such as code generation.).
3841   *         This is the underlying object with id, value and extensions. The
3842   *         accessor "getName" gives direct access to the value
3843   */
3844  public StringType getNameElement() {
3845    if (this.name == null)
3846      if (Configuration.errorOnAutoCreate())
3847        throw new Error("Attempt to auto-create TerminologyCapabilities.name");
3848      else if (Configuration.doAutoCreate())
3849        this.name = new StringType(); // bb
3850    return this.name;
3851  }
3852
3853  public boolean hasNameElement() {
3854    return this.name != null && !this.name.isEmpty();
3855  }
3856
3857  public boolean hasName() {
3858    return this.name != null && !this.name.isEmpty();
3859  }
3860
3861  /**
3862   * @param value {@link #name} (A natural language name identifying the
3863   *              terminology capabilities. This name should be usable as an
3864   *              identifier for the module by machine processing applications
3865   *              such as code generation.). This is the underlying object with
3866   *              id, value and extensions. The accessor "getName" gives direct
3867   *              access to the value
3868   */
3869  public TerminologyCapabilities setNameElement(StringType value) {
3870    this.name = value;
3871    return this;
3872  }
3873
3874  /**
3875   * @return A natural language name identifying the terminology capabilities.
3876   *         This name should be usable as an identifier for the module by machine
3877   *         processing applications such as code generation.
3878   */
3879  public String getName() {
3880    return this.name == null ? null : this.name.getValue();
3881  }
3882
3883  /**
3884   * @param value A natural language name identifying the terminology
3885   *              capabilities. This name should be usable as an identifier for
3886   *              the module by machine processing applications such as code
3887   *              generation.
3888   */
3889  public TerminologyCapabilities setName(String value) {
3890    if (Utilities.noString(value))
3891      this.name = null;
3892    else {
3893      if (this.name == null)
3894        this.name = new StringType();
3895      this.name.setValue(value);
3896    }
3897    return this;
3898  }
3899
3900  /**
3901   * @return {@link #title} (A short, descriptive, user-friendly title for the
3902   *         terminology capabilities.). This is the underlying object with id,
3903   *         value and extensions. The accessor "getTitle" gives direct access to
3904   *         the value
3905   */
3906  public StringType getTitleElement() {
3907    if (this.title == null)
3908      if (Configuration.errorOnAutoCreate())
3909        throw new Error("Attempt to auto-create TerminologyCapabilities.title");
3910      else if (Configuration.doAutoCreate())
3911        this.title = new StringType(); // bb
3912    return this.title;
3913  }
3914
3915  public boolean hasTitleElement() {
3916    return this.title != null && !this.title.isEmpty();
3917  }
3918
3919  public boolean hasTitle() {
3920    return this.title != null && !this.title.isEmpty();
3921  }
3922
3923  /**
3924   * @param value {@link #title} (A short, descriptive, user-friendly title for
3925   *              the terminology capabilities.). This is the underlying object
3926   *              with id, value and extensions. The accessor "getTitle" gives
3927   *              direct access to the value
3928   */
3929  public TerminologyCapabilities setTitleElement(StringType value) {
3930    this.title = value;
3931    return this;
3932  }
3933
3934  /**
3935   * @return A short, descriptive, user-friendly title for the terminology
3936   *         capabilities.
3937   */
3938  public String getTitle() {
3939    return this.title == null ? null : this.title.getValue();
3940  }
3941
3942  /**
3943   * @param value A short, descriptive, user-friendly title for the terminology
3944   *              capabilities.
3945   */
3946  public TerminologyCapabilities setTitle(String value) {
3947    if (Utilities.noString(value))
3948      this.title = null;
3949    else {
3950      if (this.title == null)
3951        this.title = new StringType();
3952      this.title.setValue(value);
3953    }
3954    return this;
3955  }
3956
3957  /**
3958   * @return {@link #status} (The status of this terminology capabilities. Enables
3959   *         tracking the life-cycle of the content.). This is the underlying
3960   *         object with id, value and extensions. The accessor "getStatus" gives
3961   *         direct access to the value
3962   */
3963  public Enumeration<PublicationStatus> getStatusElement() {
3964    if (this.status == null)
3965      if (Configuration.errorOnAutoCreate())
3966        throw new Error("Attempt to auto-create TerminologyCapabilities.status");
3967      else if (Configuration.doAutoCreate())
3968        this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb
3969    return this.status;
3970  }
3971
3972  public boolean hasStatusElement() {
3973    return this.status != null && !this.status.isEmpty();
3974  }
3975
3976  public boolean hasStatus() {
3977    return this.status != null && !this.status.isEmpty();
3978  }
3979
3980  /**
3981   * @param value {@link #status} (The status of this terminology capabilities.
3982   *              Enables tracking the life-cycle of the content.). This is the
3983   *              underlying object with id, value and extensions. The accessor
3984   *              "getStatus" gives direct access to the value
3985   */
3986  public TerminologyCapabilities setStatusElement(Enumeration<PublicationStatus> value) {
3987    this.status = value;
3988    return this;
3989  }
3990
3991  /**
3992   * @return The status of this terminology capabilities. Enables tracking the
3993   *         life-cycle of the content.
3994   */
3995  public PublicationStatus getStatus() {
3996    return this.status == null ? null : this.status.getValue();
3997  }
3998
3999  /**
4000   * @param value The status of this terminology capabilities. Enables tracking
4001   *              the life-cycle of the content.
4002   */
4003  public TerminologyCapabilities setStatus(PublicationStatus value) {
4004    if (this.status == null)
4005      this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory());
4006    this.status.setValue(value);
4007    return this;
4008  }
4009
4010  /**
4011   * @return {@link #experimental} (A Boolean value to indicate that this
4012   *         terminology capabilities is authored for testing purposes (or
4013   *         education/evaluation/marketing) and is not intended to be used for
4014   *         genuine usage.). This is the underlying object with id, value and
4015   *         extensions. The accessor "getExperimental" gives direct access to the
4016   *         value
4017   */
4018  public BooleanType getExperimentalElement() {
4019    if (this.experimental == null)
4020      if (Configuration.errorOnAutoCreate())
4021        throw new Error("Attempt to auto-create TerminologyCapabilities.experimental");
4022      else if (Configuration.doAutoCreate())
4023        this.experimental = new BooleanType(); // bb
4024    return this.experimental;
4025  }
4026
4027  public boolean hasExperimentalElement() {
4028    return this.experimental != null && !this.experimental.isEmpty();
4029  }
4030
4031  public boolean hasExperimental() {
4032    return this.experimental != null && !this.experimental.isEmpty();
4033  }
4034
4035  /**
4036   * @param value {@link #experimental} (A Boolean value to indicate that this
4037   *              terminology capabilities is authored for testing purposes (or
4038   *              education/evaluation/marketing) and is not intended to be used
4039   *              for genuine usage.). This is the underlying object with id,
4040   *              value and extensions. The accessor "getExperimental" gives
4041   *              direct access to the value
4042   */
4043  public TerminologyCapabilities setExperimentalElement(BooleanType value) {
4044    this.experimental = value;
4045    return this;
4046  }
4047
4048  /**
4049   * @return A Boolean value to indicate that this terminology capabilities is
4050   *         authored for testing purposes (or education/evaluation/marketing) and
4051   *         is not intended to be used for genuine usage.
4052   */
4053  public boolean getExperimental() {
4054    return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue();
4055  }
4056
4057  /**
4058   * @param value A Boolean value to indicate that this terminology capabilities
4059   *              is authored for testing purposes (or
4060   *              education/evaluation/marketing) and is not intended to be used
4061   *              for genuine usage.
4062   */
4063  public TerminologyCapabilities setExperimental(boolean value) {
4064    if (this.experimental == null)
4065      this.experimental = new BooleanType();
4066    this.experimental.setValue(value);
4067    return this;
4068  }
4069
4070  /**
4071   * @return {@link #date} (The date (and optionally time) when the terminology
4072   *         capabilities was published. The date must change when the business
4073   *         version changes and it must change if the status code changes. In
4074   *         addition, it should change when the substantive content of the
4075   *         terminology capabilities changes.). This is the underlying object
4076   *         with id, value and extensions. The accessor "getDate" gives direct
4077   *         access to the value
4078   */
4079  public DateTimeType getDateElement() {
4080    if (this.date == null)
4081      if (Configuration.errorOnAutoCreate())
4082        throw new Error("Attempt to auto-create TerminologyCapabilities.date");
4083      else if (Configuration.doAutoCreate())
4084        this.date = new DateTimeType(); // bb
4085    return this.date;
4086  }
4087
4088  public boolean hasDateElement() {
4089    return this.date != null && !this.date.isEmpty();
4090  }
4091
4092  public boolean hasDate() {
4093    return this.date != null && !this.date.isEmpty();
4094  }
4095
4096  /**
4097   * @param value {@link #date} (The date (and optionally time) when the
4098   *              terminology capabilities was published. The date must change
4099   *              when the business version changes and it must change if the
4100   *              status code changes. In addition, it should change when the
4101   *              substantive content of the terminology capabilities changes.).
4102   *              This is the underlying object with id, value and extensions. The
4103   *              accessor "getDate" gives direct access to the value
4104   */
4105  public TerminologyCapabilities setDateElement(DateTimeType value) {
4106    this.date = value;
4107    return this;
4108  }
4109
4110  /**
4111   * @return The date (and optionally time) when the terminology capabilities was
4112   *         published. The date must change when the business version changes and
4113   *         it must change if the status code changes. In addition, it should
4114   *         change when the substantive content of the terminology capabilities
4115   *         changes.
4116   */
4117  public Date getDate() {
4118    return this.date == null ? null : this.date.getValue();
4119  }
4120
4121  /**
4122   * @param value The date (and optionally time) when the terminology capabilities
4123   *              was published. The date must change when the business version
4124   *              changes and it must change if the status code changes. In
4125   *              addition, it should change when the substantive content of the
4126   *              terminology capabilities changes.
4127   */
4128  public TerminologyCapabilities setDate(Date value) {
4129    if (this.date == null)
4130      this.date = new DateTimeType();
4131    this.date.setValue(value);
4132    return this;
4133  }
4134
4135  /**
4136   * @return {@link #publisher} (The name of the organization or individual that
4137   *         published the terminology capabilities.). This is the underlying
4138   *         object with id, value and extensions. The accessor "getPublisher"
4139   *         gives direct access to the value
4140   */
4141  public StringType getPublisherElement() {
4142    if (this.publisher == null)
4143      if (Configuration.errorOnAutoCreate())
4144        throw new Error("Attempt to auto-create TerminologyCapabilities.publisher");
4145      else if (Configuration.doAutoCreate())
4146        this.publisher = new StringType(); // bb
4147    return this.publisher;
4148  }
4149
4150  public boolean hasPublisherElement() {
4151    return this.publisher != null && !this.publisher.isEmpty();
4152  }
4153
4154  public boolean hasPublisher() {
4155    return this.publisher != null && !this.publisher.isEmpty();
4156  }
4157
4158  /**
4159   * @param value {@link #publisher} (The name of the organization or individual
4160   *              that published the terminology capabilities.). This is the
4161   *              underlying object with id, value and extensions. The accessor
4162   *              "getPublisher" gives direct access to the value
4163   */
4164  public TerminologyCapabilities setPublisherElement(StringType value) {
4165    this.publisher = value;
4166    return this;
4167  }
4168
4169  /**
4170   * @return The name of the organization or individual that published the
4171   *         terminology capabilities.
4172   */
4173  public String getPublisher() {
4174    return this.publisher == null ? null : this.publisher.getValue();
4175  }
4176
4177  /**
4178   * @param value The name of the organization or individual that published the
4179   *              terminology capabilities.
4180   */
4181  public TerminologyCapabilities setPublisher(String value) {
4182    if (Utilities.noString(value))
4183      this.publisher = null;
4184    else {
4185      if (this.publisher == null)
4186        this.publisher = new StringType();
4187      this.publisher.setValue(value);
4188    }
4189    return this;
4190  }
4191
4192  /**
4193   * @return {@link #contact} (Contact details to assist a user in finding and
4194   *         communicating with the publisher.)
4195   */
4196  public List<ContactDetail> getContact() {
4197    if (this.contact == null)
4198      this.contact = new ArrayList<ContactDetail>();
4199    return this.contact;
4200  }
4201
4202  /**
4203   * @return Returns a reference to <code>this</code> for easy method chaining
4204   */
4205  public TerminologyCapabilities setContact(List<ContactDetail> theContact) {
4206    this.contact = theContact;
4207    return this;
4208  }
4209
4210  public boolean hasContact() {
4211    if (this.contact == null)
4212      return false;
4213    for (ContactDetail item : this.contact)
4214      if (!item.isEmpty())
4215        return true;
4216    return false;
4217  }
4218
4219  public ContactDetail addContact() { // 3
4220    ContactDetail t = new ContactDetail();
4221    if (this.contact == null)
4222      this.contact = new ArrayList<ContactDetail>();
4223    this.contact.add(t);
4224    return t;
4225  }
4226
4227  public TerminologyCapabilities addContact(ContactDetail t) { // 3
4228    if (t == null)
4229      return this;
4230    if (this.contact == null)
4231      this.contact = new ArrayList<ContactDetail>();
4232    this.contact.add(t);
4233    return this;
4234  }
4235
4236  /**
4237   * @return The first repetition of repeating field {@link #contact}, creating it
4238   *         if it does not already exist
4239   */
4240  public ContactDetail getContactFirstRep() {
4241    if (getContact().isEmpty()) {
4242      addContact();
4243    }
4244    return getContact().get(0);
4245  }
4246
4247  /**
4248   * @return {@link #description} (A free text natural language description of the
4249   *         terminology capabilities from a consumer's perspective. Typically,
4250   *         this is used when the capability statement describes a desired rather
4251   *         than an actual solution, for example as a formal expression of
4252   *         requirements as part of an RFP.). This is the underlying object with
4253   *         id, value and extensions. The accessor "getDescription" gives direct
4254   *         access to the value
4255   */
4256  public MarkdownType getDescriptionElement() {
4257    if (this.description == null)
4258      if (Configuration.errorOnAutoCreate())
4259        throw new Error("Attempt to auto-create TerminologyCapabilities.description");
4260      else if (Configuration.doAutoCreate())
4261        this.description = new MarkdownType(); // bb
4262    return this.description;
4263  }
4264
4265  public boolean hasDescriptionElement() {
4266    return this.description != null && !this.description.isEmpty();
4267  }
4268
4269  public boolean hasDescription() {
4270    return this.description != null && !this.description.isEmpty();
4271  }
4272
4273  /**
4274   * @param value {@link #description} (A free text natural language description
4275   *              of the terminology capabilities from a consumer's perspective.
4276   *              Typically, this is used when the capability statement describes
4277   *              a desired rather than an actual solution, for example as a
4278   *              formal expression of requirements as part of an RFP.). This is
4279   *              the underlying object with id, value and extensions. The
4280   *              accessor "getDescription" gives direct access to the value
4281   */
4282  public TerminologyCapabilities setDescriptionElement(MarkdownType value) {
4283    this.description = value;
4284    return this;
4285  }
4286
4287  /**
4288   * @return A free text natural language description of the terminology
4289   *         capabilities from a consumer's perspective. Typically, this is used
4290   *         when the capability statement describes a desired rather than an
4291   *         actual solution, for example as a formal expression of requirements
4292   *         as part of an RFP.
4293   */
4294  public String getDescription() {
4295    return this.description == null ? null : this.description.getValue();
4296  }
4297
4298  /**
4299   * @param value A free text natural language description of the terminology
4300   *              capabilities from a consumer's perspective. Typically, this is
4301   *              used when the capability statement describes a desired rather
4302   *              than an actual solution, for example as a formal expression of
4303   *              requirements as part of an RFP.
4304   */
4305  public TerminologyCapabilities setDescription(String value) {
4306    if (value == null)
4307      this.description = null;
4308    else {
4309      if (this.description == null)
4310        this.description = new MarkdownType();
4311      this.description.setValue(value);
4312    }
4313    return this;
4314  }
4315
4316  /**
4317   * @return {@link #useContext} (The content was developed with a focus and
4318   *         intent of supporting the contexts that are listed. These contexts may
4319   *         be general categories (gender, age, ...) or may be references to
4320   *         specific programs (insurance plans, studies, ...) and may be used to
4321   *         assist with indexing and searching for appropriate terminology
4322   *         capabilities instances.)
4323   */
4324  public List<UsageContext> getUseContext() {
4325    if (this.useContext == null)
4326      this.useContext = new ArrayList<UsageContext>();
4327    return this.useContext;
4328  }
4329
4330  /**
4331   * @return Returns a reference to <code>this</code> for easy method chaining
4332   */
4333  public TerminologyCapabilities setUseContext(List<UsageContext> theUseContext) {
4334    this.useContext = theUseContext;
4335    return this;
4336  }
4337
4338  public boolean hasUseContext() {
4339    if (this.useContext == null)
4340      return false;
4341    for (UsageContext item : this.useContext)
4342      if (!item.isEmpty())
4343        return true;
4344    return false;
4345  }
4346
4347  public UsageContext addUseContext() { // 3
4348    UsageContext t = new UsageContext();
4349    if (this.useContext == null)
4350      this.useContext = new ArrayList<UsageContext>();
4351    this.useContext.add(t);
4352    return t;
4353  }
4354
4355  public TerminologyCapabilities addUseContext(UsageContext t) { // 3
4356    if (t == null)
4357      return this;
4358    if (this.useContext == null)
4359      this.useContext = new ArrayList<UsageContext>();
4360    this.useContext.add(t);
4361    return this;
4362  }
4363
4364  /**
4365   * @return The first repetition of repeating field {@link #useContext}, creating
4366   *         it if it does not already exist
4367   */
4368  public UsageContext getUseContextFirstRep() {
4369    if (getUseContext().isEmpty()) {
4370      addUseContext();
4371    }
4372    return getUseContext().get(0);
4373  }
4374
4375  /**
4376   * @return {@link #jurisdiction} (A legal or geographic region in which the
4377   *         terminology capabilities is intended to be used.)
4378   */
4379  public List<CodeableConcept> getJurisdiction() {
4380    if (this.jurisdiction == null)
4381      this.jurisdiction = new ArrayList<CodeableConcept>();
4382    return this.jurisdiction;
4383  }
4384
4385  /**
4386   * @return Returns a reference to <code>this</code> for easy method chaining
4387   */
4388  public TerminologyCapabilities setJurisdiction(List<CodeableConcept> theJurisdiction) {
4389    this.jurisdiction = theJurisdiction;
4390    return this;
4391  }
4392
4393  public boolean hasJurisdiction() {
4394    if (this.jurisdiction == null)
4395      return false;
4396    for (CodeableConcept item : this.jurisdiction)
4397      if (!item.isEmpty())
4398        return true;
4399    return false;
4400  }
4401
4402  public CodeableConcept addJurisdiction() { // 3
4403    CodeableConcept t = new CodeableConcept();
4404    if (this.jurisdiction == null)
4405      this.jurisdiction = new ArrayList<CodeableConcept>();
4406    this.jurisdiction.add(t);
4407    return t;
4408  }
4409
4410  public TerminologyCapabilities addJurisdiction(CodeableConcept t) { // 3
4411    if (t == null)
4412      return this;
4413    if (this.jurisdiction == null)
4414      this.jurisdiction = new ArrayList<CodeableConcept>();
4415    this.jurisdiction.add(t);
4416    return this;
4417  }
4418
4419  /**
4420   * @return The first repetition of repeating field {@link #jurisdiction},
4421   *         creating it if it does not already exist
4422   */
4423  public CodeableConcept getJurisdictionFirstRep() {
4424    if (getJurisdiction().isEmpty()) {
4425      addJurisdiction();
4426    }
4427    return getJurisdiction().get(0);
4428  }
4429
4430  /**
4431   * @return {@link #purpose} (Explanation of why this terminology capabilities is
4432   *         needed and why it has been designed as it has.). This is the
4433   *         underlying object with id, value and extensions. The accessor
4434   *         "getPurpose" gives direct access to the value
4435   */
4436  public MarkdownType getPurposeElement() {
4437    if (this.purpose == null)
4438      if (Configuration.errorOnAutoCreate())
4439        throw new Error("Attempt to auto-create TerminologyCapabilities.purpose");
4440      else if (Configuration.doAutoCreate())
4441        this.purpose = new MarkdownType(); // bb
4442    return this.purpose;
4443  }
4444
4445  public boolean hasPurposeElement() {
4446    return this.purpose != null && !this.purpose.isEmpty();
4447  }
4448
4449  public boolean hasPurpose() {
4450    return this.purpose != null && !this.purpose.isEmpty();
4451  }
4452
4453  /**
4454   * @param value {@link #purpose} (Explanation of why this terminology
4455   *              capabilities is needed and why it has been designed as it has.).
4456   *              This is the underlying object with id, value and extensions. The
4457   *              accessor "getPurpose" gives direct access to the value
4458   */
4459  public TerminologyCapabilities setPurposeElement(MarkdownType value) {
4460    this.purpose = value;
4461    return this;
4462  }
4463
4464  /**
4465   * @return Explanation of why this terminology capabilities is needed and why it
4466   *         has been designed as it has.
4467   */
4468  public String getPurpose() {
4469    return this.purpose == null ? null : this.purpose.getValue();
4470  }
4471
4472  /**
4473   * @param value Explanation of why this terminology capabilities is needed and
4474   *              why it has been designed as it has.
4475   */
4476  public TerminologyCapabilities setPurpose(String value) {
4477    if (value == null)
4478      this.purpose = null;
4479    else {
4480      if (this.purpose == null)
4481        this.purpose = new MarkdownType();
4482      this.purpose.setValue(value);
4483    }
4484    return this;
4485  }
4486
4487  /**
4488   * @return {@link #copyright} (A copyright statement relating to the terminology
4489   *         capabilities and/or its contents. Copyright statements are generally
4490   *         legal restrictions on the use and publishing of the terminology
4491   *         capabilities.). This is the underlying object with id, value and
4492   *         extensions. The accessor "getCopyright" gives direct access to the
4493   *         value
4494   */
4495  public MarkdownType getCopyrightElement() {
4496    if (this.copyright == null)
4497      if (Configuration.errorOnAutoCreate())
4498        throw new Error("Attempt to auto-create TerminologyCapabilities.copyright");
4499      else if (Configuration.doAutoCreate())
4500        this.copyright = new MarkdownType(); // bb
4501    return this.copyright;
4502  }
4503
4504  public boolean hasCopyrightElement() {
4505    return this.copyright != null && !this.copyright.isEmpty();
4506  }
4507
4508  public boolean hasCopyright() {
4509    return this.copyright != null && !this.copyright.isEmpty();
4510  }
4511
4512  /**
4513   * @param value {@link #copyright} (A copyright statement relating to the
4514   *              terminology capabilities and/or its contents. Copyright
4515   *              statements are generally legal restrictions on the use and
4516   *              publishing of the terminology capabilities.). This is the
4517   *              underlying object with id, value and extensions. The accessor
4518   *              "getCopyright" gives direct access to the value
4519   */
4520  public TerminologyCapabilities setCopyrightElement(MarkdownType value) {
4521    this.copyright = value;
4522    return this;
4523  }
4524
4525  /**
4526   * @return A copyright statement relating to the terminology capabilities and/or
4527   *         its contents. Copyright statements are generally legal restrictions
4528   *         on the use and publishing of the terminology capabilities.
4529   */
4530  public String getCopyright() {
4531    return this.copyright == null ? null : this.copyright.getValue();
4532  }
4533
4534  /**
4535   * @param value A copyright statement relating to the terminology capabilities
4536   *              and/or its contents. Copyright statements are generally legal
4537   *              restrictions on the use and publishing of the terminology
4538   *              capabilities.
4539   */
4540  public TerminologyCapabilities setCopyright(String value) {
4541    if (value == null)
4542      this.copyright = null;
4543    else {
4544      if (this.copyright == null)
4545        this.copyright = new MarkdownType();
4546      this.copyright.setValue(value);
4547    }
4548    return this;
4549  }
4550
4551  /**
4552   * @return {@link #kind} (The way that this statement is intended to be used, to
4553   *         describe an actual running instance of software, a particular product
4554   *         (kind, not instance of software) or a class of implementation (e.g. a
4555   *         desired purchase).). This is the underlying object with id, value and
4556   *         extensions. The accessor "getKind" gives direct access to the value
4557   */
4558  public Enumeration<CapabilityStatementKind> getKindElement() {
4559    if (this.kind == null)
4560      if (Configuration.errorOnAutoCreate())
4561        throw new Error("Attempt to auto-create TerminologyCapabilities.kind");
4562      else if (Configuration.doAutoCreate())
4563        this.kind = new Enumeration<CapabilityStatementKind>(new CapabilityStatementKindEnumFactory()); // bb
4564    return this.kind;
4565  }
4566
4567  public boolean hasKindElement() {
4568    return this.kind != null && !this.kind.isEmpty();
4569  }
4570
4571  public boolean hasKind() {
4572    return this.kind != null && !this.kind.isEmpty();
4573  }
4574
4575  /**
4576   * @param value {@link #kind} (The way that this statement is intended to be
4577   *              used, to describe an actual running instance of software, a
4578   *              particular product (kind, not instance of software) or a class
4579   *              of implementation (e.g. a desired purchase).). This is the
4580   *              underlying object with id, value and extensions. The accessor
4581   *              "getKind" gives direct access to the value
4582   */
4583  public TerminologyCapabilities setKindElement(Enumeration<CapabilityStatementKind> value) {
4584    this.kind = value;
4585    return this;
4586  }
4587
4588  /**
4589   * @return The way that this statement is intended to be used, to describe an
4590   *         actual running instance of software, a particular product (kind, not
4591   *         instance of software) or a class of implementation (e.g. a desired
4592   *         purchase).
4593   */
4594  public CapabilityStatementKind getKind() {
4595    return this.kind == null ? null : this.kind.getValue();
4596  }
4597
4598  /**
4599   * @param value The way that this statement is intended to be used, to describe
4600   *              an actual running instance of software, a particular product
4601   *              (kind, not instance of software) or a class of implementation
4602   *              (e.g. a desired purchase).
4603   */
4604  public TerminologyCapabilities setKind(CapabilityStatementKind value) {
4605    if (this.kind == null)
4606      this.kind = new Enumeration<CapabilityStatementKind>(new CapabilityStatementKindEnumFactory());
4607    this.kind.setValue(value);
4608    return this;
4609  }
4610
4611  /**
4612   * @return {@link #software} (Software that is covered by this terminology
4613   *         capability statement. It is used when the statement describes the
4614   *         capabilities of a particular software version, independent of an
4615   *         installation.)
4616   */
4617  public TerminologyCapabilitiesSoftwareComponent getSoftware() {
4618    if (this.software == null)
4619      if (Configuration.errorOnAutoCreate())
4620        throw new Error("Attempt to auto-create TerminologyCapabilities.software");
4621      else if (Configuration.doAutoCreate())
4622        this.software = new TerminologyCapabilitiesSoftwareComponent(); // cc
4623    return this.software;
4624  }
4625
4626  public boolean hasSoftware() {
4627    return this.software != null && !this.software.isEmpty();
4628  }
4629
4630  /**
4631   * @param value {@link #software} (Software that is covered by this terminology
4632   *              capability statement. It is used when the statement describes
4633   *              the capabilities of a particular software version, independent
4634   *              of an installation.)
4635   */
4636  public TerminologyCapabilities setSoftware(TerminologyCapabilitiesSoftwareComponent value) {
4637    this.software = value;
4638    return this;
4639  }
4640
4641  /**
4642   * @return {@link #implementation} (Identifies a specific implementation
4643   *         instance that is described by the terminology capability statement -
4644   *         i.e. a particular installation, rather than the capabilities of a
4645   *         software program.)
4646   */
4647  public TerminologyCapabilitiesImplementationComponent getImplementation() {
4648    if (this.implementation == null)
4649      if (Configuration.errorOnAutoCreate())
4650        throw new Error("Attempt to auto-create TerminologyCapabilities.implementation");
4651      else if (Configuration.doAutoCreate())
4652        this.implementation = new TerminologyCapabilitiesImplementationComponent(); // cc
4653    return this.implementation;
4654  }
4655
4656  public boolean hasImplementation() {
4657    return this.implementation != null && !this.implementation.isEmpty();
4658  }
4659
4660  /**
4661   * @param value {@link #implementation} (Identifies a specific implementation
4662   *              instance that is described by the terminology capability
4663   *              statement - i.e. a particular installation, rather than the
4664   *              capabilities of a software program.)
4665   */
4666  public TerminologyCapabilities setImplementation(TerminologyCapabilitiesImplementationComponent value) {
4667    this.implementation = value;
4668    return this;
4669  }
4670
4671  /**
4672   * @return {@link #lockedDate} (Whether the server supports lockedDate.). This
4673   *         is the underlying object with id, value and extensions. The accessor
4674   *         "getLockedDate" gives direct access to the value
4675   */
4676  public BooleanType getLockedDateElement() {
4677    if (this.lockedDate == null)
4678      if (Configuration.errorOnAutoCreate())
4679        throw new Error("Attempt to auto-create TerminologyCapabilities.lockedDate");
4680      else if (Configuration.doAutoCreate())
4681        this.lockedDate = new BooleanType(); // bb
4682    return this.lockedDate;
4683  }
4684
4685  public boolean hasLockedDateElement() {
4686    return this.lockedDate != null && !this.lockedDate.isEmpty();
4687  }
4688
4689  public boolean hasLockedDate() {
4690    return this.lockedDate != null && !this.lockedDate.isEmpty();
4691  }
4692
4693  /**
4694   * @param value {@link #lockedDate} (Whether the server supports lockedDate.).
4695   *              This is the underlying object with id, value and extensions. The
4696   *              accessor "getLockedDate" gives direct access to the value
4697   */
4698  public TerminologyCapabilities setLockedDateElement(BooleanType value) {
4699    this.lockedDate = value;
4700    return this;
4701  }
4702
4703  /**
4704   * @return Whether the server supports lockedDate.
4705   */
4706  public boolean getLockedDate() {
4707    return this.lockedDate == null || this.lockedDate.isEmpty() ? false : this.lockedDate.getValue();
4708  }
4709
4710  /**
4711   * @param value Whether the server supports lockedDate.
4712   */
4713  public TerminologyCapabilities setLockedDate(boolean value) {
4714    if (this.lockedDate == null)
4715      this.lockedDate = new BooleanType();
4716    this.lockedDate.setValue(value);
4717    return this;
4718  }
4719
4720  /**
4721   * @return {@link #codeSystem} (Identifies a code system that is supported by
4722   *         the server. If there is a no code system URL, then this declares the
4723   *         general assumptions a client can make about support for any
4724   *         CodeSystem resource.)
4725   */
4726  public List<TerminologyCapabilitiesCodeSystemComponent> getCodeSystem() {
4727    if (this.codeSystem == null)
4728      this.codeSystem = new ArrayList<TerminologyCapabilitiesCodeSystemComponent>();
4729    return this.codeSystem;
4730  }
4731
4732  /**
4733   * @return Returns a reference to <code>this</code> for easy method chaining
4734   */
4735  public TerminologyCapabilities setCodeSystem(List<TerminologyCapabilitiesCodeSystemComponent> theCodeSystem) {
4736    this.codeSystem = theCodeSystem;
4737    return this;
4738  }
4739
4740  public boolean hasCodeSystem() {
4741    if (this.codeSystem == null)
4742      return false;
4743    for (TerminologyCapabilitiesCodeSystemComponent item : this.codeSystem)
4744      if (!item.isEmpty())
4745        return true;
4746    return false;
4747  }
4748
4749  public TerminologyCapabilitiesCodeSystemComponent addCodeSystem() { // 3
4750    TerminologyCapabilitiesCodeSystemComponent t = new TerminologyCapabilitiesCodeSystemComponent();
4751    if (this.codeSystem == null)
4752      this.codeSystem = new ArrayList<TerminologyCapabilitiesCodeSystemComponent>();
4753    this.codeSystem.add(t);
4754    return t;
4755  }
4756
4757  public TerminologyCapabilities addCodeSystem(TerminologyCapabilitiesCodeSystemComponent t) { // 3
4758    if (t == null)
4759      return this;
4760    if (this.codeSystem == null)
4761      this.codeSystem = new ArrayList<TerminologyCapabilitiesCodeSystemComponent>();
4762    this.codeSystem.add(t);
4763    return this;
4764  }
4765
4766  /**
4767   * @return The first repetition of repeating field {@link #codeSystem}, creating
4768   *         it if it does not already exist
4769   */
4770  public TerminologyCapabilitiesCodeSystemComponent getCodeSystemFirstRep() {
4771    if (getCodeSystem().isEmpty()) {
4772      addCodeSystem();
4773    }
4774    return getCodeSystem().get(0);
4775  }
4776
4777  /**
4778   * @return {@link #expansion} (Information about the
4779   *         [ValueSet/$expand](valueset-operation-expand.html) operation.)
4780   */
4781  public TerminologyCapabilitiesExpansionComponent getExpansion() {
4782    if (this.expansion == null)
4783      if (Configuration.errorOnAutoCreate())
4784        throw new Error("Attempt to auto-create TerminologyCapabilities.expansion");
4785      else if (Configuration.doAutoCreate())
4786        this.expansion = new TerminologyCapabilitiesExpansionComponent(); // cc
4787    return this.expansion;
4788  }
4789
4790  public boolean hasExpansion() {
4791    return this.expansion != null && !this.expansion.isEmpty();
4792  }
4793
4794  /**
4795   * @param value {@link #expansion} (Information about the
4796   *              [ValueSet/$expand](valueset-operation-expand.html) operation.)
4797   */
4798  public TerminologyCapabilities setExpansion(TerminologyCapabilitiesExpansionComponent value) {
4799    this.expansion = value;
4800    return this;
4801  }
4802
4803  /**
4804   * @return {@link #codeSearch} (The degree to which the server supports the code
4805   *         search parameter on ValueSet, if it is supported.). This is the
4806   *         underlying object with id, value and extensions. The accessor
4807   *         "getCodeSearch" gives direct access to the value
4808   */
4809  public Enumeration<CodeSearchSupport> getCodeSearchElement() {
4810    if (this.codeSearch == null)
4811      if (Configuration.errorOnAutoCreate())
4812        throw new Error("Attempt to auto-create TerminologyCapabilities.codeSearch");
4813      else if (Configuration.doAutoCreate())
4814        this.codeSearch = new Enumeration<CodeSearchSupport>(new CodeSearchSupportEnumFactory()); // bb
4815    return this.codeSearch;
4816  }
4817
4818  public boolean hasCodeSearchElement() {
4819    return this.codeSearch != null && !this.codeSearch.isEmpty();
4820  }
4821
4822  public boolean hasCodeSearch() {
4823    return this.codeSearch != null && !this.codeSearch.isEmpty();
4824  }
4825
4826  /**
4827   * @param value {@link #codeSearch} (The degree to which the server supports the
4828   *              code search parameter on ValueSet, if it is supported.). This is
4829   *              the underlying object with id, value and extensions. The
4830   *              accessor "getCodeSearch" gives direct access to the value
4831   */
4832  public TerminologyCapabilities setCodeSearchElement(Enumeration<CodeSearchSupport> value) {
4833    this.codeSearch = value;
4834    return this;
4835  }
4836
4837  /**
4838   * @return The degree to which the server supports the code search parameter on
4839   *         ValueSet, if it is supported.
4840   */
4841  public CodeSearchSupport getCodeSearch() {
4842    return this.codeSearch == null ? null : this.codeSearch.getValue();
4843  }
4844
4845  /**
4846   * @param value The degree to which the server supports the code search
4847   *              parameter on ValueSet, if it is supported.
4848   */
4849  public TerminologyCapabilities setCodeSearch(CodeSearchSupport value) {
4850    if (value == null)
4851      this.codeSearch = null;
4852    else {
4853      if (this.codeSearch == null)
4854        this.codeSearch = new Enumeration<CodeSearchSupport>(new CodeSearchSupportEnumFactory());
4855      this.codeSearch.setValue(value);
4856    }
4857    return this;
4858  }
4859
4860  /**
4861   * @return {@link #validateCode} (Information about the
4862   *         [ValueSet/$validate-code](valueset-operation-validate-code.html)
4863   *         operation.)
4864   */
4865  public TerminologyCapabilitiesValidateCodeComponent getValidateCode() {
4866    if (this.validateCode == null)
4867      if (Configuration.errorOnAutoCreate())
4868        throw new Error("Attempt to auto-create TerminologyCapabilities.validateCode");
4869      else if (Configuration.doAutoCreate())
4870        this.validateCode = new TerminologyCapabilitiesValidateCodeComponent(); // cc
4871    return this.validateCode;
4872  }
4873
4874  public boolean hasValidateCode() {
4875    return this.validateCode != null && !this.validateCode.isEmpty();
4876  }
4877
4878  /**
4879   * @param value {@link #validateCode} (Information about the
4880   *              [ValueSet/$validate-code](valueset-operation-validate-code.html)
4881   *              operation.)
4882   */
4883  public TerminologyCapabilities setValidateCode(TerminologyCapabilitiesValidateCodeComponent value) {
4884    this.validateCode = value;
4885    return this;
4886  }
4887
4888  /**
4889   * @return {@link #translation} (Information about the
4890   *         [ConceptMap/$translate](conceptmap-operation-translate.html)
4891   *         operation.)
4892   */
4893  public TerminologyCapabilitiesTranslationComponent getTranslation() {
4894    if (this.translation == null)
4895      if (Configuration.errorOnAutoCreate())
4896        throw new Error("Attempt to auto-create TerminologyCapabilities.translation");
4897      else if (Configuration.doAutoCreate())
4898        this.translation = new TerminologyCapabilitiesTranslationComponent(); // cc
4899    return this.translation;
4900  }
4901
4902  public boolean hasTranslation() {
4903    return this.translation != null && !this.translation.isEmpty();
4904  }
4905
4906  /**
4907   * @param value {@link #translation} (Information about the
4908   *              [ConceptMap/$translate](conceptmap-operation-translate.html)
4909   *              operation.)
4910   */
4911  public TerminologyCapabilities setTranslation(TerminologyCapabilitiesTranslationComponent value) {
4912    this.translation = value;
4913    return this;
4914  }
4915
4916  /**
4917   * @return {@link #closure} (Whether the $closure operation is supported.)
4918   */
4919  public TerminologyCapabilitiesClosureComponent getClosure() {
4920    if (this.closure == null)
4921      if (Configuration.errorOnAutoCreate())
4922        throw new Error("Attempt to auto-create TerminologyCapabilities.closure");
4923      else if (Configuration.doAutoCreate())
4924        this.closure = new TerminologyCapabilitiesClosureComponent(); // cc
4925    return this.closure;
4926  }
4927
4928  public boolean hasClosure() {
4929    return this.closure != null && !this.closure.isEmpty();
4930  }
4931
4932  /**
4933   * @param value {@link #closure} (Whether the $closure operation is supported.)
4934   */
4935  public TerminologyCapabilities setClosure(TerminologyCapabilitiesClosureComponent value) {
4936    this.closure = value;
4937    return this;
4938  }
4939
4940  protected void listChildren(List<Property> children) {
4941    super.listChildren(children);
4942    children.add(new Property("url", "uri",
4943        "An absolute URI that is used to identify this terminology capabilities when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this terminology capabilities is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the terminology capabilities is stored on different servers.",
4944        0, 1, url));
4945    children.add(new Property("version", "string",
4946        "The identifier that is used to identify this version of the terminology capabilities when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the terminology capabilities author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
4947        0, 1, version));
4948    children.add(new Property("name", "string",
4949        "A natural language name identifying the terminology capabilities. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
4950        0, 1, name));
4951    children.add(new Property("title", "string",
4952        "A short, descriptive, user-friendly title for the terminology capabilities.", 0, 1, title));
4953    children.add(new Property("status", "code",
4954        "The status of this terminology capabilities. Enables tracking the life-cycle of the content.", 0, 1, status));
4955    children.add(new Property("experimental", "boolean",
4956        "A Boolean value to indicate that this terminology capabilities is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.",
4957        0, 1, experimental));
4958    children.add(new Property("date", "dateTime",
4959        "The date  (and optionally time) when the terminology capabilities was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the terminology capabilities changes.",
4960        0, 1, date));
4961    children.add(new Property("publisher", "string",
4962        "The name of the organization or individual that published the terminology capabilities.", 0, 1, publisher));
4963    children.add(new Property("contact", "ContactDetail",
4964        "Contact details to assist a user in finding and communicating with the publisher.", 0,
4965        java.lang.Integer.MAX_VALUE, contact));
4966    children.add(new Property("description", "markdown",
4967        "A free text natural language description of the terminology capabilities from a consumer's perspective. Typically, this is used when the capability statement describes a desired rather than an actual solution, for example as a formal expression of requirements as part of an RFP.",
4968        0, 1, description));
4969    children.add(new Property("useContext", "UsageContext",
4970        "The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate terminology capabilities instances.",
4971        0, java.lang.Integer.MAX_VALUE, useContext));
4972    children.add(new Property("jurisdiction", "CodeableConcept",
4973        "A legal or geographic region in which the terminology capabilities is intended to be used.", 0,
4974        java.lang.Integer.MAX_VALUE, jurisdiction));
4975    children.add(new Property("purpose", "markdown",
4976        "Explanation of why this terminology capabilities is needed and why it has been designed as it has.", 0, 1,
4977        purpose));
4978    children.add(new Property("copyright", "markdown",
4979        "A copyright statement relating to the terminology capabilities and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the terminology capabilities.",
4980        0, 1, copyright));
4981    children.add(new Property("kind", "code",
4982        "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).",
4983        0, 1, kind));
4984    children.add(new Property("software", "",
4985        "Software that is covered by this terminology capability statement.  It is used when the statement describes the capabilities of a particular software version, independent of an installation.",
4986        0, 1, software));
4987    children.add(new Property("implementation", "",
4988        "Identifies a specific implementation instance that is described by the terminology capability statement - i.e. a particular installation, rather than the capabilities of a software program.",
4989        0, 1, implementation));
4990    children.add(new Property("lockedDate", "boolean", "Whether the server supports lockedDate.", 0, 1, lockedDate));
4991    children.add(new Property("codeSystem", "",
4992        "Identifies a code system that is supported by the server. If there is a no code system URL, then this declares the general assumptions a client can make about support for any CodeSystem resource.",
4993        0, java.lang.Integer.MAX_VALUE, codeSystem));
4994    children.add(new Property("expansion", "",
4995        "Information about the [ValueSet/$expand](valueset-operation-expand.html) operation.", 0, 1, expansion));
4996    children.add(new Property("codeSearch", "code",
4997        "The degree to which the server supports the code search parameter on ValueSet, if it is supported.", 0, 1,
4998        codeSearch));
4999    children.add(new Property("validateCode", "",
5000        "Information about the [ValueSet/$validate-code](valueset-operation-validate-code.html) operation.", 0, 1,
5001        validateCode));
5002    children.add(new Property("translation", "",
5003        "Information about the [ConceptMap/$translate](conceptmap-operation-translate.html) operation.", 0, 1,
5004        translation));
5005    children.add(new Property("closure", "", "Whether the $closure operation is supported.", 0, 1, closure));
5006  }
5007
5008  @Override
5009  public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
5010    switch (_hash) {
5011    case 116079:
5012      /* url */ return new Property("url", "uri",
5013          "An absolute URI that is used to identify this terminology capabilities when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which at which an authoritative instance of this terminology capabilities is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the terminology capabilities is stored on different servers.",
5014          0, 1, url);
5015    case 351608024:
5016      /* version */ return new Property("version", "string",
5017          "The identifier that is used to identify this version of the terminology capabilities when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the terminology capabilities author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.",
5018          0, 1, version);
5019    case 3373707:
5020      /* name */ return new Property("name", "string",
5021          "A natural language name identifying the terminology capabilities. This name should be usable as an identifier for the module by machine processing applications such as code generation.",
5022          0, 1, name);
5023    case 110371416:
5024      /* title */ return new Property("title", "string",
5025          "A short, descriptive, user-friendly title for the terminology capabilities.", 0, 1, title);
5026    case -892481550:
5027      /* status */ return new Property("status", "code",
5028          "The status of this terminology capabilities. Enables tracking the life-cycle of the content.", 0, 1, status);
5029    case -404562712:
5030      /* experimental */ return new Property("experimental", "boolean",
5031          "A Boolean value to indicate that this terminology capabilities is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.",
5032          0, 1, experimental);
5033    case 3076014:
5034      /* date */ return new Property("date", "dateTime",
5035          "The date  (and optionally time) when the terminology capabilities was published. The date must change when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the terminology capabilities changes.",
5036          0, 1, date);
5037    case 1447404028:
5038      /* publisher */ return new Property("publisher", "string",
5039          "The name of the organization or individual that published the terminology capabilities.", 0, 1, publisher);
5040    case 951526432:
5041      /* contact */ return new Property("contact", "ContactDetail",
5042          "Contact details to assist a user in finding and communicating with the publisher.", 0,
5043          java.lang.Integer.MAX_VALUE, contact);
5044    case -1724546052:
5045      /* description */ return new Property("description", "markdown",
5046          "A free text natural language description of the terminology capabilities from a consumer's perspective. Typically, this is used when the capability statement describes a desired rather than an actual solution, for example as a formal expression of requirements as part of an RFP.",
5047          0, 1, description);
5048    case -669707736:
5049      /* useContext */ return new Property("useContext", "UsageContext",
5050          "The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate terminology capabilities instances.",
5051          0, java.lang.Integer.MAX_VALUE, useContext);
5052    case -507075711:
5053      /* jurisdiction */ return new Property("jurisdiction", "CodeableConcept",
5054          "A legal or geographic region in which the terminology capabilities is intended to be used.", 0,
5055          java.lang.Integer.MAX_VALUE, jurisdiction);
5056    case -220463842:
5057      /* purpose */ return new Property("purpose", "markdown",
5058          "Explanation of why this terminology capabilities is needed and why it has been designed as it has.", 0, 1,
5059          purpose);
5060    case 1522889671:
5061      /* copyright */ return new Property("copyright", "markdown",
5062          "A copyright statement relating to the terminology capabilities and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the terminology capabilities.",
5063          0, 1, copyright);
5064    case 3292052:
5065      /* kind */ return new Property("kind", "code",
5066          "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).",
5067          0, 1, kind);
5068    case 1319330215:
5069      /* software */ return new Property("software", "",
5070          "Software that is covered by this terminology capability statement.  It is used when the statement describes the capabilities of a particular software version, independent of an installation.",
5071          0, 1, software);
5072    case 1683336114:
5073      /* implementation */ return new Property("implementation", "",
5074          "Identifies a specific implementation instance that is described by the terminology capability statement - i.e. a particular installation, rather than the capabilities of a software program.",
5075          0, 1, implementation);
5076    case 1391591896:
5077      /* lockedDate */ return new Property("lockedDate", "boolean", "Whether the server supports lockedDate.", 0, 1,
5078          lockedDate);
5079    case -916511108:
5080      /* codeSystem */ return new Property("codeSystem", "",
5081          "Identifies a code system that is supported by the server. If there is a no code system URL, then this declares the general assumptions a client can make about support for any CodeSystem resource.",
5082          0, java.lang.Integer.MAX_VALUE, codeSystem);
5083    case 17878207:
5084      /* expansion */ return new Property("expansion", "",
5085          "Information about the [ValueSet/$expand](valueset-operation-expand.html) operation.", 0, 1, expansion);
5086    case -935519755:
5087      /* codeSearch */ return new Property("codeSearch", "code",
5088          "The degree to which the server supports the code search parameter on ValueSet, if it is supported.", 0, 1,
5089          codeSearch);
5090    case 1080737827:
5091      /* validateCode */ return new Property("validateCode", "",
5092          "Information about the [ValueSet/$validate-code](valueset-operation-validate-code.html) operation.", 0, 1,
5093          validateCode);
5094    case -1840647503:
5095      /* translation */ return new Property("translation", "",
5096          "Information about the [ConceptMap/$translate](conceptmap-operation-translate.html) operation.", 0, 1,
5097          translation);
5098    case 866552379:
5099      /* closure */ return new Property("closure", "", "Whether the $closure operation is supported.", 0, 1, closure);
5100    default:
5101      return super.getNamedProperty(_hash, _name, _checkValid);
5102    }
5103
5104  }
5105
5106  @Override
5107  public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
5108    switch (hash) {
5109    case 116079:
5110      /* url */ return this.url == null ? new Base[0] : new Base[] { this.url }; // UriType
5111    case 351608024:
5112      /* version */ return this.version == null ? new Base[0] : new Base[] { this.version }; // StringType
5113    case 3373707:
5114      /* name */ return this.name == null ? new Base[0] : new Base[] { this.name }; // StringType
5115    case 110371416:
5116      /* title */ return this.title == null ? new Base[0] : new Base[] { this.title }; // StringType
5117    case -892481550:
5118      /* status */ return this.status == null ? new Base[0] : new Base[] { this.status }; // Enumeration<PublicationStatus>
5119    case -404562712:
5120      /* experimental */ return this.experimental == null ? new Base[0] : new Base[] { this.experimental }; // BooleanType
5121    case 3076014:
5122      /* date */ return this.date == null ? new Base[0] : new Base[] { this.date }; // DateTimeType
5123    case 1447404028:
5124      /* publisher */ return this.publisher == null ? new Base[0] : new Base[] { this.publisher }; // StringType
5125    case 951526432:
5126      /* contact */ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail
5127    case -1724546052:
5128      /* description */ return this.description == null ? new Base[0] : new Base[] { this.description }; // MarkdownType
5129    case -669707736:
5130      /* useContext */ return this.useContext == null ? new Base[0]
5131          : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext
5132    case -507075711:
5133      /* jurisdiction */ return this.jurisdiction == null ? new Base[0]
5134          : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept
5135    case -220463842:
5136      /* purpose */ return this.purpose == null ? new Base[0] : new Base[] { this.purpose }; // MarkdownType
5137    case 1522889671:
5138      /* copyright */ return this.copyright == null ? new Base[0] : new Base[] { this.copyright }; // MarkdownType
5139    case 3292052:
5140      /* kind */ return this.kind == null ? new Base[0] : new Base[] { this.kind }; // Enumeration<CapabilityStatementKind>
5141    case 1319330215:
5142      /* software */ return this.software == null ? new Base[0] : new Base[] { this.software }; // TerminologyCapabilitiesSoftwareComponent
5143    case 1683336114:
5144      /* implementation */ return this.implementation == null ? new Base[0] : new Base[] { this.implementation }; // TerminologyCapabilitiesImplementationComponent
5145    case 1391591896:
5146      /* lockedDate */ return this.lockedDate == null ? new Base[0] : new Base[] { this.lockedDate }; // BooleanType
5147    case -916511108:
5148      /* codeSystem */ return this.codeSystem == null ? new Base[0]
5149          : this.codeSystem.toArray(new Base[this.codeSystem.size()]); // TerminologyCapabilitiesCodeSystemComponent
5150    case 17878207:
5151      /* expansion */ return this.expansion == null ? new Base[0] : new Base[] { this.expansion }; // TerminologyCapabilitiesExpansionComponent
5152    case -935519755:
5153      /* codeSearch */ return this.codeSearch == null ? new Base[0] : new Base[] { this.codeSearch }; // Enumeration<CodeSearchSupport>
5154    case 1080737827:
5155      /* validateCode */ return this.validateCode == null ? new Base[0] : new Base[] { this.validateCode }; // TerminologyCapabilitiesValidateCodeComponent
5156    case -1840647503:
5157      /* translation */ return this.translation == null ? new Base[0] : new Base[] { this.translation }; // TerminologyCapabilitiesTranslationComponent
5158    case 866552379:
5159      /* closure */ return this.closure == null ? new Base[0] : new Base[] { this.closure }; // TerminologyCapabilitiesClosureComponent
5160    default:
5161      return super.getProperty(hash, name, checkValid);
5162    }
5163
5164  }
5165
5166  @Override
5167  public Base setProperty(int hash, String name, Base value) throws FHIRException {
5168    switch (hash) {
5169    case 116079: // url
5170      this.url = castToUri(value); // UriType
5171      return value;
5172    case 351608024: // version
5173      this.version = castToString(value); // StringType
5174      return value;
5175    case 3373707: // name
5176      this.name = castToString(value); // StringType
5177      return value;
5178    case 110371416: // title
5179      this.title = castToString(value); // StringType
5180      return value;
5181    case -892481550: // status
5182      value = new PublicationStatusEnumFactory().fromType(castToCode(value));
5183      this.status = (Enumeration) value; // Enumeration<PublicationStatus>
5184      return value;
5185    case -404562712: // experimental
5186      this.experimental = castToBoolean(value); // BooleanType
5187      return value;
5188    case 3076014: // date
5189      this.date = castToDateTime(value); // DateTimeType
5190      return value;
5191    case 1447404028: // publisher
5192      this.publisher = castToString(value); // StringType
5193      return value;
5194    case 951526432: // contact
5195      this.getContact().add(castToContactDetail(value)); // ContactDetail
5196      return value;
5197    case -1724546052: // description
5198      this.description = castToMarkdown(value); // MarkdownType
5199      return value;
5200    case -669707736: // useContext
5201      this.getUseContext().add(castToUsageContext(value)); // UsageContext
5202      return value;
5203    case -507075711: // jurisdiction
5204      this.getJurisdiction().add(castToCodeableConcept(value)); // CodeableConcept
5205      return value;
5206    case -220463842: // purpose
5207      this.purpose = castToMarkdown(value); // MarkdownType
5208      return value;
5209    case 1522889671: // copyright
5210      this.copyright = castToMarkdown(value); // MarkdownType
5211      return value;
5212    case 3292052: // kind
5213      value = new CapabilityStatementKindEnumFactory().fromType(castToCode(value));
5214      this.kind = (Enumeration) value; // Enumeration<CapabilityStatementKind>
5215      return value;
5216    case 1319330215: // software
5217      this.software = (TerminologyCapabilitiesSoftwareComponent) value; // TerminologyCapabilitiesSoftwareComponent
5218      return value;
5219    case 1683336114: // implementation
5220      this.implementation = (TerminologyCapabilitiesImplementationComponent) value; // TerminologyCapabilitiesImplementationComponent
5221      return value;
5222    case 1391591896: // lockedDate
5223      this.lockedDate = castToBoolean(value); // BooleanType
5224      return value;
5225    case -916511108: // codeSystem
5226      this.getCodeSystem().add((TerminologyCapabilitiesCodeSystemComponent) value); // TerminologyCapabilitiesCodeSystemComponent
5227      return value;
5228    case 17878207: // expansion
5229      this.expansion = (TerminologyCapabilitiesExpansionComponent) value; // TerminologyCapabilitiesExpansionComponent
5230      return value;
5231    case -935519755: // codeSearch
5232      value = new CodeSearchSupportEnumFactory().fromType(castToCode(value));
5233      this.codeSearch = (Enumeration) value; // Enumeration<CodeSearchSupport>
5234      return value;
5235    case 1080737827: // validateCode
5236      this.validateCode = (TerminologyCapabilitiesValidateCodeComponent) value; // TerminologyCapabilitiesValidateCodeComponent
5237      return value;
5238    case -1840647503: // translation
5239      this.translation = (TerminologyCapabilitiesTranslationComponent) value; // TerminologyCapabilitiesTranslationComponent
5240      return value;
5241    case 866552379: // closure
5242      this.closure = (TerminologyCapabilitiesClosureComponent) value; // TerminologyCapabilitiesClosureComponent
5243      return value;
5244    default:
5245      return super.setProperty(hash, name, value);
5246    }
5247
5248  }
5249
5250  @Override
5251  public Base setProperty(String name, Base value) throws FHIRException {
5252    if (name.equals("url")) {
5253      this.url = castToUri(value); // UriType
5254    } else if (name.equals("version")) {
5255      this.version = castToString(value); // StringType
5256    } else if (name.equals("name")) {
5257      this.name = castToString(value); // StringType
5258    } else if (name.equals("title")) {
5259      this.title = castToString(value); // StringType
5260    } else if (name.equals("status")) {
5261      value = new PublicationStatusEnumFactory().fromType(castToCode(value));
5262      this.status = (Enumeration) value; // Enumeration<PublicationStatus>
5263    } else if (name.equals("experimental")) {
5264      this.experimental = castToBoolean(value); // BooleanType
5265    } else if (name.equals("date")) {
5266      this.date = castToDateTime(value); // DateTimeType
5267    } else if (name.equals("publisher")) {
5268      this.publisher = castToString(value); // StringType
5269    } else if (name.equals("contact")) {
5270      this.getContact().add(castToContactDetail(value));
5271    } else if (name.equals("description")) {
5272      this.description = castToMarkdown(value); // MarkdownType
5273    } else if (name.equals("useContext")) {
5274      this.getUseContext().add(castToUsageContext(value));
5275    } else if (name.equals("jurisdiction")) {
5276      this.getJurisdiction().add(castToCodeableConcept(value));
5277    } else if (name.equals("purpose")) {
5278      this.purpose = castToMarkdown(value); // MarkdownType
5279    } else if (name.equals("copyright")) {
5280      this.copyright = castToMarkdown(value); // MarkdownType
5281    } else if (name.equals("kind")) {
5282      value = new CapabilityStatementKindEnumFactory().fromType(castToCode(value));
5283      this.kind = (Enumeration) value; // Enumeration<CapabilityStatementKind>
5284    } else if (name.equals("software")) {
5285      this.software = (TerminologyCapabilitiesSoftwareComponent) value; // TerminologyCapabilitiesSoftwareComponent
5286    } else if (name.equals("implementation")) {
5287      this.implementation = (TerminologyCapabilitiesImplementationComponent) value; // TerminologyCapabilitiesImplementationComponent
5288    } else if (name.equals("lockedDate")) {
5289      this.lockedDate = castToBoolean(value); // BooleanType
5290    } else if (name.equals("codeSystem")) {
5291      this.getCodeSystem().add((TerminologyCapabilitiesCodeSystemComponent) value);
5292    } else if (name.equals("expansion")) {
5293      this.expansion = (TerminologyCapabilitiesExpansionComponent) value; // TerminologyCapabilitiesExpansionComponent
5294    } else if (name.equals("codeSearch")) {
5295      value = new CodeSearchSupportEnumFactory().fromType(castToCode(value));
5296      this.codeSearch = (Enumeration) value; // Enumeration<CodeSearchSupport>
5297    } else if (name.equals("validateCode")) {
5298      this.validateCode = (TerminologyCapabilitiesValidateCodeComponent) value; // TerminologyCapabilitiesValidateCodeComponent
5299    } else if (name.equals("translation")) {
5300      this.translation = (TerminologyCapabilitiesTranslationComponent) value; // TerminologyCapabilitiesTranslationComponent
5301    } else if (name.equals("closure")) {
5302      this.closure = (TerminologyCapabilitiesClosureComponent) value; // TerminologyCapabilitiesClosureComponent
5303    } else
5304      return super.setProperty(name, value);
5305    return value;
5306  }
5307
5308  @Override
5309  public Base makeProperty(int hash, String name) throws FHIRException {
5310    switch (hash) {
5311    case 116079:
5312      return getUrlElement();
5313    case 351608024:
5314      return getVersionElement();
5315    case 3373707:
5316      return getNameElement();
5317    case 110371416:
5318      return getTitleElement();
5319    case -892481550:
5320      return getStatusElement();
5321    case -404562712:
5322      return getExperimentalElement();
5323    case 3076014:
5324      return getDateElement();
5325    case 1447404028:
5326      return getPublisherElement();
5327    case 951526432:
5328      return addContact();
5329    case -1724546052:
5330      return getDescriptionElement();
5331    case -669707736:
5332      return addUseContext();
5333    case -507075711:
5334      return addJurisdiction();
5335    case -220463842:
5336      return getPurposeElement();
5337    case 1522889671:
5338      return getCopyrightElement();
5339    case 3292052:
5340      return getKindElement();
5341    case 1319330215:
5342      return getSoftware();
5343    case 1683336114:
5344      return getImplementation();
5345    case 1391591896:
5346      return getLockedDateElement();
5347    case -916511108:
5348      return addCodeSystem();
5349    case 17878207:
5350      return getExpansion();
5351    case -935519755:
5352      return getCodeSearchElement();
5353    case 1080737827:
5354      return getValidateCode();
5355    case -1840647503:
5356      return getTranslation();
5357    case 866552379:
5358      return getClosure();
5359    default:
5360      return super.makeProperty(hash, name);
5361    }
5362
5363  }
5364
5365  @Override
5366  public String[] getTypesForProperty(int hash, String name) throws FHIRException {
5367    switch (hash) {
5368    case 116079:
5369      /* url */ return new String[] { "uri" };
5370    case 351608024:
5371      /* version */ return new String[] { "string" };
5372    case 3373707:
5373      /* name */ return new String[] { "string" };
5374    case 110371416:
5375      /* title */ return new String[] { "string" };
5376    case -892481550:
5377      /* status */ return new String[] { "code" };
5378    case -404562712:
5379      /* experimental */ return new String[] { "boolean" };
5380    case 3076014:
5381      /* date */ return new String[] { "dateTime" };
5382    case 1447404028:
5383      /* publisher */ return new String[] { "string" };
5384    case 951526432:
5385      /* contact */ return new String[] { "ContactDetail" };
5386    case -1724546052:
5387      /* description */ return new String[] { "markdown" };
5388    case -669707736:
5389      /* useContext */ return new String[] { "UsageContext" };
5390    case -507075711:
5391      /* jurisdiction */ return new String[] { "CodeableConcept" };
5392    case -220463842:
5393      /* purpose */ return new String[] { "markdown" };
5394    case 1522889671:
5395      /* copyright */ return new String[] { "markdown" };
5396    case 3292052:
5397      /* kind */ return new String[] { "code" };
5398    case 1319330215:
5399      /* software */ return new String[] {};
5400    case 1683336114:
5401      /* implementation */ return new String[] {};
5402    case 1391591896:
5403      /* lockedDate */ return new String[] { "boolean" };
5404    case -916511108:
5405      /* codeSystem */ return new String[] {};
5406    case 17878207:
5407      /* expansion */ return new String[] {};
5408    case -935519755:
5409      /* codeSearch */ return new String[] { "code" };
5410    case 1080737827:
5411      /* validateCode */ return new String[] {};
5412    case -1840647503:
5413      /* translation */ return new String[] {};
5414    case 866552379:
5415      /* closure */ return new String[] {};
5416    default:
5417      return super.getTypesForProperty(hash, name);
5418    }
5419
5420  }
5421
5422  @Override
5423  public Base addChild(String name) throws FHIRException {
5424    if (name.equals("url")) {
5425      throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.url");
5426    } else if (name.equals("version")) {
5427      throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.version");
5428    } else if (name.equals("name")) {
5429      throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.name");
5430    } else if (name.equals("title")) {
5431      throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.title");
5432    } else if (name.equals("status")) {
5433      throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.status");
5434    } else if (name.equals("experimental")) {
5435      throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.experimental");
5436    } else if (name.equals("date")) {
5437      throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.date");
5438    } else if (name.equals("publisher")) {
5439      throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.publisher");
5440    } else if (name.equals("contact")) {
5441      return addContact();
5442    } else if (name.equals("description")) {
5443      throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.description");
5444    } else if (name.equals("useContext")) {
5445      return addUseContext();
5446    } else if (name.equals("jurisdiction")) {
5447      return addJurisdiction();
5448    } else if (name.equals("purpose")) {
5449      throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.purpose");
5450    } else if (name.equals("copyright")) {
5451      throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.copyright");
5452    } else if (name.equals("kind")) {
5453      throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.kind");
5454    } else if (name.equals("software")) {
5455      this.software = new TerminologyCapabilitiesSoftwareComponent();
5456      return this.software;
5457    } else if (name.equals("implementation")) {
5458      this.implementation = new TerminologyCapabilitiesImplementationComponent();
5459      return this.implementation;
5460    } else if (name.equals("lockedDate")) {
5461      throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.lockedDate");
5462    } else if (name.equals("codeSystem")) {
5463      return addCodeSystem();
5464    } else if (name.equals("expansion")) {
5465      this.expansion = new TerminologyCapabilitiesExpansionComponent();
5466      return this.expansion;
5467    } else if (name.equals("codeSearch")) {
5468      throw new FHIRException("Cannot call addChild on a singleton property TerminologyCapabilities.codeSearch");
5469    } else if (name.equals("validateCode")) {
5470      this.validateCode = new TerminologyCapabilitiesValidateCodeComponent();
5471      return this.validateCode;
5472    } else if (name.equals("translation")) {
5473      this.translation = new TerminologyCapabilitiesTranslationComponent();
5474      return this.translation;
5475    } else if (name.equals("closure")) {
5476      this.closure = new TerminologyCapabilitiesClosureComponent();
5477      return this.closure;
5478    } else
5479      return super.addChild(name);
5480  }
5481
5482  public String fhirType() {
5483    return "TerminologyCapabilities";
5484
5485  }
5486
5487  public TerminologyCapabilities copy() {
5488    TerminologyCapabilities dst = new TerminologyCapabilities();
5489    copyValues(dst);
5490    return dst;
5491  }
5492
5493  public void copyValues(TerminologyCapabilities dst) {
5494    super.copyValues(dst);
5495    dst.url = url == null ? null : url.copy();
5496    dst.version = version == null ? null : version.copy();
5497    dst.name = name == null ? null : name.copy();
5498    dst.title = title == null ? null : title.copy();
5499    dst.status = status == null ? null : status.copy();
5500    dst.experimental = experimental == null ? null : experimental.copy();
5501    dst.date = date == null ? null : date.copy();
5502    dst.publisher = publisher == null ? null : publisher.copy();
5503    if (contact != null) {
5504      dst.contact = new ArrayList<ContactDetail>();
5505      for (ContactDetail i : contact)
5506        dst.contact.add(i.copy());
5507    }
5508    ;
5509    dst.description = description == null ? null : description.copy();
5510    if (useContext != null) {
5511      dst.useContext = new ArrayList<UsageContext>();
5512      for (UsageContext i : useContext)
5513        dst.useContext.add(i.copy());
5514    }
5515    ;
5516    if (jurisdiction != null) {
5517      dst.jurisdiction = new ArrayList<CodeableConcept>();
5518      for (CodeableConcept i : jurisdiction)
5519        dst.jurisdiction.add(i.copy());
5520    }
5521    ;
5522    dst.purpose = purpose == null ? null : purpose.copy();
5523    dst.copyright = copyright == null ? null : copyright.copy();
5524    dst.kind = kind == null ? null : kind.copy();
5525    dst.software = software == null ? null : software.copy();
5526    dst.implementation = implementation == null ? null : implementation.copy();
5527    dst.lockedDate = lockedDate == null ? null : lockedDate.copy();
5528    if (codeSystem != null) {
5529      dst.codeSystem = new ArrayList<TerminologyCapabilitiesCodeSystemComponent>();
5530      for (TerminologyCapabilitiesCodeSystemComponent i : codeSystem)
5531        dst.codeSystem.add(i.copy());
5532    }
5533    ;
5534    dst.expansion = expansion == null ? null : expansion.copy();
5535    dst.codeSearch = codeSearch == null ? null : codeSearch.copy();
5536    dst.validateCode = validateCode == null ? null : validateCode.copy();
5537    dst.translation = translation == null ? null : translation.copy();
5538    dst.closure = closure == null ? null : closure.copy();
5539  }
5540
5541  protected TerminologyCapabilities typedCopy() {
5542    return copy();
5543  }
5544
5545  @Override
5546  public boolean equalsDeep(Base other_) {
5547    if (!super.equalsDeep(other_))
5548      return false;
5549    if (!(other_ instanceof TerminologyCapabilities))
5550      return false;
5551    TerminologyCapabilities o = (TerminologyCapabilities) other_;
5552    return compareDeep(purpose, o.purpose, true) && compareDeep(copyright, o.copyright, true)
5553        && compareDeep(kind, o.kind, true) && compareDeep(software, o.software, true)
5554        && compareDeep(implementation, o.implementation, true) && compareDeep(lockedDate, o.lockedDate, true)
5555        && compareDeep(codeSystem, o.codeSystem, true) && compareDeep(expansion, o.expansion, true)
5556        && compareDeep(codeSearch, o.codeSearch, true) && compareDeep(validateCode, o.validateCode, true)
5557        && compareDeep(translation, o.translation, true) && compareDeep(closure, o.closure, true);
5558  }
5559
5560  @Override
5561  public boolean equalsShallow(Base other_) {
5562    if (!super.equalsShallow(other_))
5563      return false;
5564    if (!(other_ instanceof TerminologyCapabilities))
5565      return false;
5566    TerminologyCapabilities o = (TerminologyCapabilities) other_;
5567    return compareValues(purpose, o.purpose, true) && compareValues(copyright, o.copyright, true)
5568        && compareValues(kind, o.kind, true) && compareValues(lockedDate, o.lockedDate, true)
5569        && compareValues(codeSearch, o.codeSearch, true);
5570  }
5571
5572  public boolean isEmpty() {
5573    return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(purpose, copyright, kind, software, implementation,
5574        lockedDate, codeSystem, expansion, codeSearch, validateCode, translation, closure);
5575  }
5576
5577  @Override
5578  public ResourceType getResourceType() {
5579    return ResourceType.TerminologyCapabilities;
5580  }
5581
5582  /**
5583   * Search parameter: <b>date</b>
5584   * <p>
5585   * Description: <b>The terminology capabilities publication date</b><br>
5586   * Type: <b>date</b><br>
5587   * Path: <b>TerminologyCapabilities.date</b><br>
5588   * </p>
5589   */
5590  @SearchParamDefinition(name = "date", path = "TerminologyCapabilities.date", description = "The terminology capabilities publication date", type = "date")
5591  public static final String SP_DATE = "date";
5592  /**
5593   * <b>Fluent Client</b> search parameter constant for <b>date</b>
5594   * <p>
5595   * Description: <b>The terminology capabilities publication date</b><br>
5596   * Type: <b>date</b><br>
5597   * Path: <b>TerminologyCapabilities.date</b><br>
5598   * </p>
5599   */
5600  public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(
5601      SP_DATE);
5602
5603  /**
5604   * Search parameter: <b>context-type-value</b>
5605   * <p>
5606   * Description: <b>A use context type and value assigned to the terminology
5607   * capabilities</b><br>
5608   * Type: <b>composite</b><br>
5609   * Path: <b></b><br>
5610   * </p>
5611   */
5612  @SearchParamDefinition(name = "context-type-value", path = "TerminologyCapabilities.useContext", description = "A use context type and value assigned to the terminology capabilities", type = "composite", compositeOf = {
5613      "context-type", "context" })
5614  public static final String SP_CONTEXT_TYPE_VALUE = "context-type-value";
5615  /**
5616   * <b>Fluent Client</b> search parameter constant for <b>context-type-value</b>
5617   * <p>
5618   * Description: <b>A use context type and value assigned to the terminology
5619   * capabilities</b><br>
5620   * Type: <b>composite</b><br>
5621   * Path: <b></b><br>
5622   * </p>
5623   */
5624  public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.TokenClientParam> CONTEXT_TYPE_VALUE = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.TokenClientParam>(
5625      SP_CONTEXT_TYPE_VALUE);
5626
5627  /**
5628   * Search parameter: <b>jurisdiction</b>
5629   * <p>
5630   * Description: <b>Intended jurisdiction for the terminology
5631   * capabilities</b><br>
5632   * Type: <b>token</b><br>
5633   * Path: <b>TerminologyCapabilities.jurisdiction</b><br>
5634   * </p>
5635   */
5636  @SearchParamDefinition(name = "jurisdiction", path = "TerminologyCapabilities.jurisdiction", description = "Intended jurisdiction for the terminology capabilities", type = "token")
5637  public static final String SP_JURISDICTION = "jurisdiction";
5638  /**
5639   * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b>
5640   * <p>
5641   * Description: <b>Intended jurisdiction for the terminology
5642   * capabilities</b><br>
5643   * Type: <b>token</b><br>
5644   * Path: <b>TerminologyCapabilities.jurisdiction</b><br>
5645   * </p>
5646   */
5647  public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(
5648      SP_JURISDICTION);
5649
5650  /**
5651   * Search parameter: <b>description</b>
5652   * <p>
5653   * Description: <b>The description of the terminology capabilities</b><br>
5654   * Type: <b>string</b><br>
5655   * Path: <b>TerminologyCapabilities.description</b><br>
5656   * </p>
5657   */
5658  @SearchParamDefinition(name = "description", path = "TerminologyCapabilities.description", description = "The description of the terminology capabilities", type = "string")
5659  public static final String SP_DESCRIPTION = "description";
5660  /**
5661   * <b>Fluent Client</b> search parameter constant for <b>description</b>
5662   * <p>
5663   * Description: <b>The description of the terminology capabilities</b><br>
5664   * Type: <b>string</b><br>
5665   * Path: <b>TerminologyCapabilities.description</b><br>
5666   * </p>
5667   */
5668  public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(
5669      SP_DESCRIPTION);
5670
5671  /**
5672   * Search parameter: <b>context-type</b>
5673   * <p>
5674   * Description: <b>A type of use context assigned to the terminology
5675   * capabilities</b><br>
5676   * Type: <b>token</b><br>
5677   * Path: <b>TerminologyCapabilities.useContext.code</b><br>
5678   * </p>
5679   */
5680  @SearchParamDefinition(name = "context-type", path = "TerminologyCapabilities.useContext.code", description = "A type of use context assigned to the terminology capabilities", type = "token")
5681  public static final String SP_CONTEXT_TYPE = "context-type";
5682  /**
5683   * <b>Fluent Client</b> search parameter constant for <b>context-type</b>
5684   * <p>
5685   * Description: <b>A type of use context assigned to the terminology
5686   * capabilities</b><br>
5687   * Type: <b>token</b><br>
5688   * Path: <b>TerminologyCapabilities.useContext.code</b><br>
5689   * </p>
5690   */
5691  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT_TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(
5692      SP_CONTEXT_TYPE);
5693
5694  /**
5695   * Search parameter: <b>title</b>
5696   * <p>
5697   * Description: <b>The human-friendly name of the terminology
5698   * capabilities</b><br>
5699   * Type: <b>string</b><br>
5700   * Path: <b>TerminologyCapabilities.title</b><br>
5701   * </p>
5702   */
5703  @SearchParamDefinition(name = "title", path = "TerminologyCapabilities.title", description = "The human-friendly name of the terminology capabilities", type = "string")
5704  public static final String SP_TITLE = "title";
5705  /**
5706   * <b>Fluent Client</b> search parameter constant for <b>title</b>
5707   * <p>
5708   * Description: <b>The human-friendly name of the terminology
5709   * capabilities</b><br>
5710   * Type: <b>string</b><br>
5711   * Path: <b>TerminologyCapabilities.title</b><br>
5712   * </p>
5713   */
5714  public static final ca.uhn.fhir.rest.gclient.StringClientParam TITLE = new ca.uhn.fhir.rest.gclient.StringClientParam(
5715      SP_TITLE);
5716
5717  /**
5718   * Search parameter: <b>version</b>
5719   * <p>
5720   * Description: <b>The business version of the terminology capabilities</b><br>
5721   * Type: <b>token</b><br>
5722   * Path: <b>TerminologyCapabilities.version</b><br>
5723   * </p>
5724   */
5725  @SearchParamDefinition(name = "version", path = "TerminologyCapabilities.version", description = "The business version of the terminology capabilities", type = "token")
5726  public static final String SP_VERSION = "version";
5727  /**
5728   * <b>Fluent Client</b> search parameter constant for <b>version</b>
5729   * <p>
5730   * Description: <b>The business version of the terminology capabilities</b><br>
5731   * Type: <b>token</b><br>
5732   * Path: <b>TerminologyCapabilities.version</b><br>
5733   * </p>
5734   */
5735  public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(
5736      SP_VERSION);
5737
5738  /**
5739   * Search parameter: <b>url</b>
5740   * <p>
5741   * Description: <b>The uri that identifies the terminology capabilities</b><br>
5742   * Type: <b>uri</b><br>
5743   * Path: <b>TerminologyCapabilities.url</b><br>
5744   * </p>
5745   */
5746  @SearchParamDefinition(name = "url", path = "TerminologyCapabilities.url", description = "The uri that identifies the terminology capabilities", type = "uri")
5747  public static final String SP_URL = "url";
5748  /**
5749   * <b>Fluent Client</b> search parameter constant for <b>url</b>
5750   * <p>
5751   * Description: <b>The uri that identifies the terminology capabilities</b><br>
5752   * Type: <b>uri</b><br>
5753   * Path: <b>TerminologyCapabilities.url</b><br>
5754   * </p>
5755   */
5756  public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL);
5757
5758  /**
5759   * Search parameter: <b>context-quantity</b>
5760   * <p>
5761   * Description: <b>A quantity- or range-valued use context assigned to the
5762   * terminology capabilities</b><br>
5763   * Type: <b>quantity</b><br>
5764   * Path: <b>TerminologyCapabilities.useContext.valueQuantity,
5765   * TerminologyCapabilities.useContext.valueRange</b><br>
5766   * </p>
5767   */
5768  @SearchParamDefinition(name = "context-quantity", path = "(TerminologyCapabilities.useContext.value as Quantity) | (TerminologyCapabilities.useContext.value as Range)", description = "A quantity- or range-valued use context assigned to the terminology capabilities", type = "quantity")
5769  public static final String SP_CONTEXT_QUANTITY = "context-quantity";
5770  /**
5771   * <b>Fluent Client</b> search parameter constant for <b>context-quantity</b>
5772   * <p>
5773   * Description: <b>A quantity- or range-valued use context assigned to the
5774   * terminology capabilities</b><br>
5775   * Type: <b>quantity</b><br>
5776   * Path: <b>TerminologyCapabilities.useContext.valueQuantity,
5777   * TerminologyCapabilities.useContext.valueRange</b><br>
5778   * </p>
5779   */
5780  public static final ca.uhn.fhir.rest.gclient.QuantityClientParam CONTEXT_QUANTITY = new ca.uhn.fhir.rest.gclient.QuantityClientParam(
5781      SP_CONTEXT_QUANTITY);
5782
5783  /**
5784   * Search parameter: <b>name</b>
5785   * <p>
5786   * Description: <b>Computationally friendly name of the terminology
5787   * capabilities</b><br>
5788   * Type: <b>string</b><br>
5789   * Path: <b>TerminologyCapabilities.name</b><br>
5790   * </p>
5791   */
5792  @SearchParamDefinition(name = "name", path = "TerminologyCapabilities.name", description = "Computationally friendly name of the terminology capabilities", type = "string")
5793  public static final String SP_NAME = "name";
5794  /**
5795   * <b>Fluent Client</b> search parameter constant for <b>name</b>
5796   * <p>
5797   * Description: <b>Computationally friendly name of the terminology
5798   * capabilities</b><br>
5799   * Type: <b>string</b><br>
5800   * Path: <b>TerminologyCapabilities.name</b><br>
5801   * </p>
5802   */
5803  public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(
5804      SP_NAME);
5805
5806  /**
5807   * Search parameter: <b>context</b>
5808   * <p>
5809   * Description: <b>A use context assigned to the terminology
5810   * capabilities</b><br>
5811   * Type: <b>token</b><br>
5812   * Path: <b>TerminologyCapabilities.useContext.valueCodeableConcept</b><br>
5813   * </p>
5814   */
5815  @SearchParamDefinition(name = "context", path = "(TerminologyCapabilities.useContext.value as CodeableConcept)", description = "A use context assigned to the terminology capabilities", type = "token")
5816  public static final String SP_CONTEXT = "context";
5817  /**
5818   * <b>Fluent Client</b> search parameter constant for <b>context</b>
5819   * <p>
5820   * Description: <b>A use context assigned to the terminology
5821   * capabilities</b><br>
5822   * Type: <b>token</b><br>
5823   * Path: <b>TerminologyCapabilities.useContext.valueCodeableConcept</b><br>
5824   * </p>
5825   */
5826  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT = new ca.uhn.fhir.rest.gclient.TokenClientParam(
5827      SP_CONTEXT);
5828
5829  /**
5830   * Search parameter: <b>publisher</b>
5831   * <p>
5832   * Description: <b>Name of the publisher of the terminology capabilities</b><br>
5833   * Type: <b>string</b><br>
5834   * Path: <b>TerminologyCapabilities.publisher</b><br>
5835   * </p>
5836   */
5837  @SearchParamDefinition(name = "publisher", path = "TerminologyCapabilities.publisher", description = "Name of the publisher of the terminology capabilities", type = "string")
5838  public static final String SP_PUBLISHER = "publisher";
5839  /**
5840   * <b>Fluent Client</b> search parameter constant for <b>publisher</b>
5841   * <p>
5842   * Description: <b>Name of the publisher of the terminology capabilities</b><br>
5843   * Type: <b>string</b><br>
5844   * Path: <b>TerminologyCapabilities.publisher</b><br>
5845   * </p>
5846   */
5847  public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(
5848      SP_PUBLISHER);
5849
5850  /**
5851   * Search parameter: <b>context-type-quantity</b>
5852   * <p>
5853   * Description: <b>A use context type and quantity- or range-based value
5854   * assigned to the terminology capabilities</b><br>
5855   * Type: <b>composite</b><br>
5856   * Path: <b></b><br>
5857   * </p>
5858   */
5859  @SearchParamDefinition(name = "context-type-quantity", path = "TerminologyCapabilities.useContext", description = "A use context type and quantity- or range-based value assigned to the terminology capabilities", type = "composite", compositeOf = {
5860      "context-type", "context-quantity" })
5861  public static final String SP_CONTEXT_TYPE_QUANTITY = "context-type-quantity";
5862  /**
5863   * <b>Fluent Client</b> search parameter constant for
5864   * <b>context-type-quantity</b>
5865   * <p>
5866   * Description: <b>A use context type and quantity- or range-based value
5867   * assigned to the terminology capabilities</b><br>
5868   * Type: <b>composite</b><br>
5869   * Path: <b></b><br>
5870   * </p>
5871   */
5872  public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.QuantityClientParam> CONTEXT_TYPE_QUANTITY = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.QuantityClientParam>(
5873      SP_CONTEXT_TYPE_QUANTITY);
5874
5875  /**
5876   * Search parameter: <b>status</b>
5877   * <p>
5878   * Description: <b>The current status of the terminology capabilities</b><br>
5879   * Type: <b>token</b><br>
5880   * Path: <b>TerminologyCapabilities.status</b><br>
5881   * </p>
5882   */
5883  @SearchParamDefinition(name = "status", path = "TerminologyCapabilities.status", description = "The current status of the terminology capabilities", type = "token")
5884  public static final String SP_STATUS = "status";
5885  /**
5886   * <b>Fluent Client</b> search parameter constant for <b>status</b>
5887   * <p>
5888   * Description: <b>The current status of the terminology capabilities</b><br>
5889   * Type: <b>token</b><br>
5890   * Path: <b>TerminologyCapabilities.status</b><br>
5891   * </p>
5892   */
5893  public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(
5894      SP_STATUS);
5895
5896}