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