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 Thu, Mar 23, 2023 19:59+1100 for FHIR v5.0.0
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
050import org.hl7.fhir.instance.model.api.IBaseConformance;
051/**
052 * A Capability Statement documents a set of capabilities (behaviors) of a FHIR Server or Client 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.
053 */
054@ResourceDef(name="CapabilityStatement", profile="http://hl7.org/fhir/StructureDefinition/CapabilityStatement")
055public class CapabilityStatement extends CanonicalResource implements IBaseConformance {
056
057    public enum ConditionalDeleteStatus {
058        /**
059         * No support for conditional deletes.
060         */
061        NOTSUPPORTED, 
062        /**
063         * Conditional deletes are supported, but only single resources at a time.
064         */
065        SINGLE, 
066        /**
067         * Conditional deletes are supported, and multiple resources can be deleted in a single interaction.
068         */
069        MULTIPLE, 
070        /**
071         * added to help the parsers with the generic types
072         */
073        NULL;
074        public static ConditionalDeleteStatus fromCode(String codeString) throws FHIRException {
075            if (codeString == null || "".equals(codeString))
076                return null;
077        if ("not-supported".equals(codeString))
078          return NOTSUPPORTED;
079        if ("single".equals(codeString))
080          return SINGLE;
081        if ("multiple".equals(codeString))
082          return MULTIPLE;
083        if (Configuration.isAcceptInvalidEnums())
084          return null;
085        else
086          throw new FHIRException("Unknown ConditionalDeleteStatus code '"+codeString+"'");
087        }
088        public String toCode() {
089          switch (this) {
090            case NOTSUPPORTED: return "not-supported";
091            case SINGLE: return "single";
092            case MULTIPLE: return "multiple";
093            case NULL: return null;
094            default: return "?";
095          }
096        }
097        public String getSystem() {
098          switch (this) {
099            case NOTSUPPORTED: return "http://hl7.org/fhir/conditional-delete-status";
100            case SINGLE: return "http://hl7.org/fhir/conditional-delete-status";
101            case MULTIPLE: return "http://hl7.org/fhir/conditional-delete-status";
102            case NULL: return null;
103            default: return "?";
104          }
105        }
106        public String getDefinition() {
107          switch (this) {
108            case NOTSUPPORTED: return "No support for conditional deletes.";
109            case SINGLE: return "Conditional deletes are supported, but only single resources at a time.";
110            case MULTIPLE: return "Conditional deletes are supported, and multiple resources can be deleted in a single interaction.";
111            case NULL: return null;
112            default: return "?";
113          }
114        }
115        public String getDisplay() {
116          switch (this) {
117            case NOTSUPPORTED: return "Not Supported";
118            case SINGLE: return "Single Deletes Supported";
119            case MULTIPLE: return "Multiple Deletes Supported";
120            case NULL: return null;
121            default: return "?";
122          }
123        }
124    }
125
126  public static class ConditionalDeleteStatusEnumFactory implements EnumFactory<ConditionalDeleteStatus> {
127    public ConditionalDeleteStatus fromCode(String codeString) throws IllegalArgumentException {
128      if (codeString == null || "".equals(codeString))
129            if (codeString == null || "".equals(codeString))
130                return null;
131        if ("not-supported".equals(codeString))
132          return ConditionalDeleteStatus.NOTSUPPORTED;
133        if ("single".equals(codeString))
134          return ConditionalDeleteStatus.SINGLE;
135        if ("multiple".equals(codeString))
136          return ConditionalDeleteStatus.MULTIPLE;
137        throw new IllegalArgumentException("Unknown ConditionalDeleteStatus code '"+codeString+"'");
138        }
139        public Enumeration<ConditionalDeleteStatus> fromType(PrimitiveType<?> code) throws FHIRException {
140          if (code == null)
141            return null;
142          if (code.isEmpty())
143            return new Enumeration<ConditionalDeleteStatus>(this, ConditionalDeleteStatus.NULL, code);
144          String codeString = ((PrimitiveType) code).asStringValue();
145          if (codeString == null || "".equals(codeString))
146            return new Enumeration<ConditionalDeleteStatus>(this, ConditionalDeleteStatus.NULL, code);
147        if ("not-supported".equals(codeString))
148          return new Enumeration<ConditionalDeleteStatus>(this, ConditionalDeleteStatus.NOTSUPPORTED, code);
149        if ("single".equals(codeString))
150          return new Enumeration<ConditionalDeleteStatus>(this, ConditionalDeleteStatus.SINGLE, code);
151        if ("multiple".equals(codeString))
152          return new Enumeration<ConditionalDeleteStatus>(this, ConditionalDeleteStatus.MULTIPLE, code);
153        throw new FHIRException("Unknown ConditionalDeleteStatus code '"+codeString+"'");
154        }
155    public String toCode(ConditionalDeleteStatus code) {
156      if (code == ConditionalDeleteStatus.NOTSUPPORTED)
157        return "not-supported";
158      if (code == ConditionalDeleteStatus.SINGLE)
159        return "single";
160      if (code == ConditionalDeleteStatus.MULTIPLE)
161        return "multiple";
162      return "?";
163      }
164    public String toSystem(ConditionalDeleteStatus code) {
165      return code.getSystem();
166      }
167    }
168
169    public enum ConditionalReadStatus {
170        /**
171         * No support for conditional reads.
172         */
173        NOTSUPPORTED, 
174        /**
175         * Conditional reads are supported, but only with the If-Modified-Since HTTP Header.
176         */
177        MODIFIEDSINCE, 
178        /**
179         * Conditional reads are supported, but only with the If-None-Match HTTP Header.
180         */
181        NOTMATCH, 
182        /**
183         * Conditional reads are supported, with both If-Modified-Since and If-None-Match HTTP Headers.
184         */
185        FULLSUPPORT, 
186        /**
187         * added to help the parsers with the generic types
188         */
189        NULL;
190        public static ConditionalReadStatus fromCode(String codeString) throws FHIRException {
191            if (codeString == null || "".equals(codeString))
192                return null;
193        if ("not-supported".equals(codeString))
194          return NOTSUPPORTED;
195        if ("modified-since".equals(codeString))
196          return MODIFIEDSINCE;
197        if ("not-match".equals(codeString))
198          return NOTMATCH;
199        if ("full-support".equals(codeString))
200          return FULLSUPPORT;
201        if (Configuration.isAcceptInvalidEnums())
202          return null;
203        else
204          throw new FHIRException("Unknown ConditionalReadStatus code '"+codeString+"'");
205        }
206        public String toCode() {
207          switch (this) {
208            case NOTSUPPORTED: return "not-supported";
209            case MODIFIEDSINCE: return "modified-since";
210            case NOTMATCH: return "not-match";
211            case FULLSUPPORT: return "full-support";
212            case NULL: return null;
213            default: return "?";
214          }
215        }
216        public String getSystem() {
217          switch (this) {
218            case NOTSUPPORTED: return "http://hl7.org/fhir/conditional-read-status";
219            case MODIFIEDSINCE: return "http://hl7.org/fhir/conditional-read-status";
220            case NOTMATCH: return "http://hl7.org/fhir/conditional-read-status";
221            case FULLSUPPORT: return "http://hl7.org/fhir/conditional-read-status";
222            case NULL: return null;
223            default: return "?";
224          }
225        }
226        public String getDefinition() {
227          switch (this) {
228            case NOTSUPPORTED: return "No support for conditional reads.";
229            case MODIFIEDSINCE: return "Conditional reads are supported, but only with the If-Modified-Since HTTP Header.";
230            case NOTMATCH: return "Conditional reads are supported, but only with the If-None-Match HTTP Header.";
231            case FULLSUPPORT: return "Conditional reads are supported, with both If-Modified-Since and If-None-Match HTTP Headers.";
232            case NULL: return null;
233            default: return "?";
234          }
235        }
236        public String getDisplay() {
237          switch (this) {
238            case NOTSUPPORTED: return "Not Supported";
239            case MODIFIEDSINCE: return "If-Modified-Since";
240            case NOTMATCH: return "If-None-Match";
241            case FULLSUPPORT: return "Full Support";
242            case NULL: return null;
243            default: return "?";
244          }
245        }
246    }
247
248  public static class ConditionalReadStatusEnumFactory implements EnumFactory<ConditionalReadStatus> {
249    public ConditionalReadStatus fromCode(String codeString) throws IllegalArgumentException {
250      if (codeString == null || "".equals(codeString))
251            if (codeString == null || "".equals(codeString))
252                return null;
253        if ("not-supported".equals(codeString))
254          return ConditionalReadStatus.NOTSUPPORTED;
255        if ("modified-since".equals(codeString))
256          return ConditionalReadStatus.MODIFIEDSINCE;
257        if ("not-match".equals(codeString))
258          return ConditionalReadStatus.NOTMATCH;
259        if ("full-support".equals(codeString))
260          return ConditionalReadStatus.FULLSUPPORT;
261        throw new IllegalArgumentException("Unknown ConditionalReadStatus code '"+codeString+"'");
262        }
263        public Enumeration<ConditionalReadStatus> fromType(PrimitiveType<?> code) throws FHIRException {
264          if (code == null)
265            return null;
266          if (code.isEmpty())
267            return new Enumeration<ConditionalReadStatus>(this, ConditionalReadStatus.NULL, code);
268          String codeString = ((PrimitiveType) code).asStringValue();
269          if (codeString == null || "".equals(codeString))
270            return new Enumeration<ConditionalReadStatus>(this, ConditionalReadStatus.NULL, code);
271        if ("not-supported".equals(codeString))
272          return new Enumeration<ConditionalReadStatus>(this, ConditionalReadStatus.NOTSUPPORTED, code);
273        if ("modified-since".equals(codeString))
274          return new Enumeration<ConditionalReadStatus>(this, ConditionalReadStatus.MODIFIEDSINCE, code);
275        if ("not-match".equals(codeString))
276          return new Enumeration<ConditionalReadStatus>(this, ConditionalReadStatus.NOTMATCH, code);
277        if ("full-support".equals(codeString))
278          return new Enumeration<ConditionalReadStatus>(this, ConditionalReadStatus.FULLSUPPORT, code);
279        throw new FHIRException("Unknown ConditionalReadStatus code '"+codeString+"'");
280        }
281    public String toCode(ConditionalReadStatus code) {
282      if (code == ConditionalReadStatus.NOTSUPPORTED)
283        return "not-supported";
284      if (code == ConditionalReadStatus.MODIFIEDSINCE)
285        return "modified-since";
286      if (code == ConditionalReadStatus.NOTMATCH)
287        return "not-match";
288      if (code == ConditionalReadStatus.FULLSUPPORT)
289        return "full-support";
290      return "?";
291      }
292    public String toSystem(ConditionalReadStatus code) {
293      return code.getSystem();
294      }
295    }
296
297    public enum DocumentMode {
298        /**
299         * The application produces documents of the specified type.
300         */
301        PRODUCER, 
302        /**
303         * The application consumes documents of the specified type.
304         */
305        CONSUMER, 
306        /**
307         * added to help the parsers with the generic types
308         */
309        NULL;
310        public static DocumentMode fromCode(String codeString) throws FHIRException {
311            if (codeString == null || "".equals(codeString))
312                return null;
313        if ("producer".equals(codeString))
314          return PRODUCER;
315        if ("consumer".equals(codeString))
316          return CONSUMER;
317        if (Configuration.isAcceptInvalidEnums())
318          return null;
319        else
320          throw new FHIRException("Unknown DocumentMode code '"+codeString+"'");
321        }
322        public String toCode() {
323          switch (this) {
324            case PRODUCER: return "producer";
325            case CONSUMER: return "consumer";
326            case NULL: return null;
327            default: return "?";
328          }
329        }
330        public String getSystem() {
331          switch (this) {
332            case PRODUCER: return "http://hl7.org/fhir/document-mode";
333            case CONSUMER: return "http://hl7.org/fhir/document-mode";
334            case NULL: return null;
335            default: return "?";
336          }
337        }
338        public String getDefinition() {
339          switch (this) {
340            case PRODUCER: return "The application produces documents of the specified type.";
341            case CONSUMER: return "The application consumes documents of the specified type.";
342            case NULL: return null;
343            default: return "?";
344          }
345        }
346        public String getDisplay() {
347          switch (this) {
348            case PRODUCER: return "Producer";
349            case CONSUMER: return "Consumer";
350            case NULL: return null;
351            default: return "?";
352          }
353        }
354    }
355
356  public static class DocumentModeEnumFactory implements EnumFactory<DocumentMode> {
357    public DocumentMode fromCode(String codeString) throws IllegalArgumentException {
358      if (codeString == null || "".equals(codeString))
359            if (codeString == null || "".equals(codeString))
360                return null;
361        if ("producer".equals(codeString))
362          return DocumentMode.PRODUCER;
363        if ("consumer".equals(codeString))
364          return DocumentMode.CONSUMER;
365        throw new IllegalArgumentException("Unknown DocumentMode code '"+codeString+"'");
366        }
367        public Enumeration<DocumentMode> fromType(PrimitiveType<?> code) throws FHIRException {
368          if (code == null)
369            return null;
370          if (code.isEmpty())
371            return new Enumeration<DocumentMode>(this, DocumentMode.NULL, code);
372          String codeString = ((PrimitiveType) code).asStringValue();
373          if (codeString == null || "".equals(codeString))
374            return new Enumeration<DocumentMode>(this, DocumentMode.NULL, code);
375        if ("producer".equals(codeString))
376          return new Enumeration<DocumentMode>(this, DocumentMode.PRODUCER, code);
377        if ("consumer".equals(codeString))
378          return new Enumeration<DocumentMode>(this, DocumentMode.CONSUMER, code);
379        throw new FHIRException("Unknown DocumentMode code '"+codeString+"'");
380        }
381    public String toCode(DocumentMode code) {
382      if (code == DocumentMode.PRODUCER)
383        return "producer";
384      if (code == DocumentMode.CONSUMER)
385        return "consumer";
386      return "?";
387      }
388    public String toSystem(DocumentMode code) {
389      return code.getSystem();
390      }
391    }
392
393    public enum EventCapabilityMode {
394        /**
395         * The application sends requests and receives responses.
396         */
397        SENDER, 
398        /**
399         * The application receives requests and sends responses.
400         */
401        RECEIVER, 
402        /**
403         * added to help the parsers with the generic types
404         */
405        NULL;
406        public static EventCapabilityMode fromCode(String codeString) throws FHIRException {
407            if (codeString == null || "".equals(codeString))
408                return null;
409        if ("sender".equals(codeString))
410          return SENDER;
411        if ("receiver".equals(codeString))
412          return RECEIVER;
413        if (Configuration.isAcceptInvalidEnums())
414          return null;
415        else
416          throw new FHIRException("Unknown EventCapabilityMode code '"+codeString+"'");
417        }
418        public String toCode() {
419          switch (this) {
420            case SENDER: return "sender";
421            case RECEIVER: return "receiver";
422            case NULL: return null;
423            default: return "?";
424          }
425        }
426        public String getSystem() {
427          switch (this) {
428            case SENDER: return "http://hl7.org/fhir/event-capability-mode";
429            case RECEIVER: return "http://hl7.org/fhir/event-capability-mode";
430            case NULL: return null;
431            default: return "?";
432          }
433        }
434        public String getDefinition() {
435          switch (this) {
436            case SENDER: return "The application sends requests and receives responses.";
437            case RECEIVER: return "The application receives requests and sends responses.";
438            case NULL: return null;
439            default: return "?";
440          }
441        }
442        public String getDisplay() {
443          switch (this) {
444            case SENDER: return "Sender";
445            case RECEIVER: return "Receiver";
446            case NULL: return null;
447            default: return "?";
448          }
449        }
450    }
451
452  public static class EventCapabilityModeEnumFactory implements EnumFactory<EventCapabilityMode> {
453    public EventCapabilityMode fromCode(String codeString) throws IllegalArgumentException {
454      if (codeString == null || "".equals(codeString))
455            if (codeString == null || "".equals(codeString))
456                return null;
457        if ("sender".equals(codeString))
458          return EventCapabilityMode.SENDER;
459        if ("receiver".equals(codeString))
460          return EventCapabilityMode.RECEIVER;
461        throw new IllegalArgumentException("Unknown EventCapabilityMode code '"+codeString+"'");
462        }
463        public Enumeration<EventCapabilityMode> fromType(PrimitiveType<?> code) throws FHIRException {
464          if (code == null)
465            return null;
466          if (code.isEmpty())
467            return new Enumeration<EventCapabilityMode>(this, EventCapabilityMode.NULL, code);
468          String codeString = ((PrimitiveType) code).asStringValue();
469          if (codeString == null || "".equals(codeString))
470            return new Enumeration<EventCapabilityMode>(this, EventCapabilityMode.NULL, code);
471        if ("sender".equals(codeString))
472          return new Enumeration<EventCapabilityMode>(this, EventCapabilityMode.SENDER, code);
473        if ("receiver".equals(codeString))
474          return new Enumeration<EventCapabilityMode>(this, EventCapabilityMode.RECEIVER, code);
475        throw new FHIRException("Unknown EventCapabilityMode code '"+codeString+"'");
476        }
477    public String toCode(EventCapabilityMode code) {
478      if (code == EventCapabilityMode.SENDER)
479        return "sender";
480      if (code == EventCapabilityMode.RECEIVER)
481        return "receiver";
482      return "?";
483      }
484    public String toSystem(EventCapabilityMode code) {
485      return code.getSystem();
486      }
487    }
488
489    public enum ReferenceHandlingPolicy {
490        /**
491         * 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').
492         */
493        LITERAL, 
494        /**
495         * The server allows logical references (i.e. using Reference.identifier).
496         */
497        LOGICAL, 
498        /**
499         * 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).
500         */
501        RESOLVES, 
502        /**
503         * 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.
504         */
505        ENFORCED, 
506        /**
507         * The server does not support references that point to other servers.
508         */
509        LOCAL, 
510        /**
511         * added to help the parsers with the generic types
512         */
513        NULL;
514        public static ReferenceHandlingPolicy fromCode(String codeString) throws FHIRException {
515            if (codeString == null || "".equals(codeString))
516                return null;
517        if ("literal".equals(codeString))
518          return LITERAL;
519        if ("logical".equals(codeString))
520          return LOGICAL;
521        if ("resolves".equals(codeString))
522          return RESOLVES;
523        if ("enforced".equals(codeString))
524          return ENFORCED;
525        if ("local".equals(codeString))
526          return LOCAL;
527        if (Configuration.isAcceptInvalidEnums())
528          return null;
529        else
530          throw new FHIRException("Unknown ReferenceHandlingPolicy code '"+codeString+"'");
531        }
532        public String toCode() {
533          switch (this) {
534            case LITERAL: return "literal";
535            case LOGICAL: return "logical";
536            case RESOLVES: return "resolves";
537            case ENFORCED: return "enforced";
538            case LOCAL: return "local";
539            case NULL: return null;
540            default: return "?";
541          }
542        }
543        public String getSystem() {
544          switch (this) {
545            case LITERAL: return "http://hl7.org/fhir/reference-handling-policy";
546            case LOGICAL: return "http://hl7.org/fhir/reference-handling-policy";
547            case RESOLVES: return "http://hl7.org/fhir/reference-handling-policy";
548            case ENFORCED: return "http://hl7.org/fhir/reference-handling-policy";
549            case LOCAL: return "http://hl7.org/fhir/reference-handling-policy";
550            case NULL: return null;
551            default: return "?";
552          }
553        }
554        public String getDefinition() {
555          switch (this) {
556            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').";
557            case LOGICAL: return "The server allows logical references (i.e. using Reference.identifier).";
558            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).";
559            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.";
560            case LOCAL: return "The server does not support references that point to other servers.";
561            case NULL: return null;
562            default: return "?";
563          }
564        }
565        public String getDisplay() {
566          switch (this) {
567            case LITERAL: return "Literal References";
568            case LOGICAL: return "Logical References";
569            case RESOLVES: return "Resolves References";
570            case ENFORCED: return "Reference Integrity Enforced";
571            case LOCAL: return "Local References Only";
572            case NULL: return null;
573            default: return "?";
574          }
575        }
576    }
577
578  public static class ReferenceHandlingPolicyEnumFactory implements EnumFactory<ReferenceHandlingPolicy> {
579    public ReferenceHandlingPolicy fromCode(String codeString) throws IllegalArgumentException {
580      if (codeString == null || "".equals(codeString))
581            if (codeString == null || "".equals(codeString))
582                return null;
583        if ("literal".equals(codeString))
584          return ReferenceHandlingPolicy.LITERAL;
585        if ("logical".equals(codeString))
586          return ReferenceHandlingPolicy.LOGICAL;
587        if ("resolves".equals(codeString))
588          return ReferenceHandlingPolicy.RESOLVES;
589        if ("enforced".equals(codeString))
590          return ReferenceHandlingPolicy.ENFORCED;
591        if ("local".equals(codeString))
592          return ReferenceHandlingPolicy.LOCAL;
593        throw new IllegalArgumentException("Unknown ReferenceHandlingPolicy code '"+codeString+"'");
594        }
595        public Enumeration<ReferenceHandlingPolicy> fromType(PrimitiveType<?> code) throws FHIRException {
596          if (code == null)
597            return null;
598          if (code.isEmpty())
599            return new Enumeration<ReferenceHandlingPolicy>(this, ReferenceHandlingPolicy.NULL, code);
600          String codeString = ((PrimitiveType) code).asStringValue();
601          if (codeString == null || "".equals(codeString))
602            return new Enumeration<ReferenceHandlingPolicy>(this, ReferenceHandlingPolicy.NULL, code);
603        if ("literal".equals(codeString))
604          return new Enumeration<ReferenceHandlingPolicy>(this, ReferenceHandlingPolicy.LITERAL, code);
605        if ("logical".equals(codeString))
606          return new Enumeration<ReferenceHandlingPolicy>(this, ReferenceHandlingPolicy.LOGICAL, code);
607        if ("resolves".equals(codeString))
608          return new Enumeration<ReferenceHandlingPolicy>(this, ReferenceHandlingPolicy.RESOLVES, code);
609        if ("enforced".equals(codeString))
610          return new Enumeration<ReferenceHandlingPolicy>(this, ReferenceHandlingPolicy.ENFORCED, code);
611        if ("local".equals(codeString))
612          return new Enumeration<ReferenceHandlingPolicy>(this, ReferenceHandlingPolicy.LOCAL, code);
613        throw new FHIRException("Unknown ReferenceHandlingPolicy code '"+codeString+"'");
614        }
615    public String toCode(ReferenceHandlingPolicy code) {
616      if (code == ReferenceHandlingPolicy.LITERAL)
617        return "literal";
618      if (code == ReferenceHandlingPolicy.LOGICAL)
619        return "logical";
620      if (code == ReferenceHandlingPolicy.RESOLVES)
621        return "resolves";
622      if (code == ReferenceHandlingPolicy.ENFORCED)
623        return "enforced";
624      if (code == ReferenceHandlingPolicy.LOCAL)
625        return "local";
626      return "?";
627      }
628    public String toSystem(ReferenceHandlingPolicy code) {
629      return code.getSystem();
630      }
631    }
632
633    public enum ResourceVersionPolicy {
634        /**
635         * VersionId meta-property is not supported (server) or used (client).
636         */
637        NOVERSION, 
638        /**
639         * VersionId meta-property is supported (server) or used (client).
640         */
641        VERSIONED, 
642        /**
643         * Supports version-aware updates (server) or will be specified (If-match header) for updates (client).
644         */
645        VERSIONEDUPDATE, 
646        /**
647         * added to help the parsers with the generic types
648         */
649        NULL;
650        public static ResourceVersionPolicy fromCode(String codeString) throws FHIRException {
651            if (codeString == null || "".equals(codeString))
652                return null;
653        if ("no-version".equals(codeString))
654          return NOVERSION;
655        if ("versioned".equals(codeString))
656          return VERSIONED;
657        if ("versioned-update".equals(codeString))
658          return VERSIONEDUPDATE;
659        if (Configuration.isAcceptInvalidEnums())
660          return null;
661        else
662          throw new FHIRException("Unknown ResourceVersionPolicy code '"+codeString+"'");
663        }
664        public String toCode() {
665          switch (this) {
666            case NOVERSION: return "no-version";
667            case VERSIONED: return "versioned";
668            case VERSIONEDUPDATE: return "versioned-update";
669            case NULL: return null;
670            default: return "?";
671          }
672        }
673        public String getSystem() {
674          switch (this) {
675            case NOVERSION: return "http://hl7.org/fhir/versioning-policy";
676            case VERSIONED: return "http://hl7.org/fhir/versioning-policy";
677            case VERSIONEDUPDATE: return "http://hl7.org/fhir/versioning-policy";
678            case NULL: return null;
679            default: return "?";
680          }
681        }
682        public String getDefinition() {
683          switch (this) {
684            case NOVERSION: return "VersionId meta-property is not supported (server) or used (client).";
685            case VERSIONED: return "VersionId meta-property is supported (server) or used (client).";
686            case VERSIONEDUPDATE: return "Supports version-aware updates (server) or will be specified (If-match header) for updates (client).";
687            case NULL: return null;
688            default: return "?";
689          }
690        }
691        public String getDisplay() {
692          switch (this) {
693            case NOVERSION: return "No VersionId Support";
694            case VERSIONED: return "Versioned";
695            case VERSIONEDUPDATE: return "VersionId tracked fully";
696            case NULL: return null;
697            default: return "?";
698          }
699        }
700    }
701
702  public static class ResourceVersionPolicyEnumFactory implements EnumFactory<ResourceVersionPolicy> {
703    public ResourceVersionPolicy fromCode(String codeString) throws IllegalArgumentException {
704      if (codeString == null || "".equals(codeString))
705            if (codeString == null || "".equals(codeString))
706                return null;
707        if ("no-version".equals(codeString))
708          return ResourceVersionPolicy.NOVERSION;
709        if ("versioned".equals(codeString))
710          return ResourceVersionPolicy.VERSIONED;
711        if ("versioned-update".equals(codeString))
712          return ResourceVersionPolicy.VERSIONEDUPDATE;
713        throw new IllegalArgumentException("Unknown ResourceVersionPolicy code '"+codeString+"'");
714        }
715        public Enumeration<ResourceVersionPolicy> fromType(PrimitiveType<?> code) throws FHIRException {
716          if (code == null)
717            return null;
718          if (code.isEmpty())
719            return new Enumeration<ResourceVersionPolicy>(this, ResourceVersionPolicy.NULL, code);
720          String codeString = ((PrimitiveType) code).asStringValue();
721          if (codeString == null || "".equals(codeString))
722            return new Enumeration<ResourceVersionPolicy>(this, ResourceVersionPolicy.NULL, code);
723        if ("no-version".equals(codeString))
724          return new Enumeration<ResourceVersionPolicy>(this, ResourceVersionPolicy.NOVERSION, code);
725        if ("versioned".equals(codeString))
726          return new Enumeration<ResourceVersionPolicy>(this, ResourceVersionPolicy.VERSIONED, code);
727        if ("versioned-update".equals(codeString))
728          return new Enumeration<ResourceVersionPolicy>(this, ResourceVersionPolicy.VERSIONEDUPDATE, code);
729        throw new FHIRException("Unknown ResourceVersionPolicy code '"+codeString+"'");
730        }
731    public String toCode(ResourceVersionPolicy code) {
732      if (code == ResourceVersionPolicy.NOVERSION)
733        return "no-version";
734      if (code == ResourceVersionPolicy.VERSIONED)
735        return "versioned";
736      if (code == ResourceVersionPolicy.VERSIONEDUPDATE)
737        return "versioned-update";
738      return "?";
739      }
740    public String toSystem(ResourceVersionPolicy code) {
741      return code.getSystem();
742      }
743    }
744
745    public enum RestfulCapabilityMode {
746        /**
747         * The application acts as a client for this resource.
748         */
749        CLIENT, 
750        /**
751         * The application acts as a server for this resource.
752         */
753        SERVER, 
754        /**
755         * added to help the parsers with the generic types
756         */
757        NULL;
758        public static RestfulCapabilityMode fromCode(String codeString) throws FHIRException {
759            if (codeString == null || "".equals(codeString))
760                return null;
761        if ("client".equals(codeString))
762          return CLIENT;
763        if ("server".equals(codeString))
764          return SERVER;
765        if (Configuration.isAcceptInvalidEnums())
766          return null;
767        else
768          throw new FHIRException("Unknown RestfulCapabilityMode code '"+codeString+"'");
769        }
770        public String toCode() {
771          switch (this) {
772            case CLIENT: return "client";
773            case SERVER: return "server";
774            case NULL: return null;
775            default: return "?";
776          }
777        }
778        public String getSystem() {
779          switch (this) {
780            case CLIENT: return "http://hl7.org/fhir/restful-capability-mode";
781            case SERVER: return "http://hl7.org/fhir/restful-capability-mode";
782            case NULL: return null;
783            default: return "?";
784          }
785        }
786        public String getDefinition() {
787          switch (this) {
788            case CLIENT: return "The application acts as a client for this resource.";
789            case SERVER: return "The application acts as a server for this resource.";
790            case NULL: return null;
791            default: return "?";
792          }
793        }
794        public String getDisplay() {
795          switch (this) {
796            case CLIENT: return "Client";
797            case SERVER: return "Server";
798            case NULL: return null;
799            default: return "?";
800          }
801        }
802    }
803
804  public static class RestfulCapabilityModeEnumFactory implements EnumFactory<RestfulCapabilityMode> {
805    public RestfulCapabilityMode fromCode(String codeString) throws IllegalArgumentException {
806      if (codeString == null || "".equals(codeString))
807            if (codeString == null || "".equals(codeString))
808                return null;
809        if ("client".equals(codeString))
810          return RestfulCapabilityMode.CLIENT;
811        if ("server".equals(codeString))
812          return RestfulCapabilityMode.SERVER;
813        throw new IllegalArgumentException("Unknown RestfulCapabilityMode code '"+codeString+"'");
814        }
815        public Enumeration<RestfulCapabilityMode> fromType(PrimitiveType<?> code) throws FHIRException {
816          if (code == null)
817            return null;
818          if (code.isEmpty())
819            return new Enumeration<RestfulCapabilityMode>(this, RestfulCapabilityMode.NULL, code);
820          String codeString = ((PrimitiveType) code).asStringValue();
821          if (codeString == null || "".equals(codeString))
822            return new Enumeration<RestfulCapabilityMode>(this, RestfulCapabilityMode.NULL, code);
823        if ("client".equals(codeString))
824          return new Enumeration<RestfulCapabilityMode>(this, RestfulCapabilityMode.CLIENT, code);
825        if ("server".equals(codeString))
826          return new Enumeration<RestfulCapabilityMode>(this, RestfulCapabilityMode.SERVER, code);
827        throw new FHIRException("Unknown RestfulCapabilityMode code '"+codeString+"'");
828        }
829    public String toCode(RestfulCapabilityMode code) {
830      if (code == RestfulCapabilityMode.CLIENT)
831        return "client";
832      if (code == RestfulCapabilityMode.SERVER)
833        return "server";
834      return "?";
835      }
836    public String toSystem(RestfulCapabilityMode code) {
837      return code.getSystem();
838      }
839    }
840
841    public enum SystemRestfulInteraction {
842        /**
843         * Update, create or delete a set of resources as a single transaction.
844         */
845        TRANSACTION, 
846        /**
847         * perform a set of a separate interactions in a single http operation
848         */
849        BATCH, 
850        /**
851         * Search all resources based on some filter criteria.
852         */
853        SEARCHSYSTEM, 
854        /**
855         * Retrieve the change history for all resources on a system.
856         */
857        HISTORYSYSTEM, 
858        /**
859         * added to help the parsers with the generic types
860         */
861        NULL;
862        public static SystemRestfulInteraction fromCode(String codeString) throws FHIRException {
863            if (codeString == null || "".equals(codeString))
864                return null;
865        if ("transaction".equals(codeString))
866          return TRANSACTION;
867        if ("batch".equals(codeString))
868          return BATCH;
869        if ("search-system".equals(codeString))
870          return SEARCHSYSTEM;
871        if ("history-system".equals(codeString))
872          return HISTORYSYSTEM;
873        if (Configuration.isAcceptInvalidEnums())
874          return null;
875        else
876          throw new FHIRException("Unknown SystemRestfulInteraction code '"+codeString+"'");
877        }
878        public String toCode() {
879          switch (this) {
880            case TRANSACTION: return "transaction";
881            case BATCH: return "batch";
882            case SEARCHSYSTEM: return "search-system";
883            case HISTORYSYSTEM: return "history-system";
884            case NULL: return null;
885            default: return "?";
886          }
887        }
888        public String getSystem() {
889          switch (this) {
890            case TRANSACTION: return "http://hl7.org/fhir/restful-interaction";
891            case BATCH: return "http://hl7.org/fhir/restful-interaction";
892            case SEARCHSYSTEM: return "http://hl7.org/fhir/restful-interaction";
893            case HISTORYSYSTEM: return "http://hl7.org/fhir/restful-interaction";
894            case NULL: return null;
895            default: return "?";
896          }
897        }
898        public String getDefinition() {
899          switch (this) {
900            case TRANSACTION: return "Update, create or delete a set of resources as a single transaction.";
901            case BATCH: return "perform a set of a separate interactions in a single http operation";
902            case SEARCHSYSTEM: return "Search all resources based on some filter criteria.";
903            case HISTORYSYSTEM: return "Retrieve the change history for all resources on a system.";
904            case NULL: return null;
905            default: return "?";
906          }
907        }
908        public String getDisplay() {
909          switch (this) {
910            case TRANSACTION: return "transaction";
911            case BATCH: return "batch";
912            case SEARCHSYSTEM: return "search-system";
913            case HISTORYSYSTEM: return "history-system";
914            case NULL: return null;
915            default: return "?";
916          }
917        }
918    }
919
920  public static class SystemRestfulInteractionEnumFactory implements EnumFactory<SystemRestfulInteraction> {
921    public SystemRestfulInteraction fromCode(String codeString) throws IllegalArgumentException {
922      if (codeString == null || "".equals(codeString))
923            if (codeString == null || "".equals(codeString))
924                return null;
925        if ("transaction".equals(codeString))
926          return SystemRestfulInteraction.TRANSACTION;
927        if ("batch".equals(codeString))
928          return SystemRestfulInteraction.BATCH;
929        if ("search-system".equals(codeString))
930          return SystemRestfulInteraction.SEARCHSYSTEM;
931        if ("history-system".equals(codeString))
932          return SystemRestfulInteraction.HISTORYSYSTEM;
933        throw new IllegalArgumentException("Unknown SystemRestfulInteraction code '"+codeString+"'");
934        }
935        public Enumeration<SystemRestfulInteraction> fromType(PrimitiveType<?> code) throws FHIRException {
936          if (code == null)
937            return null;
938          if (code.isEmpty())
939            return new Enumeration<SystemRestfulInteraction>(this, SystemRestfulInteraction.NULL, code);
940          String codeString = ((PrimitiveType) code).asStringValue();
941          if (codeString == null || "".equals(codeString))
942            return new Enumeration<SystemRestfulInteraction>(this, SystemRestfulInteraction.NULL, code);
943        if ("transaction".equals(codeString))
944          return new Enumeration<SystemRestfulInteraction>(this, SystemRestfulInteraction.TRANSACTION, code);
945        if ("batch".equals(codeString))
946          return new Enumeration<SystemRestfulInteraction>(this, SystemRestfulInteraction.BATCH, code);
947        if ("search-system".equals(codeString))
948          return new Enumeration<SystemRestfulInteraction>(this, SystemRestfulInteraction.SEARCHSYSTEM, code);
949        if ("history-system".equals(codeString))
950          return new Enumeration<SystemRestfulInteraction>(this, SystemRestfulInteraction.HISTORYSYSTEM, code);
951        throw new FHIRException("Unknown SystemRestfulInteraction code '"+codeString+"'");
952        }
953    public String toCode(SystemRestfulInteraction code) {
954      if (code == SystemRestfulInteraction.TRANSACTION)
955        return "transaction";
956      if (code == SystemRestfulInteraction.BATCH)
957        return "batch";
958      if (code == SystemRestfulInteraction.SEARCHSYSTEM)
959        return "search-system";
960      if (code == SystemRestfulInteraction.HISTORYSYSTEM)
961        return "history-system";
962      return "?";
963      }
964    public String toSystem(SystemRestfulInteraction code) {
965      return code.getSystem();
966      }
967    }
968
969    public enum TypeRestfulInteraction {
970        /**
971         * Read the current state of the resource.
972         */
973        READ, 
974        /**
975         * Read the state of a specific version of the resource.
976         */
977        VREAD, 
978        /**
979         * Update an existing resource by its id (or create it if it is new).
980         */
981        UPDATE, 
982        /**
983         * Update an existing resource by posting a set of changes to it.
984         */
985        PATCH, 
986        /**
987         * Delete a resource.
988         */
989        DELETE, 
990        /**
991         * Retrieve the change history for a particular resource.
992         */
993        HISTORYINSTANCE, 
994        /**
995         * Retrieve the change history for all resources of a particular type.
996         */
997        HISTORYTYPE, 
998        /**
999         * Create a new resource with a server assigned id.
1000         */
1001        CREATE, 
1002        /**
1003         * Search all resources of the specified type based on some filter criteria.
1004         */
1005        SEARCHTYPE, 
1006        /**
1007         * added to help the parsers with the generic types
1008         */
1009        NULL;
1010        public static TypeRestfulInteraction fromCode(String codeString) throws FHIRException {
1011            if (codeString == null || "".equals(codeString))
1012                return null;
1013        if ("read".equals(codeString))
1014          return READ;
1015        if ("vread".equals(codeString))
1016          return VREAD;
1017        if ("update".equals(codeString))
1018          return UPDATE;
1019        if ("patch".equals(codeString))
1020          return PATCH;
1021        if ("delete".equals(codeString))
1022          return DELETE;
1023        if ("history-instance".equals(codeString))
1024          return HISTORYINSTANCE;
1025        if ("history-type".equals(codeString))
1026          return HISTORYTYPE;
1027        if ("create".equals(codeString))
1028          return CREATE;
1029        if ("search-type".equals(codeString))
1030          return SEARCHTYPE;
1031        if (Configuration.isAcceptInvalidEnums())
1032          return null;
1033        else
1034          throw new FHIRException("Unknown TypeRestfulInteraction code '"+codeString+"'");
1035        }
1036        public String toCode() {
1037          switch (this) {
1038            case READ: return "read";
1039            case VREAD: return "vread";
1040            case UPDATE: return "update";
1041            case PATCH: return "patch";
1042            case DELETE: return "delete";
1043            case HISTORYINSTANCE: return "history-instance";
1044            case HISTORYTYPE: return "history-type";
1045            case CREATE: return "create";
1046            case SEARCHTYPE: return "search-type";
1047            case NULL: return null;
1048            default: return "?";
1049          }
1050        }
1051        public String getSystem() {
1052          switch (this) {
1053            case READ: return "http://hl7.org/fhir/restful-interaction";
1054            case VREAD: return "http://hl7.org/fhir/restful-interaction";
1055            case UPDATE: return "http://hl7.org/fhir/restful-interaction";
1056            case PATCH: return "http://hl7.org/fhir/restful-interaction";
1057            case DELETE: return "http://hl7.org/fhir/restful-interaction";
1058            case HISTORYINSTANCE: return "http://hl7.org/fhir/restful-interaction";
1059            case HISTORYTYPE: return "http://hl7.org/fhir/restful-interaction";
1060            case CREATE: return "http://hl7.org/fhir/restful-interaction";
1061            case SEARCHTYPE: return "http://hl7.org/fhir/restful-interaction";
1062            case NULL: return null;
1063            default: return "?";
1064          }
1065        }
1066        public String getDefinition() {
1067          switch (this) {
1068            case READ: return "Read the current state of the resource.";
1069            case VREAD: return "Read the state of a specific version of the resource.";
1070            case UPDATE: return "Update an existing resource by its id (or create it if it is new).";
1071            case PATCH: return "Update an existing resource by posting a set of changes to it.";
1072            case DELETE: return "Delete a resource.";
1073            case HISTORYINSTANCE: return "Retrieve the change history for a particular resource.";
1074            case HISTORYTYPE: return "Retrieve the change history for all resources of a particular type.";
1075            case CREATE: return "Create a new resource with a server assigned id.";
1076            case SEARCHTYPE: return "Search all resources of the specified type based on some filter criteria.";
1077            case NULL: return null;
1078            default: return "?";
1079          }
1080        }
1081        public String getDisplay() {
1082          switch (this) {
1083            case READ: return "read";
1084            case VREAD: return "vread";
1085            case UPDATE: return "update";
1086            case PATCH: return "patch";
1087            case DELETE: return "delete";
1088            case HISTORYINSTANCE: return "history-instance";
1089            case HISTORYTYPE: return "history-type";
1090            case CREATE: return "create";
1091            case SEARCHTYPE: return "search-type";
1092            case NULL: return null;
1093            default: return "?";
1094          }
1095        }
1096    }
1097
1098  public static class TypeRestfulInteractionEnumFactory implements EnumFactory<TypeRestfulInteraction> {
1099    public TypeRestfulInteraction fromCode(String codeString) throws IllegalArgumentException {
1100      if (codeString == null || "".equals(codeString))
1101            if (codeString == null || "".equals(codeString))
1102                return null;
1103        if ("read".equals(codeString))
1104          return TypeRestfulInteraction.READ;
1105        if ("vread".equals(codeString))
1106          return TypeRestfulInteraction.VREAD;
1107        if ("update".equals(codeString))
1108          return TypeRestfulInteraction.UPDATE;
1109        if ("patch".equals(codeString))
1110          return TypeRestfulInteraction.PATCH;
1111        if ("delete".equals(codeString))
1112          return TypeRestfulInteraction.DELETE;
1113        if ("history-instance".equals(codeString))
1114          return TypeRestfulInteraction.HISTORYINSTANCE;
1115        if ("history-type".equals(codeString))
1116          return TypeRestfulInteraction.HISTORYTYPE;
1117        if ("create".equals(codeString))
1118          return TypeRestfulInteraction.CREATE;
1119        if ("search-type".equals(codeString))
1120          return TypeRestfulInteraction.SEARCHTYPE;
1121        throw new IllegalArgumentException("Unknown TypeRestfulInteraction code '"+codeString+"'");
1122        }
1123        public Enumeration<TypeRestfulInteraction> fromType(PrimitiveType<?> code) throws FHIRException {
1124          if (code == null)
1125            return null;
1126          if (code.isEmpty())
1127            return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.NULL, code);
1128          String codeString = ((PrimitiveType) code).asStringValue();
1129          if (codeString == null || "".equals(codeString))
1130            return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.NULL, code);
1131        if ("read".equals(codeString))
1132          return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.READ, code);
1133        if ("vread".equals(codeString))
1134          return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.VREAD, code);
1135        if ("update".equals(codeString))
1136          return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.UPDATE, code);
1137        if ("patch".equals(codeString))
1138          return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.PATCH, code);
1139        if ("delete".equals(codeString))
1140          return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.DELETE, code);
1141        if ("history-instance".equals(codeString))
1142          return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.HISTORYINSTANCE, code);
1143        if ("history-type".equals(codeString))
1144          return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.HISTORYTYPE, code);
1145        if ("create".equals(codeString))
1146          return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.CREATE, code);
1147        if ("search-type".equals(codeString))
1148          return new Enumeration<TypeRestfulInteraction>(this, TypeRestfulInteraction.SEARCHTYPE, code);
1149        throw new FHIRException("Unknown TypeRestfulInteraction code '"+codeString+"'");
1150        }
1151    public String toCode(TypeRestfulInteraction code) {
1152      if (code == TypeRestfulInteraction.READ)
1153        return "read";
1154      if (code == TypeRestfulInteraction.VREAD)
1155        return "vread";
1156      if (code == TypeRestfulInteraction.UPDATE)
1157        return "update";
1158      if (code == TypeRestfulInteraction.PATCH)
1159        return "patch";
1160      if (code == TypeRestfulInteraction.DELETE)
1161        return "delete";
1162      if (code == TypeRestfulInteraction.HISTORYINSTANCE)
1163        return "history-instance";
1164      if (code == TypeRestfulInteraction.HISTORYTYPE)
1165        return "history-type";
1166      if (code == TypeRestfulInteraction.CREATE)
1167        return "create";
1168      if (code == TypeRestfulInteraction.SEARCHTYPE)
1169        return "search-type";
1170      return "?";
1171      }
1172    public String toSystem(TypeRestfulInteraction code) {
1173      return code.getSystem();
1174      }
1175    }
1176
1177    @Block()
1178    public static class CapabilityStatementSoftwareComponent extends BackboneElement implements IBaseBackboneElement {
1179        /**
1180         * Name the software is known by.
1181         */
1182        @Child(name = "name", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true)
1183        @Description(shortDefinition="A name the software is known by", formalDefinition="Name the software is known by." )
1184        protected StringType name;
1185
1186        /**
1187         * The version identifier for the software covered by this statement.
1188         */
1189        @Child(name = "version", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true)
1190        @Description(shortDefinition="Version covered by this statement", formalDefinition="The version identifier for the software covered by this statement." )
1191        protected StringType version;
1192
1193        /**
1194         * Date this version of the software was released.
1195         */
1196        @Child(name = "releaseDate", type = {DateTimeType.class}, order=3, min=0, max=1, modifier=false, summary=true)
1197        @Description(shortDefinition="Date this version was released", formalDefinition="Date this version of the software was released." )
1198        protected DateTimeType releaseDate;
1199
1200        private static final long serialVersionUID = 1819769027L;
1201
1202    /**
1203     * Constructor
1204     */
1205      public CapabilityStatementSoftwareComponent() {
1206        super();
1207      }
1208
1209    /**
1210     * Constructor
1211     */
1212      public CapabilityStatementSoftwareComponent(String name) {
1213        super();
1214        this.setName(name);
1215      }
1216
1217        /**
1218         * @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
1219         */
1220        public StringType getNameElement() { 
1221          if (this.name == null)
1222            if (Configuration.errorOnAutoCreate())
1223              throw new Error("Attempt to auto-create CapabilityStatementSoftwareComponent.name");
1224            else if (Configuration.doAutoCreate())
1225              this.name = new StringType(); // bb
1226          return this.name;
1227        }
1228
1229        public boolean hasNameElement() { 
1230          return this.name != null && !this.name.isEmpty();
1231        }
1232
1233        public boolean hasName() { 
1234          return this.name != null && !this.name.isEmpty();
1235        }
1236
1237        /**
1238         * @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
1239         */
1240        public CapabilityStatementSoftwareComponent setNameElement(StringType value) { 
1241          this.name = value;
1242          return this;
1243        }
1244
1245        /**
1246         * @return Name the software is known by.
1247         */
1248        public String getName() { 
1249          return this.name == null ? null : this.name.getValue();
1250        }
1251
1252        /**
1253         * @param value Name the software is known by.
1254         */
1255        public CapabilityStatementSoftwareComponent setName(String value) { 
1256            if (this.name == null)
1257              this.name = new StringType();
1258            this.name.setValue(value);
1259          return this;
1260        }
1261
1262        /**
1263         * @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
1264         */
1265        public StringType getVersionElement() { 
1266          if (this.version == null)
1267            if (Configuration.errorOnAutoCreate())
1268              throw new Error("Attempt to auto-create CapabilityStatementSoftwareComponent.version");
1269            else if (Configuration.doAutoCreate())
1270              this.version = new StringType(); // bb
1271          return this.version;
1272        }
1273
1274        public boolean hasVersionElement() { 
1275          return this.version != null && !this.version.isEmpty();
1276        }
1277
1278        public boolean hasVersion() { 
1279          return this.version != null && !this.version.isEmpty();
1280        }
1281
1282        /**
1283         * @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
1284         */
1285        public CapabilityStatementSoftwareComponent setVersionElement(StringType value) { 
1286          this.version = value;
1287          return this;
1288        }
1289
1290        /**
1291         * @return The version identifier for the software covered by this statement.
1292         */
1293        public String getVersion() { 
1294          return this.version == null ? null : this.version.getValue();
1295        }
1296
1297        /**
1298         * @param value The version identifier for the software covered by this statement.
1299         */
1300        public CapabilityStatementSoftwareComponent setVersion(String value) { 
1301          if (Utilities.noString(value))
1302            this.version = null;
1303          else {
1304            if (this.version == null)
1305              this.version = new StringType();
1306            this.version.setValue(value);
1307          }
1308          return this;
1309        }
1310
1311        /**
1312         * @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
1313         */
1314        public DateTimeType getReleaseDateElement() { 
1315          if (this.releaseDate == null)
1316            if (Configuration.errorOnAutoCreate())
1317              throw new Error("Attempt to auto-create CapabilityStatementSoftwareComponent.releaseDate");
1318            else if (Configuration.doAutoCreate())
1319              this.releaseDate = new DateTimeType(); // bb
1320          return this.releaseDate;
1321        }
1322
1323        public boolean hasReleaseDateElement() { 
1324          return this.releaseDate != null && !this.releaseDate.isEmpty();
1325        }
1326
1327        public boolean hasReleaseDate() { 
1328          return this.releaseDate != null && !this.releaseDate.isEmpty();
1329        }
1330
1331        /**
1332         * @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
1333         */
1334        public CapabilityStatementSoftwareComponent setReleaseDateElement(DateTimeType value) { 
1335          this.releaseDate = value;
1336          return this;
1337        }
1338
1339        /**
1340         * @return Date this version of the software was released.
1341         */
1342        public Date getReleaseDate() { 
1343          return this.releaseDate == null ? null : this.releaseDate.getValue();
1344        }
1345
1346        /**
1347         * @param value Date this version of the software was released.
1348         */
1349        public CapabilityStatementSoftwareComponent setReleaseDate(Date value) { 
1350          if (value == null)
1351            this.releaseDate = null;
1352          else {
1353            if (this.releaseDate == null)
1354              this.releaseDate = new DateTimeType();
1355            this.releaseDate.setValue(value);
1356          }
1357          return this;
1358        }
1359
1360        protected void listChildren(List<Property> children) {
1361          super.listChildren(children);
1362          children.add(new Property("name", "string", "Name the software is known by.", 0, 1, name));
1363          children.add(new Property("version", "string", "The version identifier for the software covered by this statement.", 0, 1, version));
1364          children.add(new Property("releaseDate", "dateTime", "Date this version of the software was released.", 0, 1, releaseDate));
1365        }
1366
1367        @Override
1368        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1369          switch (_hash) {
1370          case 3373707: /*name*/  return new Property("name", "string", "Name the software is known by.", 0, 1, name);
1371          case 351608024: /*version*/  return new Property("version", "string", "The version identifier for the software covered by this statement.", 0, 1, version);
1372          case 212873301: /*releaseDate*/  return new Property("releaseDate", "dateTime", "Date this version of the software was released.", 0, 1, releaseDate);
1373          default: return super.getNamedProperty(_hash, _name, _checkValid);
1374          }
1375
1376        }
1377
1378      @Override
1379      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1380        switch (hash) {
1381        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
1382        case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType
1383        case 212873301: /*releaseDate*/ return this.releaseDate == null ? new Base[0] : new Base[] {this.releaseDate}; // DateTimeType
1384        default: return super.getProperty(hash, name, checkValid);
1385        }
1386
1387      }
1388
1389      @Override
1390      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1391        switch (hash) {
1392        case 3373707: // name
1393          this.name = TypeConvertor.castToString(value); // StringType
1394          return value;
1395        case 351608024: // version
1396          this.version = TypeConvertor.castToString(value); // StringType
1397          return value;
1398        case 212873301: // releaseDate
1399          this.releaseDate = TypeConvertor.castToDateTime(value); // DateTimeType
1400          return value;
1401        default: return super.setProperty(hash, name, value);
1402        }
1403
1404      }
1405
1406      @Override
1407      public Base setProperty(String name, Base value) throws FHIRException {
1408        if (name.equals("name")) {
1409          this.name = TypeConvertor.castToString(value); // StringType
1410        } else if (name.equals("version")) {
1411          this.version = TypeConvertor.castToString(value); // StringType
1412        } else if (name.equals("releaseDate")) {
1413          this.releaseDate = TypeConvertor.castToDateTime(value); // DateTimeType
1414        } else
1415          return super.setProperty(name, value);
1416        return value;
1417      }
1418
1419      @Override
1420      public Base makeProperty(int hash, String name) throws FHIRException {
1421        switch (hash) {
1422        case 3373707:  return getNameElement();
1423        case 351608024:  return getVersionElement();
1424        case 212873301:  return getReleaseDateElement();
1425        default: return super.makeProperty(hash, name);
1426        }
1427
1428      }
1429
1430      @Override
1431      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1432        switch (hash) {
1433        case 3373707: /*name*/ return new String[] {"string"};
1434        case 351608024: /*version*/ return new String[] {"string"};
1435        case 212873301: /*releaseDate*/ return new String[] {"dateTime"};
1436        default: return super.getTypesForProperty(hash, name);
1437        }
1438
1439      }
1440
1441      @Override
1442      public Base addChild(String name) throws FHIRException {
1443        if (name.equals("name")) {
1444          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.software.name");
1445        }
1446        else if (name.equals("version")) {
1447          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.software.version");
1448        }
1449        else if (name.equals("releaseDate")) {
1450          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.software.releaseDate");
1451        }
1452        else
1453          return super.addChild(name);
1454      }
1455
1456      public CapabilityStatementSoftwareComponent copy() {
1457        CapabilityStatementSoftwareComponent dst = new CapabilityStatementSoftwareComponent();
1458        copyValues(dst);
1459        return dst;
1460      }
1461
1462      public void copyValues(CapabilityStatementSoftwareComponent dst) {
1463        super.copyValues(dst);
1464        dst.name = name == null ? null : name.copy();
1465        dst.version = version == null ? null : version.copy();
1466        dst.releaseDate = releaseDate == null ? null : releaseDate.copy();
1467      }
1468
1469      @Override
1470      public boolean equalsDeep(Base other_) {
1471        if (!super.equalsDeep(other_))
1472          return false;
1473        if (!(other_ instanceof CapabilityStatementSoftwareComponent))
1474          return false;
1475        CapabilityStatementSoftwareComponent o = (CapabilityStatementSoftwareComponent) other_;
1476        return compareDeep(name, o.name, true) && compareDeep(version, o.version, true) && compareDeep(releaseDate, o.releaseDate, true)
1477          ;
1478      }
1479
1480      @Override
1481      public boolean equalsShallow(Base other_) {
1482        if (!super.equalsShallow(other_))
1483          return false;
1484        if (!(other_ instanceof CapabilityStatementSoftwareComponent))
1485          return false;
1486        CapabilityStatementSoftwareComponent o = (CapabilityStatementSoftwareComponent) other_;
1487        return compareValues(name, o.name, true) && compareValues(version, o.version, true) && compareValues(releaseDate, o.releaseDate, true)
1488          ;
1489      }
1490
1491      public boolean isEmpty() {
1492        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, version, releaseDate
1493          );
1494      }
1495
1496  public String fhirType() {
1497    return "CapabilityStatement.software";
1498
1499  }
1500
1501  }
1502
1503    @Block()
1504    public static class CapabilityStatementImplementationComponent extends BackboneElement implements IBaseBackboneElement {
1505        /**
1506         * Information about the specific installation that this capability statement relates to.
1507         */
1508        @Child(name = "description", type = {MarkdownType.class}, order=1, min=1, max=1, modifier=false, summary=true)
1509        @Description(shortDefinition="Describes this specific instance", formalDefinition="Information about the specific installation that this capability statement relates to." )
1510        protected MarkdownType description;
1511
1512        /**
1513         * An absolute base URL for the implementation.  This forms the base for REST interfaces as well as the mailbox and document interfaces.
1514         */
1515        @Child(name = "url", type = {UrlType.class}, order=2, min=0, max=1, modifier=false, summary=true)
1516        @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." )
1517        protected UrlType url;
1518
1519        /**
1520         * The organization responsible for the management of the instance and oversight of the data on the server at the specified URL.
1521         */
1522        @Child(name = "custodian", type = {Organization.class}, order=3, min=0, max=1, modifier=false, summary=true)
1523        @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." )
1524        protected Reference custodian;
1525
1526        private static final long serialVersionUID = -1848514556L;
1527
1528    /**
1529     * Constructor
1530     */
1531      public CapabilityStatementImplementationComponent() {
1532        super();
1533      }
1534
1535    /**
1536     * Constructor
1537     */
1538      public CapabilityStatementImplementationComponent(String description) {
1539        super();
1540        this.setDescription(description);
1541      }
1542
1543        /**
1544         * @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
1545         */
1546        public MarkdownType getDescriptionElement() { 
1547          if (this.description == null)
1548            if (Configuration.errorOnAutoCreate())
1549              throw new Error("Attempt to auto-create CapabilityStatementImplementationComponent.description");
1550            else if (Configuration.doAutoCreate())
1551              this.description = new MarkdownType(); // bb
1552          return this.description;
1553        }
1554
1555        public boolean hasDescriptionElement() { 
1556          return this.description != null && !this.description.isEmpty();
1557        }
1558
1559        public boolean hasDescription() { 
1560          return this.description != null && !this.description.isEmpty();
1561        }
1562
1563        /**
1564         * @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
1565         */
1566        public CapabilityStatementImplementationComponent setDescriptionElement(MarkdownType value) { 
1567          this.description = value;
1568          return this;
1569        }
1570
1571        /**
1572         * @return Information about the specific installation that this capability statement relates to.
1573         */
1574        public String getDescription() { 
1575          return this.description == null ? null : this.description.getValue();
1576        }
1577
1578        /**
1579         * @param value Information about the specific installation that this capability statement relates to.
1580         */
1581        public CapabilityStatementImplementationComponent setDescription(String value) { 
1582            if (this.description == null)
1583              this.description = new MarkdownType();
1584            this.description.setValue(value);
1585          return this;
1586        }
1587
1588        /**
1589         * @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
1590         */
1591        public UrlType getUrlElement() { 
1592          if (this.url == null)
1593            if (Configuration.errorOnAutoCreate())
1594              throw new Error("Attempt to auto-create CapabilityStatementImplementationComponent.url");
1595            else if (Configuration.doAutoCreate())
1596              this.url = new UrlType(); // bb
1597          return this.url;
1598        }
1599
1600        public boolean hasUrlElement() { 
1601          return this.url != null && !this.url.isEmpty();
1602        }
1603
1604        public boolean hasUrl() { 
1605          return this.url != null && !this.url.isEmpty();
1606        }
1607
1608        /**
1609         * @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
1610         */
1611        public CapabilityStatementImplementationComponent setUrlElement(UrlType value) { 
1612          this.url = value;
1613          return this;
1614        }
1615
1616        /**
1617         * @return An absolute base URL for the implementation.  This forms the base for REST interfaces as well as the mailbox and document interfaces.
1618         */
1619        public String getUrl() { 
1620          return this.url == null ? null : this.url.getValue();
1621        }
1622
1623        /**
1624         * @param value An absolute base URL for the implementation.  This forms the base for REST interfaces as well as the mailbox and document interfaces.
1625         */
1626        public CapabilityStatementImplementationComponent setUrl(String value) { 
1627          if (Utilities.noString(value))
1628            this.url = null;
1629          else {
1630            if (this.url == null)
1631              this.url = new UrlType();
1632            this.url.setValue(value);
1633          }
1634          return this;
1635        }
1636
1637        /**
1638         * @return {@link #custodian} (The organization responsible for the management of the instance and oversight of the data on the server at the specified URL.)
1639         */
1640        public Reference getCustodian() { 
1641          if (this.custodian == null)
1642            if (Configuration.errorOnAutoCreate())
1643              throw new Error("Attempt to auto-create CapabilityStatementImplementationComponent.custodian");
1644            else if (Configuration.doAutoCreate())
1645              this.custodian = new Reference(); // cc
1646          return this.custodian;
1647        }
1648
1649        public boolean hasCustodian() { 
1650          return this.custodian != null && !this.custodian.isEmpty();
1651        }
1652
1653        /**
1654         * @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.)
1655         */
1656        public CapabilityStatementImplementationComponent setCustodian(Reference value) { 
1657          this.custodian = value;
1658          return this;
1659        }
1660
1661        protected void listChildren(List<Property> children) {
1662          super.listChildren(children);
1663          children.add(new Property("description", "markdown", "Information about the specific installation that this capability statement relates to.", 0, 1, description));
1664          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));
1665          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));
1666        }
1667
1668        @Override
1669        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1670          switch (_hash) {
1671          case -1724546052: /*description*/  return new Property("description", "markdown", "Information about the specific installation that this capability statement relates to.", 0, 1, description);
1672          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);
1673          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);
1674          default: return super.getNamedProperty(_hash, _name, _checkValid);
1675          }
1676
1677        }
1678
1679      @Override
1680      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1681        switch (hash) {
1682        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType
1683        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UrlType
1684        case 1611297262: /*custodian*/ return this.custodian == null ? new Base[0] : new Base[] {this.custodian}; // Reference
1685        default: return super.getProperty(hash, name, checkValid);
1686        }
1687
1688      }
1689
1690      @Override
1691      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1692        switch (hash) {
1693        case -1724546052: // description
1694          this.description = TypeConvertor.castToMarkdown(value); // MarkdownType
1695          return value;
1696        case 116079: // url
1697          this.url = TypeConvertor.castToUrl(value); // UrlType
1698          return value;
1699        case 1611297262: // custodian
1700          this.custodian = TypeConvertor.castToReference(value); // Reference
1701          return value;
1702        default: return super.setProperty(hash, name, value);
1703        }
1704
1705      }
1706
1707      @Override
1708      public Base setProperty(String name, Base value) throws FHIRException {
1709        if (name.equals("description")) {
1710          this.description = TypeConvertor.castToMarkdown(value); // MarkdownType
1711        } else if (name.equals("url")) {
1712          this.url = TypeConvertor.castToUrl(value); // UrlType
1713        } else if (name.equals("custodian")) {
1714          this.custodian = TypeConvertor.castToReference(value); // Reference
1715        } else
1716          return super.setProperty(name, value);
1717        return value;
1718      }
1719
1720      @Override
1721      public Base makeProperty(int hash, String name) throws FHIRException {
1722        switch (hash) {
1723        case -1724546052:  return getDescriptionElement();
1724        case 116079:  return getUrlElement();
1725        case 1611297262:  return getCustodian();
1726        default: return super.makeProperty(hash, name);
1727        }
1728
1729      }
1730
1731      @Override
1732      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1733        switch (hash) {
1734        case -1724546052: /*description*/ return new String[] {"markdown"};
1735        case 116079: /*url*/ return new String[] {"url"};
1736        case 1611297262: /*custodian*/ return new String[] {"Reference"};
1737        default: return super.getTypesForProperty(hash, name);
1738        }
1739
1740      }
1741
1742      @Override
1743      public Base addChild(String name) throws FHIRException {
1744        if (name.equals("description")) {
1745          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.implementation.description");
1746        }
1747        else if (name.equals("url")) {
1748          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.implementation.url");
1749        }
1750        else if (name.equals("custodian")) {
1751          this.custodian = new Reference();
1752          return this.custodian;
1753        }
1754        else
1755          return super.addChild(name);
1756      }
1757
1758      public CapabilityStatementImplementationComponent copy() {
1759        CapabilityStatementImplementationComponent dst = new CapabilityStatementImplementationComponent();
1760        copyValues(dst);
1761        return dst;
1762      }
1763
1764      public void copyValues(CapabilityStatementImplementationComponent dst) {
1765        super.copyValues(dst);
1766        dst.description = description == null ? null : description.copy();
1767        dst.url = url == null ? null : url.copy();
1768        dst.custodian = custodian == null ? null : custodian.copy();
1769      }
1770
1771      @Override
1772      public boolean equalsDeep(Base other_) {
1773        if (!super.equalsDeep(other_))
1774          return false;
1775        if (!(other_ instanceof CapabilityStatementImplementationComponent))
1776          return false;
1777        CapabilityStatementImplementationComponent o = (CapabilityStatementImplementationComponent) other_;
1778        return compareDeep(description, o.description, true) && compareDeep(url, o.url, true) && compareDeep(custodian, o.custodian, true)
1779          ;
1780      }
1781
1782      @Override
1783      public boolean equalsShallow(Base other_) {
1784        if (!super.equalsShallow(other_))
1785          return false;
1786        if (!(other_ instanceof CapabilityStatementImplementationComponent))
1787          return false;
1788        CapabilityStatementImplementationComponent o = (CapabilityStatementImplementationComponent) other_;
1789        return compareValues(description, o.description, true) && compareValues(url, o.url, true);
1790      }
1791
1792      public boolean isEmpty() {
1793        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(description, url, custodian
1794          );
1795      }
1796
1797  public String fhirType() {
1798    return "CapabilityStatement.implementation";
1799
1800  }
1801
1802  }
1803
1804    @Block()
1805    public static class CapabilityStatementRestComponent extends BackboneElement implements IBaseBackboneElement {
1806        /**
1807         * Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations.
1808         */
1809        @Child(name = "mode", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true)
1810        @Description(shortDefinition="client | server", formalDefinition="Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations." )
1811        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/restful-capability-mode")
1812        protected Enumeration<RestfulCapabilityMode> mode;
1813
1814        /**
1815         * Information about the system's restful capabilities that apply across all applications, such as security.
1816         */
1817        @Child(name = "documentation", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=false)
1818        @Description(shortDefinition="General description of implementation", formalDefinition="Information about the system's restful capabilities that apply across all applications, such as security." )
1819        protected MarkdownType documentation;
1820
1821        /**
1822         * Information about security implementation from an interface perspective - what a client needs to know.
1823         */
1824        @Child(name = "security", type = {}, order=3, min=0, max=1, modifier=false, summary=true)
1825        @Description(shortDefinition="Information about security of implementation", formalDefinition="Information about security implementation from an interface perspective - what a client needs to know." )
1826        protected CapabilityStatementRestSecurityComponent security;
1827
1828        /**
1829         * A specification of the restful capabilities of the solution for a specific resource type.
1830         */
1831        @Child(name = "resource", type = {}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1832        @Description(shortDefinition="Resource served on the REST interface", formalDefinition="A specification of the restful capabilities of the solution for a specific resource type." )
1833        protected List<CapabilityStatementRestResourceComponent> resource;
1834
1835        /**
1836         * A specification of restful operations supported by the system.
1837         */
1838        @Child(name = "interaction", type = {}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1839        @Description(shortDefinition="What operations are supported?", formalDefinition="A specification of restful operations supported by the system." )
1840        protected List<SystemInteractionComponent> interaction;
1841
1842        /**
1843         * 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. This is only for searches executed against the system-level endpoint.
1844         */
1845        @Child(name = "searchParam", type = {CapabilityStatementRestResourceSearchParamComponent.class}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1846        @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. This is only for searches executed against the system-level endpoint." )
1847        protected List<CapabilityStatementRestResourceSearchParamComponent> searchParam;
1848
1849        /**
1850         * Definition of an operation or a named query together with its parameters and their meaning and type.
1851         */
1852        @Child(name = "operation", type = {CapabilityStatementRestResourceOperationComponent.class}, order=7, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1853        @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." )
1854        protected List<CapabilityStatementRestResourceOperationComponent> operation;
1855
1856        /**
1857         * 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 .
1858         */
1859        @Child(name = "compartment", type = {CanonicalType.class}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1860        @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 ." )
1861        protected List<CanonicalType> compartment;
1862
1863        private static final long serialVersionUID = -1442029817L;
1864
1865    /**
1866     * Constructor
1867     */
1868      public CapabilityStatementRestComponent() {
1869        super();
1870      }
1871
1872    /**
1873     * Constructor
1874     */
1875      public CapabilityStatementRestComponent(RestfulCapabilityMode mode) {
1876        super();
1877        this.setMode(mode);
1878      }
1879
1880        /**
1881         * @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
1882         */
1883        public Enumeration<RestfulCapabilityMode> getModeElement() { 
1884          if (this.mode == null)
1885            if (Configuration.errorOnAutoCreate())
1886              throw new Error("Attempt to auto-create CapabilityStatementRestComponent.mode");
1887            else if (Configuration.doAutoCreate())
1888              this.mode = new Enumeration<RestfulCapabilityMode>(new RestfulCapabilityModeEnumFactory()); // bb
1889          return this.mode;
1890        }
1891
1892        public boolean hasModeElement() { 
1893          return this.mode != null && !this.mode.isEmpty();
1894        }
1895
1896        public boolean hasMode() { 
1897          return this.mode != null && !this.mode.isEmpty();
1898        }
1899
1900        /**
1901         * @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
1902         */
1903        public CapabilityStatementRestComponent setModeElement(Enumeration<RestfulCapabilityMode> value) { 
1904          this.mode = value;
1905          return this;
1906        }
1907
1908        /**
1909         * @return Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations.
1910         */
1911        public RestfulCapabilityMode getMode() { 
1912          return this.mode == null ? null : this.mode.getValue();
1913        }
1914
1915        /**
1916         * @param value Identifies whether this portion of the statement is describing the ability to initiate or receive restful operations.
1917         */
1918        public CapabilityStatementRestComponent setMode(RestfulCapabilityMode value) { 
1919            if (this.mode == null)
1920              this.mode = new Enumeration<RestfulCapabilityMode>(new RestfulCapabilityModeEnumFactory());
1921            this.mode.setValue(value);
1922          return this;
1923        }
1924
1925        /**
1926         * @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
1927         */
1928        public MarkdownType getDocumentationElement() { 
1929          if (this.documentation == null)
1930            if (Configuration.errorOnAutoCreate())
1931              throw new Error("Attempt to auto-create CapabilityStatementRestComponent.documentation");
1932            else if (Configuration.doAutoCreate())
1933              this.documentation = new MarkdownType(); // bb
1934          return this.documentation;
1935        }
1936
1937        public boolean hasDocumentationElement() { 
1938          return this.documentation != null && !this.documentation.isEmpty();
1939        }
1940
1941        public boolean hasDocumentation() { 
1942          return this.documentation != null && !this.documentation.isEmpty();
1943        }
1944
1945        /**
1946         * @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
1947         */
1948        public CapabilityStatementRestComponent setDocumentationElement(MarkdownType value) { 
1949          this.documentation = value;
1950          return this;
1951        }
1952
1953        /**
1954         * @return Information about the system's restful capabilities that apply across all applications, such as security.
1955         */
1956        public String getDocumentation() { 
1957          return this.documentation == null ? null : this.documentation.getValue();
1958        }
1959
1960        /**
1961         * @param value Information about the system's restful capabilities that apply across all applications, such as security.
1962         */
1963        public CapabilityStatementRestComponent setDocumentation(String value) { 
1964          if (Utilities.noString(value))
1965            this.documentation = null;
1966          else {
1967            if (this.documentation == null)
1968              this.documentation = new MarkdownType();
1969            this.documentation.setValue(value);
1970          }
1971          return this;
1972        }
1973
1974        /**
1975         * @return {@link #security} (Information about security implementation from an interface perspective - what a client needs to know.)
1976         */
1977        public CapabilityStatementRestSecurityComponent getSecurity() { 
1978          if (this.security == null)
1979            if (Configuration.errorOnAutoCreate())
1980              throw new Error("Attempt to auto-create CapabilityStatementRestComponent.security");
1981            else if (Configuration.doAutoCreate())
1982              this.security = new CapabilityStatementRestSecurityComponent(); // cc
1983          return this.security;
1984        }
1985
1986        public boolean hasSecurity() { 
1987          return this.security != null && !this.security.isEmpty();
1988        }
1989
1990        /**
1991         * @param value {@link #security} (Information about security implementation from an interface perspective - what a client needs to know.)
1992         */
1993        public CapabilityStatementRestComponent setSecurity(CapabilityStatementRestSecurityComponent value) { 
1994          this.security = value;
1995          return this;
1996        }
1997
1998        /**
1999         * @return {@link #resource} (A specification of the restful capabilities of the solution for a specific resource type.)
2000         */
2001        public List<CapabilityStatementRestResourceComponent> getResource() { 
2002          if (this.resource == null)
2003            this.resource = new ArrayList<CapabilityStatementRestResourceComponent>();
2004          return this.resource;
2005        }
2006
2007        /**
2008         * @return Returns a reference to <code>this</code> for easy method chaining
2009         */
2010        public CapabilityStatementRestComponent setResource(List<CapabilityStatementRestResourceComponent> theResource) { 
2011          this.resource = theResource;
2012          return this;
2013        }
2014
2015        public boolean hasResource() { 
2016          if (this.resource == null)
2017            return false;
2018          for (CapabilityStatementRestResourceComponent item : this.resource)
2019            if (!item.isEmpty())
2020              return true;
2021          return false;
2022        }
2023
2024        public CapabilityStatementRestResourceComponent addResource() { //3
2025          CapabilityStatementRestResourceComponent t = new CapabilityStatementRestResourceComponent();
2026          if (this.resource == null)
2027            this.resource = new ArrayList<CapabilityStatementRestResourceComponent>();
2028          this.resource.add(t);
2029          return t;
2030        }
2031
2032        public CapabilityStatementRestComponent addResource(CapabilityStatementRestResourceComponent t) { //3
2033          if (t == null)
2034            return this;
2035          if (this.resource == null)
2036            this.resource = new ArrayList<CapabilityStatementRestResourceComponent>();
2037          this.resource.add(t);
2038          return this;
2039        }
2040
2041        /**
2042         * @return The first repetition of repeating field {@link #resource}, creating it if it does not already exist {3}
2043         */
2044        public CapabilityStatementRestResourceComponent getResourceFirstRep() { 
2045          if (getResource().isEmpty()) {
2046            addResource();
2047          }
2048          return getResource().get(0);
2049        }
2050
2051        /**
2052         * @return {@link #interaction} (A specification of restful operations supported by the system.)
2053         */
2054        public List<SystemInteractionComponent> getInteraction() { 
2055          if (this.interaction == null)
2056            this.interaction = new ArrayList<SystemInteractionComponent>();
2057          return this.interaction;
2058        }
2059
2060        /**
2061         * @return Returns a reference to <code>this</code> for easy method chaining
2062         */
2063        public CapabilityStatementRestComponent setInteraction(List<SystemInteractionComponent> theInteraction) { 
2064          this.interaction = theInteraction;
2065          return this;
2066        }
2067
2068        public boolean hasInteraction() { 
2069          if (this.interaction == null)
2070            return false;
2071          for (SystemInteractionComponent item : this.interaction)
2072            if (!item.isEmpty())
2073              return true;
2074          return false;
2075        }
2076
2077        public SystemInteractionComponent addInteraction() { //3
2078          SystemInteractionComponent t = new SystemInteractionComponent();
2079          if (this.interaction == null)
2080            this.interaction = new ArrayList<SystemInteractionComponent>();
2081          this.interaction.add(t);
2082          return t;
2083        }
2084
2085        public CapabilityStatementRestComponent addInteraction(SystemInteractionComponent t) { //3
2086          if (t == null)
2087            return this;
2088          if (this.interaction == null)
2089            this.interaction = new ArrayList<SystemInteractionComponent>();
2090          this.interaction.add(t);
2091          return this;
2092        }
2093
2094        /**
2095         * @return The first repetition of repeating field {@link #interaction}, creating it if it does not already exist {3}
2096         */
2097        public SystemInteractionComponent getInteractionFirstRep() { 
2098          if (getInteraction().isEmpty()) {
2099            addInteraction();
2100          }
2101          return getInteraction().get(0);
2102        }
2103
2104        /**
2105         * @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. This is only for searches executed against the system-level endpoint.)
2106         */
2107        public List<CapabilityStatementRestResourceSearchParamComponent> getSearchParam() { 
2108          if (this.searchParam == null)
2109            this.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>();
2110          return this.searchParam;
2111        }
2112
2113        /**
2114         * @return Returns a reference to <code>this</code> for easy method chaining
2115         */
2116        public CapabilityStatementRestComponent setSearchParam(List<CapabilityStatementRestResourceSearchParamComponent> theSearchParam) { 
2117          this.searchParam = theSearchParam;
2118          return this;
2119        }
2120
2121        public boolean hasSearchParam() { 
2122          if (this.searchParam == null)
2123            return false;
2124          for (CapabilityStatementRestResourceSearchParamComponent item : this.searchParam)
2125            if (!item.isEmpty())
2126              return true;
2127          return false;
2128        }
2129
2130        public CapabilityStatementRestResourceSearchParamComponent addSearchParam() { //3
2131          CapabilityStatementRestResourceSearchParamComponent t = new CapabilityStatementRestResourceSearchParamComponent();
2132          if (this.searchParam == null)
2133            this.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>();
2134          this.searchParam.add(t);
2135          return t;
2136        }
2137
2138        public CapabilityStatementRestComponent addSearchParam(CapabilityStatementRestResourceSearchParamComponent t) { //3
2139          if (t == null)
2140            return this;
2141          if (this.searchParam == null)
2142            this.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>();
2143          this.searchParam.add(t);
2144          return this;
2145        }
2146
2147        /**
2148         * @return The first repetition of repeating field {@link #searchParam}, creating it if it does not already exist {3}
2149         */
2150        public CapabilityStatementRestResourceSearchParamComponent getSearchParamFirstRep() { 
2151          if (getSearchParam().isEmpty()) {
2152            addSearchParam();
2153          }
2154          return getSearchParam().get(0);
2155        }
2156
2157        /**
2158         * @return {@link #operation} (Definition of an operation or a named query together with its parameters and their meaning and type.)
2159         */
2160        public List<CapabilityStatementRestResourceOperationComponent> getOperation() { 
2161          if (this.operation == null)
2162            this.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>();
2163          return this.operation;
2164        }
2165
2166        /**
2167         * @return Returns a reference to <code>this</code> for easy method chaining
2168         */
2169        public CapabilityStatementRestComponent setOperation(List<CapabilityStatementRestResourceOperationComponent> theOperation) { 
2170          this.operation = theOperation;
2171          return this;
2172        }
2173
2174        public boolean hasOperation() { 
2175          if (this.operation == null)
2176            return false;
2177          for (CapabilityStatementRestResourceOperationComponent item : this.operation)
2178            if (!item.isEmpty())
2179              return true;
2180          return false;
2181        }
2182
2183        public CapabilityStatementRestResourceOperationComponent addOperation() { //3
2184          CapabilityStatementRestResourceOperationComponent t = new CapabilityStatementRestResourceOperationComponent();
2185          if (this.operation == null)
2186            this.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>();
2187          this.operation.add(t);
2188          return t;
2189        }
2190
2191        public CapabilityStatementRestComponent addOperation(CapabilityStatementRestResourceOperationComponent t) { //3
2192          if (t == null)
2193            return this;
2194          if (this.operation == null)
2195            this.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>();
2196          this.operation.add(t);
2197          return this;
2198        }
2199
2200        /**
2201         * @return The first repetition of repeating field {@link #operation}, creating it if it does not already exist {3}
2202         */
2203        public CapabilityStatementRestResourceOperationComponent getOperationFirstRep() { 
2204          if (getOperation().isEmpty()) {
2205            addOperation();
2206          }
2207          return getOperation().get(0);
2208        }
2209
2210        /**
2211         * @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 .)
2212         */
2213        public List<CanonicalType> getCompartment() { 
2214          if (this.compartment == null)
2215            this.compartment = new ArrayList<CanonicalType>();
2216          return this.compartment;
2217        }
2218
2219        /**
2220         * @return Returns a reference to <code>this</code> for easy method chaining
2221         */
2222        public CapabilityStatementRestComponent setCompartment(List<CanonicalType> theCompartment) { 
2223          this.compartment = theCompartment;
2224          return this;
2225        }
2226
2227        public boolean hasCompartment() { 
2228          if (this.compartment == null)
2229            return false;
2230          for (CanonicalType item : this.compartment)
2231            if (!item.isEmpty())
2232              return true;
2233          return false;
2234        }
2235
2236        /**
2237         * @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 .)
2238         */
2239        public CanonicalType addCompartmentElement() {//2 
2240          CanonicalType t = new CanonicalType();
2241          if (this.compartment == null)
2242            this.compartment = new ArrayList<CanonicalType>();
2243          this.compartment.add(t);
2244          return t;
2245        }
2246
2247        /**
2248         * @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 .)
2249         */
2250        public CapabilityStatementRestComponent addCompartment(String value) { //1
2251          CanonicalType t = new CanonicalType();
2252          t.setValue(value);
2253          if (this.compartment == null)
2254            this.compartment = new ArrayList<CanonicalType>();
2255          this.compartment.add(t);
2256          return this;
2257        }
2258
2259        /**
2260         * @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 .)
2261         */
2262        public boolean hasCompartment(String value) { 
2263          if (this.compartment == null)
2264            return false;
2265          for (CanonicalType v : this.compartment)
2266            if (v.getValue().equals(value)) // canonical
2267              return true;
2268          return false;
2269        }
2270
2271        protected void listChildren(List<Property> children) {
2272          super.listChildren(children);
2273          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));
2274          children.add(new Property("documentation", "markdown", "Information about the system's restful capabilities that apply across all applications, such as security.", 0, 1, documentation));
2275          children.add(new Property("security", "", "Information about security implementation from an interface perspective - what a client needs to know.", 0, 1, security));
2276          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));
2277          children.add(new Property("interaction", "", "A specification of restful operations supported by the system.", 0, java.lang.Integer.MAX_VALUE, interaction));
2278          children.add(new Property("searchParam", "@CapabilityStatement.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. This is only for searches executed against the system-level endpoint.", 0, java.lang.Integer.MAX_VALUE, searchParam));
2279          children.add(new Property("operation", "@CapabilityStatement.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));
2280          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));
2281        }
2282
2283        @Override
2284        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2285          switch (_hash) {
2286          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);
2287          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);
2288          case 949122880: /*security*/  return new Property("security", "", "Information about security implementation from an interface perspective - what a client needs to know.", 0, 1, security);
2289          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);
2290          case 1844104722: /*interaction*/  return new Property("interaction", "", "A specification of restful operations supported by the system.", 0, java.lang.Integer.MAX_VALUE, interaction);
2291          case -553645115: /*searchParam*/  return new Property("searchParam", "@CapabilityStatement.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. This is only for searches executed against the system-level endpoint.", 0, java.lang.Integer.MAX_VALUE, searchParam);
2292          case 1662702951: /*operation*/  return new Property("operation", "@CapabilityStatement.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);
2293          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);
2294          default: return super.getNamedProperty(_hash, _name, _checkValid);
2295          }
2296
2297        }
2298
2299      @Override
2300      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2301        switch (hash) {
2302        case 3357091: /*mode*/ return this.mode == null ? new Base[0] : new Base[] {this.mode}; // Enumeration<RestfulCapabilityMode>
2303        case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType
2304        case 949122880: /*security*/ return this.security == null ? new Base[0] : new Base[] {this.security}; // CapabilityStatementRestSecurityComponent
2305        case -341064690: /*resource*/ return this.resource == null ? new Base[0] : this.resource.toArray(new Base[this.resource.size()]); // CapabilityStatementRestResourceComponent
2306        case 1844104722: /*interaction*/ return this.interaction == null ? new Base[0] : this.interaction.toArray(new Base[this.interaction.size()]); // SystemInteractionComponent
2307        case -553645115: /*searchParam*/ return this.searchParam == null ? new Base[0] : this.searchParam.toArray(new Base[this.searchParam.size()]); // CapabilityStatementRestResourceSearchParamComponent
2308        case 1662702951: /*operation*/ return this.operation == null ? new Base[0] : this.operation.toArray(new Base[this.operation.size()]); // CapabilityStatementRestResourceOperationComponent
2309        case -397756334: /*compartment*/ return this.compartment == null ? new Base[0] : this.compartment.toArray(new Base[this.compartment.size()]); // CanonicalType
2310        default: return super.getProperty(hash, name, checkValid);
2311        }
2312
2313      }
2314
2315      @Override
2316      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2317        switch (hash) {
2318        case 3357091: // mode
2319          value = new RestfulCapabilityModeEnumFactory().fromType(TypeConvertor.castToCode(value));
2320          this.mode = (Enumeration) value; // Enumeration<RestfulCapabilityMode>
2321          return value;
2322        case 1587405498: // documentation
2323          this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType
2324          return value;
2325        case 949122880: // security
2326          this.security = (CapabilityStatementRestSecurityComponent) value; // CapabilityStatementRestSecurityComponent
2327          return value;
2328        case -341064690: // resource
2329          this.getResource().add((CapabilityStatementRestResourceComponent) value); // CapabilityStatementRestResourceComponent
2330          return value;
2331        case 1844104722: // interaction
2332          this.getInteraction().add((SystemInteractionComponent) value); // SystemInteractionComponent
2333          return value;
2334        case -553645115: // searchParam
2335          this.getSearchParam().add((CapabilityStatementRestResourceSearchParamComponent) value); // CapabilityStatementRestResourceSearchParamComponent
2336          return value;
2337        case 1662702951: // operation
2338          this.getOperation().add((CapabilityStatementRestResourceOperationComponent) value); // CapabilityStatementRestResourceOperationComponent
2339          return value;
2340        case -397756334: // compartment
2341          this.getCompartment().add(TypeConvertor.castToCanonical(value)); // CanonicalType
2342          return value;
2343        default: return super.setProperty(hash, name, value);
2344        }
2345
2346      }
2347
2348      @Override
2349      public Base setProperty(String name, Base value) throws FHIRException {
2350        if (name.equals("mode")) {
2351          value = new RestfulCapabilityModeEnumFactory().fromType(TypeConvertor.castToCode(value));
2352          this.mode = (Enumeration) value; // Enumeration<RestfulCapabilityMode>
2353        } else if (name.equals("documentation")) {
2354          this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType
2355        } else if (name.equals("security")) {
2356          this.security = (CapabilityStatementRestSecurityComponent) value; // CapabilityStatementRestSecurityComponent
2357        } else if (name.equals("resource")) {
2358          this.getResource().add((CapabilityStatementRestResourceComponent) value);
2359        } else if (name.equals("interaction")) {
2360          this.getInteraction().add((SystemInteractionComponent) value);
2361        } else if (name.equals("searchParam")) {
2362          this.getSearchParam().add((CapabilityStatementRestResourceSearchParamComponent) value);
2363        } else if (name.equals("operation")) {
2364          this.getOperation().add((CapabilityStatementRestResourceOperationComponent) value);
2365        } else if (name.equals("compartment")) {
2366          this.getCompartment().add(TypeConvertor.castToCanonical(value));
2367        } else
2368          return super.setProperty(name, value);
2369        return value;
2370      }
2371
2372      @Override
2373      public Base makeProperty(int hash, String name) throws FHIRException {
2374        switch (hash) {
2375        case 3357091:  return getModeElement();
2376        case 1587405498:  return getDocumentationElement();
2377        case 949122880:  return getSecurity();
2378        case -341064690:  return addResource(); 
2379        case 1844104722:  return addInteraction(); 
2380        case -553645115:  return addSearchParam(); 
2381        case 1662702951:  return addOperation(); 
2382        case -397756334:  return addCompartmentElement();
2383        default: return super.makeProperty(hash, name);
2384        }
2385
2386      }
2387
2388      @Override
2389      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2390        switch (hash) {
2391        case 3357091: /*mode*/ return new String[] {"code"};
2392        case 1587405498: /*documentation*/ return new String[] {"markdown"};
2393        case 949122880: /*security*/ return new String[] {};
2394        case -341064690: /*resource*/ return new String[] {};
2395        case 1844104722: /*interaction*/ return new String[] {};
2396        case -553645115: /*searchParam*/ return new String[] {"@CapabilityStatement.rest.resource.searchParam"};
2397        case 1662702951: /*operation*/ return new String[] {"@CapabilityStatement.rest.resource.operation"};
2398        case -397756334: /*compartment*/ return new String[] {"canonical"};
2399        default: return super.getTypesForProperty(hash, name);
2400        }
2401
2402      }
2403
2404      @Override
2405      public Base addChild(String name) throws FHIRException {
2406        if (name.equals("mode")) {
2407          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.mode");
2408        }
2409        else if (name.equals("documentation")) {
2410          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.documentation");
2411        }
2412        else if (name.equals("security")) {
2413          this.security = new CapabilityStatementRestSecurityComponent();
2414          return this.security;
2415        }
2416        else if (name.equals("resource")) {
2417          return addResource();
2418        }
2419        else if (name.equals("interaction")) {
2420          return addInteraction();
2421        }
2422        else if (name.equals("searchParam")) {
2423          return addSearchParam();
2424        }
2425        else if (name.equals("operation")) {
2426          return addOperation();
2427        }
2428        else if (name.equals("compartment")) {
2429          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.compartment");
2430        }
2431        else
2432          return super.addChild(name);
2433      }
2434
2435      public CapabilityStatementRestComponent copy() {
2436        CapabilityStatementRestComponent dst = new CapabilityStatementRestComponent();
2437        copyValues(dst);
2438        return dst;
2439      }
2440
2441      public void copyValues(CapabilityStatementRestComponent dst) {
2442        super.copyValues(dst);
2443        dst.mode = mode == null ? null : mode.copy();
2444        dst.documentation = documentation == null ? null : documentation.copy();
2445        dst.security = security == null ? null : security.copy();
2446        if (resource != null) {
2447          dst.resource = new ArrayList<CapabilityStatementRestResourceComponent>();
2448          for (CapabilityStatementRestResourceComponent i : resource)
2449            dst.resource.add(i.copy());
2450        };
2451        if (interaction != null) {
2452          dst.interaction = new ArrayList<SystemInteractionComponent>();
2453          for (SystemInteractionComponent i : interaction)
2454            dst.interaction.add(i.copy());
2455        };
2456        if (searchParam != null) {
2457          dst.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>();
2458          for (CapabilityStatementRestResourceSearchParamComponent i : searchParam)
2459            dst.searchParam.add(i.copy());
2460        };
2461        if (operation != null) {
2462          dst.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>();
2463          for (CapabilityStatementRestResourceOperationComponent i : operation)
2464            dst.operation.add(i.copy());
2465        };
2466        if (compartment != null) {
2467          dst.compartment = new ArrayList<CanonicalType>();
2468          for (CanonicalType i : compartment)
2469            dst.compartment.add(i.copy());
2470        };
2471      }
2472
2473      @Override
2474      public boolean equalsDeep(Base other_) {
2475        if (!super.equalsDeep(other_))
2476          return false;
2477        if (!(other_ instanceof CapabilityStatementRestComponent))
2478          return false;
2479        CapabilityStatementRestComponent o = (CapabilityStatementRestComponent) other_;
2480        return compareDeep(mode, o.mode, true) && compareDeep(documentation, o.documentation, true) && compareDeep(security, o.security, true)
2481           && compareDeep(resource, o.resource, true) && compareDeep(interaction, o.interaction, true) && compareDeep(searchParam, o.searchParam, true)
2482           && compareDeep(operation, o.operation, true) && compareDeep(compartment, o.compartment, true);
2483      }
2484
2485      @Override
2486      public boolean equalsShallow(Base other_) {
2487        if (!super.equalsShallow(other_))
2488          return false;
2489        if (!(other_ instanceof CapabilityStatementRestComponent))
2490          return false;
2491        CapabilityStatementRestComponent o = (CapabilityStatementRestComponent) other_;
2492        return compareValues(mode, o.mode, true) && compareValues(documentation, o.documentation, true) && compareValues(compartment, o.compartment, true)
2493          ;
2494      }
2495
2496      public boolean isEmpty() {
2497        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(mode, documentation, security
2498          , resource, interaction, searchParam, operation, compartment);
2499      }
2500
2501  public String fhirType() {
2502    return "CapabilityStatement.rest";
2503
2504  }
2505
2506  }
2507
2508    @Block()
2509    public static class CapabilityStatementRestSecurityComponent extends BackboneElement implements IBaseBackboneElement {
2510        /**
2511         * Server adds CORS headers when responding to requests - this enables Javascript applications to use the server.
2512         */
2513        @Child(name = "cors", type = {BooleanType.class}, order=1, min=0, max=1, modifier=false, summary=true)
2514        @Description(shortDefinition="Adds CORS Headers (http://enable-cors.org/)", formalDefinition="Server adds CORS headers when responding to requests - this enables Javascript applications to use the server." )
2515        protected BooleanType cors;
2516
2517        /**
2518         * Types of security services that are supported/required by the system.
2519         */
2520        @Child(name = "service", type = {CodeableConcept.class}, order=2, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
2521        @Description(shortDefinition="OAuth | SMART-on-FHIR | NTLM | Basic | Kerberos | Certificates", formalDefinition="Types of security services that are supported/required by the system." )
2522        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/restful-security-service")
2523        protected List<CodeableConcept> service;
2524
2525        /**
2526         * General description of how security works.
2527         */
2528        @Child(name = "description", type = {MarkdownType.class}, order=3, min=0, max=1, modifier=false, summary=false)
2529        @Description(shortDefinition="General description of how security works", formalDefinition="General description of how security works." )
2530        protected MarkdownType description;
2531
2532        private static final long serialVersionUID = -1348900500L;
2533
2534    /**
2535     * Constructor
2536     */
2537      public CapabilityStatementRestSecurityComponent() {
2538        super();
2539      }
2540
2541        /**
2542         * @return {@link #cors} (Server adds CORS headers when responding to requests - this enables Javascript applications to use the server.). This is the underlying object with id, value and extensions. The accessor "getCors" gives direct access to the value
2543         */
2544        public BooleanType getCorsElement() { 
2545          if (this.cors == null)
2546            if (Configuration.errorOnAutoCreate())
2547              throw new Error("Attempt to auto-create CapabilityStatementRestSecurityComponent.cors");
2548            else if (Configuration.doAutoCreate())
2549              this.cors = new BooleanType(); // bb
2550          return this.cors;
2551        }
2552
2553        public boolean hasCorsElement() { 
2554          return this.cors != null && !this.cors.isEmpty();
2555        }
2556
2557        public boolean hasCors() { 
2558          return this.cors != null && !this.cors.isEmpty();
2559        }
2560
2561        /**
2562         * @param value {@link #cors} (Server adds CORS headers when responding to requests - this enables Javascript applications to use the server.). This is the underlying object with id, value and extensions. The accessor "getCors" gives direct access to the value
2563         */
2564        public CapabilityStatementRestSecurityComponent setCorsElement(BooleanType value) { 
2565          this.cors = value;
2566          return this;
2567        }
2568
2569        /**
2570         * @return Server adds CORS headers when responding to requests - this enables Javascript applications to use the server.
2571         */
2572        public boolean getCors() { 
2573          return this.cors == null || this.cors.isEmpty() ? false : this.cors.getValue();
2574        }
2575
2576        /**
2577         * @param value Server adds CORS headers when responding to requests - this enables Javascript applications to use the server.
2578         */
2579        public CapabilityStatementRestSecurityComponent setCors(boolean value) { 
2580            if (this.cors == null)
2581              this.cors = new BooleanType();
2582            this.cors.setValue(value);
2583          return this;
2584        }
2585
2586        /**
2587         * @return {@link #service} (Types of security services that are supported/required by the system.)
2588         */
2589        public List<CodeableConcept> getService() { 
2590          if (this.service == null)
2591            this.service = new ArrayList<CodeableConcept>();
2592          return this.service;
2593        }
2594
2595        /**
2596         * @return Returns a reference to <code>this</code> for easy method chaining
2597         */
2598        public CapabilityStatementRestSecurityComponent setService(List<CodeableConcept> theService) { 
2599          this.service = theService;
2600          return this;
2601        }
2602
2603        public boolean hasService() { 
2604          if (this.service == null)
2605            return false;
2606          for (CodeableConcept item : this.service)
2607            if (!item.isEmpty())
2608              return true;
2609          return false;
2610        }
2611
2612        public CodeableConcept addService() { //3
2613          CodeableConcept t = new CodeableConcept();
2614          if (this.service == null)
2615            this.service = new ArrayList<CodeableConcept>();
2616          this.service.add(t);
2617          return t;
2618        }
2619
2620        public CapabilityStatementRestSecurityComponent addService(CodeableConcept t) { //3
2621          if (t == null)
2622            return this;
2623          if (this.service == null)
2624            this.service = new ArrayList<CodeableConcept>();
2625          this.service.add(t);
2626          return this;
2627        }
2628
2629        /**
2630         * @return The first repetition of repeating field {@link #service}, creating it if it does not already exist {3}
2631         */
2632        public CodeableConcept getServiceFirstRep() { 
2633          if (getService().isEmpty()) {
2634            addService();
2635          }
2636          return getService().get(0);
2637        }
2638
2639        /**
2640         * @return {@link #description} (General description of how security works.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
2641         */
2642        public MarkdownType getDescriptionElement() { 
2643          if (this.description == null)
2644            if (Configuration.errorOnAutoCreate())
2645              throw new Error("Attempt to auto-create CapabilityStatementRestSecurityComponent.description");
2646            else if (Configuration.doAutoCreate())
2647              this.description = new MarkdownType(); // bb
2648          return this.description;
2649        }
2650
2651        public boolean hasDescriptionElement() { 
2652          return this.description != null && !this.description.isEmpty();
2653        }
2654
2655        public boolean hasDescription() { 
2656          return this.description != null && !this.description.isEmpty();
2657        }
2658
2659        /**
2660         * @param value {@link #description} (General description of how security works.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
2661         */
2662        public CapabilityStatementRestSecurityComponent setDescriptionElement(MarkdownType value) { 
2663          this.description = value;
2664          return this;
2665        }
2666
2667        /**
2668         * @return General description of how security works.
2669         */
2670        public String getDescription() { 
2671          return this.description == null ? null : this.description.getValue();
2672        }
2673
2674        /**
2675         * @param value General description of how security works.
2676         */
2677        public CapabilityStatementRestSecurityComponent setDescription(String value) { 
2678          if (Utilities.noString(value))
2679            this.description = null;
2680          else {
2681            if (this.description == null)
2682              this.description = new MarkdownType();
2683            this.description.setValue(value);
2684          }
2685          return this;
2686        }
2687
2688        protected void listChildren(List<Property> children) {
2689          super.listChildren(children);
2690          children.add(new Property("cors", "boolean", "Server adds CORS headers when responding to requests - this enables Javascript applications to use the server.", 0, 1, cors));
2691          children.add(new Property("service", "CodeableConcept", "Types of security services that are supported/required by the system.", 0, java.lang.Integer.MAX_VALUE, service));
2692          children.add(new Property("description", "markdown", "General description of how security works.", 0, 1, description));
2693        }
2694
2695        @Override
2696        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2697          switch (_hash) {
2698          case 3059629: /*cors*/  return new Property("cors", "boolean", "Server adds CORS headers when responding to requests - this enables Javascript applications to use the server.", 0, 1, cors);
2699          case 1984153269: /*service*/  return new Property("service", "CodeableConcept", "Types of security services that are supported/required by the system.", 0, java.lang.Integer.MAX_VALUE, service);
2700          case -1724546052: /*description*/  return new Property("description", "markdown", "General description of how security works.", 0, 1, description);
2701          default: return super.getNamedProperty(_hash, _name, _checkValid);
2702          }
2703
2704        }
2705
2706      @Override
2707      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2708        switch (hash) {
2709        case 3059629: /*cors*/ return this.cors == null ? new Base[0] : new Base[] {this.cors}; // BooleanType
2710        case 1984153269: /*service*/ return this.service == null ? new Base[0] : this.service.toArray(new Base[this.service.size()]); // CodeableConcept
2711        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType
2712        default: return super.getProperty(hash, name, checkValid);
2713        }
2714
2715      }
2716
2717      @Override
2718      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2719        switch (hash) {
2720        case 3059629: // cors
2721          this.cors = TypeConvertor.castToBoolean(value); // BooleanType
2722          return value;
2723        case 1984153269: // service
2724          this.getService().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept
2725          return value;
2726        case -1724546052: // description
2727          this.description = TypeConvertor.castToMarkdown(value); // MarkdownType
2728          return value;
2729        default: return super.setProperty(hash, name, value);
2730        }
2731
2732      }
2733
2734      @Override
2735      public Base setProperty(String name, Base value) throws FHIRException {
2736        if (name.equals("cors")) {
2737          this.cors = TypeConvertor.castToBoolean(value); // BooleanType
2738        } else if (name.equals("service")) {
2739          this.getService().add(TypeConvertor.castToCodeableConcept(value));
2740        } else if (name.equals("description")) {
2741          this.description = TypeConvertor.castToMarkdown(value); // MarkdownType
2742        } else
2743          return super.setProperty(name, value);
2744        return value;
2745      }
2746
2747      @Override
2748      public Base makeProperty(int hash, String name) throws FHIRException {
2749        switch (hash) {
2750        case 3059629:  return getCorsElement();
2751        case 1984153269:  return addService(); 
2752        case -1724546052:  return getDescriptionElement();
2753        default: return super.makeProperty(hash, name);
2754        }
2755
2756      }
2757
2758      @Override
2759      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2760        switch (hash) {
2761        case 3059629: /*cors*/ return new String[] {"boolean"};
2762        case 1984153269: /*service*/ return new String[] {"CodeableConcept"};
2763        case -1724546052: /*description*/ return new String[] {"markdown"};
2764        default: return super.getTypesForProperty(hash, name);
2765        }
2766
2767      }
2768
2769      @Override
2770      public Base addChild(String name) throws FHIRException {
2771        if (name.equals("cors")) {
2772          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.security.cors");
2773        }
2774        else if (name.equals("service")) {
2775          return addService();
2776        }
2777        else if (name.equals("description")) {
2778          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.security.description");
2779        }
2780        else
2781          return super.addChild(name);
2782      }
2783
2784      public CapabilityStatementRestSecurityComponent copy() {
2785        CapabilityStatementRestSecurityComponent dst = new CapabilityStatementRestSecurityComponent();
2786        copyValues(dst);
2787        return dst;
2788      }
2789
2790      public void copyValues(CapabilityStatementRestSecurityComponent dst) {
2791        super.copyValues(dst);
2792        dst.cors = cors == null ? null : cors.copy();
2793        if (service != null) {
2794          dst.service = new ArrayList<CodeableConcept>();
2795          for (CodeableConcept i : service)
2796            dst.service.add(i.copy());
2797        };
2798        dst.description = description == null ? null : description.copy();
2799      }
2800
2801      @Override
2802      public boolean equalsDeep(Base other_) {
2803        if (!super.equalsDeep(other_))
2804          return false;
2805        if (!(other_ instanceof CapabilityStatementRestSecurityComponent))
2806          return false;
2807        CapabilityStatementRestSecurityComponent o = (CapabilityStatementRestSecurityComponent) other_;
2808        return compareDeep(cors, o.cors, true) && compareDeep(service, o.service, true) && compareDeep(description, o.description, true)
2809          ;
2810      }
2811
2812      @Override
2813      public boolean equalsShallow(Base other_) {
2814        if (!super.equalsShallow(other_))
2815          return false;
2816        if (!(other_ instanceof CapabilityStatementRestSecurityComponent))
2817          return false;
2818        CapabilityStatementRestSecurityComponent o = (CapabilityStatementRestSecurityComponent) other_;
2819        return compareValues(cors, o.cors, true) && compareValues(description, o.description, true);
2820      }
2821
2822      public boolean isEmpty() {
2823        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(cors, service, description
2824          );
2825      }
2826
2827  public String fhirType() {
2828    return "CapabilityStatement.rest.security";
2829
2830  }
2831
2832  }
2833
2834    @Block()
2835    public static class CapabilityStatementRestResourceComponent extends BackboneElement implements IBaseBackboneElement {
2836        /**
2837         * A type of resource exposed via the restful interface.
2838         */
2839        @Child(name = "type", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true)
2840        @Description(shortDefinition="A resource type that is supported", formalDefinition="A type of resource exposed via the restful interface." )
2841        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/resource-types")
2842        protected CodeType type;
2843
2844        /**
2845         * A system-wide profile that is applied across *all* instances of the resource supported by the system. For example, if declared on Observation, this profile is the "superset" of capabilities for laboratory *and* vitals *and* other domains. See further discussion in [Using Profiles](profiling.html#profile-uses).
2846         */
2847        @Child(name = "profile", type = {CanonicalType.class}, order=2, min=0, max=1, modifier=false, summary=true)
2848        @Description(shortDefinition="System-wide profile", formalDefinition="A system-wide profile that is applied across *all* instances of the resource supported by the system. For example, if declared on Observation, this profile is the \"superset\" of capabilities for laboratory *and* vitals *and* other domains. See further discussion in [Using Profiles](profiling.html#profile-uses)." )
2849        protected CanonicalType profile;
2850
2851        /**
2852         * A list of profiles representing different use cases the system hosts/produces. A supported profile is a statement about the functionality of the data and services provided by the server (or the client) for supported use cases. For example, a system can define and declare multiple Observation profiles for laboratory observations, vital sign observations, etc. By declaring supported profiles, systems provide a way to determine whether individual resources are conformant. See further discussion in [Using Profiles](profiling.html#profile-uses).
2853         */
2854        @Child(name = "supportedProfile", type = {CanonicalType.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
2855        @Description(shortDefinition="Use-case specific profiles", formalDefinition="A list of profiles representing different use cases the system hosts/produces. A supported profile is a statement about the functionality of the data and services provided by the server (or the client) for supported use cases. For example, a system can define and declare multiple Observation profiles for laboratory observations, vital sign observations, etc. By declaring supported profiles, systems provide a way to determine whether individual resources are conformant. See further discussion in [Using Profiles](profiling.html#profile-uses)." )
2856        protected List<CanonicalType> supportedProfile;
2857
2858        /**
2859         * Additional information about the resource type used by the system.
2860         */
2861        @Child(name = "documentation", type = {MarkdownType.class}, order=4, min=0, max=1, modifier=false, summary=false)
2862        @Description(shortDefinition="Additional information about the use of the resource type", formalDefinition="Additional information about the resource type used by the system." )
2863        protected MarkdownType documentation;
2864
2865        /**
2866         * Identifies a restful operation supported by the solution.
2867         */
2868        @Child(name = "interaction", type = {}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2869        @Description(shortDefinition="What operations are supported?", formalDefinition="Identifies a restful operation supported by the solution." )
2870        protected List<ResourceInteractionComponent> interaction;
2871
2872        /**
2873         * This field is set to no-version to specify that the system does not support (server) or use (client) versioning for this resource type. If this has some other value, the server must at least correctly track and populate the versionId meta-property on resources. If the value is 'versioned-update', then the server supports all the versioning features, including using e-tags for version integrity in the API.
2874         */
2875        @Child(name = "versioning", type = {CodeType.class}, order=6, min=0, max=1, modifier=false, summary=false)
2876        @Description(shortDefinition="no-version | versioned | versioned-update", formalDefinition="This field is set to no-version to specify that the system does not support (server) or use (client) versioning for this resource type. If this has some other value, the server must at least correctly track and populate the versionId meta-property on resources. If the value is 'versioned-update', then the server supports all the versioning features, including using e-tags for version integrity in the API." )
2877        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/versioning-policy")
2878        protected Enumeration<ResourceVersionPolicy> versioning;
2879
2880        /**
2881         * A flag for whether the server is able to return past versions as part of the vRead operation.
2882         */
2883        @Child(name = "readHistory", type = {BooleanType.class}, order=7, min=0, max=1, modifier=false, summary=false)
2884        @Description(shortDefinition="Whether vRead can return past versions", formalDefinition="A flag for whether the server is able to return past versions as part of the vRead operation." )
2885        protected BooleanType readHistory;
2886
2887        /**
2888         * A flag to indicate that the server allows or needs to allow the client to create new identities on the server (that is, the client PUTs to a location where there is no existing resource). Allowing this operation means that the server allows the client to create new identities on the server.
2889         */
2890        @Child(name = "updateCreate", type = {BooleanType.class}, order=8, min=0, max=1, modifier=false, summary=false)
2891        @Description(shortDefinition="If update can commit to a new identity", formalDefinition="A flag to indicate that the server allows or needs to allow the client to create new identities on the server (that is, the client PUTs to a location where there is no existing resource). Allowing this operation means that the server allows the client to create new identities on the server." )
2892        protected BooleanType updateCreate;
2893
2894        /**
2895         * A flag that indicates that the server supports conditional create.
2896         */
2897        @Child(name = "conditionalCreate", type = {BooleanType.class}, order=9, min=0, max=1, modifier=false, summary=false)
2898        @Description(shortDefinition="If allows/uses conditional create", formalDefinition="A flag that indicates that the server supports conditional create." )
2899        protected BooleanType conditionalCreate;
2900
2901        /**
2902         * A code that indicates how the server supports conditional read.
2903         */
2904        @Child(name = "conditionalRead", type = {CodeType.class}, order=10, min=0, max=1, modifier=false, summary=false)
2905        @Description(shortDefinition="not-supported | modified-since | not-match | full-support", formalDefinition="A code that indicates how the server supports conditional read." )
2906        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/conditional-read-status")
2907        protected Enumeration<ConditionalReadStatus> conditionalRead;
2908
2909        /**
2910         * A flag that indicates that the server supports conditional update.
2911         */
2912        @Child(name = "conditionalUpdate", type = {BooleanType.class}, order=11, min=0, max=1, modifier=false, summary=false)
2913        @Description(shortDefinition="If allows/uses conditional update", formalDefinition="A flag that indicates that the server supports conditional update." )
2914        protected BooleanType conditionalUpdate;
2915
2916        /**
2917         * A flag that indicates that the server supports conditional patch.
2918         */
2919        @Child(name = "conditionalPatch", type = {BooleanType.class}, order=12, min=0, max=1, modifier=false, summary=false)
2920        @Description(shortDefinition="If allows/uses conditional patch", formalDefinition="A flag that indicates that the server supports conditional patch." )
2921        protected BooleanType conditionalPatch;
2922
2923        /**
2924         * A code that indicates how the server supports conditional delete.
2925         */
2926        @Child(name = "conditionalDelete", type = {CodeType.class}, order=13, min=0, max=1, modifier=false, summary=false)
2927        @Description(shortDefinition="not-supported | single | multiple - how conditional delete is supported", formalDefinition="A code that indicates how the server supports conditional delete." )
2928        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/conditional-delete-status")
2929        protected Enumeration<ConditionalDeleteStatus> conditionalDelete;
2930
2931        /**
2932         * A set of flags that defines how references are supported.
2933         */
2934        @Child(name = "referencePolicy", type = {CodeType.class}, order=14, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2935        @Description(shortDefinition="literal | logical | resolves | enforced | local", formalDefinition="A set of flags that defines how references are supported." )
2936        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/reference-handling-policy")
2937        protected List<Enumeration<ReferenceHandlingPolicy>> referencePolicy;
2938
2939        /**
2940         * A list of _include values supported by the server.
2941         */
2942        @Child(name = "searchInclude", type = {StringType.class}, order=15, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2943        @Description(shortDefinition="_include values supported by the server", formalDefinition="A list of _include values supported by the server." )
2944        protected List<StringType> searchInclude;
2945
2946        /**
2947         * A list of _revinclude (reverse include) values supported by the server.
2948         */
2949        @Child(name = "searchRevInclude", type = {StringType.class}, order=16, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2950        @Description(shortDefinition="_revinclude values supported by the server", formalDefinition="A list of _revinclude (reverse include) values supported by the server." )
2951        protected List<StringType> searchRevInclude;
2952
2953        /**
2954         * 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.
2955         */
2956        @Child(name = "searchParam", type = {}, order=17, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2957        @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." )
2958        protected List<CapabilityStatementRestResourceSearchParamComponent> searchParam;
2959
2960        /**
2961         * 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.
2962         */
2963        @Child(name = "operation", type = {}, order=18, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
2964        @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." )
2965        protected List<CapabilityStatementRestResourceOperationComponent> operation;
2966
2967        private static final long serialVersionUID = -1565226425L;
2968
2969    /**
2970     * Constructor
2971     */
2972      public CapabilityStatementRestResourceComponent() {
2973        super();
2974      }
2975
2976    /**
2977     * Constructor
2978     */
2979      public CapabilityStatementRestResourceComponent(String type) {
2980        super();
2981        this.setType(type);
2982      }
2983
2984        /**
2985         * @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
2986         */
2987        public CodeType getTypeElement() { 
2988          if (this.type == null)
2989            if (Configuration.errorOnAutoCreate())
2990              throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.type");
2991            else if (Configuration.doAutoCreate())
2992              this.type = new CodeType(); // bb
2993          return this.type;
2994        }
2995
2996        public boolean hasTypeElement() { 
2997          return this.type != null && !this.type.isEmpty();
2998        }
2999
3000        public boolean hasType() { 
3001          return this.type != null && !this.type.isEmpty();
3002        }
3003
3004        /**
3005         * @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
3006         */
3007        public CapabilityStatementRestResourceComponent setTypeElement(CodeType value) { 
3008          this.type = value;
3009          return this;
3010        }
3011
3012        /**
3013         * @return A type of resource exposed via the restful interface.
3014         */
3015        public String getType() { 
3016          return this.type == null ? null : this.type.getValue();
3017        }
3018
3019        /**
3020         * @param value A type of resource exposed via the restful interface.
3021         */
3022        public CapabilityStatementRestResourceComponent setType(String value) { 
3023            if (this.type == null)
3024              this.type = new CodeType();
3025            this.type.setValue(value);
3026          return this;
3027        }
3028
3029        /**
3030         * @return {@link #profile} (A system-wide profile that is applied across *all* instances of the resource supported by the system. For example, if declared on Observation, this profile is the "superset" of capabilities for laboratory *and* vitals *and* other domains. 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
3031         */
3032        public CanonicalType getProfileElement() { 
3033          if (this.profile == null)
3034            if (Configuration.errorOnAutoCreate())
3035              throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.profile");
3036            else if (Configuration.doAutoCreate())
3037              this.profile = new CanonicalType(); // bb
3038          return this.profile;
3039        }
3040
3041        public boolean hasProfileElement() { 
3042          return this.profile != null && !this.profile.isEmpty();
3043        }
3044
3045        public boolean hasProfile() { 
3046          return this.profile != null && !this.profile.isEmpty();
3047        }
3048
3049        /**
3050         * @param value {@link #profile} (A system-wide profile that is applied across *all* instances of the resource supported by the system. For example, if declared on Observation, this profile is the "superset" of capabilities for laboratory *and* vitals *and* other domains. 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
3051         */
3052        public CapabilityStatementRestResourceComponent setProfileElement(CanonicalType value) { 
3053          this.profile = value;
3054          return this;
3055        }
3056
3057        /**
3058         * @return A system-wide profile that is applied across *all* instances of the resource supported by the system. For example, if declared on Observation, this profile is the "superset" of capabilities for laboratory *and* vitals *and* other domains. See further discussion in [Using Profiles](profiling.html#profile-uses).
3059         */
3060        public String getProfile() { 
3061          return this.profile == null ? null : this.profile.getValue();
3062        }
3063
3064        /**
3065         * @param value A system-wide profile that is applied across *all* instances of the resource supported by the system. For example, if declared on Observation, this profile is the "superset" of capabilities for laboratory *and* vitals *and* other domains. See further discussion in [Using Profiles](profiling.html#profile-uses).
3066         */
3067        public CapabilityStatementRestResourceComponent setProfile(String value) { 
3068          if (Utilities.noString(value))
3069            this.profile = null;
3070          else {
3071            if (this.profile == null)
3072              this.profile = new CanonicalType();
3073            this.profile.setValue(value);
3074          }
3075          return this;
3076        }
3077
3078        /**
3079         * @return {@link #supportedProfile} (A list of profiles representing different use cases the system hosts/produces. A supported profile is a statement about the functionality of the data and services provided by the server (or the client) for supported use cases. For example, a system can define and declare multiple Observation profiles for laboratory observations, vital sign observations, etc. By declaring supported profiles, systems provide a way to determine whether individual resources are conformant. See further discussion in [Using Profiles](profiling.html#profile-uses).)
3080         */
3081        public List<CanonicalType> getSupportedProfile() { 
3082          if (this.supportedProfile == null)
3083            this.supportedProfile = new ArrayList<CanonicalType>();
3084          return this.supportedProfile;
3085        }
3086
3087        /**
3088         * @return Returns a reference to <code>this</code> for easy method chaining
3089         */
3090        public CapabilityStatementRestResourceComponent setSupportedProfile(List<CanonicalType> theSupportedProfile) { 
3091          this.supportedProfile = theSupportedProfile;
3092          return this;
3093        }
3094
3095        public boolean hasSupportedProfile() { 
3096          if (this.supportedProfile == null)
3097            return false;
3098          for (CanonicalType item : this.supportedProfile)
3099            if (!item.isEmpty())
3100              return true;
3101          return false;
3102        }
3103
3104        /**
3105         * @return {@link #supportedProfile} (A list of profiles representing different use cases the system hosts/produces. A supported profile is a statement about the functionality of the data and services provided by the server (or the client) for supported use cases. For example, a system can define and declare multiple Observation profiles for laboratory observations, vital sign observations, etc. By declaring supported profiles, systems provide a way to determine whether individual resources are conformant. See further discussion in [Using Profiles](profiling.html#profile-uses).)
3106         */
3107        public CanonicalType addSupportedProfileElement() {//2 
3108          CanonicalType t = new CanonicalType();
3109          if (this.supportedProfile == null)
3110            this.supportedProfile = new ArrayList<CanonicalType>();
3111          this.supportedProfile.add(t);
3112          return t;
3113        }
3114
3115        /**
3116         * @param value {@link #supportedProfile} (A list of profiles representing different use cases the system hosts/produces. A supported profile is a statement about the functionality of the data and services provided by the server (or the client) for supported use cases. For example, a system can define and declare multiple Observation profiles for laboratory observations, vital sign observations, etc. By declaring supported profiles, systems provide a way to determine whether individual resources are conformant. See further discussion in [Using Profiles](profiling.html#profile-uses).)
3117         */
3118        public CapabilityStatementRestResourceComponent addSupportedProfile(String value) { //1
3119          CanonicalType t = new CanonicalType();
3120          t.setValue(value);
3121          if (this.supportedProfile == null)
3122            this.supportedProfile = new ArrayList<CanonicalType>();
3123          this.supportedProfile.add(t);
3124          return this;
3125        }
3126
3127        /**
3128         * @param value {@link #supportedProfile} (A list of profiles representing different use cases the system hosts/produces. A supported profile is a statement about the functionality of the data and services provided by the server (or the client) for supported use cases. For example, a system can define and declare multiple Observation profiles for laboratory observations, vital sign observations, etc. By declaring supported profiles, systems provide a way to determine whether individual resources are conformant. See further discussion in [Using Profiles](profiling.html#profile-uses).)
3129         */
3130        public boolean hasSupportedProfile(String value) { 
3131          if (this.supportedProfile == null)
3132            return false;
3133          for (CanonicalType v : this.supportedProfile)
3134            if (v.getValue().equals(value)) // canonical
3135              return true;
3136          return false;
3137        }
3138
3139        /**
3140         * @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
3141         */
3142        public MarkdownType getDocumentationElement() { 
3143          if (this.documentation == null)
3144            if (Configuration.errorOnAutoCreate())
3145              throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.documentation");
3146            else if (Configuration.doAutoCreate())
3147              this.documentation = new MarkdownType(); // bb
3148          return this.documentation;
3149        }
3150
3151        public boolean hasDocumentationElement() { 
3152          return this.documentation != null && !this.documentation.isEmpty();
3153        }
3154
3155        public boolean hasDocumentation() { 
3156          return this.documentation != null && !this.documentation.isEmpty();
3157        }
3158
3159        /**
3160         * @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
3161         */
3162        public CapabilityStatementRestResourceComponent setDocumentationElement(MarkdownType value) { 
3163          this.documentation = value;
3164          return this;
3165        }
3166
3167        /**
3168         * @return Additional information about the resource type used by the system.
3169         */
3170        public String getDocumentation() { 
3171          return this.documentation == null ? null : this.documentation.getValue();
3172        }
3173
3174        /**
3175         * @param value Additional information about the resource type used by the system.
3176         */
3177        public CapabilityStatementRestResourceComponent setDocumentation(String value) { 
3178          if (Utilities.noString(value))
3179            this.documentation = null;
3180          else {
3181            if (this.documentation == null)
3182              this.documentation = new MarkdownType();
3183            this.documentation.setValue(value);
3184          }
3185          return this;
3186        }
3187
3188        /**
3189         * @return {@link #interaction} (Identifies a restful operation supported by the solution.)
3190         */
3191        public List<ResourceInteractionComponent> getInteraction() { 
3192          if (this.interaction == null)
3193            this.interaction = new ArrayList<ResourceInteractionComponent>();
3194          return this.interaction;
3195        }
3196
3197        /**
3198         * @return Returns a reference to <code>this</code> for easy method chaining
3199         */
3200        public CapabilityStatementRestResourceComponent setInteraction(List<ResourceInteractionComponent> theInteraction) { 
3201          this.interaction = theInteraction;
3202          return this;
3203        }
3204
3205        public boolean hasInteraction() { 
3206          if (this.interaction == null)
3207            return false;
3208          for (ResourceInteractionComponent item : this.interaction)
3209            if (!item.isEmpty())
3210              return true;
3211          return false;
3212        }
3213
3214        public ResourceInteractionComponent addInteraction() { //3
3215          ResourceInteractionComponent t = new ResourceInteractionComponent();
3216          if (this.interaction == null)
3217            this.interaction = new ArrayList<ResourceInteractionComponent>();
3218          this.interaction.add(t);
3219          return t;
3220        }
3221
3222        public CapabilityStatementRestResourceComponent addInteraction(ResourceInteractionComponent t) { //3
3223          if (t == null)
3224            return this;
3225          if (this.interaction == null)
3226            this.interaction = new ArrayList<ResourceInteractionComponent>();
3227          this.interaction.add(t);
3228          return this;
3229        }
3230
3231        /**
3232         * @return The first repetition of repeating field {@link #interaction}, creating it if it does not already exist {3}
3233         */
3234        public ResourceInteractionComponent getInteractionFirstRep() { 
3235          if (getInteraction().isEmpty()) {
3236            addInteraction();
3237          }
3238          return getInteraction().get(0);
3239        }
3240
3241        /**
3242         * @return {@link #versioning} (This field is set to no-version to specify that the system does not support (server) or use (client) versioning for this resource type. If this has some other value, the server must at least correctly track and populate the versionId meta-property on resources. If the value is 'versioned-update', then the server supports all the versioning features, including using e-tags for version integrity in the API.). This is the underlying object with id, value and extensions. The accessor "getVersioning" gives direct access to the value
3243         */
3244        public Enumeration<ResourceVersionPolicy> getVersioningElement() { 
3245          if (this.versioning == null)
3246            if (Configuration.errorOnAutoCreate())
3247              throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.versioning");
3248            else if (Configuration.doAutoCreate())
3249              this.versioning = new Enumeration<ResourceVersionPolicy>(new ResourceVersionPolicyEnumFactory()); // bb
3250          return this.versioning;
3251        }
3252
3253        public boolean hasVersioningElement() { 
3254          return this.versioning != null && !this.versioning.isEmpty();
3255        }
3256
3257        public boolean hasVersioning() { 
3258          return this.versioning != null && !this.versioning.isEmpty();
3259        }
3260
3261        /**
3262         * @param value {@link #versioning} (This field is set to no-version to specify that the system does not support (server) or use (client) versioning for this resource type. If this has some other value, the server must at least correctly track and populate the versionId meta-property on resources. If the value is 'versioned-update', then the server supports all the versioning features, including using e-tags for version integrity in the API.). This is the underlying object with id, value and extensions. The accessor "getVersioning" gives direct access to the value
3263         */
3264        public CapabilityStatementRestResourceComponent setVersioningElement(Enumeration<ResourceVersionPolicy> value) { 
3265          this.versioning = value;
3266          return this;
3267        }
3268
3269        /**
3270         * @return This field is set to no-version to specify that the system does not support (server) or use (client) versioning for this resource type. If this has some other value, the server must at least correctly track and populate the versionId meta-property on resources. If the value is 'versioned-update', then the server supports all the versioning features, including using e-tags for version integrity in the API.
3271         */
3272        public ResourceVersionPolicy getVersioning() { 
3273          return this.versioning == null ? null : this.versioning.getValue();
3274        }
3275
3276        /**
3277         * @param value This field is set to no-version to specify that the system does not support (server) or use (client) versioning for this resource type. If this has some other value, the server must at least correctly track and populate the versionId meta-property on resources. If the value is 'versioned-update', then the server supports all the versioning features, including using e-tags for version integrity in the API.
3278         */
3279        public CapabilityStatementRestResourceComponent setVersioning(ResourceVersionPolicy value) { 
3280          if (value == null)
3281            this.versioning = null;
3282          else {
3283            if (this.versioning == null)
3284              this.versioning = new Enumeration<ResourceVersionPolicy>(new ResourceVersionPolicyEnumFactory());
3285            this.versioning.setValue(value);
3286          }
3287          return this;
3288        }
3289
3290        /**
3291         * @return {@link #readHistory} (A flag for whether the server is able to return past versions as part of the vRead operation.). This is the underlying object with id, value and extensions. The accessor "getReadHistory" gives direct access to the value
3292         */
3293        public BooleanType getReadHistoryElement() { 
3294          if (this.readHistory == null)
3295            if (Configuration.errorOnAutoCreate())
3296              throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.readHistory");
3297            else if (Configuration.doAutoCreate())
3298              this.readHistory = new BooleanType(); // bb
3299          return this.readHistory;
3300        }
3301
3302        public boolean hasReadHistoryElement() { 
3303          return this.readHistory != null && !this.readHistory.isEmpty();
3304        }
3305
3306        public boolean hasReadHistory() { 
3307          return this.readHistory != null && !this.readHistory.isEmpty();
3308        }
3309
3310        /**
3311         * @param value {@link #readHistory} (A flag for whether the server is able to return past versions as part of the vRead operation.). This is the underlying object with id, value and extensions. The accessor "getReadHistory" gives direct access to the value
3312         */
3313        public CapabilityStatementRestResourceComponent setReadHistoryElement(BooleanType value) { 
3314          this.readHistory = value;
3315          return this;
3316        }
3317
3318        /**
3319         * @return A flag for whether the server is able to return past versions as part of the vRead operation.
3320         */
3321        public boolean getReadHistory() { 
3322          return this.readHistory == null || this.readHistory.isEmpty() ? false : this.readHistory.getValue();
3323        }
3324
3325        /**
3326         * @param value A flag for whether the server is able to return past versions as part of the vRead operation.
3327         */
3328        public CapabilityStatementRestResourceComponent setReadHistory(boolean value) { 
3329            if (this.readHistory == null)
3330              this.readHistory = new BooleanType();
3331            this.readHistory.setValue(value);
3332          return this;
3333        }
3334
3335        /**
3336         * @return {@link #updateCreate} (A flag to indicate that the server allows or needs to allow the client to create new identities on the server (that is, the client PUTs to a location where there is no existing resource). Allowing this operation means that the server allows the client to create new identities on the server.). This is the underlying object with id, value and extensions. The accessor "getUpdateCreate" gives direct access to the value
3337         */
3338        public BooleanType getUpdateCreateElement() { 
3339          if (this.updateCreate == null)
3340            if (Configuration.errorOnAutoCreate())
3341              throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.updateCreate");
3342            else if (Configuration.doAutoCreate())
3343              this.updateCreate = new BooleanType(); // bb
3344          return this.updateCreate;
3345        }
3346
3347        public boolean hasUpdateCreateElement() { 
3348          return this.updateCreate != null && !this.updateCreate.isEmpty();
3349        }
3350
3351        public boolean hasUpdateCreate() { 
3352          return this.updateCreate != null && !this.updateCreate.isEmpty();
3353        }
3354
3355        /**
3356         * @param value {@link #updateCreate} (A flag to indicate that the server allows or needs to allow the client to create new identities on the server (that is, the client PUTs to a location where there is no existing resource). Allowing this operation means that the server allows the client to create new identities on the server.). This is the underlying object with id, value and extensions. The accessor "getUpdateCreate" gives direct access to the value
3357         */
3358        public CapabilityStatementRestResourceComponent setUpdateCreateElement(BooleanType value) { 
3359          this.updateCreate = value;
3360          return this;
3361        }
3362
3363        /**
3364         * @return A flag to indicate that the server allows or needs to allow the client to create new identities on the server (that is, the client PUTs to a location where there is no existing resource). Allowing this operation means that the server allows the client to create new identities on the server.
3365         */
3366        public boolean getUpdateCreate() { 
3367          return this.updateCreate == null || this.updateCreate.isEmpty() ? false : this.updateCreate.getValue();
3368        }
3369
3370        /**
3371         * @param value A flag to indicate that the server allows or needs to allow the client to create new identities on the server (that is, the client PUTs to a location where there is no existing resource). Allowing this operation means that the server allows the client to create new identities on the server.
3372         */
3373        public CapabilityStatementRestResourceComponent setUpdateCreate(boolean value) { 
3374            if (this.updateCreate == null)
3375              this.updateCreate = new BooleanType();
3376            this.updateCreate.setValue(value);
3377          return this;
3378        }
3379
3380        /**
3381         * @return {@link #conditionalCreate} (A flag that indicates that the server supports conditional create.). This is the underlying object with id, value and extensions. The accessor "getConditionalCreate" gives direct access to the value
3382         */
3383        public BooleanType getConditionalCreateElement() { 
3384          if (this.conditionalCreate == null)
3385            if (Configuration.errorOnAutoCreate())
3386              throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.conditionalCreate");
3387            else if (Configuration.doAutoCreate())
3388              this.conditionalCreate = new BooleanType(); // bb
3389          return this.conditionalCreate;
3390        }
3391
3392        public boolean hasConditionalCreateElement() { 
3393          return this.conditionalCreate != null && !this.conditionalCreate.isEmpty();
3394        }
3395
3396        public boolean hasConditionalCreate() { 
3397          return this.conditionalCreate != null && !this.conditionalCreate.isEmpty();
3398        }
3399
3400        /**
3401         * @param value {@link #conditionalCreate} (A flag that indicates that the server supports conditional create.). This is the underlying object with id, value and extensions. The accessor "getConditionalCreate" gives direct access to the value
3402         */
3403        public CapabilityStatementRestResourceComponent setConditionalCreateElement(BooleanType value) { 
3404          this.conditionalCreate = value;
3405          return this;
3406        }
3407
3408        /**
3409         * @return A flag that indicates that the server supports conditional create.
3410         */
3411        public boolean getConditionalCreate() { 
3412          return this.conditionalCreate == null || this.conditionalCreate.isEmpty() ? false : this.conditionalCreate.getValue();
3413        }
3414
3415        /**
3416         * @param value A flag that indicates that the server supports conditional create.
3417         */
3418        public CapabilityStatementRestResourceComponent setConditionalCreate(boolean value) { 
3419            if (this.conditionalCreate == null)
3420              this.conditionalCreate = new BooleanType();
3421            this.conditionalCreate.setValue(value);
3422          return this;
3423        }
3424
3425        /**
3426         * @return {@link #conditionalRead} (A code that indicates how the server supports conditional read.). This is the underlying object with id, value and extensions. The accessor "getConditionalRead" gives direct access to the value
3427         */
3428        public Enumeration<ConditionalReadStatus> getConditionalReadElement() { 
3429          if (this.conditionalRead == null)
3430            if (Configuration.errorOnAutoCreate())
3431              throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.conditionalRead");
3432            else if (Configuration.doAutoCreate())
3433              this.conditionalRead = new Enumeration<ConditionalReadStatus>(new ConditionalReadStatusEnumFactory()); // bb
3434          return this.conditionalRead;
3435        }
3436
3437        public boolean hasConditionalReadElement() { 
3438          return this.conditionalRead != null && !this.conditionalRead.isEmpty();
3439        }
3440
3441        public boolean hasConditionalRead() { 
3442          return this.conditionalRead != null && !this.conditionalRead.isEmpty();
3443        }
3444
3445        /**
3446         * @param value {@link #conditionalRead} (A code that indicates how the server supports conditional read.). This is the underlying object with id, value and extensions. The accessor "getConditionalRead" gives direct access to the value
3447         */
3448        public CapabilityStatementRestResourceComponent setConditionalReadElement(Enumeration<ConditionalReadStatus> value) { 
3449          this.conditionalRead = value;
3450          return this;
3451        }
3452
3453        /**
3454         * @return A code that indicates how the server supports conditional read.
3455         */
3456        public ConditionalReadStatus getConditionalRead() { 
3457          return this.conditionalRead == null ? null : this.conditionalRead.getValue();
3458        }
3459
3460        /**
3461         * @param value A code that indicates how the server supports conditional read.
3462         */
3463        public CapabilityStatementRestResourceComponent setConditionalRead(ConditionalReadStatus value) { 
3464          if (value == null)
3465            this.conditionalRead = null;
3466          else {
3467            if (this.conditionalRead == null)
3468              this.conditionalRead = new Enumeration<ConditionalReadStatus>(new ConditionalReadStatusEnumFactory());
3469            this.conditionalRead.setValue(value);
3470          }
3471          return this;
3472        }
3473
3474        /**
3475         * @return {@link #conditionalUpdate} (A flag that indicates that the server supports conditional update.). This is the underlying object with id, value and extensions. The accessor "getConditionalUpdate" gives direct access to the value
3476         */
3477        public BooleanType getConditionalUpdateElement() { 
3478          if (this.conditionalUpdate == null)
3479            if (Configuration.errorOnAutoCreate())
3480              throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.conditionalUpdate");
3481            else if (Configuration.doAutoCreate())
3482              this.conditionalUpdate = new BooleanType(); // bb
3483          return this.conditionalUpdate;
3484        }
3485
3486        public boolean hasConditionalUpdateElement() { 
3487          return this.conditionalUpdate != null && !this.conditionalUpdate.isEmpty();
3488        }
3489
3490        public boolean hasConditionalUpdate() { 
3491          return this.conditionalUpdate != null && !this.conditionalUpdate.isEmpty();
3492        }
3493
3494        /**
3495         * @param value {@link #conditionalUpdate} (A flag that indicates that the server supports conditional update.). This is the underlying object with id, value and extensions. The accessor "getConditionalUpdate" gives direct access to the value
3496         */
3497        public CapabilityStatementRestResourceComponent setConditionalUpdateElement(BooleanType value) { 
3498          this.conditionalUpdate = value;
3499          return this;
3500        }
3501
3502        /**
3503         * @return A flag that indicates that the server supports conditional update.
3504         */
3505        public boolean getConditionalUpdate() { 
3506          return this.conditionalUpdate == null || this.conditionalUpdate.isEmpty() ? false : this.conditionalUpdate.getValue();
3507        }
3508
3509        /**
3510         * @param value A flag that indicates that the server supports conditional update.
3511         */
3512        public CapabilityStatementRestResourceComponent setConditionalUpdate(boolean value) { 
3513            if (this.conditionalUpdate == null)
3514              this.conditionalUpdate = new BooleanType();
3515            this.conditionalUpdate.setValue(value);
3516          return this;
3517        }
3518
3519        /**
3520         * @return {@link #conditionalPatch} (A flag that indicates that the server supports conditional patch.). This is the underlying object with id, value and extensions. The accessor "getConditionalPatch" gives direct access to the value
3521         */
3522        public BooleanType getConditionalPatchElement() { 
3523          if (this.conditionalPatch == null)
3524            if (Configuration.errorOnAutoCreate())
3525              throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.conditionalPatch");
3526            else if (Configuration.doAutoCreate())
3527              this.conditionalPatch = new BooleanType(); // bb
3528          return this.conditionalPatch;
3529        }
3530
3531        public boolean hasConditionalPatchElement() { 
3532          return this.conditionalPatch != null && !this.conditionalPatch.isEmpty();
3533        }
3534
3535        public boolean hasConditionalPatch() { 
3536          return this.conditionalPatch != null && !this.conditionalPatch.isEmpty();
3537        }
3538
3539        /**
3540         * @param value {@link #conditionalPatch} (A flag that indicates that the server supports conditional patch.). This is the underlying object with id, value and extensions. The accessor "getConditionalPatch" gives direct access to the value
3541         */
3542        public CapabilityStatementRestResourceComponent setConditionalPatchElement(BooleanType value) { 
3543          this.conditionalPatch = value;
3544          return this;
3545        }
3546
3547        /**
3548         * @return A flag that indicates that the server supports conditional patch.
3549         */
3550        public boolean getConditionalPatch() { 
3551          return this.conditionalPatch == null || this.conditionalPatch.isEmpty() ? false : this.conditionalPatch.getValue();
3552        }
3553
3554        /**
3555         * @param value A flag that indicates that the server supports conditional patch.
3556         */
3557        public CapabilityStatementRestResourceComponent setConditionalPatch(boolean value) { 
3558            if (this.conditionalPatch == null)
3559              this.conditionalPatch = new BooleanType();
3560            this.conditionalPatch.setValue(value);
3561          return this;
3562        }
3563
3564        /**
3565         * @return {@link #conditionalDelete} (A code that indicates how the server supports conditional delete.). This is the underlying object with id, value and extensions. The accessor "getConditionalDelete" gives direct access to the value
3566         */
3567        public Enumeration<ConditionalDeleteStatus> getConditionalDeleteElement() { 
3568          if (this.conditionalDelete == null)
3569            if (Configuration.errorOnAutoCreate())
3570              throw new Error("Attempt to auto-create CapabilityStatementRestResourceComponent.conditionalDelete");
3571            else if (Configuration.doAutoCreate())
3572              this.conditionalDelete = new Enumeration<ConditionalDeleteStatus>(new ConditionalDeleteStatusEnumFactory()); // bb
3573          return this.conditionalDelete;
3574        }
3575
3576        public boolean hasConditionalDeleteElement() { 
3577          return this.conditionalDelete != null && !this.conditionalDelete.isEmpty();
3578        }
3579
3580        public boolean hasConditionalDelete() { 
3581          return this.conditionalDelete != null && !this.conditionalDelete.isEmpty();
3582        }
3583
3584        /**
3585         * @param value {@link #conditionalDelete} (A code that indicates how the server supports conditional delete.). This is the underlying object with id, value and extensions. The accessor "getConditionalDelete" gives direct access to the value
3586         */
3587        public CapabilityStatementRestResourceComponent setConditionalDeleteElement(Enumeration<ConditionalDeleteStatus> value) { 
3588          this.conditionalDelete = value;
3589          return this;
3590        }
3591
3592        /**
3593         * @return A code that indicates how the server supports conditional delete.
3594         */
3595        public ConditionalDeleteStatus getConditionalDelete() { 
3596          return this.conditionalDelete == null ? null : this.conditionalDelete.getValue();
3597        }
3598
3599        /**
3600         * @param value A code that indicates how the server supports conditional delete.
3601         */
3602        public CapabilityStatementRestResourceComponent setConditionalDelete(ConditionalDeleteStatus value) { 
3603          if (value == null)
3604            this.conditionalDelete = null;
3605          else {
3606            if (this.conditionalDelete == null)
3607              this.conditionalDelete = new Enumeration<ConditionalDeleteStatus>(new ConditionalDeleteStatusEnumFactory());
3608            this.conditionalDelete.setValue(value);
3609          }
3610          return this;
3611        }
3612
3613        /**
3614         * @return {@link #referencePolicy} (A set of flags that defines how references are supported.)
3615         */
3616        public List<Enumeration<ReferenceHandlingPolicy>> getReferencePolicy() { 
3617          if (this.referencePolicy == null)
3618            this.referencePolicy = new ArrayList<Enumeration<ReferenceHandlingPolicy>>();
3619          return this.referencePolicy;
3620        }
3621
3622        /**
3623         * @return Returns a reference to <code>this</code> for easy method chaining
3624         */
3625        public CapabilityStatementRestResourceComponent setReferencePolicy(List<Enumeration<ReferenceHandlingPolicy>> theReferencePolicy) { 
3626          this.referencePolicy = theReferencePolicy;
3627          return this;
3628        }
3629
3630        public boolean hasReferencePolicy() { 
3631          if (this.referencePolicy == null)
3632            return false;
3633          for (Enumeration<ReferenceHandlingPolicy> item : this.referencePolicy)
3634            if (!item.isEmpty())
3635              return true;
3636          return false;
3637        }
3638
3639        /**
3640         * @return {@link #referencePolicy} (A set of flags that defines how references are supported.)
3641         */
3642        public Enumeration<ReferenceHandlingPolicy> addReferencePolicyElement() {//2 
3643          Enumeration<ReferenceHandlingPolicy> t = new Enumeration<ReferenceHandlingPolicy>(new ReferenceHandlingPolicyEnumFactory());
3644          if (this.referencePolicy == null)
3645            this.referencePolicy = new ArrayList<Enumeration<ReferenceHandlingPolicy>>();
3646          this.referencePolicy.add(t);
3647          return t;
3648        }
3649
3650        /**
3651         * @param value {@link #referencePolicy} (A set of flags that defines how references are supported.)
3652         */
3653        public CapabilityStatementRestResourceComponent addReferencePolicy(ReferenceHandlingPolicy value) { //1
3654          Enumeration<ReferenceHandlingPolicy> t = new Enumeration<ReferenceHandlingPolicy>(new ReferenceHandlingPolicyEnumFactory());
3655          t.setValue(value);
3656          if (this.referencePolicy == null)
3657            this.referencePolicy = new ArrayList<Enumeration<ReferenceHandlingPolicy>>();
3658          this.referencePolicy.add(t);
3659          return this;
3660        }
3661
3662        /**
3663         * @param value {@link #referencePolicy} (A set of flags that defines how references are supported.)
3664         */
3665        public boolean hasReferencePolicy(ReferenceHandlingPolicy value) { 
3666          if (this.referencePolicy == null)
3667            return false;
3668          for (Enumeration<ReferenceHandlingPolicy> v : this.referencePolicy)
3669            if (v.getValue().equals(value)) // code
3670              return true;
3671          return false;
3672        }
3673
3674        /**
3675         * @return {@link #searchInclude} (A list of _include values supported by the server.)
3676         */
3677        public List<StringType> getSearchInclude() { 
3678          if (this.searchInclude == null)
3679            this.searchInclude = new ArrayList<StringType>();
3680          return this.searchInclude;
3681        }
3682
3683        /**
3684         * @return Returns a reference to <code>this</code> for easy method chaining
3685         */
3686        public CapabilityStatementRestResourceComponent setSearchInclude(List<StringType> theSearchInclude) { 
3687          this.searchInclude = theSearchInclude;
3688          return this;
3689        }
3690
3691        public boolean hasSearchInclude() { 
3692          if (this.searchInclude == null)
3693            return false;
3694          for (StringType item : this.searchInclude)
3695            if (!item.isEmpty())
3696              return true;
3697          return false;
3698        }
3699
3700        /**
3701         * @return {@link #searchInclude} (A list of _include values supported by the server.)
3702         */
3703        public StringType addSearchIncludeElement() {//2 
3704          StringType t = new StringType();
3705          if (this.searchInclude == null)
3706            this.searchInclude = new ArrayList<StringType>();
3707          this.searchInclude.add(t);
3708          return t;
3709        }
3710
3711        /**
3712         * @param value {@link #searchInclude} (A list of _include values supported by the server.)
3713         */
3714        public CapabilityStatementRestResourceComponent addSearchInclude(String value) { //1
3715          StringType t = new StringType();
3716          t.setValue(value);
3717          if (this.searchInclude == null)
3718            this.searchInclude = new ArrayList<StringType>();
3719          this.searchInclude.add(t);
3720          return this;
3721        }
3722
3723        /**
3724         * @param value {@link #searchInclude} (A list of _include values supported by the server.)
3725         */
3726        public boolean hasSearchInclude(String value) { 
3727          if (this.searchInclude == null)
3728            return false;
3729          for (StringType v : this.searchInclude)
3730            if (v.getValue().equals(value)) // string
3731              return true;
3732          return false;
3733        }
3734
3735        /**
3736         * @return {@link #searchRevInclude} (A list of _revinclude (reverse include) values supported by the server.)
3737         */
3738        public List<StringType> getSearchRevInclude() { 
3739          if (this.searchRevInclude == null)
3740            this.searchRevInclude = new ArrayList<StringType>();
3741          return this.searchRevInclude;
3742        }
3743
3744        /**
3745         * @return Returns a reference to <code>this</code> for easy method chaining
3746         */
3747        public CapabilityStatementRestResourceComponent setSearchRevInclude(List<StringType> theSearchRevInclude) { 
3748          this.searchRevInclude = theSearchRevInclude;
3749          return this;
3750        }
3751
3752        public boolean hasSearchRevInclude() { 
3753          if (this.searchRevInclude == null)
3754            return false;
3755          for (StringType item : this.searchRevInclude)
3756            if (!item.isEmpty())
3757              return true;
3758          return false;
3759        }
3760
3761        /**
3762         * @return {@link #searchRevInclude} (A list of _revinclude (reverse include) values supported by the server.)
3763         */
3764        public StringType addSearchRevIncludeElement() {//2 
3765          StringType t = new StringType();
3766          if (this.searchRevInclude == null)
3767            this.searchRevInclude = new ArrayList<StringType>();
3768          this.searchRevInclude.add(t);
3769          return t;
3770        }
3771
3772        /**
3773         * @param value {@link #searchRevInclude} (A list of _revinclude (reverse include) values supported by the server.)
3774         */
3775        public CapabilityStatementRestResourceComponent addSearchRevInclude(String value) { //1
3776          StringType t = new StringType();
3777          t.setValue(value);
3778          if (this.searchRevInclude == null)
3779            this.searchRevInclude = new ArrayList<StringType>();
3780          this.searchRevInclude.add(t);
3781          return this;
3782        }
3783
3784        /**
3785         * @param value {@link #searchRevInclude} (A list of _revinclude (reverse include) values supported by the server.)
3786         */
3787        public boolean hasSearchRevInclude(String value) { 
3788          if (this.searchRevInclude == null)
3789            return false;
3790          for (StringType v : this.searchRevInclude)
3791            if (v.getValue().equals(value)) // string
3792              return true;
3793          return false;
3794        }
3795
3796        /**
3797         * @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.)
3798         */
3799        public List<CapabilityStatementRestResourceSearchParamComponent> getSearchParam() { 
3800          if (this.searchParam == null)
3801            this.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>();
3802          return this.searchParam;
3803        }
3804
3805        /**
3806         * @return Returns a reference to <code>this</code> for easy method chaining
3807         */
3808        public CapabilityStatementRestResourceComponent setSearchParam(List<CapabilityStatementRestResourceSearchParamComponent> theSearchParam) { 
3809          this.searchParam = theSearchParam;
3810          return this;
3811        }
3812
3813        public boolean hasSearchParam() { 
3814          if (this.searchParam == null)
3815            return false;
3816          for (CapabilityStatementRestResourceSearchParamComponent item : this.searchParam)
3817            if (!item.isEmpty())
3818              return true;
3819          return false;
3820        }
3821
3822        public CapabilityStatementRestResourceSearchParamComponent addSearchParam() { //3
3823          CapabilityStatementRestResourceSearchParamComponent t = new CapabilityStatementRestResourceSearchParamComponent();
3824          if (this.searchParam == null)
3825            this.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>();
3826          this.searchParam.add(t);
3827          return t;
3828        }
3829
3830        public CapabilityStatementRestResourceComponent addSearchParam(CapabilityStatementRestResourceSearchParamComponent t) { //3
3831          if (t == null)
3832            return this;
3833          if (this.searchParam == null)
3834            this.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>();
3835          this.searchParam.add(t);
3836          return this;
3837        }
3838
3839        /**
3840         * @return The first repetition of repeating field {@link #searchParam}, creating it if it does not already exist {3}
3841         */
3842        public CapabilityStatementRestResourceSearchParamComponent getSearchParamFirstRep() { 
3843          if (getSearchParam().isEmpty()) {
3844            addSearchParam();
3845          }
3846          return getSearchParam().get(0);
3847        }
3848
3849        /**
3850         * @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.)
3851         */
3852        public List<CapabilityStatementRestResourceOperationComponent> getOperation() { 
3853          if (this.operation == null)
3854            this.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>();
3855          return this.operation;
3856        }
3857
3858        /**
3859         * @return Returns a reference to <code>this</code> for easy method chaining
3860         */
3861        public CapabilityStatementRestResourceComponent setOperation(List<CapabilityStatementRestResourceOperationComponent> theOperation) { 
3862          this.operation = theOperation;
3863          return this;
3864        }
3865
3866        public boolean hasOperation() { 
3867          if (this.operation == null)
3868            return false;
3869          for (CapabilityStatementRestResourceOperationComponent item : this.operation)
3870            if (!item.isEmpty())
3871              return true;
3872          return false;
3873        }
3874
3875        public CapabilityStatementRestResourceOperationComponent addOperation() { //3
3876          CapabilityStatementRestResourceOperationComponent t = new CapabilityStatementRestResourceOperationComponent();
3877          if (this.operation == null)
3878            this.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>();
3879          this.operation.add(t);
3880          return t;
3881        }
3882
3883        public CapabilityStatementRestResourceComponent addOperation(CapabilityStatementRestResourceOperationComponent t) { //3
3884          if (t == null)
3885            return this;
3886          if (this.operation == null)
3887            this.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>();
3888          this.operation.add(t);
3889          return this;
3890        }
3891
3892        /**
3893         * @return The first repetition of repeating field {@link #operation}, creating it if it does not already exist {3}
3894         */
3895        public CapabilityStatementRestResourceOperationComponent getOperationFirstRep() { 
3896          if (getOperation().isEmpty()) {
3897            addOperation();
3898          }
3899          return getOperation().get(0);
3900        }
3901
3902        protected void listChildren(List<Property> children) {
3903          super.listChildren(children);
3904          children.add(new Property("type", "code", "A type of resource exposed via the restful interface.", 0, 1, type));
3905          children.add(new Property("profile", "canonical(StructureDefinition)", "A system-wide profile that is applied across *all* instances of the resource supported by the system. For example, if declared on Observation, this profile is the \"superset\" of capabilities for laboratory *and* vitals *and* other domains. See further discussion in [Using Profiles](profiling.html#profile-uses).", 0, 1, profile));
3906          children.add(new Property("supportedProfile", "canonical(StructureDefinition)", "A list of profiles representing different use cases the system hosts/produces. A supported profile is a statement about the functionality of the data and services provided by the server (or the client) for supported use cases. For example, a system can define and declare multiple Observation profiles for laboratory observations, vital sign observations, etc. By declaring supported profiles, systems provide a way to determine whether individual resources are conformant. See further discussion in [Using Profiles](profiling.html#profile-uses).", 0, java.lang.Integer.MAX_VALUE, supportedProfile));
3907          children.add(new Property("documentation", "markdown", "Additional information about the resource type used by the system.", 0, 1, documentation));
3908          children.add(new Property("interaction", "", "Identifies a restful operation supported by the solution.", 0, java.lang.Integer.MAX_VALUE, interaction));
3909          children.add(new Property("versioning", "code", "This field is set to no-version to specify that the system does not support (server) or use (client) versioning for this resource type. If this has some other value, the server must at least correctly track and populate the versionId meta-property on resources. If the value is 'versioned-update', then the server supports all the versioning features, including using e-tags for version integrity in the API.", 0, 1, versioning));
3910          children.add(new Property("readHistory", "boolean", "A flag for whether the server is able to return past versions as part of the vRead operation.", 0, 1, readHistory));
3911          children.add(new Property("updateCreate", "boolean", "A flag to indicate that the server allows or needs to allow the client to create new identities on the server (that is, the client PUTs to a location where there is no existing resource). Allowing this operation means that the server allows the client to create new identities on the server.", 0, 1, updateCreate));
3912          children.add(new Property("conditionalCreate", "boolean", "A flag that indicates that the server supports conditional create.", 0, 1, conditionalCreate));
3913          children.add(new Property("conditionalRead", "code", "A code that indicates how the server supports conditional read.", 0, 1, conditionalRead));
3914          children.add(new Property("conditionalUpdate", "boolean", "A flag that indicates that the server supports conditional update.", 0, 1, conditionalUpdate));
3915          children.add(new Property("conditionalPatch", "boolean", "A flag that indicates that the server supports conditional patch.", 0, 1, conditionalPatch));
3916          children.add(new Property("conditionalDelete", "code", "A code that indicates how the server supports conditional delete.", 0, 1, conditionalDelete));
3917          children.add(new Property("referencePolicy", "code", "A set of flags that defines how references are supported.", 0, java.lang.Integer.MAX_VALUE, referencePolicy));
3918          children.add(new Property("searchInclude", "string", "A list of _include values supported by the server.", 0, java.lang.Integer.MAX_VALUE, searchInclude));
3919          children.add(new Property("searchRevInclude", "string", "A list of _revinclude (reverse include) values supported by the server.", 0, java.lang.Integer.MAX_VALUE, searchRevInclude));
3920          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));
3921          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));
3922        }
3923
3924        @Override
3925        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3926          switch (_hash) {
3927          case 3575610: /*type*/  return new Property("type", "code", "A type of resource exposed via the restful interface.", 0, 1, type);
3928          case -309425751: /*profile*/  return new Property("profile", "canonical(StructureDefinition)", "A system-wide profile that is applied across *all* instances of the resource supported by the system. For example, if declared on Observation, this profile is the \"superset\" of capabilities for laboratory *and* vitals *and* other domains. See further discussion in [Using Profiles](profiling.html#profile-uses).", 0, 1, profile);
3929          case 1225477403: /*supportedProfile*/  return new Property("supportedProfile", "canonical(StructureDefinition)", "A list of profiles representing different use cases the system hosts/produces. A supported profile is a statement about the functionality of the data and services provided by the server (or the client) for supported use cases. For example, a system can define and declare multiple Observation profiles for laboratory observations, vital sign observations, etc. By declaring supported profiles, systems provide a way to determine whether individual resources are conformant. See further discussion in [Using Profiles](profiling.html#profile-uses).", 0, java.lang.Integer.MAX_VALUE, supportedProfile);
3930          case 1587405498: /*documentation*/  return new Property("documentation", "markdown", "Additional information about the resource type used by the system.", 0, 1, documentation);
3931          case 1844104722: /*interaction*/  return new Property("interaction", "", "Identifies a restful operation supported by the solution.", 0, java.lang.Integer.MAX_VALUE, interaction);
3932          case -670487542: /*versioning*/  return new Property("versioning", "code", "This field is set to no-version to specify that the system does not support (server) or use (client) versioning for this resource type. If this has some other value, the server must at least correctly track and populate the versionId meta-property on resources. If the value is 'versioned-update', then the server supports all the versioning features, including using e-tags for version integrity in the API.", 0, 1, versioning);
3933          case 187518494: /*readHistory*/  return new Property("readHistory", "boolean", "A flag for whether the server is able to return past versions as part of the vRead operation.", 0, 1, readHistory);
3934          case -1400550619: /*updateCreate*/  return new Property("updateCreate", "boolean", "A flag to indicate that the server allows or needs to allow the client to create new identities on the server (that is, the client PUTs to a location where there is no existing resource). Allowing this operation means that the server allows the client to create new identities on the server.", 0, 1, updateCreate);
3935          case 6401826: /*conditionalCreate*/  return new Property("conditionalCreate", "boolean", "A flag that indicates that the server supports conditional create.", 0, 1, conditionalCreate);
3936          case 822786364: /*conditionalRead*/  return new Property("conditionalRead", "code", "A code that indicates how the server supports conditional read.", 0, 1, conditionalRead);
3937          case 519849711: /*conditionalUpdate*/  return new Property("conditionalUpdate", "boolean", "A flag that indicates that the server supports conditional update.", 0, 1, conditionalUpdate);
3938          case -265374366: /*conditionalPatch*/  return new Property("conditionalPatch", "boolean", "A flag that indicates that the server supports conditional patch.", 0, 1, conditionalPatch);
3939          case 23237585: /*conditionalDelete*/  return new Property("conditionalDelete", "code", "A code that indicates how the server supports conditional delete.", 0, 1, conditionalDelete);
3940          case 796257373: /*referencePolicy*/  return new Property("referencePolicy", "code", "A set of flags that defines how references are supported.", 0, java.lang.Integer.MAX_VALUE, referencePolicy);
3941          case -1035904544: /*searchInclude*/  return new Property("searchInclude", "string", "A list of _include values supported by the server.", 0, java.lang.Integer.MAX_VALUE, searchInclude);
3942          case -2123884979: /*searchRevInclude*/  return new Property("searchRevInclude", "string", "A list of _revinclude (reverse include) values supported by the server.", 0, java.lang.Integer.MAX_VALUE, searchRevInclude);
3943          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);
3944          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);
3945          default: return super.getNamedProperty(_hash, _name, _checkValid);
3946          }
3947
3948        }
3949
3950      @Override
3951      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3952        switch (hash) {
3953        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // CodeType
3954        case -309425751: /*profile*/ return this.profile == null ? new Base[0] : new Base[] {this.profile}; // CanonicalType
3955        case 1225477403: /*supportedProfile*/ return this.supportedProfile == null ? new Base[0] : this.supportedProfile.toArray(new Base[this.supportedProfile.size()]); // CanonicalType
3956        case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType
3957        case 1844104722: /*interaction*/ return this.interaction == null ? new Base[0] : this.interaction.toArray(new Base[this.interaction.size()]); // ResourceInteractionComponent
3958        case -670487542: /*versioning*/ return this.versioning == null ? new Base[0] : new Base[] {this.versioning}; // Enumeration<ResourceVersionPolicy>
3959        case 187518494: /*readHistory*/ return this.readHistory == null ? new Base[0] : new Base[] {this.readHistory}; // BooleanType
3960        case -1400550619: /*updateCreate*/ return this.updateCreate == null ? new Base[0] : new Base[] {this.updateCreate}; // BooleanType
3961        case 6401826: /*conditionalCreate*/ return this.conditionalCreate == null ? new Base[0] : new Base[] {this.conditionalCreate}; // BooleanType
3962        case 822786364: /*conditionalRead*/ return this.conditionalRead == null ? new Base[0] : new Base[] {this.conditionalRead}; // Enumeration<ConditionalReadStatus>
3963        case 519849711: /*conditionalUpdate*/ return this.conditionalUpdate == null ? new Base[0] : new Base[] {this.conditionalUpdate}; // BooleanType
3964        case -265374366: /*conditionalPatch*/ return this.conditionalPatch == null ? new Base[0] : new Base[] {this.conditionalPatch}; // BooleanType
3965        case 23237585: /*conditionalDelete*/ return this.conditionalDelete == null ? new Base[0] : new Base[] {this.conditionalDelete}; // Enumeration<ConditionalDeleteStatus>
3966        case 796257373: /*referencePolicy*/ return this.referencePolicy == null ? new Base[0] : this.referencePolicy.toArray(new Base[this.referencePolicy.size()]); // Enumeration<ReferenceHandlingPolicy>
3967        case -1035904544: /*searchInclude*/ return this.searchInclude == null ? new Base[0] : this.searchInclude.toArray(new Base[this.searchInclude.size()]); // StringType
3968        case -2123884979: /*searchRevInclude*/ return this.searchRevInclude == null ? new Base[0] : this.searchRevInclude.toArray(new Base[this.searchRevInclude.size()]); // StringType
3969        case -553645115: /*searchParam*/ return this.searchParam == null ? new Base[0] : this.searchParam.toArray(new Base[this.searchParam.size()]); // CapabilityStatementRestResourceSearchParamComponent
3970        case 1662702951: /*operation*/ return this.operation == null ? new Base[0] : this.operation.toArray(new Base[this.operation.size()]); // CapabilityStatementRestResourceOperationComponent
3971        default: return super.getProperty(hash, name, checkValid);
3972        }
3973
3974      }
3975
3976      @Override
3977      public Base setProperty(int hash, String name, Base value) throws FHIRException {
3978        switch (hash) {
3979        case 3575610: // type
3980          this.type = TypeConvertor.castToCode(value); // CodeType
3981          return value;
3982        case -309425751: // profile
3983          this.profile = TypeConvertor.castToCanonical(value); // CanonicalType
3984          return value;
3985        case 1225477403: // supportedProfile
3986          this.getSupportedProfile().add(TypeConvertor.castToCanonical(value)); // CanonicalType
3987          return value;
3988        case 1587405498: // documentation
3989          this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType
3990          return value;
3991        case 1844104722: // interaction
3992          this.getInteraction().add((ResourceInteractionComponent) value); // ResourceInteractionComponent
3993          return value;
3994        case -670487542: // versioning
3995          value = new ResourceVersionPolicyEnumFactory().fromType(TypeConvertor.castToCode(value));
3996          this.versioning = (Enumeration) value; // Enumeration<ResourceVersionPolicy>
3997          return value;
3998        case 187518494: // readHistory
3999          this.readHistory = TypeConvertor.castToBoolean(value); // BooleanType
4000          return value;
4001        case -1400550619: // updateCreate
4002          this.updateCreate = TypeConvertor.castToBoolean(value); // BooleanType
4003          return value;
4004        case 6401826: // conditionalCreate
4005          this.conditionalCreate = TypeConvertor.castToBoolean(value); // BooleanType
4006          return value;
4007        case 822786364: // conditionalRead
4008          value = new ConditionalReadStatusEnumFactory().fromType(TypeConvertor.castToCode(value));
4009          this.conditionalRead = (Enumeration) value; // Enumeration<ConditionalReadStatus>
4010          return value;
4011        case 519849711: // conditionalUpdate
4012          this.conditionalUpdate = TypeConvertor.castToBoolean(value); // BooleanType
4013          return value;
4014        case -265374366: // conditionalPatch
4015          this.conditionalPatch = TypeConvertor.castToBoolean(value); // BooleanType
4016          return value;
4017        case 23237585: // conditionalDelete
4018          value = new ConditionalDeleteStatusEnumFactory().fromType(TypeConvertor.castToCode(value));
4019          this.conditionalDelete = (Enumeration) value; // Enumeration<ConditionalDeleteStatus>
4020          return value;
4021        case 796257373: // referencePolicy
4022          value = new ReferenceHandlingPolicyEnumFactory().fromType(TypeConvertor.castToCode(value));
4023          this.getReferencePolicy().add((Enumeration) value); // Enumeration<ReferenceHandlingPolicy>
4024          return value;
4025        case -1035904544: // searchInclude
4026          this.getSearchInclude().add(TypeConvertor.castToString(value)); // StringType
4027          return value;
4028        case -2123884979: // searchRevInclude
4029          this.getSearchRevInclude().add(TypeConvertor.castToString(value)); // StringType
4030          return value;
4031        case -553645115: // searchParam
4032          this.getSearchParam().add((CapabilityStatementRestResourceSearchParamComponent) value); // CapabilityStatementRestResourceSearchParamComponent
4033          return value;
4034        case 1662702951: // operation
4035          this.getOperation().add((CapabilityStatementRestResourceOperationComponent) value); // CapabilityStatementRestResourceOperationComponent
4036          return value;
4037        default: return super.setProperty(hash, name, value);
4038        }
4039
4040      }
4041
4042      @Override
4043      public Base setProperty(String name, Base value) throws FHIRException {
4044        if (name.equals("type")) {
4045          this.type = TypeConvertor.castToCode(value); // CodeType
4046        } else if (name.equals("profile")) {
4047          this.profile = TypeConvertor.castToCanonical(value); // CanonicalType
4048        } else if (name.equals("supportedProfile")) {
4049          this.getSupportedProfile().add(TypeConvertor.castToCanonical(value));
4050        } else if (name.equals("documentation")) {
4051          this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType
4052        } else if (name.equals("interaction")) {
4053          this.getInteraction().add((ResourceInteractionComponent) value);
4054        } else if (name.equals("versioning")) {
4055          value = new ResourceVersionPolicyEnumFactory().fromType(TypeConvertor.castToCode(value));
4056          this.versioning = (Enumeration) value; // Enumeration<ResourceVersionPolicy>
4057        } else if (name.equals("readHistory")) {
4058          this.readHistory = TypeConvertor.castToBoolean(value); // BooleanType
4059        } else if (name.equals("updateCreate")) {
4060          this.updateCreate = TypeConvertor.castToBoolean(value); // BooleanType
4061        } else if (name.equals("conditionalCreate")) {
4062          this.conditionalCreate = TypeConvertor.castToBoolean(value); // BooleanType
4063        } else if (name.equals("conditionalRead")) {
4064          value = new ConditionalReadStatusEnumFactory().fromType(TypeConvertor.castToCode(value));
4065          this.conditionalRead = (Enumeration) value; // Enumeration<ConditionalReadStatus>
4066        } else if (name.equals("conditionalUpdate")) {
4067          this.conditionalUpdate = TypeConvertor.castToBoolean(value); // BooleanType
4068        } else if (name.equals("conditionalPatch")) {
4069          this.conditionalPatch = TypeConvertor.castToBoolean(value); // BooleanType
4070        } else if (name.equals("conditionalDelete")) {
4071          value = new ConditionalDeleteStatusEnumFactory().fromType(TypeConvertor.castToCode(value));
4072          this.conditionalDelete = (Enumeration) value; // Enumeration<ConditionalDeleteStatus>
4073        } else if (name.equals("referencePolicy")) {
4074          value = new ReferenceHandlingPolicyEnumFactory().fromType(TypeConvertor.castToCode(value));
4075          this.getReferencePolicy().add((Enumeration) value);
4076        } else if (name.equals("searchInclude")) {
4077          this.getSearchInclude().add(TypeConvertor.castToString(value));
4078        } else if (name.equals("searchRevInclude")) {
4079          this.getSearchRevInclude().add(TypeConvertor.castToString(value));
4080        } else if (name.equals("searchParam")) {
4081          this.getSearchParam().add((CapabilityStatementRestResourceSearchParamComponent) value);
4082        } else if (name.equals("operation")) {
4083          this.getOperation().add((CapabilityStatementRestResourceOperationComponent) value);
4084        } else
4085          return super.setProperty(name, value);
4086        return value;
4087      }
4088
4089      @Override
4090      public Base makeProperty(int hash, String name) throws FHIRException {
4091        switch (hash) {
4092        case 3575610:  return getTypeElement();
4093        case -309425751:  return getProfileElement();
4094        case 1225477403:  return addSupportedProfileElement();
4095        case 1587405498:  return getDocumentationElement();
4096        case 1844104722:  return addInteraction(); 
4097        case -670487542:  return getVersioningElement();
4098        case 187518494:  return getReadHistoryElement();
4099        case -1400550619:  return getUpdateCreateElement();
4100        case 6401826:  return getConditionalCreateElement();
4101        case 822786364:  return getConditionalReadElement();
4102        case 519849711:  return getConditionalUpdateElement();
4103        case -265374366:  return getConditionalPatchElement();
4104        case 23237585:  return getConditionalDeleteElement();
4105        case 796257373:  return addReferencePolicyElement();
4106        case -1035904544:  return addSearchIncludeElement();
4107        case -2123884979:  return addSearchRevIncludeElement();
4108        case -553645115:  return addSearchParam(); 
4109        case 1662702951:  return addOperation(); 
4110        default: return super.makeProperty(hash, name);
4111        }
4112
4113      }
4114
4115      @Override
4116      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
4117        switch (hash) {
4118        case 3575610: /*type*/ return new String[] {"code"};
4119        case -309425751: /*profile*/ return new String[] {"canonical"};
4120        case 1225477403: /*supportedProfile*/ return new String[] {"canonical"};
4121        case 1587405498: /*documentation*/ return new String[] {"markdown"};
4122        case 1844104722: /*interaction*/ return new String[] {};
4123        case -670487542: /*versioning*/ return new String[] {"code"};
4124        case 187518494: /*readHistory*/ return new String[] {"boolean"};
4125        case -1400550619: /*updateCreate*/ return new String[] {"boolean"};
4126        case 6401826: /*conditionalCreate*/ return new String[] {"boolean"};
4127        case 822786364: /*conditionalRead*/ return new String[] {"code"};
4128        case 519849711: /*conditionalUpdate*/ return new String[] {"boolean"};
4129        case -265374366: /*conditionalPatch*/ return new String[] {"boolean"};
4130        case 23237585: /*conditionalDelete*/ return new String[] {"code"};
4131        case 796257373: /*referencePolicy*/ return new String[] {"code"};
4132        case -1035904544: /*searchInclude*/ return new String[] {"string"};
4133        case -2123884979: /*searchRevInclude*/ return new String[] {"string"};
4134        case -553645115: /*searchParam*/ return new String[] {};
4135        case 1662702951: /*operation*/ return new String[] {};
4136        default: return super.getTypesForProperty(hash, name);
4137        }
4138
4139      }
4140
4141      @Override
4142      public Base addChild(String name) throws FHIRException {
4143        if (name.equals("type")) {
4144          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.type");
4145        }
4146        else if (name.equals("profile")) {
4147          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.profile");
4148        }
4149        else if (name.equals("supportedProfile")) {
4150          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.supportedProfile");
4151        }
4152        else if (name.equals("documentation")) {
4153          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.documentation");
4154        }
4155        else if (name.equals("interaction")) {
4156          return addInteraction();
4157        }
4158        else if (name.equals("versioning")) {
4159          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.versioning");
4160        }
4161        else if (name.equals("readHistory")) {
4162          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.readHistory");
4163        }
4164        else if (name.equals("updateCreate")) {
4165          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.updateCreate");
4166        }
4167        else if (name.equals("conditionalCreate")) {
4168          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.conditionalCreate");
4169        }
4170        else if (name.equals("conditionalRead")) {
4171          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.conditionalRead");
4172        }
4173        else if (name.equals("conditionalUpdate")) {
4174          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.conditionalUpdate");
4175        }
4176        else if (name.equals("conditionalPatch")) {
4177          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.conditionalPatch");
4178        }
4179        else if (name.equals("conditionalDelete")) {
4180          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.conditionalDelete");
4181        }
4182        else if (name.equals("referencePolicy")) {
4183          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.referencePolicy");
4184        }
4185        else if (name.equals("searchInclude")) {
4186          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.searchInclude");
4187        }
4188        else if (name.equals("searchRevInclude")) {
4189          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.searchRevInclude");
4190        }
4191        else if (name.equals("searchParam")) {
4192          return addSearchParam();
4193        }
4194        else if (name.equals("operation")) {
4195          return addOperation();
4196        }
4197        else
4198          return super.addChild(name);
4199      }
4200
4201      public CapabilityStatementRestResourceComponent copy() {
4202        CapabilityStatementRestResourceComponent dst = new CapabilityStatementRestResourceComponent();
4203        copyValues(dst);
4204        return dst;
4205      }
4206
4207      public void copyValues(CapabilityStatementRestResourceComponent dst) {
4208        super.copyValues(dst);
4209        dst.type = type == null ? null : type.copy();
4210        dst.profile = profile == null ? null : profile.copy();
4211        if (supportedProfile != null) {
4212          dst.supportedProfile = new ArrayList<CanonicalType>();
4213          for (CanonicalType i : supportedProfile)
4214            dst.supportedProfile.add(i.copy());
4215        };
4216        dst.documentation = documentation == null ? null : documentation.copy();
4217        if (interaction != null) {
4218          dst.interaction = new ArrayList<ResourceInteractionComponent>();
4219          for (ResourceInteractionComponent i : interaction)
4220            dst.interaction.add(i.copy());
4221        };
4222        dst.versioning = versioning == null ? null : versioning.copy();
4223        dst.readHistory = readHistory == null ? null : readHistory.copy();
4224        dst.updateCreate = updateCreate == null ? null : updateCreate.copy();
4225        dst.conditionalCreate = conditionalCreate == null ? null : conditionalCreate.copy();
4226        dst.conditionalRead = conditionalRead == null ? null : conditionalRead.copy();
4227        dst.conditionalUpdate = conditionalUpdate == null ? null : conditionalUpdate.copy();
4228        dst.conditionalPatch = conditionalPatch == null ? null : conditionalPatch.copy();
4229        dst.conditionalDelete = conditionalDelete == null ? null : conditionalDelete.copy();
4230        if (referencePolicy != null) {
4231          dst.referencePolicy = new ArrayList<Enumeration<ReferenceHandlingPolicy>>();
4232          for (Enumeration<ReferenceHandlingPolicy> i : referencePolicy)
4233            dst.referencePolicy.add(i.copy());
4234        };
4235        if (searchInclude != null) {
4236          dst.searchInclude = new ArrayList<StringType>();
4237          for (StringType i : searchInclude)
4238            dst.searchInclude.add(i.copy());
4239        };
4240        if (searchRevInclude != null) {
4241          dst.searchRevInclude = new ArrayList<StringType>();
4242          for (StringType i : searchRevInclude)
4243            dst.searchRevInclude.add(i.copy());
4244        };
4245        if (searchParam != null) {
4246          dst.searchParam = new ArrayList<CapabilityStatementRestResourceSearchParamComponent>();
4247          for (CapabilityStatementRestResourceSearchParamComponent i : searchParam)
4248            dst.searchParam.add(i.copy());
4249        };
4250        if (operation != null) {
4251          dst.operation = new ArrayList<CapabilityStatementRestResourceOperationComponent>();
4252          for (CapabilityStatementRestResourceOperationComponent i : operation)
4253            dst.operation.add(i.copy());
4254        };
4255      }
4256
4257      @Override
4258      public boolean equalsDeep(Base other_) {
4259        if (!super.equalsDeep(other_))
4260          return false;
4261        if (!(other_ instanceof CapabilityStatementRestResourceComponent))
4262          return false;
4263        CapabilityStatementRestResourceComponent o = (CapabilityStatementRestResourceComponent) other_;
4264        return compareDeep(type, o.type, true) && compareDeep(profile, o.profile, true) && compareDeep(supportedProfile, o.supportedProfile, true)
4265           && compareDeep(documentation, o.documentation, true) && compareDeep(interaction, o.interaction, true)
4266           && compareDeep(versioning, o.versioning, true) && compareDeep(readHistory, o.readHistory, true)
4267           && compareDeep(updateCreate, o.updateCreate, true) && compareDeep(conditionalCreate, o.conditionalCreate, true)
4268           && compareDeep(conditionalRead, o.conditionalRead, true) && compareDeep(conditionalUpdate, o.conditionalUpdate, true)
4269           && compareDeep(conditionalPatch, o.conditionalPatch, true) && compareDeep(conditionalDelete, o.conditionalDelete, true)
4270           && compareDeep(referencePolicy, o.referencePolicy, true) && compareDeep(searchInclude, o.searchInclude, true)
4271           && compareDeep(searchRevInclude, o.searchRevInclude, true) && compareDeep(searchParam, o.searchParam, true)
4272           && compareDeep(operation, o.operation, true);
4273      }
4274
4275      @Override
4276      public boolean equalsShallow(Base other_) {
4277        if (!super.equalsShallow(other_))
4278          return false;
4279        if (!(other_ instanceof CapabilityStatementRestResourceComponent))
4280          return false;
4281        CapabilityStatementRestResourceComponent o = (CapabilityStatementRestResourceComponent) other_;
4282        return compareValues(type, o.type, true) && compareValues(profile, o.profile, true) && compareValues(supportedProfile, o.supportedProfile, true)
4283           && compareValues(documentation, o.documentation, true) && compareValues(versioning, o.versioning, true)
4284           && compareValues(readHistory, o.readHistory, true) && compareValues(updateCreate, o.updateCreate, true)
4285           && compareValues(conditionalCreate, o.conditionalCreate, true) && compareValues(conditionalRead, o.conditionalRead, true)
4286           && compareValues(conditionalUpdate, o.conditionalUpdate, true) && compareValues(conditionalPatch, o.conditionalPatch, true)
4287           && compareValues(conditionalDelete, o.conditionalDelete, true) && compareValues(referencePolicy, o.referencePolicy, true)
4288           && compareValues(searchInclude, o.searchInclude, true) && compareValues(searchRevInclude, o.searchRevInclude, true)
4289          ;
4290      }
4291
4292      public boolean isEmpty() {
4293        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, profile, supportedProfile
4294          , documentation, interaction, versioning, readHistory, updateCreate, conditionalCreate
4295          , conditionalRead, conditionalUpdate, conditionalPatch, conditionalDelete, referencePolicy
4296          , searchInclude, searchRevInclude, searchParam, operation);
4297      }
4298
4299  public String fhirType() {
4300    return "CapabilityStatement.rest.resource";
4301
4302  }
4303
4304  }
4305
4306    @Block()
4307    public static class ResourceInteractionComponent extends BackboneElement implements IBaseBackboneElement {
4308        /**
4309         * Coded identifier of the operation, supported by the system resource.
4310         */
4311        @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=false)
4312        @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." )
4313        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/type-restful-interaction")
4314        protected Enumeration<TypeRestfulInteraction> code;
4315
4316        /**
4317         * 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'.
4318         */
4319        @Child(name = "documentation", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=false)
4320        @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'." )
4321        protected MarkdownType documentation;
4322
4323        private static final long serialVersionUID = 2128937796L;
4324
4325    /**
4326     * Constructor
4327     */
4328      public ResourceInteractionComponent() {
4329        super();
4330      }
4331
4332    /**
4333     * Constructor
4334     */
4335      public ResourceInteractionComponent(TypeRestfulInteraction code) {
4336        super();
4337        this.setCode(code);
4338      }
4339
4340        /**
4341         * @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
4342         */
4343        public Enumeration<TypeRestfulInteraction> getCodeElement() { 
4344          if (this.code == null)
4345            if (Configuration.errorOnAutoCreate())
4346              throw new Error("Attempt to auto-create ResourceInteractionComponent.code");
4347            else if (Configuration.doAutoCreate())
4348              this.code = new Enumeration<TypeRestfulInteraction>(new TypeRestfulInteractionEnumFactory()); // bb
4349          return this.code;
4350        }
4351
4352        public boolean hasCodeElement() { 
4353          return this.code != null && !this.code.isEmpty();
4354        }
4355
4356        public boolean hasCode() { 
4357          return this.code != null && !this.code.isEmpty();
4358        }
4359
4360        /**
4361         * @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
4362         */
4363        public ResourceInteractionComponent setCodeElement(Enumeration<TypeRestfulInteraction> value) { 
4364          this.code = value;
4365          return this;
4366        }
4367
4368        /**
4369         * @return Coded identifier of the operation, supported by the system resource.
4370         */
4371        public TypeRestfulInteraction getCode() { 
4372          return this.code == null ? null : this.code.getValue();
4373        }
4374
4375        /**
4376         * @param value Coded identifier of the operation, supported by the system resource.
4377         */
4378        public ResourceInteractionComponent setCode(TypeRestfulInteraction value) { 
4379            if (this.code == null)
4380              this.code = new Enumeration<TypeRestfulInteraction>(new TypeRestfulInteractionEnumFactory());
4381            this.code.setValue(value);
4382          return this;
4383        }
4384
4385        /**
4386         * @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
4387         */
4388        public MarkdownType getDocumentationElement() { 
4389          if (this.documentation == null)
4390            if (Configuration.errorOnAutoCreate())
4391              throw new Error("Attempt to auto-create ResourceInteractionComponent.documentation");
4392            else if (Configuration.doAutoCreate())
4393              this.documentation = new MarkdownType(); // bb
4394          return this.documentation;
4395        }
4396
4397        public boolean hasDocumentationElement() { 
4398          return this.documentation != null && !this.documentation.isEmpty();
4399        }
4400
4401        public boolean hasDocumentation() { 
4402          return this.documentation != null && !this.documentation.isEmpty();
4403        }
4404
4405        /**
4406         * @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
4407         */
4408        public ResourceInteractionComponent setDocumentationElement(MarkdownType value) { 
4409          this.documentation = value;
4410          return this;
4411        }
4412
4413        /**
4414         * @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'.
4415         */
4416        public String getDocumentation() { 
4417          return this.documentation == null ? null : this.documentation.getValue();
4418        }
4419
4420        /**
4421         * @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'.
4422         */
4423        public ResourceInteractionComponent setDocumentation(String value) { 
4424          if (Utilities.noString(value))
4425            this.documentation = null;
4426          else {
4427            if (this.documentation == null)
4428              this.documentation = new MarkdownType();
4429            this.documentation.setValue(value);
4430          }
4431          return this;
4432        }
4433
4434        protected void listChildren(List<Property> children) {
4435          super.listChildren(children);
4436          children.add(new Property("code", "code", "Coded identifier of the operation, supported by the system resource.", 0, 1, code));
4437          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));
4438        }
4439
4440        @Override
4441        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
4442          switch (_hash) {
4443          case 3059181: /*code*/  return new Property("code", "code", "Coded identifier of the operation, supported by the system resource.", 0, 1, code);
4444          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);
4445          default: return super.getNamedProperty(_hash, _name, _checkValid);
4446          }
4447
4448        }
4449
4450      @Override
4451      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
4452        switch (hash) {
4453        case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // Enumeration<TypeRestfulInteraction>
4454        case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType
4455        default: return super.getProperty(hash, name, checkValid);
4456        }
4457
4458      }
4459
4460      @Override
4461      public Base setProperty(int hash, String name, Base value) throws FHIRException {
4462        switch (hash) {
4463        case 3059181: // code
4464          value = new TypeRestfulInteractionEnumFactory().fromType(TypeConvertor.castToCode(value));
4465          this.code = (Enumeration) value; // Enumeration<TypeRestfulInteraction>
4466          return value;
4467        case 1587405498: // documentation
4468          this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType
4469          return value;
4470        default: return super.setProperty(hash, name, value);
4471        }
4472
4473      }
4474
4475      @Override
4476      public Base setProperty(String name, Base value) throws FHIRException {
4477        if (name.equals("code")) {
4478          value = new TypeRestfulInteractionEnumFactory().fromType(TypeConvertor.castToCode(value));
4479          this.code = (Enumeration) value; // Enumeration<TypeRestfulInteraction>
4480        } else if (name.equals("documentation")) {
4481          this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType
4482        } else
4483          return super.setProperty(name, value);
4484        return value;
4485      }
4486
4487      @Override
4488      public Base makeProperty(int hash, String name) throws FHIRException {
4489        switch (hash) {
4490        case 3059181:  return getCodeElement();
4491        case 1587405498:  return getDocumentationElement();
4492        default: return super.makeProperty(hash, name);
4493        }
4494
4495      }
4496
4497      @Override
4498      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
4499        switch (hash) {
4500        case 3059181: /*code*/ return new String[] {"code"};
4501        case 1587405498: /*documentation*/ return new String[] {"markdown"};
4502        default: return super.getTypesForProperty(hash, name);
4503        }
4504
4505      }
4506
4507      @Override
4508      public Base addChild(String name) throws FHIRException {
4509        if (name.equals("code")) {
4510          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.interaction.code");
4511        }
4512        else if (name.equals("documentation")) {
4513          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.interaction.documentation");
4514        }
4515        else
4516          return super.addChild(name);
4517      }
4518
4519      public ResourceInteractionComponent copy() {
4520        ResourceInteractionComponent dst = new ResourceInteractionComponent();
4521        copyValues(dst);
4522        return dst;
4523      }
4524
4525      public void copyValues(ResourceInteractionComponent dst) {
4526        super.copyValues(dst);
4527        dst.code = code == null ? null : code.copy();
4528        dst.documentation = documentation == null ? null : documentation.copy();
4529      }
4530
4531      @Override
4532      public boolean equalsDeep(Base other_) {
4533        if (!super.equalsDeep(other_))
4534          return false;
4535        if (!(other_ instanceof ResourceInteractionComponent))
4536          return false;
4537        ResourceInteractionComponent o = (ResourceInteractionComponent) other_;
4538        return compareDeep(code, o.code, true) && compareDeep(documentation, o.documentation, true);
4539      }
4540
4541      @Override
4542      public boolean equalsShallow(Base other_) {
4543        if (!super.equalsShallow(other_))
4544          return false;
4545        if (!(other_ instanceof ResourceInteractionComponent))
4546          return false;
4547        ResourceInteractionComponent o = (ResourceInteractionComponent) other_;
4548        return compareValues(code, o.code, true) && compareValues(documentation, o.documentation, true);
4549      }
4550
4551      public boolean isEmpty() {
4552        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, documentation);
4553      }
4554
4555  public String fhirType() {
4556    return "CapabilityStatement.rest.resource.interaction";
4557
4558  }
4559
4560  }
4561
4562    @Block()
4563    public static class CapabilityStatementRestResourceSearchParamComponent extends BackboneElement implements IBaseBackboneElement {
4564        /**
4565         * The label used for the search parameter in this particular system's API - i.e. the 'name' portion of the name-value pair that will appear as part of the search URL.  This SHOULD be the same as the SearchParameter.code of the defining SearchParameter.  However, it can sometimes differ if necessary to disambiguate when a server supports multiple SearchParameters that happen to share the same code.
4566         */
4567        @Child(name = "name", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=false)
4568        @Description(shortDefinition="Name for parameter in search url", formalDefinition="The label used for the search parameter in this particular system's API - i.e. the 'name' portion of the name-value pair that will appear as part of the search URL.  This SHOULD be the same as the SearchParameter.code of the defining SearchParameter.  However, it can sometimes differ if necessary to disambiguate when a server supports multiple SearchParameters that happen to share the same code." )
4569        protected StringType name;
4570
4571        /**
4572         * 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.
4573         */
4574        @Child(name = "definition", type = {CanonicalType.class}, order=2, min=0, max=1, modifier=false, summary=false)
4575        @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." )
4576        protected CanonicalType definition;
4577
4578        /**
4579         * The type of value a search parameter refers to, and how the content is interpreted.
4580         */
4581        @Child(name = "type", type = {CodeType.class}, order=3, min=1, max=1, modifier=false, summary=false)
4582        @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." )
4583        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/search-param-type")
4584        protected Enumeration<SearchParamType> type;
4585
4586        /**
4587         * This allows documentation of any distinct behaviors about how the search parameter is used.  For example, text matching algorithms.
4588         */
4589        @Child(name = "documentation", type = {MarkdownType.class}, order=4, min=0, max=1, modifier=false, summary=false)
4590        @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." )
4591        protected MarkdownType documentation;
4592
4593        private static final long serialVersionUID = -171123928L;
4594
4595    /**
4596     * Constructor
4597     */
4598      public CapabilityStatementRestResourceSearchParamComponent() {
4599        super();
4600      }
4601
4602    /**
4603     * Constructor
4604     */
4605      public CapabilityStatementRestResourceSearchParamComponent(String name, SearchParamType type) {
4606        super();
4607        this.setName(name);
4608        this.setType(type);
4609      }
4610
4611        /**
4612         * @return {@link #name} (The label used for the search parameter in this particular system's API - i.e. the 'name' portion of the name-value pair that will appear as part of the search URL.  This SHOULD be the same as the SearchParameter.code of the defining SearchParameter.  However, it can sometimes differ if necessary to disambiguate when a server supports multiple SearchParameters that happen to share the same code.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
4613         */
4614        public StringType getNameElement() { 
4615          if (this.name == null)
4616            if (Configuration.errorOnAutoCreate())
4617              throw new Error("Attempt to auto-create CapabilityStatementRestResourceSearchParamComponent.name");
4618            else if (Configuration.doAutoCreate())
4619              this.name = new StringType(); // bb
4620          return this.name;
4621        }
4622
4623        public boolean hasNameElement() { 
4624          return this.name != null && !this.name.isEmpty();
4625        }
4626
4627        public boolean hasName() { 
4628          return this.name != null && !this.name.isEmpty();
4629        }
4630
4631        /**
4632         * @param value {@link #name} (The label used for the search parameter in this particular system's API - i.e. the 'name' portion of the name-value pair that will appear as part of the search URL.  This SHOULD be the same as the SearchParameter.code of the defining SearchParameter.  However, it can sometimes differ if necessary to disambiguate when a server supports multiple SearchParameters that happen to share the same code.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
4633         */
4634        public CapabilityStatementRestResourceSearchParamComponent setNameElement(StringType value) { 
4635          this.name = value;
4636          return this;
4637        }
4638
4639        /**
4640         * @return The label used for the search parameter in this particular system's API - i.e. the 'name' portion of the name-value pair that will appear as part of the search URL.  This SHOULD be the same as the SearchParameter.code of the defining SearchParameter.  However, it can sometimes differ if necessary to disambiguate when a server supports multiple SearchParameters that happen to share the same code.
4641         */
4642        public String getName() { 
4643          return this.name == null ? null : this.name.getValue();
4644        }
4645
4646        /**
4647         * @param value The label used for the search parameter in this particular system's API - i.e. the 'name' portion of the name-value pair that will appear as part of the search URL.  This SHOULD be the same as the SearchParameter.code of the defining SearchParameter.  However, it can sometimes differ if necessary to disambiguate when a server supports multiple SearchParameters that happen to share the same code.
4648         */
4649        public CapabilityStatementRestResourceSearchParamComponent setName(String value) { 
4650            if (this.name == null)
4651              this.name = new StringType();
4652            this.name.setValue(value);
4653          return this;
4654        }
4655
4656        /**
4657         * @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
4658         */
4659        public CanonicalType getDefinitionElement() { 
4660          if (this.definition == null)
4661            if (Configuration.errorOnAutoCreate())
4662              throw new Error("Attempt to auto-create CapabilityStatementRestResourceSearchParamComponent.definition");
4663            else if (Configuration.doAutoCreate())
4664              this.definition = new CanonicalType(); // bb
4665          return this.definition;
4666        }
4667
4668        public boolean hasDefinitionElement() { 
4669          return this.definition != null && !this.definition.isEmpty();
4670        }
4671
4672        public boolean hasDefinition() { 
4673          return this.definition != null && !this.definition.isEmpty();
4674        }
4675
4676        /**
4677         * @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
4678         */
4679        public CapabilityStatementRestResourceSearchParamComponent setDefinitionElement(CanonicalType value) { 
4680          this.definition = value;
4681          return this;
4682        }
4683
4684        /**
4685         * @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.
4686         */
4687        public String getDefinition() { 
4688          return this.definition == null ? null : this.definition.getValue();
4689        }
4690
4691        /**
4692         * @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.
4693         */
4694        public CapabilityStatementRestResourceSearchParamComponent setDefinition(String value) { 
4695          if (Utilities.noString(value))
4696            this.definition = null;
4697          else {
4698            if (this.definition == null)
4699              this.definition = new CanonicalType();
4700            this.definition.setValue(value);
4701          }
4702          return this;
4703        }
4704
4705        /**
4706         * @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
4707         */
4708        public Enumeration<SearchParamType> getTypeElement() { 
4709          if (this.type == null)
4710            if (Configuration.errorOnAutoCreate())
4711              throw new Error("Attempt to auto-create CapabilityStatementRestResourceSearchParamComponent.type");
4712            else if (Configuration.doAutoCreate())
4713              this.type = new Enumeration<SearchParamType>(new SearchParamTypeEnumFactory()); // bb
4714          return this.type;
4715        }
4716
4717        public boolean hasTypeElement() { 
4718          return this.type != null && !this.type.isEmpty();
4719        }
4720
4721        public boolean hasType() { 
4722          return this.type != null && !this.type.isEmpty();
4723        }
4724
4725        /**
4726         * @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
4727         */
4728        public CapabilityStatementRestResourceSearchParamComponent setTypeElement(Enumeration<SearchParamType> value) { 
4729          this.type = value;
4730          return this;
4731        }
4732
4733        /**
4734         * @return The type of value a search parameter refers to, and how the content is interpreted.
4735         */
4736        public SearchParamType getType() { 
4737          return this.type == null ? null : this.type.getValue();
4738        }
4739
4740        /**
4741         * @param value The type of value a search parameter refers to, and how the content is interpreted.
4742         */
4743        public CapabilityStatementRestResourceSearchParamComponent setType(SearchParamType value) { 
4744            if (this.type == null)
4745              this.type = new Enumeration<SearchParamType>(new SearchParamTypeEnumFactory());
4746            this.type.setValue(value);
4747          return this;
4748        }
4749
4750        /**
4751         * @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
4752         */
4753        public MarkdownType getDocumentationElement() { 
4754          if (this.documentation == null)
4755            if (Configuration.errorOnAutoCreate())
4756              throw new Error("Attempt to auto-create CapabilityStatementRestResourceSearchParamComponent.documentation");
4757            else if (Configuration.doAutoCreate())
4758              this.documentation = new MarkdownType(); // bb
4759          return this.documentation;
4760        }
4761
4762        public boolean hasDocumentationElement() { 
4763          return this.documentation != null && !this.documentation.isEmpty();
4764        }
4765
4766        public boolean hasDocumentation() { 
4767          return this.documentation != null && !this.documentation.isEmpty();
4768        }
4769
4770        /**
4771         * @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
4772         */
4773        public CapabilityStatementRestResourceSearchParamComponent setDocumentationElement(MarkdownType value) { 
4774          this.documentation = value;
4775          return this;
4776        }
4777
4778        /**
4779         * @return This allows documentation of any distinct behaviors about how the search parameter is used.  For example, text matching algorithms.
4780         */
4781        public String getDocumentation() { 
4782          return this.documentation == null ? null : this.documentation.getValue();
4783        }
4784
4785        /**
4786         * @param value This allows documentation of any distinct behaviors about how the search parameter is used.  For example, text matching algorithms.
4787         */
4788        public CapabilityStatementRestResourceSearchParamComponent setDocumentation(String value) { 
4789          if (Utilities.noString(value))
4790            this.documentation = null;
4791          else {
4792            if (this.documentation == null)
4793              this.documentation = new MarkdownType();
4794            this.documentation.setValue(value);
4795          }
4796          return this;
4797        }
4798
4799        protected void listChildren(List<Property> children) {
4800          super.listChildren(children);
4801          children.add(new Property("name", "string", "The label used for the search parameter in this particular system's API - i.e. the 'name' portion of the name-value pair that will appear as part of the search URL.  This SHOULD be the same as the SearchParameter.code of the defining SearchParameter.  However, it can sometimes differ if necessary to disambiguate when a server supports multiple SearchParameters that happen to share the same code.", 0, 1, name));
4802          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));
4803          children.add(new Property("type", "code", "The type of value a search parameter refers to, and how the content is interpreted.", 0, 1, type));
4804          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));
4805        }
4806
4807        @Override
4808        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
4809          switch (_hash) {
4810          case 3373707: /*name*/  return new Property("name", "string", "The label used for the search parameter in this particular system's API - i.e. the 'name' portion of the name-value pair that will appear as part of the search URL.  This SHOULD be the same as the SearchParameter.code of the defining SearchParameter.  However, it can sometimes differ if necessary to disambiguate when a server supports multiple SearchParameters that happen to share the same code.", 0, 1, name);
4811          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);
4812          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);
4813          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);
4814          default: return super.getNamedProperty(_hash, _name, _checkValid);
4815          }
4816
4817        }
4818
4819      @Override
4820      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
4821        switch (hash) {
4822        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
4823        case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : new Base[] {this.definition}; // CanonicalType
4824        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<SearchParamType>
4825        case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType
4826        default: return super.getProperty(hash, name, checkValid);
4827        }
4828
4829      }
4830
4831      @Override
4832      public Base setProperty(int hash, String name, Base value) throws FHIRException {
4833        switch (hash) {
4834        case 3373707: // name
4835          this.name = TypeConvertor.castToString(value); // StringType
4836          return value;
4837        case -1014418093: // definition
4838          this.definition = TypeConvertor.castToCanonical(value); // CanonicalType
4839          return value;
4840        case 3575610: // type
4841          value = new SearchParamTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
4842          this.type = (Enumeration) value; // Enumeration<SearchParamType>
4843          return value;
4844        case 1587405498: // documentation
4845          this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType
4846          return value;
4847        default: return super.setProperty(hash, name, value);
4848        }
4849
4850      }
4851
4852      @Override
4853      public Base setProperty(String name, Base value) throws FHIRException {
4854        if (name.equals("name")) {
4855          this.name = TypeConvertor.castToString(value); // StringType
4856        } else if (name.equals("definition")) {
4857          this.definition = TypeConvertor.castToCanonical(value); // CanonicalType
4858        } else if (name.equals("type")) {
4859          value = new SearchParamTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
4860          this.type = (Enumeration) value; // Enumeration<SearchParamType>
4861        } else if (name.equals("documentation")) {
4862          this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType
4863        } else
4864          return super.setProperty(name, value);
4865        return value;
4866      }
4867
4868      @Override
4869      public Base makeProperty(int hash, String name) throws FHIRException {
4870        switch (hash) {
4871        case 3373707:  return getNameElement();
4872        case -1014418093:  return getDefinitionElement();
4873        case 3575610:  return getTypeElement();
4874        case 1587405498:  return getDocumentationElement();
4875        default: return super.makeProperty(hash, name);
4876        }
4877
4878      }
4879
4880      @Override
4881      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
4882        switch (hash) {
4883        case 3373707: /*name*/ return new String[] {"string"};
4884        case -1014418093: /*definition*/ return new String[] {"canonical"};
4885        case 3575610: /*type*/ return new String[] {"code"};
4886        case 1587405498: /*documentation*/ return new String[] {"markdown"};
4887        default: return super.getTypesForProperty(hash, name);
4888        }
4889
4890      }
4891
4892      @Override
4893      public Base addChild(String name) throws FHIRException {
4894        if (name.equals("name")) {
4895          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.searchParam.name");
4896        }
4897        else if (name.equals("definition")) {
4898          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.searchParam.definition");
4899        }
4900        else if (name.equals("type")) {
4901          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.searchParam.type");
4902        }
4903        else if (name.equals("documentation")) {
4904          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.searchParam.documentation");
4905        }
4906        else
4907          return super.addChild(name);
4908      }
4909
4910      public CapabilityStatementRestResourceSearchParamComponent copy() {
4911        CapabilityStatementRestResourceSearchParamComponent dst = new CapabilityStatementRestResourceSearchParamComponent();
4912        copyValues(dst);
4913        return dst;
4914      }
4915
4916      public void copyValues(CapabilityStatementRestResourceSearchParamComponent dst) {
4917        super.copyValues(dst);
4918        dst.name = name == null ? null : name.copy();
4919        dst.definition = definition == null ? null : definition.copy();
4920        dst.type = type == null ? null : type.copy();
4921        dst.documentation = documentation == null ? null : documentation.copy();
4922      }
4923
4924      @Override
4925      public boolean equalsDeep(Base other_) {
4926        if (!super.equalsDeep(other_))
4927          return false;
4928        if (!(other_ instanceof CapabilityStatementRestResourceSearchParamComponent))
4929          return false;
4930        CapabilityStatementRestResourceSearchParamComponent o = (CapabilityStatementRestResourceSearchParamComponent) other_;
4931        return compareDeep(name, o.name, true) && compareDeep(definition, o.definition, true) && compareDeep(type, o.type, true)
4932           && compareDeep(documentation, o.documentation, true);
4933      }
4934
4935      @Override
4936      public boolean equalsShallow(Base other_) {
4937        if (!super.equalsShallow(other_))
4938          return false;
4939        if (!(other_ instanceof CapabilityStatementRestResourceSearchParamComponent))
4940          return false;
4941        CapabilityStatementRestResourceSearchParamComponent o = (CapabilityStatementRestResourceSearchParamComponent) other_;
4942        return compareValues(name, o.name, true) && compareValues(definition, o.definition, true) && compareValues(type, o.type, true)
4943           && compareValues(documentation, o.documentation, true);
4944      }
4945
4946      public boolean isEmpty() {
4947        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, definition, type, documentation
4948          );
4949      }
4950
4951  public String fhirType() {
4952    return "CapabilityStatement.rest.resource.searchParam";
4953
4954  }
4955
4956  }
4957
4958    @Block()
4959    public static class CapabilityStatementRestResourceOperationComponent extends BackboneElement implements IBaseBackboneElement {
4960        /**
4961         * The name of the operation or query. For an operation, this name is 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 SHOULD be the same as the OperationDefinition.code of the defining OperationDefinition.  However, it can sometimes differ if necessary to disambiguate when a server supports multiple OperationDefinition that happen to share the same code.
4962         */
4963        @Child(name = "name", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true)
4964        @Description(shortDefinition="Name by which the operation/query is invoked", formalDefinition="The name of the operation or query. For an operation, this name is 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 SHOULD be the same as the OperationDefinition.code of the defining OperationDefinition.  However, it can sometimes differ if necessary to disambiguate when a server supports multiple OperationDefinition that happen to share the same code." )
4965        protected StringType name;
4966
4967        /**
4968         * 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.
4969         */
4970        @Child(name = "definition", type = {CanonicalType.class}, order=2, min=1, max=1, modifier=false, summary=true)
4971        @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." )
4972        protected CanonicalType definition;
4973
4974        /**
4975         * Documentation that describes anything special about the operation behavior, possibly detailing different behavior for system, type and instance-level invocation of the operation.
4976         */
4977        @Child(name = "documentation", type = {MarkdownType.class}, order=3, min=0, max=1, modifier=false, summary=false)
4978        @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." )
4979        protected MarkdownType documentation;
4980
4981        private static final long serialVersionUID = -388608084L;
4982
4983    /**
4984     * Constructor
4985     */
4986      public CapabilityStatementRestResourceOperationComponent() {
4987        super();
4988      }
4989
4990    /**
4991     * Constructor
4992     */
4993      public CapabilityStatementRestResourceOperationComponent(String name, String definition) {
4994        super();
4995        this.setName(name);
4996        this.setDefinition(definition);
4997      }
4998
4999        /**
5000         * @return {@link #name} (The name of the operation or query. For an operation, this name is 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 SHOULD be the same as the OperationDefinition.code of the defining OperationDefinition.  However, it can sometimes differ if necessary to disambiguate when a server supports multiple OperationDefinition that happen to share the same code.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
5001         */
5002        public StringType getNameElement() { 
5003          if (this.name == null)
5004            if (Configuration.errorOnAutoCreate())
5005              throw new Error("Attempt to auto-create CapabilityStatementRestResourceOperationComponent.name");
5006            else if (Configuration.doAutoCreate())
5007              this.name = new StringType(); // bb
5008          return this.name;
5009        }
5010
5011        public boolean hasNameElement() { 
5012          return this.name != null && !this.name.isEmpty();
5013        }
5014
5015        public boolean hasName() { 
5016          return this.name != null && !this.name.isEmpty();
5017        }
5018
5019        /**
5020         * @param value {@link #name} (The name of the operation or query. For an operation, this name is 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 SHOULD be the same as the OperationDefinition.code of the defining OperationDefinition.  However, it can sometimes differ if necessary to disambiguate when a server supports multiple OperationDefinition that happen to share the same code.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
5021         */
5022        public CapabilityStatementRestResourceOperationComponent setNameElement(StringType value) { 
5023          this.name = value;
5024          return this;
5025        }
5026
5027        /**
5028         * @return The name of the operation or query. For an operation, this name is 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 SHOULD be the same as the OperationDefinition.code of the defining OperationDefinition.  However, it can sometimes differ if necessary to disambiguate when a server supports multiple OperationDefinition that happen to share the same code.
5029         */
5030        public String getName() { 
5031          return this.name == null ? null : this.name.getValue();
5032        }
5033
5034        /**
5035         * @param value The name of the operation or query. For an operation, this name is 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 SHOULD be the same as the OperationDefinition.code of the defining OperationDefinition.  However, it can sometimes differ if necessary to disambiguate when a server supports multiple OperationDefinition that happen to share the same code.
5036         */
5037        public CapabilityStatementRestResourceOperationComponent setName(String value) { 
5038            if (this.name == null)
5039              this.name = new StringType();
5040            this.name.setValue(value);
5041          return this;
5042        }
5043
5044        /**
5045         * @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
5046         */
5047        public CanonicalType getDefinitionElement() { 
5048          if (this.definition == null)
5049            if (Configuration.errorOnAutoCreate())
5050              throw new Error("Attempt to auto-create CapabilityStatementRestResourceOperationComponent.definition");
5051            else if (Configuration.doAutoCreate())
5052              this.definition = new CanonicalType(); // bb
5053          return this.definition;
5054        }
5055
5056        public boolean hasDefinitionElement() { 
5057          return this.definition != null && !this.definition.isEmpty();
5058        }
5059
5060        public boolean hasDefinition() { 
5061          return this.definition != null && !this.definition.isEmpty();
5062        }
5063
5064        /**
5065         * @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
5066         */
5067        public CapabilityStatementRestResourceOperationComponent setDefinitionElement(CanonicalType value) { 
5068          this.definition = value;
5069          return this;
5070        }
5071
5072        /**
5073         * @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.
5074         */
5075        public String getDefinition() { 
5076          return this.definition == null ? null : this.definition.getValue();
5077        }
5078
5079        /**
5080         * @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.
5081         */
5082        public CapabilityStatementRestResourceOperationComponent setDefinition(String value) { 
5083            if (this.definition == null)
5084              this.definition = new CanonicalType();
5085            this.definition.setValue(value);
5086          return this;
5087        }
5088
5089        /**
5090         * @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
5091         */
5092        public MarkdownType getDocumentationElement() { 
5093          if (this.documentation == null)
5094            if (Configuration.errorOnAutoCreate())
5095              throw new Error("Attempt to auto-create CapabilityStatementRestResourceOperationComponent.documentation");
5096            else if (Configuration.doAutoCreate())
5097              this.documentation = new MarkdownType(); // bb
5098          return this.documentation;
5099        }
5100
5101        public boolean hasDocumentationElement() { 
5102          return this.documentation != null && !this.documentation.isEmpty();
5103        }
5104
5105        public boolean hasDocumentation() { 
5106          return this.documentation != null && !this.documentation.isEmpty();
5107        }
5108
5109        /**
5110         * @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
5111         */
5112        public CapabilityStatementRestResourceOperationComponent setDocumentationElement(MarkdownType value) { 
5113          this.documentation = value;
5114          return this;
5115        }
5116
5117        /**
5118         * @return Documentation that describes anything special about the operation behavior, possibly detailing different behavior for system, type and instance-level invocation of the operation.
5119         */
5120        public String getDocumentation() { 
5121          return this.documentation == null ? null : this.documentation.getValue();
5122        }
5123
5124        /**
5125         * @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.
5126         */
5127        public CapabilityStatementRestResourceOperationComponent setDocumentation(String value) { 
5128          if (Utilities.noString(value))
5129            this.documentation = null;
5130          else {
5131            if (this.documentation == null)
5132              this.documentation = new MarkdownType();
5133            this.documentation.setValue(value);
5134          }
5135          return this;
5136        }
5137
5138        protected void listChildren(List<Property> children) {
5139          super.listChildren(children);
5140          children.add(new Property("name", "string", "The name of the operation or query. For an operation, this name is 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 SHOULD be the same as the OperationDefinition.code of the defining OperationDefinition.  However, it can sometimes differ if necessary to disambiguate when a server supports multiple OperationDefinition that happen to share the same code.", 0, 1, name));
5141          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));
5142          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));
5143        }
5144
5145        @Override
5146        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
5147          switch (_hash) {
5148          case 3373707: /*name*/  return new Property("name", "string", "The name of the operation or query. For an operation, this name is 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 SHOULD be the same as the OperationDefinition.code of the defining OperationDefinition.  However, it can sometimes differ if necessary to disambiguate when a server supports multiple OperationDefinition that happen to share the same code.", 0, 1, name);
5149          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);
5150          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);
5151          default: return super.getNamedProperty(_hash, _name, _checkValid);
5152          }
5153
5154        }
5155
5156      @Override
5157      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
5158        switch (hash) {
5159        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
5160        case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : new Base[] {this.definition}; // CanonicalType
5161        case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType
5162        default: return super.getProperty(hash, name, checkValid);
5163        }
5164
5165      }
5166
5167      @Override
5168      public Base setProperty(int hash, String name, Base value) throws FHIRException {
5169        switch (hash) {
5170        case 3373707: // name
5171          this.name = TypeConvertor.castToString(value); // StringType
5172          return value;
5173        case -1014418093: // definition
5174          this.definition = TypeConvertor.castToCanonical(value); // CanonicalType
5175          return value;
5176        case 1587405498: // documentation
5177          this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType
5178          return value;
5179        default: return super.setProperty(hash, name, value);
5180        }
5181
5182      }
5183
5184      @Override
5185      public Base setProperty(String name, Base value) throws FHIRException {
5186        if (name.equals("name")) {
5187          this.name = TypeConvertor.castToString(value); // StringType
5188        } else if (name.equals("definition")) {
5189          this.definition = TypeConvertor.castToCanonical(value); // CanonicalType
5190        } else if (name.equals("documentation")) {
5191          this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType
5192        } else
5193          return super.setProperty(name, value);
5194        return value;
5195      }
5196
5197      @Override
5198      public Base makeProperty(int hash, String name) throws FHIRException {
5199        switch (hash) {
5200        case 3373707:  return getNameElement();
5201        case -1014418093:  return getDefinitionElement();
5202        case 1587405498:  return getDocumentationElement();
5203        default: return super.makeProperty(hash, name);
5204        }
5205
5206      }
5207
5208      @Override
5209      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
5210        switch (hash) {
5211        case 3373707: /*name*/ return new String[] {"string"};
5212        case -1014418093: /*definition*/ return new String[] {"canonical"};
5213        case 1587405498: /*documentation*/ return new String[] {"markdown"};
5214        default: return super.getTypesForProperty(hash, name);
5215        }
5216
5217      }
5218
5219      @Override
5220      public Base addChild(String name) throws FHIRException {
5221        if (name.equals("name")) {
5222          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.operation.name");
5223        }
5224        else if (name.equals("definition")) {
5225          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.operation.definition");
5226        }
5227        else if (name.equals("documentation")) {
5228          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.resource.operation.documentation");
5229        }
5230        else
5231          return super.addChild(name);
5232      }
5233
5234      public CapabilityStatementRestResourceOperationComponent copy() {
5235        CapabilityStatementRestResourceOperationComponent dst = new CapabilityStatementRestResourceOperationComponent();
5236        copyValues(dst);
5237        return dst;
5238      }
5239
5240      public void copyValues(CapabilityStatementRestResourceOperationComponent dst) {
5241        super.copyValues(dst);
5242        dst.name = name == null ? null : name.copy();
5243        dst.definition = definition == null ? null : definition.copy();
5244        dst.documentation = documentation == null ? null : documentation.copy();
5245      }
5246
5247      @Override
5248      public boolean equalsDeep(Base other_) {
5249        if (!super.equalsDeep(other_))
5250          return false;
5251        if (!(other_ instanceof CapabilityStatementRestResourceOperationComponent))
5252          return false;
5253        CapabilityStatementRestResourceOperationComponent o = (CapabilityStatementRestResourceOperationComponent) other_;
5254        return compareDeep(name, o.name, true) && compareDeep(definition, o.definition, true) && compareDeep(documentation, o.documentation, true)
5255          ;
5256      }
5257
5258      @Override
5259      public boolean equalsShallow(Base other_) {
5260        if (!super.equalsShallow(other_))
5261          return false;
5262        if (!(other_ instanceof CapabilityStatementRestResourceOperationComponent))
5263          return false;
5264        CapabilityStatementRestResourceOperationComponent o = (CapabilityStatementRestResourceOperationComponent) other_;
5265        return compareValues(name, o.name, true) && compareValues(definition, o.definition, true) && compareValues(documentation, o.documentation, true)
5266          ;
5267      }
5268
5269      public boolean isEmpty() {
5270        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, definition, documentation
5271          );
5272      }
5273
5274  public String fhirType() {
5275    return "CapabilityStatement.rest.resource.operation";
5276
5277  }
5278
5279  }
5280
5281    @Block()
5282    public static class SystemInteractionComponent extends BackboneElement implements IBaseBackboneElement {
5283        /**
5284         * A coded identifier of the operation, supported by the system.
5285         */
5286        @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=false)
5287        @Description(shortDefinition="transaction | batch | search-system | history-system", formalDefinition="A coded identifier of the operation, supported by the system." )
5288        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/system-restful-interaction")
5289        protected Enumeration<SystemRestfulInteraction> code;
5290
5291        /**
5292         * 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.
5293         */
5294        @Child(name = "documentation", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=false)
5295        @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." )
5296        protected MarkdownType documentation;
5297
5298        private static final long serialVersionUID = -1495143879L;
5299
5300    /**
5301     * Constructor
5302     */
5303      public SystemInteractionComponent() {
5304        super();
5305      }
5306
5307    /**
5308     * Constructor
5309     */
5310      public SystemInteractionComponent(SystemRestfulInteraction code) {
5311        super();
5312        this.setCode(code);
5313      }
5314
5315        /**
5316         * @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
5317         */
5318        public Enumeration<SystemRestfulInteraction> getCodeElement() { 
5319          if (this.code == null)
5320            if (Configuration.errorOnAutoCreate())
5321              throw new Error("Attempt to auto-create SystemInteractionComponent.code");
5322            else if (Configuration.doAutoCreate())
5323              this.code = new Enumeration<SystemRestfulInteraction>(new SystemRestfulInteractionEnumFactory()); // bb
5324          return this.code;
5325        }
5326
5327        public boolean hasCodeElement() { 
5328          return this.code != null && !this.code.isEmpty();
5329        }
5330
5331        public boolean hasCode() { 
5332          return this.code != null && !this.code.isEmpty();
5333        }
5334
5335        /**
5336         * @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
5337         */
5338        public SystemInteractionComponent setCodeElement(Enumeration<SystemRestfulInteraction> value) { 
5339          this.code = value;
5340          return this;
5341        }
5342
5343        /**
5344         * @return A coded identifier of the operation, supported by the system.
5345         */
5346        public SystemRestfulInteraction getCode() { 
5347          return this.code == null ? null : this.code.getValue();
5348        }
5349
5350        /**
5351         * @param value A coded identifier of the operation, supported by the system.
5352         */
5353        public SystemInteractionComponent setCode(SystemRestfulInteraction value) { 
5354            if (this.code == null)
5355              this.code = new Enumeration<SystemRestfulInteraction>(new SystemRestfulInteractionEnumFactory());
5356            this.code.setValue(value);
5357          return this;
5358        }
5359
5360        /**
5361         * @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
5362         */
5363        public MarkdownType getDocumentationElement() { 
5364          if (this.documentation == null)
5365            if (Configuration.errorOnAutoCreate())
5366              throw new Error("Attempt to auto-create SystemInteractionComponent.documentation");
5367            else if (Configuration.doAutoCreate())
5368              this.documentation = new MarkdownType(); // bb
5369          return this.documentation;
5370        }
5371
5372        public boolean hasDocumentationElement() { 
5373          return this.documentation != null && !this.documentation.isEmpty();
5374        }
5375
5376        public boolean hasDocumentation() { 
5377          return this.documentation != null && !this.documentation.isEmpty();
5378        }
5379
5380        /**
5381         * @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
5382         */
5383        public SystemInteractionComponent setDocumentationElement(MarkdownType value) { 
5384          this.documentation = value;
5385          return this;
5386        }
5387
5388        /**
5389         * @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.
5390         */
5391        public String getDocumentation() { 
5392          return this.documentation == null ? null : this.documentation.getValue();
5393        }
5394
5395        /**
5396         * @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.
5397         */
5398        public SystemInteractionComponent setDocumentation(String value) { 
5399          if (Utilities.noString(value))
5400            this.documentation = null;
5401          else {
5402            if (this.documentation == null)
5403              this.documentation = new MarkdownType();
5404            this.documentation.setValue(value);
5405          }
5406          return this;
5407        }
5408
5409        protected void listChildren(List<Property> children) {
5410          super.listChildren(children);
5411          children.add(new Property("code", "code", "A coded identifier of the operation, supported by the system.", 0, 1, code));
5412          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));
5413        }
5414
5415        @Override
5416        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
5417          switch (_hash) {
5418          case 3059181: /*code*/  return new Property("code", "code", "A coded identifier of the operation, supported by the system.", 0, 1, code);
5419          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);
5420          default: return super.getNamedProperty(_hash, _name, _checkValid);
5421          }
5422
5423        }
5424
5425      @Override
5426      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
5427        switch (hash) {
5428        case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // Enumeration<SystemRestfulInteraction>
5429        case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType
5430        default: return super.getProperty(hash, name, checkValid);
5431        }
5432
5433      }
5434
5435      @Override
5436      public Base setProperty(int hash, String name, Base value) throws FHIRException {
5437        switch (hash) {
5438        case 3059181: // code
5439          value = new SystemRestfulInteractionEnumFactory().fromType(TypeConvertor.castToCode(value));
5440          this.code = (Enumeration) value; // Enumeration<SystemRestfulInteraction>
5441          return value;
5442        case 1587405498: // documentation
5443          this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType
5444          return value;
5445        default: return super.setProperty(hash, name, value);
5446        }
5447
5448      }
5449
5450      @Override
5451      public Base setProperty(String name, Base value) throws FHIRException {
5452        if (name.equals("code")) {
5453          value = new SystemRestfulInteractionEnumFactory().fromType(TypeConvertor.castToCode(value));
5454          this.code = (Enumeration) value; // Enumeration<SystemRestfulInteraction>
5455        } else if (name.equals("documentation")) {
5456          this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType
5457        } else
5458          return super.setProperty(name, value);
5459        return value;
5460      }
5461
5462      @Override
5463      public Base makeProperty(int hash, String name) throws FHIRException {
5464        switch (hash) {
5465        case 3059181:  return getCodeElement();
5466        case 1587405498:  return getDocumentationElement();
5467        default: return super.makeProperty(hash, name);
5468        }
5469
5470      }
5471
5472      @Override
5473      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
5474        switch (hash) {
5475        case 3059181: /*code*/ return new String[] {"code"};
5476        case 1587405498: /*documentation*/ return new String[] {"markdown"};
5477        default: return super.getTypesForProperty(hash, name);
5478        }
5479
5480      }
5481
5482      @Override
5483      public Base addChild(String name) throws FHIRException {
5484        if (name.equals("code")) {
5485          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.interaction.code");
5486        }
5487        else if (name.equals("documentation")) {
5488          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.rest.interaction.documentation");
5489        }
5490        else
5491          return super.addChild(name);
5492      }
5493
5494      public SystemInteractionComponent copy() {
5495        SystemInteractionComponent dst = new SystemInteractionComponent();
5496        copyValues(dst);
5497        return dst;
5498      }
5499
5500      public void copyValues(SystemInteractionComponent dst) {
5501        super.copyValues(dst);
5502        dst.code = code == null ? null : code.copy();
5503        dst.documentation = documentation == null ? null : documentation.copy();
5504      }
5505
5506      @Override
5507      public boolean equalsDeep(Base other_) {
5508        if (!super.equalsDeep(other_))
5509          return false;
5510        if (!(other_ instanceof SystemInteractionComponent))
5511          return false;
5512        SystemInteractionComponent o = (SystemInteractionComponent) other_;
5513        return compareDeep(code, o.code, true) && compareDeep(documentation, o.documentation, true);
5514      }
5515
5516      @Override
5517      public boolean equalsShallow(Base other_) {
5518        if (!super.equalsShallow(other_))
5519          return false;
5520        if (!(other_ instanceof SystemInteractionComponent))
5521          return false;
5522        SystemInteractionComponent o = (SystemInteractionComponent) other_;
5523        return compareValues(code, o.code, true) && compareValues(documentation, o.documentation, true);
5524      }
5525
5526      public boolean isEmpty() {
5527        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, documentation);
5528      }
5529
5530  public String fhirType() {
5531    return "CapabilityStatement.rest.interaction";
5532
5533  }
5534
5535  }
5536
5537    @Block()
5538    public static class CapabilityStatementMessagingComponent extends BackboneElement implements IBaseBackboneElement {
5539        /**
5540         * An endpoint (network accessible address) to which messages and/or replies are to be sent.
5541         */
5542        @Child(name = "endpoint", type = {}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
5543        @Description(shortDefinition="Where messages should be sent", formalDefinition="An endpoint (network accessible address) to which messages and/or replies are to be sent." )
5544        protected List<CapabilityStatementMessagingEndpointComponent> endpoint;
5545
5546        /**
5547         * Length if the receiver's reliable messaging cache in minutes (if a receiver) or how long the cache length on the receiver should be (if a sender).
5548         */
5549        @Child(name = "reliableCache", type = {UnsignedIntType.class}, order=2, min=0, max=1, modifier=false, summary=false)
5550        @Description(shortDefinition="Reliable Message Cache Length (min)", formalDefinition="Length if the receiver's reliable messaging cache in minutes (if a receiver) or how long the cache length on the receiver should be (if a sender)." )
5551        protected UnsignedIntType reliableCache;
5552
5553        /**
5554         * Documentation about the system's messaging capabilities for this endpoint not otherwise documented by the capability statement.  For example, the process for becoming an authorized messaging exchange partner.
5555         */
5556        @Child(name = "documentation", type = {MarkdownType.class}, order=3, min=0, max=1, modifier=false, summary=false)
5557        @Description(shortDefinition="Messaging interface behavior details", formalDefinition="Documentation about the system's messaging capabilities for this endpoint not otherwise documented by the capability statement.  For example, the process for becoming an authorized messaging exchange partner." )
5558        protected MarkdownType documentation;
5559
5560        /**
5561         * References to message definitions for messages this system can send or receive.
5562         */
5563        @Child(name = "supportedMessage", type = {}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
5564        @Description(shortDefinition="Messages supported by this system", formalDefinition="References to message definitions for messages this system can send or receive." )
5565        protected List<CapabilityStatementMessagingSupportedMessageComponent> supportedMessage;
5566
5567        private static final long serialVersionUID = 300411231L;
5568
5569    /**
5570     * Constructor
5571     */
5572      public CapabilityStatementMessagingComponent() {
5573        super();
5574      }
5575
5576        /**
5577         * @return {@link #endpoint} (An endpoint (network accessible address) to which messages and/or replies are to be sent.)
5578         */
5579        public List<CapabilityStatementMessagingEndpointComponent> getEndpoint() { 
5580          if (this.endpoint == null)
5581            this.endpoint = new ArrayList<CapabilityStatementMessagingEndpointComponent>();
5582          return this.endpoint;
5583        }
5584
5585        /**
5586         * @return Returns a reference to <code>this</code> for easy method chaining
5587         */
5588        public CapabilityStatementMessagingComponent setEndpoint(List<CapabilityStatementMessagingEndpointComponent> theEndpoint) { 
5589          this.endpoint = theEndpoint;
5590          return this;
5591        }
5592
5593        public boolean hasEndpoint() { 
5594          if (this.endpoint == null)
5595            return false;
5596          for (CapabilityStatementMessagingEndpointComponent item : this.endpoint)
5597            if (!item.isEmpty())
5598              return true;
5599          return false;
5600        }
5601
5602        public CapabilityStatementMessagingEndpointComponent addEndpoint() { //3
5603          CapabilityStatementMessagingEndpointComponent t = new CapabilityStatementMessagingEndpointComponent();
5604          if (this.endpoint == null)
5605            this.endpoint = new ArrayList<CapabilityStatementMessagingEndpointComponent>();
5606          this.endpoint.add(t);
5607          return t;
5608        }
5609
5610        public CapabilityStatementMessagingComponent addEndpoint(CapabilityStatementMessagingEndpointComponent t) { //3
5611          if (t == null)
5612            return this;
5613          if (this.endpoint == null)
5614            this.endpoint = new ArrayList<CapabilityStatementMessagingEndpointComponent>();
5615          this.endpoint.add(t);
5616          return this;
5617        }
5618
5619        /**
5620         * @return The first repetition of repeating field {@link #endpoint}, creating it if it does not already exist {3}
5621         */
5622        public CapabilityStatementMessagingEndpointComponent getEndpointFirstRep() { 
5623          if (getEndpoint().isEmpty()) {
5624            addEndpoint();
5625          }
5626          return getEndpoint().get(0);
5627        }
5628
5629        /**
5630         * @return {@link #reliableCache} (Length if the receiver's reliable messaging cache in minutes (if a receiver) or how long the cache length on the receiver should be (if a sender).). This is the underlying object with id, value and extensions. The accessor "getReliableCache" gives direct access to the value
5631         */
5632        public UnsignedIntType getReliableCacheElement() { 
5633          if (this.reliableCache == null)
5634            if (Configuration.errorOnAutoCreate())
5635              throw new Error("Attempt to auto-create CapabilityStatementMessagingComponent.reliableCache");
5636            else if (Configuration.doAutoCreate())
5637              this.reliableCache = new UnsignedIntType(); // bb
5638          return this.reliableCache;
5639        }
5640
5641        public boolean hasReliableCacheElement() { 
5642          return this.reliableCache != null && !this.reliableCache.isEmpty();
5643        }
5644
5645        public boolean hasReliableCache() { 
5646          return this.reliableCache != null && !this.reliableCache.isEmpty();
5647        }
5648
5649        /**
5650         * @param value {@link #reliableCache} (Length if the receiver's reliable messaging cache in minutes (if a receiver) or how long the cache length on the receiver should be (if a sender).). This is the underlying object with id, value and extensions. The accessor "getReliableCache" gives direct access to the value
5651         */
5652        public CapabilityStatementMessagingComponent setReliableCacheElement(UnsignedIntType value) { 
5653          this.reliableCache = value;
5654          return this;
5655        }
5656
5657        /**
5658         * @return Length if the receiver's reliable messaging cache in minutes (if a receiver) or how long the cache length on the receiver should be (if a sender).
5659         */
5660        public int getReliableCache() { 
5661          return this.reliableCache == null || this.reliableCache.isEmpty() ? 0 : this.reliableCache.getValue();
5662        }
5663
5664        /**
5665         * @param value Length if the receiver's reliable messaging cache in minutes (if a receiver) or how long the cache length on the receiver should be (if a sender).
5666         */
5667        public CapabilityStatementMessagingComponent setReliableCache(int value) { 
5668            if (this.reliableCache == null)
5669              this.reliableCache = new UnsignedIntType();
5670            this.reliableCache.setValue(value);
5671          return this;
5672        }
5673
5674        /**
5675         * @return {@link #documentation} (Documentation about the system's messaging capabilities for this endpoint not otherwise documented by the capability statement.  For example, the process for becoming an authorized messaging exchange partner.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value
5676         */
5677        public MarkdownType getDocumentationElement() { 
5678          if (this.documentation == null)
5679            if (Configuration.errorOnAutoCreate())
5680              throw new Error("Attempt to auto-create CapabilityStatementMessagingComponent.documentation");
5681            else if (Configuration.doAutoCreate())
5682              this.documentation = new MarkdownType(); // bb
5683          return this.documentation;
5684        }
5685
5686        public boolean hasDocumentationElement() { 
5687          return this.documentation != null && !this.documentation.isEmpty();
5688        }
5689
5690        public boolean hasDocumentation() { 
5691          return this.documentation != null && !this.documentation.isEmpty();
5692        }
5693
5694        /**
5695         * @param value {@link #documentation} (Documentation about the system's messaging capabilities for this endpoint not otherwise documented by the capability statement.  For example, the process for becoming an authorized messaging exchange partner.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value
5696         */
5697        public CapabilityStatementMessagingComponent setDocumentationElement(MarkdownType value) { 
5698          this.documentation = value;
5699          return this;
5700        }
5701
5702        /**
5703         * @return Documentation about the system's messaging capabilities for this endpoint not otherwise documented by the capability statement.  For example, the process for becoming an authorized messaging exchange partner.
5704         */
5705        public String getDocumentation() { 
5706          return this.documentation == null ? null : this.documentation.getValue();
5707        }
5708
5709        /**
5710         * @param value Documentation about the system's messaging capabilities for this endpoint not otherwise documented by the capability statement.  For example, the process for becoming an authorized messaging exchange partner.
5711         */
5712        public CapabilityStatementMessagingComponent setDocumentation(String value) { 
5713          if (Utilities.noString(value))
5714            this.documentation = null;
5715          else {
5716            if (this.documentation == null)
5717              this.documentation = new MarkdownType();
5718            this.documentation.setValue(value);
5719          }
5720          return this;
5721        }
5722
5723        /**
5724         * @return {@link #supportedMessage} (References to message definitions for messages this system can send or receive.)
5725         */
5726        public List<CapabilityStatementMessagingSupportedMessageComponent> getSupportedMessage() { 
5727          if (this.supportedMessage == null)
5728            this.supportedMessage = new ArrayList<CapabilityStatementMessagingSupportedMessageComponent>();
5729          return this.supportedMessage;
5730        }
5731
5732        /**
5733         * @return Returns a reference to <code>this</code> for easy method chaining
5734         */
5735        public CapabilityStatementMessagingComponent setSupportedMessage(List<CapabilityStatementMessagingSupportedMessageComponent> theSupportedMessage) { 
5736          this.supportedMessage = theSupportedMessage;
5737          return this;
5738        }
5739
5740        public boolean hasSupportedMessage() { 
5741          if (this.supportedMessage == null)
5742            return false;
5743          for (CapabilityStatementMessagingSupportedMessageComponent item : this.supportedMessage)
5744            if (!item.isEmpty())
5745              return true;
5746          return false;
5747        }
5748
5749        public CapabilityStatementMessagingSupportedMessageComponent addSupportedMessage() { //3
5750          CapabilityStatementMessagingSupportedMessageComponent t = new CapabilityStatementMessagingSupportedMessageComponent();
5751          if (this.supportedMessage == null)
5752            this.supportedMessage = new ArrayList<CapabilityStatementMessagingSupportedMessageComponent>();
5753          this.supportedMessage.add(t);
5754          return t;
5755        }
5756
5757        public CapabilityStatementMessagingComponent addSupportedMessage(CapabilityStatementMessagingSupportedMessageComponent t) { //3
5758          if (t == null)
5759            return this;
5760          if (this.supportedMessage == null)
5761            this.supportedMessage = new ArrayList<CapabilityStatementMessagingSupportedMessageComponent>();
5762          this.supportedMessage.add(t);
5763          return this;
5764        }
5765
5766        /**
5767         * @return The first repetition of repeating field {@link #supportedMessage}, creating it if it does not already exist {3}
5768         */
5769        public CapabilityStatementMessagingSupportedMessageComponent getSupportedMessageFirstRep() { 
5770          if (getSupportedMessage().isEmpty()) {
5771            addSupportedMessage();
5772          }
5773          return getSupportedMessage().get(0);
5774        }
5775
5776        protected void listChildren(List<Property> children) {
5777          super.listChildren(children);
5778          children.add(new Property("endpoint", "", "An endpoint (network accessible address) to which messages and/or replies are to be sent.", 0, java.lang.Integer.MAX_VALUE, endpoint));
5779          children.add(new Property("reliableCache", "unsignedInt", "Length if the receiver's reliable messaging cache in minutes (if a receiver) or how long the cache length on the receiver should be (if a sender).", 0, 1, reliableCache));
5780          children.add(new Property("documentation", "markdown", "Documentation about the system's messaging capabilities for this endpoint not otherwise documented by the capability statement.  For example, the process for becoming an authorized messaging exchange partner.", 0, 1, documentation));
5781          children.add(new Property("supportedMessage", "", "References to message definitions for messages this system can send or receive.", 0, java.lang.Integer.MAX_VALUE, supportedMessage));
5782        }
5783
5784        @Override
5785        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
5786          switch (_hash) {
5787          case 1741102485: /*endpoint*/  return new Property("endpoint", "", "An endpoint (network accessible address) to which messages and/or replies are to be sent.", 0, java.lang.Integer.MAX_VALUE, endpoint);
5788          case 897803608: /*reliableCache*/  return new Property("reliableCache", "unsignedInt", "Length if the receiver's reliable messaging cache in minutes (if a receiver) or how long the cache length on the receiver should be (if a sender).", 0, 1, reliableCache);
5789          case 1587405498: /*documentation*/  return new Property("documentation", "markdown", "Documentation about the system's messaging capabilities for this endpoint not otherwise documented by the capability statement.  For example, the process for becoming an authorized messaging exchange partner.", 0, 1, documentation);
5790          case -1805139079: /*supportedMessage*/  return new Property("supportedMessage", "", "References to message definitions for messages this system can send or receive.", 0, java.lang.Integer.MAX_VALUE, supportedMessage);
5791          default: return super.getNamedProperty(_hash, _name, _checkValid);
5792          }
5793
5794        }
5795
5796      @Override
5797      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
5798        switch (hash) {
5799        case 1741102485: /*endpoint*/ return this.endpoint == null ? new Base[0] : this.endpoint.toArray(new Base[this.endpoint.size()]); // CapabilityStatementMessagingEndpointComponent
5800        case 897803608: /*reliableCache*/ return this.reliableCache == null ? new Base[0] : new Base[] {this.reliableCache}; // UnsignedIntType
5801        case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType
5802        case -1805139079: /*supportedMessage*/ return this.supportedMessage == null ? new Base[0] : this.supportedMessage.toArray(new Base[this.supportedMessage.size()]); // CapabilityStatementMessagingSupportedMessageComponent
5803        default: return super.getProperty(hash, name, checkValid);
5804        }
5805
5806      }
5807
5808      @Override
5809      public Base setProperty(int hash, String name, Base value) throws FHIRException {
5810        switch (hash) {
5811        case 1741102485: // endpoint
5812          this.getEndpoint().add((CapabilityStatementMessagingEndpointComponent) value); // CapabilityStatementMessagingEndpointComponent
5813          return value;
5814        case 897803608: // reliableCache
5815          this.reliableCache = TypeConvertor.castToUnsignedInt(value); // UnsignedIntType
5816          return value;
5817        case 1587405498: // documentation
5818          this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType
5819          return value;
5820        case -1805139079: // supportedMessage
5821          this.getSupportedMessage().add((CapabilityStatementMessagingSupportedMessageComponent) value); // CapabilityStatementMessagingSupportedMessageComponent
5822          return value;
5823        default: return super.setProperty(hash, name, value);
5824        }
5825
5826      }
5827
5828      @Override
5829      public Base setProperty(String name, Base value) throws FHIRException {
5830        if (name.equals("endpoint")) {
5831          this.getEndpoint().add((CapabilityStatementMessagingEndpointComponent) value);
5832        } else if (name.equals("reliableCache")) {
5833          this.reliableCache = TypeConvertor.castToUnsignedInt(value); // UnsignedIntType
5834        } else if (name.equals("documentation")) {
5835          this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType
5836        } else if (name.equals("supportedMessage")) {
5837          this.getSupportedMessage().add((CapabilityStatementMessagingSupportedMessageComponent) value);
5838        } else
5839          return super.setProperty(name, value);
5840        return value;
5841      }
5842
5843      @Override
5844      public Base makeProperty(int hash, String name) throws FHIRException {
5845        switch (hash) {
5846        case 1741102485:  return addEndpoint(); 
5847        case 897803608:  return getReliableCacheElement();
5848        case 1587405498:  return getDocumentationElement();
5849        case -1805139079:  return addSupportedMessage(); 
5850        default: return super.makeProperty(hash, name);
5851        }
5852
5853      }
5854
5855      @Override
5856      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
5857        switch (hash) {
5858        case 1741102485: /*endpoint*/ return new String[] {};
5859        case 897803608: /*reliableCache*/ return new String[] {"unsignedInt"};
5860        case 1587405498: /*documentation*/ return new String[] {"markdown"};
5861        case -1805139079: /*supportedMessage*/ return new String[] {};
5862        default: return super.getTypesForProperty(hash, name);
5863        }
5864
5865      }
5866
5867      @Override
5868      public Base addChild(String name) throws FHIRException {
5869        if (name.equals("endpoint")) {
5870          return addEndpoint();
5871        }
5872        else if (name.equals("reliableCache")) {
5873          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.messaging.reliableCache");
5874        }
5875        else if (name.equals("documentation")) {
5876          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.messaging.documentation");
5877        }
5878        else if (name.equals("supportedMessage")) {
5879          return addSupportedMessage();
5880        }
5881        else
5882          return super.addChild(name);
5883      }
5884
5885      public CapabilityStatementMessagingComponent copy() {
5886        CapabilityStatementMessagingComponent dst = new CapabilityStatementMessagingComponent();
5887        copyValues(dst);
5888        return dst;
5889      }
5890
5891      public void copyValues(CapabilityStatementMessagingComponent dst) {
5892        super.copyValues(dst);
5893        if (endpoint != null) {
5894          dst.endpoint = new ArrayList<CapabilityStatementMessagingEndpointComponent>();
5895          for (CapabilityStatementMessagingEndpointComponent i : endpoint)
5896            dst.endpoint.add(i.copy());
5897        };
5898        dst.reliableCache = reliableCache == null ? null : reliableCache.copy();
5899        dst.documentation = documentation == null ? null : documentation.copy();
5900        if (supportedMessage != null) {
5901          dst.supportedMessage = new ArrayList<CapabilityStatementMessagingSupportedMessageComponent>();
5902          for (CapabilityStatementMessagingSupportedMessageComponent i : supportedMessage)
5903            dst.supportedMessage.add(i.copy());
5904        };
5905      }
5906
5907      @Override
5908      public boolean equalsDeep(Base other_) {
5909        if (!super.equalsDeep(other_))
5910          return false;
5911        if (!(other_ instanceof CapabilityStatementMessagingComponent))
5912          return false;
5913        CapabilityStatementMessagingComponent o = (CapabilityStatementMessagingComponent) other_;
5914        return compareDeep(endpoint, o.endpoint, true) && compareDeep(reliableCache, o.reliableCache, true)
5915           && compareDeep(documentation, o.documentation, true) && compareDeep(supportedMessage, o.supportedMessage, true)
5916          ;
5917      }
5918
5919      @Override
5920      public boolean equalsShallow(Base other_) {
5921        if (!super.equalsShallow(other_))
5922          return false;
5923        if (!(other_ instanceof CapabilityStatementMessagingComponent))
5924          return false;
5925        CapabilityStatementMessagingComponent o = (CapabilityStatementMessagingComponent) other_;
5926        return compareValues(reliableCache, o.reliableCache, true) && compareValues(documentation, o.documentation, true)
5927          ;
5928      }
5929
5930      public boolean isEmpty() {
5931        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(endpoint, reliableCache, documentation
5932          , supportedMessage);
5933      }
5934
5935  public String fhirType() {
5936    return "CapabilityStatement.messaging";
5937
5938  }
5939
5940  }
5941
5942    @Block()
5943    public static class CapabilityStatementMessagingEndpointComponent extends BackboneElement implements IBaseBackboneElement {
5944        /**
5945         * A list of the messaging transport protocol(s) identifiers, supported by this endpoint.
5946         */
5947        @Child(name = "protocol", type = {Coding.class}, order=1, min=1, max=1, modifier=false, summary=false)
5948        @Description(shortDefinition="http | ftp | mllp +", formalDefinition="A list of the messaging transport protocol(s) identifiers, supported by this endpoint." )
5949        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/message-transport")
5950        protected Coding protocol;
5951
5952        /**
5953         * The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier.
5954         */
5955        @Child(name = "address", type = {UrlType.class}, order=2, min=1, max=1, modifier=false, summary=false)
5956        @Description(shortDefinition="Network address or identifier of the end-point", formalDefinition="The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier." )
5957        protected UrlType address;
5958
5959        private static final long serialVersionUID = -236946103L;
5960
5961    /**
5962     * Constructor
5963     */
5964      public CapabilityStatementMessagingEndpointComponent() {
5965        super();
5966      }
5967
5968    /**
5969     * Constructor
5970     */
5971      public CapabilityStatementMessagingEndpointComponent(Coding protocol, String address) {
5972        super();
5973        this.setProtocol(protocol);
5974        this.setAddress(address);
5975      }
5976
5977        /**
5978         * @return {@link #protocol} (A list of the messaging transport protocol(s) identifiers, supported by this endpoint.)
5979         */
5980        public Coding getProtocol() { 
5981          if (this.protocol == null)
5982            if (Configuration.errorOnAutoCreate())
5983              throw new Error("Attempt to auto-create CapabilityStatementMessagingEndpointComponent.protocol");
5984            else if (Configuration.doAutoCreate())
5985              this.protocol = new Coding(); // cc
5986          return this.protocol;
5987        }
5988
5989        public boolean hasProtocol() { 
5990          return this.protocol != null && !this.protocol.isEmpty();
5991        }
5992
5993        /**
5994         * @param value {@link #protocol} (A list of the messaging transport protocol(s) identifiers, supported by this endpoint.)
5995         */
5996        public CapabilityStatementMessagingEndpointComponent setProtocol(Coding value) { 
5997          this.protocol = value;
5998          return this;
5999        }
6000
6001        /**
6002         * @return {@link #address} (The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier.). This is the underlying object with id, value and extensions. The accessor "getAddress" gives direct access to the value
6003         */
6004        public UrlType getAddressElement() { 
6005          if (this.address == null)
6006            if (Configuration.errorOnAutoCreate())
6007              throw new Error("Attempt to auto-create CapabilityStatementMessagingEndpointComponent.address");
6008            else if (Configuration.doAutoCreate())
6009              this.address = new UrlType(); // bb
6010          return this.address;
6011        }
6012
6013        public boolean hasAddressElement() { 
6014          return this.address != null && !this.address.isEmpty();
6015        }
6016
6017        public boolean hasAddress() { 
6018          return this.address != null && !this.address.isEmpty();
6019        }
6020
6021        /**
6022         * @param value {@link #address} (The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier.). This is the underlying object with id, value and extensions. The accessor "getAddress" gives direct access to the value
6023         */
6024        public CapabilityStatementMessagingEndpointComponent setAddressElement(UrlType value) { 
6025          this.address = value;
6026          return this;
6027        }
6028
6029        /**
6030         * @return The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier.
6031         */
6032        public String getAddress() { 
6033          return this.address == null ? null : this.address.getValue();
6034        }
6035
6036        /**
6037         * @param value The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier.
6038         */
6039        public CapabilityStatementMessagingEndpointComponent setAddress(String value) { 
6040            if (this.address == null)
6041              this.address = new UrlType();
6042            this.address.setValue(value);
6043          return this;
6044        }
6045
6046        protected void listChildren(List<Property> children) {
6047          super.listChildren(children);
6048          children.add(new Property("protocol", "Coding", "A list of the messaging transport protocol(s) identifiers, supported by this endpoint.", 0, 1, protocol));
6049          children.add(new Property("address", "url", "The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier.", 0, 1, address));
6050        }
6051
6052        @Override
6053        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
6054          switch (_hash) {
6055          case -989163880: /*protocol*/  return new Property("protocol", "Coding", "A list of the messaging transport protocol(s) identifiers, supported by this endpoint.", 0, 1, protocol);
6056          case -1147692044: /*address*/  return new Property("address", "url", "The network address of the endpoint. For solutions that do not use network addresses for routing, it can be just an identifier.", 0, 1, address);
6057          default: return super.getNamedProperty(_hash, _name, _checkValid);
6058          }
6059
6060        }
6061
6062      @Override
6063      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
6064        switch (hash) {
6065        case -989163880: /*protocol*/ return this.protocol == null ? new Base[0] : new Base[] {this.protocol}; // Coding
6066        case -1147692044: /*address*/ return this.address == null ? new Base[0] : new Base[] {this.address}; // UrlType
6067        default: return super.getProperty(hash, name, checkValid);
6068        }
6069
6070      }
6071
6072      @Override
6073      public Base setProperty(int hash, String name, Base value) throws FHIRException {
6074        switch (hash) {
6075        case -989163880: // protocol
6076          this.protocol = TypeConvertor.castToCoding(value); // Coding
6077          return value;
6078        case -1147692044: // address
6079          this.address = TypeConvertor.castToUrl(value); // UrlType
6080          return value;
6081        default: return super.setProperty(hash, name, value);
6082        }
6083
6084      }
6085
6086      @Override
6087      public Base setProperty(String name, Base value) throws FHIRException {
6088        if (name.equals("protocol")) {
6089          this.protocol = TypeConvertor.castToCoding(value); // Coding
6090        } else if (name.equals("address")) {
6091          this.address = TypeConvertor.castToUrl(value); // UrlType
6092        } else
6093          return super.setProperty(name, value);
6094        return value;
6095      }
6096
6097      @Override
6098      public Base makeProperty(int hash, String name) throws FHIRException {
6099        switch (hash) {
6100        case -989163880:  return getProtocol();
6101        case -1147692044:  return getAddressElement();
6102        default: return super.makeProperty(hash, name);
6103        }
6104
6105      }
6106
6107      @Override
6108      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
6109        switch (hash) {
6110        case -989163880: /*protocol*/ return new String[] {"Coding"};
6111        case -1147692044: /*address*/ return new String[] {"url"};
6112        default: return super.getTypesForProperty(hash, name);
6113        }
6114
6115      }
6116
6117      @Override
6118      public Base addChild(String name) throws FHIRException {
6119        if (name.equals("protocol")) {
6120          this.protocol = new Coding();
6121          return this.protocol;
6122        }
6123        else if (name.equals("address")) {
6124          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.messaging.endpoint.address");
6125        }
6126        else
6127          return super.addChild(name);
6128      }
6129
6130      public CapabilityStatementMessagingEndpointComponent copy() {
6131        CapabilityStatementMessagingEndpointComponent dst = new CapabilityStatementMessagingEndpointComponent();
6132        copyValues(dst);
6133        return dst;
6134      }
6135
6136      public void copyValues(CapabilityStatementMessagingEndpointComponent dst) {
6137        super.copyValues(dst);
6138        dst.protocol = protocol == null ? null : protocol.copy();
6139        dst.address = address == null ? null : address.copy();
6140      }
6141
6142      @Override
6143      public boolean equalsDeep(Base other_) {
6144        if (!super.equalsDeep(other_))
6145          return false;
6146        if (!(other_ instanceof CapabilityStatementMessagingEndpointComponent))
6147          return false;
6148        CapabilityStatementMessagingEndpointComponent o = (CapabilityStatementMessagingEndpointComponent) other_;
6149        return compareDeep(protocol, o.protocol, true) && compareDeep(address, o.address, true);
6150      }
6151
6152      @Override
6153      public boolean equalsShallow(Base other_) {
6154        if (!super.equalsShallow(other_))
6155          return false;
6156        if (!(other_ instanceof CapabilityStatementMessagingEndpointComponent))
6157          return false;
6158        CapabilityStatementMessagingEndpointComponent o = (CapabilityStatementMessagingEndpointComponent) other_;
6159        return compareValues(address, o.address, true);
6160      }
6161
6162      public boolean isEmpty() {
6163        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(protocol, address);
6164      }
6165
6166  public String fhirType() {
6167    return "CapabilityStatement.messaging.endpoint";
6168
6169  }
6170
6171  }
6172
6173    @Block()
6174    public static class CapabilityStatementMessagingSupportedMessageComponent extends BackboneElement implements IBaseBackboneElement {
6175        /**
6176         * The mode of this event declaration - whether application is sender or receiver.
6177         */
6178        @Child(name = "mode", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true)
6179        @Description(shortDefinition="sender | receiver", formalDefinition="The mode of this event declaration - whether application is sender or receiver." )
6180        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/event-capability-mode")
6181        protected Enumeration<EventCapabilityMode> mode;
6182
6183        /**
6184         * Points to a message definition that identifies the messaging event, message structure, allowed responses, etc.
6185         */
6186        @Child(name = "definition", type = {CanonicalType.class}, order=2, min=1, max=1, modifier=false, summary=true)
6187        @Description(shortDefinition="Message supported by this system", formalDefinition="Points to a message definition that identifies the messaging event, message structure, allowed responses, etc." )
6188        protected CanonicalType definition;
6189
6190        private static final long serialVersionUID = -1172840676L;
6191
6192    /**
6193     * Constructor
6194     */
6195      public CapabilityStatementMessagingSupportedMessageComponent() {
6196        super();
6197      }
6198
6199    /**
6200     * Constructor
6201     */
6202      public CapabilityStatementMessagingSupportedMessageComponent(EventCapabilityMode mode, String definition) {
6203        super();
6204        this.setMode(mode);
6205        this.setDefinition(definition);
6206      }
6207
6208        /**
6209         * @return {@link #mode} (The mode of this event declaration - whether application is sender or receiver.). This is the underlying object with id, value and extensions. The accessor "getMode" gives direct access to the value
6210         */
6211        public Enumeration<EventCapabilityMode> getModeElement() { 
6212          if (this.mode == null)
6213            if (Configuration.errorOnAutoCreate())
6214              throw new Error("Attempt to auto-create CapabilityStatementMessagingSupportedMessageComponent.mode");
6215            else if (Configuration.doAutoCreate())
6216              this.mode = new Enumeration<EventCapabilityMode>(new EventCapabilityModeEnumFactory()); // bb
6217          return this.mode;
6218        }
6219
6220        public boolean hasModeElement() { 
6221          return this.mode != null && !this.mode.isEmpty();
6222        }
6223
6224        public boolean hasMode() { 
6225          return this.mode != null && !this.mode.isEmpty();
6226        }
6227
6228        /**
6229         * @param value {@link #mode} (The mode of this event declaration - whether application is sender or receiver.). This is the underlying object with id, value and extensions. The accessor "getMode" gives direct access to the value
6230         */
6231        public CapabilityStatementMessagingSupportedMessageComponent setModeElement(Enumeration<EventCapabilityMode> value) { 
6232          this.mode = value;
6233          return this;
6234        }
6235
6236        /**
6237         * @return The mode of this event declaration - whether application is sender or receiver.
6238         */
6239        public EventCapabilityMode getMode() { 
6240          return this.mode == null ? null : this.mode.getValue();
6241        }
6242
6243        /**
6244         * @param value The mode of this event declaration - whether application is sender or receiver.
6245         */
6246        public CapabilityStatementMessagingSupportedMessageComponent setMode(EventCapabilityMode value) { 
6247            if (this.mode == null)
6248              this.mode = new Enumeration<EventCapabilityMode>(new EventCapabilityModeEnumFactory());
6249            this.mode.setValue(value);
6250          return this;
6251        }
6252
6253        /**
6254         * @return {@link #definition} (Points to a message definition that identifies the messaging event, message structure, allowed responses, etc.). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value
6255         */
6256        public CanonicalType getDefinitionElement() { 
6257          if (this.definition == null)
6258            if (Configuration.errorOnAutoCreate())
6259              throw new Error("Attempt to auto-create CapabilityStatementMessagingSupportedMessageComponent.definition");
6260            else if (Configuration.doAutoCreate())
6261              this.definition = new CanonicalType(); // bb
6262          return this.definition;
6263        }
6264
6265        public boolean hasDefinitionElement() { 
6266          return this.definition != null && !this.definition.isEmpty();
6267        }
6268
6269        public boolean hasDefinition() { 
6270          return this.definition != null && !this.definition.isEmpty();
6271        }
6272
6273        /**
6274         * @param value {@link #definition} (Points to a message definition that identifies the messaging event, message structure, allowed responses, etc.). This is the underlying object with id, value and extensions. The accessor "getDefinition" gives direct access to the value
6275         */
6276        public CapabilityStatementMessagingSupportedMessageComponent setDefinitionElement(CanonicalType value) { 
6277          this.definition = value;
6278          return this;
6279        }
6280
6281        /**
6282         * @return Points to a message definition that identifies the messaging event, message structure, allowed responses, etc.
6283         */
6284        public String getDefinition() { 
6285          return this.definition == null ? null : this.definition.getValue();
6286        }
6287
6288        /**
6289         * @param value Points to a message definition that identifies the messaging event, message structure, allowed responses, etc.
6290         */
6291        public CapabilityStatementMessagingSupportedMessageComponent setDefinition(String value) { 
6292            if (this.definition == null)
6293              this.definition = new CanonicalType();
6294            this.definition.setValue(value);
6295          return this;
6296        }
6297
6298        protected void listChildren(List<Property> children) {
6299          super.listChildren(children);
6300          children.add(new Property("mode", "code", "The mode of this event declaration - whether application is sender or receiver.", 0, 1, mode));
6301          children.add(new Property("definition", "canonical(MessageDefinition)", "Points to a message definition that identifies the messaging event, message structure, allowed responses, etc.", 0, 1, definition));
6302        }
6303
6304        @Override
6305        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
6306          switch (_hash) {
6307          case 3357091: /*mode*/  return new Property("mode", "code", "The mode of this event declaration - whether application is sender or receiver.", 0, 1, mode);
6308          case -1014418093: /*definition*/  return new Property("definition", "canonical(MessageDefinition)", "Points to a message definition that identifies the messaging event, message structure, allowed responses, etc.", 0, 1, definition);
6309          default: return super.getNamedProperty(_hash, _name, _checkValid);
6310          }
6311
6312        }
6313
6314      @Override
6315      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
6316        switch (hash) {
6317        case 3357091: /*mode*/ return this.mode == null ? new Base[0] : new Base[] {this.mode}; // Enumeration<EventCapabilityMode>
6318        case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : new Base[] {this.definition}; // CanonicalType
6319        default: return super.getProperty(hash, name, checkValid);
6320        }
6321
6322      }
6323
6324      @Override
6325      public Base setProperty(int hash, String name, Base value) throws FHIRException {
6326        switch (hash) {
6327        case 3357091: // mode
6328          value = new EventCapabilityModeEnumFactory().fromType(TypeConvertor.castToCode(value));
6329          this.mode = (Enumeration) value; // Enumeration<EventCapabilityMode>
6330          return value;
6331        case -1014418093: // definition
6332          this.definition = TypeConvertor.castToCanonical(value); // CanonicalType
6333          return value;
6334        default: return super.setProperty(hash, name, value);
6335        }
6336
6337      }
6338
6339      @Override
6340      public Base setProperty(String name, Base value) throws FHIRException {
6341        if (name.equals("mode")) {
6342          value = new EventCapabilityModeEnumFactory().fromType(TypeConvertor.castToCode(value));
6343          this.mode = (Enumeration) value; // Enumeration<EventCapabilityMode>
6344        } else if (name.equals("definition")) {
6345          this.definition = TypeConvertor.castToCanonical(value); // CanonicalType
6346        } else
6347          return super.setProperty(name, value);
6348        return value;
6349      }
6350
6351      @Override
6352      public Base makeProperty(int hash, String name) throws FHIRException {
6353        switch (hash) {
6354        case 3357091:  return getModeElement();
6355        case -1014418093:  return getDefinitionElement();
6356        default: return super.makeProperty(hash, name);
6357        }
6358
6359      }
6360
6361      @Override
6362      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
6363        switch (hash) {
6364        case 3357091: /*mode*/ return new String[] {"code"};
6365        case -1014418093: /*definition*/ return new String[] {"canonical"};
6366        default: return super.getTypesForProperty(hash, name);
6367        }
6368
6369      }
6370
6371      @Override
6372      public Base addChild(String name) throws FHIRException {
6373        if (name.equals("mode")) {
6374          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.messaging.supportedMessage.mode");
6375        }
6376        else if (name.equals("definition")) {
6377          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.messaging.supportedMessage.definition");
6378        }
6379        else
6380          return super.addChild(name);
6381      }
6382
6383      public CapabilityStatementMessagingSupportedMessageComponent copy() {
6384        CapabilityStatementMessagingSupportedMessageComponent dst = new CapabilityStatementMessagingSupportedMessageComponent();
6385        copyValues(dst);
6386        return dst;
6387      }
6388
6389      public void copyValues(CapabilityStatementMessagingSupportedMessageComponent dst) {
6390        super.copyValues(dst);
6391        dst.mode = mode == null ? null : mode.copy();
6392        dst.definition = definition == null ? null : definition.copy();
6393      }
6394
6395      @Override
6396      public boolean equalsDeep(Base other_) {
6397        if (!super.equalsDeep(other_))
6398          return false;
6399        if (!(other_ instanceof CapabilityStatementMessagingSupportedMessageComponent))
6400          return false;
6401        CapabilityStatementMessagingSupportedMessageComponent o = (CapabilityStatementMessagingSupportedMessageComponent) other_;
6402        return compareDeep(mode, o.mode, true) && compareDeep(definition, o.definition, true);
6403      }
6404
6405      @Override
6406      public boolean equalsShallow(Base other_) {
6407        if (!super.equalsShallow(other_))
6408          return false;
6409        if (!(other_ instanceof CapabilityStatementMessagingSupportedMessageComponent))
6410          return false;
6411        CapabilityStatementMessagingSupportedMessageComponent o = (CapabilityStatementMessagingSupportedMessageComponent) other_;
6412        return compareValues(mode, o.mode, true) && compareValues(definition, o.definition, true);
6413      }
6414
6415      public boolean isEmpty() {
6416        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(mode, definition);
6417      }
6418
6419  public String fhirType() {
6420    return "CapabilityStatement.messaging.supportedMessage";
6421
6422  }
6423
6424  }
6425
6426    @Block()
6427    public static class CapabilityStatementDocumentComponent extends BackboneElement implements IBaseBackboneElement {
6428        /**
6429         * Mode of this document declaration - whether an application is a producer or consumer.
6430         */
6431        @Child(name = "mode", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true)
6432        @Description(shortDefinition="producer | consumer", formalDefinition="Mode of this document declaration - whether an application is a producer or consumer." )
6433        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/document-mode")
6434        protected Enumeration<DocumentMode> mode;
6435
6436        /**
6437         * A description of how the application supports or uses the specified document profile.  For example, when documents are created, what action is taken with consumed documents, etc.
6438         */
6439        @Child(name = "documentation", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=false)
6440        @Description(shortDefinition="Description of document support", formalDefinition="A description of how the application supports or uses the specified document profile.  For example, when documents are created, what action is taken with consumed documents, etc." )
6441        protected MarkdownType documentation;
6442
6443        /**
6444         * A profile on the document Bundle that constrains which resources are present, and their contents.
6445         */
6446        @Child(name = "profile", type = {CanonicalType.class}, order=3, min=1, max=1, modifier=false, summary=true)
6447        @Description(shortDefinition="Constraint on the resources used in the document", formalDefinition="A profile on the document Bundle that constrains which resources are present, and their contents." )
6448        protected CanonicalType profile;
6449
6450        private static final long serialVersionUID = 18026632L;
6451
6452    /**
6453     * Constructor
6454     */
6455      public CapabilityStatementDocumentComponent() {
6456        super();
6457      }
6458
6459    /**
6460     * Constructor
6461     */
6462      public CapabilityStatementDocumentComponent(DocumentMode mode, String profile) {
6463        super();
6464        this.setMode(mode);
6465        this.setProfile(profile);
6466      }
6467
6468        /**
6469         * @return {@link #mode} (Mode of this document declaration - whether an application is a producer or consumer.). This is the underlying object with id, value and extensions. The accessor "getMode" gives direct access to the value
6470         */
6471        public Enumeration<DocumentMode> getModeElement() { 
6472          if (this.mode == null)
6473            if (Configuration.errorOnAutoCreate())
6474              throw new Error("Attempt to auto-create CapabilityStatementDocumentComponent.mode");
6475            else if (Configuration.doAutoCreate())
6476              this.mode = new Enumeration<DocumentMode>(new DocumentModeEnumFactory()); // bb
6477          return this.mode;
6478        }
6479
6480        public boolean hasModeElement() { 
6481          return this.mode != null && !this.mode.isEmpty();
6482        }
6483
6484        public boolean hasMode() { 
6485          return this.mode != null && !this.mode.isEmpty();
6486        }
6487
6488        /**
6489         * @param value {@link #mode} (Mode of this document declaration - whether an application is a producer or consumer.). This is the underlying object with id, value and extensions. The accessor "getMode" gives direct access to the value
6490         */
6491        public CapabilityStatementDocumentComponent setModeElement(Enumeration<DocumentMode> value) { 
6492          this.mode = value;
6493          return this;
6494        }
6495
6496        /**
6497         * @return Mode of this document declaration - whether an application is a producer or consumer.
6498         */
6499        public DocumentMode getMode() { 
6500          return this.mode == null ? null : this.mode.getValue();
6501        }
6502
6503        /**
6504         * @param value Mode of this document declaration - whether an application is a producer or consumer.
6505         */
6506        public CapabilityStatementDocumentComponent setMode(DocumentMode value) { 
6507            if (this.mode == null)
6508              this.mode = new Enumeration<DocumentMode>(new DocumentModeEnumFactory());
6509            this.mode.setValue(value);
6510          return this;
6511        }
6512
6513        /**
6514         * @return {@link #documentation} (A description of how the application supports or uses the specified document profile.  For example, when documents are created, what action is taken with consumed documents, etc.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value
6515         */
6516        public MarkdownType getDocumentationElement() { 
6517          if (this.documentation == null)
6518            if (Configuration.errorOnAutoCreate())
6519              throw new Error("Attempt to auto-create CapabilityStatementDocumentComponent.documentation");
6520            else if (Configuration.doAutoCreate())
6521              this.documentation = new MarkdownType(); // bb
6522          return this.documentation;
6523        }
6524
6525        public boolean hasDocumentationElement() { 
6526          return this.documentation != null && !this.documentation.isEmpty();
6527        }
6528
6529        public boolean hasDocumentation() { 
6530          return this.documentation != null && !this.documentation.isEmpty();
6531        }
6532
6533        /**
6534         * @param value {@link #documentation} (A description of how the application supports or uses the specified document profile.  For example, when documents are created, what action is taken with consumed documents, etc.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value
6535         */
6536        public CapabilityStatementDocumentComponent setDocumentationElement(MarkdownType value) { 
6537          this.documentation = value;
6538          return this;
6539        }
6540
6541        /**
6542         * @return A description of how the application supports or uses the specified document profile.  For example, when documents are created, what action is taken with consumed documents, etc.
6543         */
6544        public String getDocumentation() { 
6545          return this.documentation == null ? null : this.documentation.getValue();
6546        }
6547
6548        /**
6549         * @param value A description of how the application supports or uses the specified document profile.  For example, when documents are created, what action is taken with consumed documents, etc.
6550         */
6551        public CapabilityStatementDocumentComponent setDocumentation(String value) { 
6552          if (Utilities.noString(value))
6553            this.documentation = null;
6554          else {
6555            if (this.documentation == null)
6556              this.documentation = new MarkdownType();
6557            this.documentation.setValue(value);
6558          }
6559          return this;
6560        }
6561
6562        /**
6563         * @return {@link #profile} (A profile on the document Bundle that constrains which resources are present, and their contents.). This is the underlying object with id, value and extensions. The accessor "getProfile" gives direct access to the value
6564         */
6565        public CanonicalType getProfileElement() { 
6566          if (this.profile == null)
6567            if (Configuration.errorOnAutoCreate())
6568              throw new Error("Attempt to auto-create CapabilityStatementDocumentComponent.profile");
6569            else if (Configuration.doAutoCreate())
6570              this.profile = new CanonicalType(); // bb
6571          return this.profile;
6572        }
6573
6574        public boolean hasProfileElement() { 
6575          return this.profile != null && !this.profile.isEmpty();
6576        }
6577
6578        public boolean hasProfile() { 
6579          return this.profile != null && !this.profile.isEmpty();
6580        }
6581
6582        /**
6583         * @param value {@link #profile} (A profile on the document Bundle that constrains which resources are present, and their contents.). This is the underlying object with id, value and extensions. The accessor "getProfile" gives direct access to the value
6584         */
6585        public CapabilityStatementDocumentComponent setProfileElement(CanonicalType value) { 
6586          this.profile = value;
6587          return this;
6588        }
6589
6590        /**
6591         * @return A profile on the document Bundle that constrains which resources are present, and their contents.
6592         */
6593        public String getProfile() { 
6594          return this.profile == null ? null : this.profile.getValue();
6595        }
6596
6597        /**
6598         * @param value A profile on the document Bundle that constrains which resources are present, and their contents.
6599         */
6600        public CapabilityStatementDocumentComponent setProfile(String value) { 
6601            if (this.profile == null)
6602              this.profile = new CanonicalType();
6603            this.profile.setValue(value);
6604          return this;
6605        }
6606
6607        protected void listChildren(List<Property> children) {
6608          super.listChildren(children);
6609          children.add(new Property("mode", "code", "Mode of this document declaration - whether an application is a producer or consumer.", 0, 1, mode));
6610          children.add(new Property("documentation", "markdown", "A description of how the application supports or uses the specified document profile.  For example, when documents are created, what action is taken with consumed documents, etc.", 0, 1, documentation));
6611          children.add(new Property("profile", "canonical(StructureDefinition)", "A profile on the document Bundle that constrains which resources are present, and their contents.", 0, 1, profile));
6612        }
6613
6614        @Override
6615        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
6616          switch (_hash) {
6617          case 3357091: /*mode*/  return new Property("mode", "code", "Mode of this document declaration - whether an application is a producer or consumer.", 0, 1, mode);
6618          case 1587405498: /*documentation*/  return new Property("documentation", "markdown", "A description of how the application supports or uses the specified document profile.  For example, when documents are created, what action is taken with consumed documents, etc.", 0, 1, documentation);
6619          case -309425751: /*profile*/  return new Property("profile", "canonical(StructureDefinition)", "A profile on the document Bundle that constrains which resources are present, and their contents.", 0, 1, profile);
6620          default: return super.getNamedProperty(_hash, _name, _checkValid);
6621          }
6622
6623        }
6624
6625      @Override
6626      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
6627        switch (hash) {
6628        case 3357091: /*mode*/ return this.mode == null ? new Base[0] : new Base[] {this.mode}; // Enumeration<DocumentMode>
6629        case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // MarkdownType
6630        case -309425751: /*profile*/ return this.profile == null ? new Base[0] : new Base[] {this.profile}; // CanonicalType
6631        default: return super.getProperty(hash, name, checkValid);
6632        }
6633
6634      }
6635
6636      @Override
6637      public Base setProperty(int hash, String name, Base value) throws FHIRException {
6638        switch (hash) {
6639        case 3357091: // mode
6640          value = new DocumentModeEnumFactory().fromType(TypeConvertor.castToCode(value));
6641          this.mode = (Enumeration) value; // Enumeration<DocumentMode>
6642          return value;
6643        case 1587405498: // documentation
6644          this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType
6645          return value;
6646        case -309425751: // profile
6647          this.profile = TypeConvertor.castToCanonical(value); // CanonicalType
6648          return value;
6649        default: return super.setProperty(hash, name, value);
6650        }
6651
6652      }
6653
6654      @Override
6655      public Base setProperty(String name, Base value) throws FHIRException {
6656        if (name.equals("mode")) {
6657          value = new DocumentModeEnumFactory().fromType(TypeConvertor.castToCode(value));
6658          this.mode = (Enumeration) value; // Enumeration<DocumentMode>
6659        } else if (name.equals("documentation")) {
6660          this.documentation = TypeConvertor.castToMarkdown(value); // MarkdownType
6661        } else if (name.equals("profile")) {
6662          this.profile = TypeConvertor.castToCanonical(value); // CanonicalType
6663        } else
6664          return super.setProperty(name, value);
6665        return value;
6666      }
6667
6668      @Override
6669      public Base makeProperty(int hash, String name) throws FHIRException {
6670        switch (hash) {
6671        case 3357091:  return getModeElement();
6672        case 1587405498:  return getDocumentationElement();
6673        case -309425751:  return getProfileElement();
6674        default: return super.makeProperty(hash, name);
6675        }
6676
6677      }
6678
6679      @Override
6680      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
6681        switch (hash) {
6682        case 3357091: /*mode*/ return new String[] {"code"};
6683        case 1587405498: /*documentation*/ return new String[] {"markdown"};
6684        case -309425751: /*profile*/ return new String[] {"canonical"};
6685        default: return super.getTypesForProperty(hash, name);
6686        }
6687
6688      }
6689
6690      @Override
6691      public Base addChild(String name) throws FHIRException {
6692        if (name.equals("mode")) {
6693          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.document.mode");
6694        }
6695        else if (name.equals("documentation")) {
6696          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.document.documentation");
6697        }
6698        else if (name.equals("profile")) {
6699          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.document.profile");
6700        }
6701        else
6702          return super.addChild(name);
6703      }
6704
6705      public CapabilityStatementDocumentComponent copy() {
6706        CapabilityStatementDocumentComponent dst = new CapabilityStatementDocumentComponent();
6707        copyValues(dst);
6708        return dst;
6709      }
6710
6711      public void copyValues(CapabilityStatementDocumentComponent dst) {
6712        super.copyValues(dst);
6713        dst.mode = mode == null ? null : mode.copy();
6714        dst.documentation = documentation == null ? null : documentation.copy();
6715        dst.profile = profile == null ? null : profile.copy();
6716      }
6717
6718      @Override
6719      public boolean equalsDeep(Base other_) {
6720        if (!super.equalsDeep(other_))
6721          return false;
6722        if (!(other_ instanceof CapabilityStatementDocumentComponent))
6723          return false;
6724        CapabilityStatementDocumentComponent o = (CapabilityStatementDocumentComponent) other_;
6725        return compareDeep(mode, o.mode, true) && compareDeep(documentation, o.documentation, true) && compareDeep(profile, o.profile, true)
6726          ;
6727      }
6728
6729      @Override
6730      public boolean equalsShallow(Base other_) {
6731        if (!super.equalsShallow(other_))
6732          return false;
6733        if (!(other_ instanceof CapabilityStatementDocumentComponent))
6734          return false;
6735        CapabilityStatementDocumentComponent o = (CapabilityStatementDocumentComponent) other_;
6736        return compareValues(mode, o.mode, true) && compareValues(documentation, o.documentation, true) && compareValues(profile, o.profile, true)
6737          ;
6738      }
6739
6740      public boolean isEmpty() {
6741        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(mode, documentation, profile
6742          );
6743      }
6744
6745  public String fhirType() {
6746    return "CapabilityStatement.document";
6747
6748  }
6749
6750  }
6751
6752    /**
6753     * An absolute URI that is used to identify this capability statement 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 an authoritative instance of this capability statement is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement is stored on different servers.
6754     */
6755    @Child(name = "url", type = {UriType.class}, order=0, min=0, max=1, modifier=false, summary=true)
6756    @Description(shortDefinition="Canonical identifier for this capability statement, represented as a URI (globally unique)", formalDefinition="An absolute URI that is used to identify this capability statement 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 an authoritative instance of this capability statement is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement is stored on different servers." )
6757    protected UriType url;
6758
6759    /**
6760     * A formal identifier that is used to identify this CapabilityStatement when it is represented in other formats, or referenced in a specification, model, design or an instance.
6761     */
6762    @Child(name = "identifier", type = {Identifier.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6763    @Description(shortDefinition="Additional identifier for the CapabilityStatement (business identifier)", formalDefinition="A formal identifier that is used to identify this CapabilityStatement when it is represented in other formats, or referenced in a specification, model, design or an instance." )
6764    protected List<Identifier> identifier;
6765
6766    /**
6767     * The identifier that is used to identify this version of the capability statement when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement 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.
6768     */
6769    @Child(name = "version", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true)
6770    @Description(shortDefinition="Business version of the capability statement", formalDefinition="The identifier that is used to identify this version of the capability statement when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement 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." )
6771    protected StringType version;
6772
6773    /**
6774     * Indicates the mechanism used to compare versions to determine which is more current.
6775     */
6776    @Child(name = "versionAlgorithm", type = {StringType.class, Coding.class}, order=3, min=0, max=1, modifier=false, summary=true)
6777    @Description(shortDefinition="How to compare versions", formalDefinition="Indicates the mechanism used to compare versions to determine which is more current." )
6778    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/version-algorithm")
6779    protected DataType versionAlgorithm;
6780
6781    /**
6782     * A natural language name identifying the capability statement. This name should be usable as an identifier for the module by machine processing applications such as code generation.
6783     */
6784    @Child(name = "name", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=true)
6785    @Description(shortDefinition="Name for this capability statement (computer friendly)", formalDefinition="A natural language name identifying the capability statement. This name should be usable as an identifier for the module by machine processing applications such as code generation." )
6786    protected StringType name;
6787
6788    /**
6789     * A short, descriptive, user-friendly title for the capability statement.
6790     */
6791    @Child(name = "title", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=true)
6792    @Description(shortDefinition="Name for this capability statement (human friendly)", formalDefinition="A short, descriptive, user-friendly title for the capability statement." )
6793    protected StringType title;
6794
6795    /**
6796     * The status of this capability statement. Enables tracking the life-cycle of the content.
6797     */
6798    @Child(name = "status", type = {CodeType.class}, order=6, min=1, max=1, modifier=true, summary=true)
6799    @Description(shortDefinition="draft | active | retired | unknown", formalDefinition="The status of this capability statement. Enables tracking the life-cycle of the content." )
6800    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/publication-status")
6801    protected Enumeration<PublicationStatus> status;
6802
6803    /**
6804     * A Boolean value to indicate that this capability statement is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.
6805     */
6806    @Child(name = "experimental", type = {BooleanType.class}, order=7, min=0, max=1, modifier=false, summary=true)
6807    @Description(shortDefinition="For testing purposes, not real usage", formalDefinition="A Boolean value to indicate that this capability statement is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage." )
6808    protected BooleanType experimental;
6809
6810    /**
6811     * The date  (and optionally time) when the capability statement was last significantly changed. 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 statement changes.
6812     */
6813    @Child(name = "date", type = {DateTimeType.class}, order=8, min=1, max=1, modifier=false, summary=true)
6814    @Description(shortDefinition="Date last changed", formalDefinition="The date  (and optionally time) when the capability statement was last significantly changed. 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 statement changes." )
6815    protected DateTimeType date;
6816
6817    /**
6818     * The name of the organization or individual responsible for the release and ongoing maintenance of the capability statement.
6819     */
6820    @Child(name = "publisher", type = {StringType.class}, order=9, min=0, max=1, modifier=false, summary=true)
6821    @Description(shortDefinition="Name of the publisher/steward (organization or individual)", formalDefinition="The name of the organization or individual responsible for the release and ongoing maintenance of the capability statement." )
6822    protected StringType publisher;
6823
6824    /**
6825     * Contact details to assist a user in finding and communicating with the publisher.
6826     */
6827    @Child(name = "contact", type = {ContactDetail.class}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6828    @Description(shortDefinition="Contact details for the publisher", formalDefinition="Contact details to assist a user in finding and communicating with the publisher." )
6829    protected List<ContactDetail> contact;
6830
6831    /**
6832     * A free text natural language description of the capability statement 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.
6833     */
6834    @Child(name = "description", type = {MarkdownType.class}, order=11, min=0, max=1, modifier=false, summary=false)
6835    @Description(shortDefinition="Natural language description of the capability statement", formalDefinition="A free text natural language description of the capability statement 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." )
6836    protected MarkdownType description;
6837
6838    /**
6839     * 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 statement instances.
6840     */
6841    @Child(name = "useContext", type = {UsageContext.class}, order=12, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6842    @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 statement instances." )
6843    protected List<UsageContext> useContext;
6844
6845    /**
6846     * A legal or geographic region in which the capability statement is intended to be used.
6847     */
6848    @Child(name = "jurisdiction", type = {CodeableConcept.class}, order=13, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6849    @Description(shortDefinition="Intended jurisdiction for capability statement (if applicable)", formalDefinition="A legal or geographic region in which the capability statement is intended to be used." )
6850    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/jurisdiction")
6851    protected List<CodeableConcept> jurisdiction;
6852
6853    /**
6854     * Explanation of why this capability statement is needed and why it has been designed as it has.
6855     */
6856    @Child(name = "purpose", type = {MarkdownType.class}, order=14, min=0, max=1, modifier=false, summary=false)
6857    @Description(shortDefinition="Why this capability statement is defined", formalDefinition="Explanation of why this capability statement is needed and why it has been designed as it has." )
6858    protected MarkdownType purpose;
6859
6860    /**
6861     * A copyright statement relating to the capability statement and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement.
6862     */
6863    @Child(name = "copyright", type = {MarkdownType.class}, order=15, min=0, max=1, modifier=false, summary=false)
6864    @Description(shortDefinition="Use and/or publishing restrictions", formalDefinition="A copyright statement relating to the capability statement and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement." )
6865    protected MarkdownType copyright;
6866
6867    /**
6868     * A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved').
6869     */
6870    @Child(name = "copyrightLabel", type = {StringType.class}, order=16, min=0, max=1, modifier=false, summary=false)
6871    @Description(shortDefinition="Copyright holder and year(s)", formalDefinition="A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved')." )
6872    protected StringType copyrightLabel;
6873
6874    /**
6875     * 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).
6876     */
6877    @Child(name = "kind", type = {CodeType.class}, order=17, min=1, max=1, modifier=false, summary=true)
6878    @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)." )
6879    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/capability-statement-kind")
6880    protected Enumeration<CapabilityStatementKind> kind;
6881
6882    /**
6883     * Reference to a canonical URL of another CapabilityStatement that this software implements. This capability statement is a published API description that corresponds to a business service. The server may actually implement a subset of the capability statement it claims to implement, so the capability statement must specify the full capability details.
6884     */
6885    @Child(name = "instantiates", type = {CanonicalType.class}, order=18, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6886    @Description(shortDefinition="Canonical URL of another capability statement this implements", formalDefinition="Reference to a canonical URL of another CapabilityStatement that this software implements. This capability statement is a published API description that corresponds to a business service. The server may actually implement a subset of the capability statement it claims to implement, so the capability statement must specify the full capability details." )
6887    protected List<CanonicalType> instantiates;
6888
6889    /**
6890     * Reference to a canonical URL of another CapabilityStatement that this software adds to. The capability statement automatically includes everything in the other statement, and it is not duplicated, though the server may repeat the same resources, interactions and operations to add additional details to them.
6891     */
6892    @Child(name = "imports", type = {CanonicalType.class}, order=19, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6893    @Description(shortDefinition="Canonical URL of another capability statement this adds to", formalDefinition="Reference to a canonical URL of another CapabilityStatement that this software adds to. The capability statement automatically includes everything in the other statement, and it is not duplicated, though the server may repeat the same resources, interactions and operations to add additional details to them." )
6894    protected List<CanonicalType> imports;
6895
6896    /**
6897     * 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.
6898     */
6899    @Child(name = "software", type = {}, order=20, min=0, max=1, modifier=false, summary=true)
6900    @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." )
6901    protected CapabilityStatementSoftwareComponent software;
6902
6903    /**
6904     * 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.
6905     */
6906    @Child(name = "implementation", type = {}, order=21, min=0, max=1, modifier=false, summary=true)
6907    @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." )
6908    protected CapabilityStatementImplementationComponent implementation;
6909
6910    /**
6911     * The version of the FHIR specification that this CapabilityStatement describes (which SHALL be the same as the FHIR version of the CapabilityStatement itself). There is no default value.
6912     */
6913    @Child(name = "fhirVersion", type = {CodeType.class}, order=22, min=1, max=1, modifier=false, summary=true)
6914    @Description(shortDefinition="FHIR Version the system supports", formalDefinition="The version of the FHIR specification that this CapabilityStatement describes (which SHALL be the same as the FHIR version of the CapabilityStatement itself). There is no default value." )
6915    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/FHIR-version")
6916    protected Enumeration<FHIRVersion> fhirVersion;
6917
6918    /**
6919     * A list of the formats supported by this implementation using their content types.
6920     */
6921    @Child(name = "format", type = {CodeType.class}, order=23, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6922    @Description(shortDefinition="formats supported (xml | json | ttl | mime type)", formalDefinition="A list of the formats supported by this implementation using their content types." )
6923    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/mimetypes")
6924    protected List<CodeType> format;
6925
6926    /**
6927     * A list of the patch formats supported by this implementation using their content types.
6928     */
6929    @Child(name = "patchFormat", type = {CodeType.class}, order=24, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6930    @Description(shortDefinition="Patch formats supported", formalDefinition="A list of the patch formats supported by this implementation using their content types." )
6931    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/mimetypes")
6932    protected List<CodeType> patchFormat;
6933
6934    /**
6935     * A list of the languages supported by this implementation that are usefully supported in the ```Accept-Language``` header.
6936     */
6937    @Child(name = "acceptLanguage", type = {CodeType.class}, order=25, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6938    @Description(shortDefinition="Languages supported", formalDefinition="A list of the languages supported by this implementation that are usefully supported in the ```Accept-Language``` header." )
6939    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/all-languages")
6940    protected List<CodeType> acceptLanguage;
6941
6942    /**
6943     * A list of implementation guides that the server does (or should) support in their entirety.
6944     */
6945    @Child(name = "implementationGuide", type = {CanonicalType.class}, order=26, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6946    @Description(shortDefinition="Implementation guides supported", formalDefinition="A list of implementation guides that the server does (or should) support in their entirety." )
6947    protected List<CanonicalType> implementationGuide;
6948
6949    /**
6950     * A definition of the restful capabilities of the solution, if any.
6951     */
6952    @Child(name = "rest", type = {}, order=27, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6953    @Description(shortDefinition="If the endpoint is a RESTful one", formalDefinition="A definition of the restful capabilities of the solution, if any." )
6954    protected List<CapabilityStatementRestComponent> rest;
6955
6956    /**
6957     * A description of the messaging capabilities of the solution.
6958     */
6959    @Child(name = "messaging", type = {}, order=28, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6960    @Description(shortDefinition="If messaging is supported", formalDefinition="A description of the messaging capabilities of the solution." )
6961    protected List<CapabilityStatementMessagingComponent> messaging;
6962
6963    /**
6964     * A document definition.
6965     */
6966    @Child(name = "document", type = {}, order=29, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
6967    @Description(shortDefinition="Document definition", formalDefinition="A document definition." )
6968    protected List<CapabilityStatementDocumentComponent> document;
6969
6970    private static final long serialVersionUID = -1432396321L;
6971
6972  /**
6973   * Constructor
6974   */
6975    public CapabilityStatement() {
6976      super();
6977    }
6978
6979  /**
6980   * Constructor
6981   */
6982    public CapabilityStatement(PublicationStatus status, Date date, CapabilityStatementKind kind, FHIRVersion fhirVersion, String format) {
6983      super();
6984      this.setStatus(status);
6985      this.setDate(date);
6986      this.setKind(kind);
6987      this.setFhirVersion(fhirVersion);
6988      this.addFormat(format);
6989    }
6990
6991    /**
6992     * @return {@link #url} (An absolute URI that is used to identify this capability statement 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 an authoritative instance of this capability statement is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement is stored on different servers.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
6993     */
6994    public UriType getUrlElement() { 
6995      if (this.url == null)
6996        if (Configuration.errorOnAutoCreate())
6997          throw new Error("Attempt to auto-create CapabilityStatement.url");
6998        else if (Configuration.doAutoCreate())
6999          this.url = new UriType(); // bb
7000      return this.url;
7001    }
7002
7003    public boolean hasUrlElement() { 
7004      return this.url != null && !this.url.isEmpty();
7005    }
7006
7007    public boolean hasUrl() { 
7008      return this.url != null && !this.url.isEmpty();
7009    }
7010
7011    /**
7012     * @param value {@link #url} (An absolute URI that is used to identify this capability statement 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 an authoritative instance of this capability statement is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement is stored on different servers.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
7013     */
7014    public CapabilityStatement setUrlElement(UriType value) { 
7015      this.url = value;
7016      return this;
7017    }
7018
7019    /**
7020     * @return An absolute URI that is used to identify this capability statement 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 an authoritative instance of this capability statement is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement is stored on different servers.
7021     */
7022    public String getUrl() { 
7023      return this.url == null ? null : this.url.getValue();
7024    }
7025
7026    /**
7027     * @param value An absolute URI that is used to identify this capability statement 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 an authoritative instance of this capability statement is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement is stored on different servers.
7028     */
7029    public CapabilityStatement setUrl(String value) { 
7030      if (Utilities.noString(value))
7031        this.url = null;
7032      else {
7033        if (this.url == null)
7034          this.url = new UriType();
7035        this.url.setValue(value);
7036      }
7037      return this;
7038    }
7039
7040    /**
7041     * @return {@link #identifier} (A formal identifier that is used to identify this CapabilityStatement when it is represented in other formats, or referenced in a specification, model, design or an instance.)
7042     */
7043    public List<Identifier> getIdentifier() { 
7044      if (this.identifier == null)
7045        this.identifier = new ArrayList<Identifier>();
7046      return this.identifier;
7047    }
7048
7049    /**
7050     * @return Returns a reference to <code>this</code> for easy method chaining
7051     */
7052    public CapabilityStatement setIdentifier(List<Identifier> theIdentifier) { 
7053      this.identifier = theIdentifier;
7054      return this;
7055    }
7056
7057    public boolean hasIdentifier() { 
7058      if (this.identifier == null)
7059        return false;
7060      for (Identifier item : this.identifier)
7061        if (!item.isEmpty())
7062          return true;
7063      return false;
7064    }
7065
7066    public Identifier addIdentifier() { //3
7067      Identifier t = new Identifier();
7068      if (this.identifier == null)
7069        this.identifier = new ArrayList<Identifier>();
7070      this.identifier.add(t);
7071      return t;
7072    }
7073
7074    public CapabilityStatement addIdentifier(Identifier t) { //3
7075      if (t == null)
7076        return this;
7077      if (this.identifier == null)
7078        this.identifier = new ArrayList<Identifier>();
7079      this.identifier.add(t);
7080      return this;
7081    }
7082
7083    /**
7084     * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist {3}
7085     */
7086    public Identifier getIdentifierFirstRep() { 
7087      if (getIdentifier().isEmpty()) {
7088        addIdentifier();
7089      }
7090      return getIdentifier().get(0);
7091    }
7092
7093    /**
7094     * @return {@link #version} (The identifier that is used to identify this version of the capability statement when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement 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
7095     */
7096    public StringType getVersionElement() { 
7097      if (this.version == null)
7098        if (Configuration.errorOnAutoCreate())
7099          throw new Error("Attempt to auto-create CapabilityStatement.version");
7100        else if (Configuration.doAutoCreate())
7101          this.version = new StringType(); // bb
7102      return this.version;
7103    }
7104
7105    public boolean hasVersionElement() { 
7106      return this.version != null && !this.version.isEmpty();
7107    }
7108
7109    public boolean hasVersion() { 
7110      return this.version != null && !this.version.isEmpty();
7111    }
7112
7113    /**
7114     * @param value {@link #version} (The identifier that is used to identify this version of the capability statement when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement 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
7115     */
7116    public CapabilityStatement setVersionElement(StringType value) { 
7117      this.version = value;
7118      return this;
7119    }
7120
7121    /**
7122     * @return The identifier that is used to identify this version of the capability statement when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement 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.
7123     */
7124    public String getVersion() { 
7125      return this.version == null ? null : this.version.getValue();
7126    }
7127
7128    /**
7129     * @param value The identifier that is used to identify this version of the capability statement when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement 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.
7130     */
7131    public CapabilityStatement setVersion(String value) { 
7132      if (Utilities.noString(value))
7133        this.version = null;
7134      else {
7135        if (this.version == null)
7136          this.version = new StringType();
7137        this.version.setValue(value);
7138      }
7139      return this;
7140    }
7141
7142    /**
7143     * @return {@link #versionAlgorithm} (Indicates the mechanism used to compare versions to determine which is more current.)
7144     */
7145    public DataType getVersionAlgorithm() { 
7146      return this.versionAlgorithm;
7147    }
7148
7149    /**
7150     * @return {@link #versionAlgorithm} (Indicates the mechanism used to compare versions to determine which is more current.)
7151     */
7152    public StringType getVersionAlgorithmStringType() throws FHIRException { 
7153      if (this.versionAlgorithm == null)
7154        this.versionAlgorithm = new StringType();
7155      if (!(this.versionAlgorithm instanceof StringType))
7156        throw new FHIRException("Type mismatch: the type StringType was expected, but "+this.versionAlgorithm.getClass().getName()+" was encountered");
7157      return (StringType) this.versionAlgorithm;
7158    }
7159
7160    public boolean hasVersionAlgorithmStringType() { 
7161      return this != null && this.versionAlgorithm instanceof StringType;
7162    }
7163
7164    /**
7165     * @return {@link #versionAlgorithm} (Indicates the mechanism used to compare versions to determine which is more current.)
7166     */
7167    public Coding getVersionAlgorithmCoding() throws FHIRException { 
7168      if (this.versionAlgorithm == null)
7169        this.versionAlgorithm = new Coding();
7170      if (!(this.versionAlgorithm instanceof Coding))
7171        throw new FHIRException("Type mismatch: the type Coding was expected, but "+this.versionAlgorithm.getClass().getName()+" was encountered");
7172      return (Coding) this.versionAlgorithm;
7173    }
7174
7175    public boolean hasVersionAlgorithmCoding() { 
7176      return this != null && this.versionAlgorithm instanceof Coding;
7177    }
7178
7179    public boolean hasVersionAlgorithm() { 
7180      return this.versionAlgorithm != null && !this.versionAlgorithm.isEmpty();
7181    }
7182
7183    /**
7184     * @param value {@link #versionAlgorithm} (Indicates the mechanism used to compare versions to determine which is more current.)
7185     */
7186    public CapabilityStatement setVersionAlgorithm(DataType value) { 
7187      if (value != null && !(value instanceof StringType || value instanceof Coding))
7188        throw new FHIRException("Not the right type for CapabilityStatement.versionAlgorithm[x]: "+value.fhirType());
7189      this.versionAlgorithm = value;
7190      return this;
7191    }
7192
7193    /**
7194     * @return {@link #name} (A natural language name identifying the capability statement. 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
7195     */
7196    public StringType getNameElement() { 
7197      if (this.name == null)
7198        if (Configuration.errorOnAutoCreate())
7199          throw new Error("Attempt to auto-create CapabilityStatement.name");
7200        else if (Configuration.doAutoCreate())
7201          this.name = new StringType(); // bb
7202      return this.name;
7203    }
7204
7205    public boolean hasNameElement() { 
7206      return this.name != null && !this.name.isEmpty();
7207    }
7208
7209    public boolean hasName() { 
7210      return this.name != null && !this.name.isEmpty();
7211    }
7212
7213    /**
7214     * @param value {@link #name} (A natural language name identifying the capability statement. 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
7215     */
7216    public CapabilityStatement setNameElement(StringType value) { 
7217      this.name = value;
7218      return this;
7219    }
7220
7221    /**
7222     * @return A natural language name identifying the capability statement. This name should be usable as an identifier for the module by machine processing applications such as code generation.
7223     */
7224    public String getName() { 
7225      return this.name == null ? null : this.name.getValue();
7226    }
7227
7228    /**
7229     * @param value A natural language name identifying the capability statement. This name should be usable as an identifier for the module by machine processing applications such as code generation.
7230     */
7231    public CapabilityStatement setName(String value) { 
7232      if (Utilities.noString(value))
7233        this.name = null;
7234      else {
7235        if (this.name == null)
7236          this.name = new StringType();
7237        this.name.setValue(value);
7238      }
7239      return this;
7240    }
7241
7242    /**
7243     * @return {@link #title} (A short, descriptive, user-friendly title for the capability statement.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
7244     */
7245    public StringType getTitleElement() { 
7246      if (this.title == null)
7247        if (Configuration.errorOnAutoCreate())
7248          throw new Error("Attempt to auto-create CapabilityStatement.title");
7249        else if (Configuration.doAutoCreate())
7250          this.title = new StringType(); // bb
7251      return this.title;
7252    }
7253
7254    public boolean hasTitleElement() { 
7255      return this.title != null && !this.title.isEmpty();
7256    }
7257
7258    public boolean hasTitle() { 
7259      return this.title != null && !this.title.isEmpty();
7260    }
7261
7262    /**
7263     * @param value {@link #title} (A short, descriptive, user-friendly title for the capability statement.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
7264     */
7265    public CapabilityStatement setTitleElement(StringType value) { 
7266      this.title = value;
7267      return this;
7268    }
7269
7270    /**
7271     * @return A short, descriptive, user-friendly title for the capability statement.
7272     */
7273    public String getTitle() { 
7274      return this.title == null ? null : this.title.getValue();
7275    }
7276
7277    /**
7278     * @param value A short, descriptive, user-friendly title for the capability statement.
7279     */
7280    public CapabilityStatement setTitle(String value) { 
7281      if (Utilities.noString(value))
7282        this.title = null;
7283      else {
7284        if (this.title == null)
7285          this.title = new StringType();
7286        this.title.setValue(value);
7287      }
7288      return this;
7289    }
7290
7291    /**
7292     * @return {@link #status} (The status of this capability statement. 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
7293     */
7294    public Enumeration<PublicationStatus> getStatusElement() { 
7295      if (this.status == null)
7296        if (Configuration.errorOnAutoCreate())
7297          throw new Error("Attempt to auto-create CapabilityStatement.status");
7298        else if (Configuration.doAutoCreate())
7299          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb
7300      return this.status;
7301    }
7302
7303    public boolean hasStatusElement() { 
7304      return this.status != null && !this.status.isEmpty();
7305    }
7306
7307    public boolean hasStatus() { 
7308      return this.status != null && !this.status.isEmpty();
7309    }
7310
7311    /**
7312     * @param value {@link #status} (The status of this capability statement. 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
7313     */
7314    public CapabilityStatement setStatusElement(Enumeration<PublicationStatus> value) { 
7315      this.status = value;
7316      return this;
7317    }
7318
7319    /**
7320     * @return The status of this capability statement. Enables tracking the life-cycle of the content.
7321     */
7322    public PublicationStatus getStatus() { 
7323      return this.status == null ? null : this.status.getValue();
7324    }
7325
7326    /**
7327     * @param value The status of this capability statement. Enables tracking the life-cycle of the content.
7328     */
7329    public CapabilityStatement setStatus(PublicationStatus value) { 
7330        if (this.status == null)
7331          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory());
7332        this.status.setValue(value);
7333      return this;
7334    }
7335
7336    /**
7337     * @return {@link #experimental} (A Boolean value to indicate that this capability statement 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
7338     */
7339    public BooleanType getExperimentalElement() { 
7340      if (this.experimental == null)
7341        if (Configuration.errorOnAutoCreate())
7342          throw new Error("Attempt to auto-create CapabilityStatement.experimental");
7343        else if (Configuration.doAutoCreate())
7344          this.experimental = new BooleanType(); // bb
7345      return this.experimental;
7346    }
7347
7348    public boolean hasExperimentalElement() { 
7349      return this.experimental != null && !this.experimental.isEmpty();
7350    }
7351
7352    public boolean hasExperimental() { 
7353      return this.experimental != null && !this.experimental.isEmpty();
7354    }
7355
7356    /**
7357     * @param value {@link #experimental} (A Boolean value to indicate that this capability statement 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
7358     */
7359    public CapabilityStatement setExperimentalElement(BooleanType value) { 
7360      this.experimental = value;
7361      return this;
7362    }
7363
7364    /**
7365     * @return A Boolean value to indicate that this capability statement is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.
7366     */
7367    public boolean getExperimental() { 
7368      return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue();
7369    }
7370
7371    /**
7372     * @param value A Boolean value to indicate that this capability statement is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.
7373     */
7374    public CapabilityStatement setExperimental(boolean value) { 
7375        if (this.experimental == null)
7376          this.experimental = new BooleanType();
7377        this.experimental.setValue(value);
7378      return this;
7379    }
7380
7381    /**
7382     * @return {@link #date} (The date  (and optionally time) when the capability statement was last significantly changed. 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 statement changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
7383     */
7384    public DateTimeType getDateElement() { 
7385      if (this.date == null)
7386        if (Configuration.errorOnAutoCreate())
7387          throw new Error("Attempt to auto-create CapabilityStatement.date");
7388        else if (Configuration.doAutoCreate())
7389          this.date = new DateTimeType(); // bb
7390      return this.date;
7391    }
7392
7393    public boolean hasDateElement() { 
7394      return this.date != null && !this.date.isEmpty();
7395    }
7396
7397    public boolean hasDate() { 
7398      return this.date != null && !this.date.isEmpty();
7399    }
7400
7401    /**
7402     * @param value {@link #date} (The date  (and optionally time) when the capability statement was last significantly changed. 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 statement changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
7403     */
7404    public CapabilityStatement setDateElement(DateTimeType value) { 
7405      this.date = value;
7406      return this;
7407    }
7408
7409    /**
7410     * @return The date  (and optionally time) when the capability statement was last significantly changed. 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 statement changes.
7411     */
7412    public Date getDate() { 
7413      return this.date == null ? null : this.date.getValue();
7414    }
7415
7416    /**
7417     * @param value The date  (and optionally time) when the capability statement was last significantly changed. 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 statement changes.
7418     */
7419    public CapabilityStatement setDate(Date value) { 
7420        if (this.date == null)
7421          this.date = new DateTimeType();
7422        this.date.setValue(value);
7423      return this;
7424    }
7425
7426    /**
7427     * @return {@link #publisher} (The name of the organization or individual responsible for the release and ongoing maintenance of the capability statement.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
7428     */
7429    public StringType getPublisherElement() { 
7430      if (this.publisher == null)
7431        if (Configuration.errorOnAutoCreate())
7432          throw new Error("Attempt to auto-create CapabilityStatement.publisher");
7433        else if (Configuration.doAutoCreate())
7434          this.publisher = new StringType(); // bb
7435      return this.publisher;
7436    }
7437
7438    public boolean hasPublisherElement() { 
7439      return this.publisher != null && !this.publisher.isEmpty();
7440    }
7441
7442    public boolean hasPublisher() { 
7443      return this.publisher != null && !this.publisher.isEmpty();
7444    }
7445
7446    /**
7447     * @param value {@link #publisher} (The name of the organization or individual responsible for the release and ongoing maintenance of the capability statement.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
7448     */
7449    public CapabilityStatement setPublisherElement(StringType value) { 
7450      this.publisher = value;
7451      return this;
7452    }
7453
7454    /**
7455     * @return The name of the organization or individual responsible for the release and ongoing maintenance of the capability statement.
7456     */
7457    public String getPublisher() { 
7458      return this.publisher == null ? null : this.publisher.getValue();
7459    }
7460
7461    /**
7462     * @param value The name of the organization or individual responsible for the release and ongoing maintenance of the capability statement.
7463     */
7464    public CapabilityStatement setPublisher(String value) { 
7465      if (Utilities.noString(value))
7466        this.publisher = null;
7467      else {
7468        if (this.publisher == null)
7469          this.publisher = new StringType();
7470        this.publisher.setValue(value);
7471      }
7472      return this;
7473    }
7474
7475    /**
7476     * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.)
7477     */
7478    public List<ContactDetail> getContact() { 
7479      if (this.contact == null)
7480        this.contact = new ArrayList<ContactDetail>();
7481      return this.contact;
7482    }
7483
7484    /**
7485     * @return Returns a reference to <code>this</code> for easy method chaining
7486     */
7487    public CapabilityStatement setContact(List<ContactDetail> theContact) { 
7488      this.contact = theContact;
7489      return this;
7490    }
7491
7492    public boolean hasContact() { 
7493      if (this.contact == null)
7494        return false;
7495      for (ContactDetail item : this.contact)
7496        if (!item.isEmpty())
7497          return true;
7498      return false;
7499    }
7500
7501    public ContactDetail addContact() { //3
7502      ContactDetail t = new ContactDetail();
7503      if (this.contact == null)
7504        this.contact = new ArrayList<ContactDetail>();
7505      this.contact.add(t);
7506      return t;
7507    }
7508
7509    public CapabilityStatement addContact(ContactDetail t) { //3
7510      if (t == null)
7511        return this;
7512      if (this.contact == null)
7513        this.contact = new ArrayList<ContactDetail>();
7514      this.contact.add(t);
7515      return this;
7516    }
7517
7518    /**
7519     * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist {3}
7520     */
7521    public ContactDetail getContactFirstRep() { 
7522      if (getContact().isEmpty()) {
7523        addContact();
7524      }
7525      return getContact().get(0);
7526    }
7527
7528    /**
7529     * @return {@link #description} (A free text natural language description of the capability statement 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
7530     */
7531    public MarkdownType getDescriptionElement() { 
7532      if (this.description == null)
7533        if (Configuration.errorOnAutoCreate())
7534          throw new Error("Attempt to auto-create CapabilityStatement.description");
7535        else if (Configuration.doAutoCreate())
7536          this.description = new MarkdownType(); // bb
7537      return this.description;
7538    }
7539
7540    public boolean hasDescriptionElement() { 
7541      return this.description != null && !this.description.isEmpty();
7542    }
7543
7544    public boolean hasDescription() { 
7545      return this.description != null && !this.description.isEmpty();
7546    }
7547
7548    /**
7549     * @param value {@link #description} (A free text natural language description of the capability statement 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
7550     */
7551    public CapabilityStatement setDescriptionElement(MarkdownType value) { 
7552      this.description = value;
7553      return this;
7554    }
7555
7556    /**
7557     * @return A free text natural language description of the capability statement 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.
7558     */
7559    public String getDescription() { 
7560      return this.description == null ? null : this.description.getValue();
7561    }
7562
7563    /**
7564     * @param value A free text natural language description of the capability statement 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.
7565     */
7566    public CapabilityStatement setDescription(String value) { 
7567      if (Utilities.noString(value))
7568        this.description = null;
7569      else {
7570        if (this.description == null)
7571          this.description = new MarkdownType();
7572        this.description.setValue(value);
7573      }
7574      return this;
7575    }
7576
7577    /**
7578     * @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 statement instances.)
7579     */
7580    public List<UsageContext> getUseContext() { 
7581      if (this.useContext == null)
7582        this.useContext = new ArrayList<UsageContext>();
7583      return this.useContext;
7584    }
7585
7586    /**
7587     * @return Returns a reference to <code>this</code> for easy method chaining
7588     */
7589    public CapabilityStatement setUseContext(List<UsageContext> theUseContext) { 
7590      this.useContext = theUseContext;
7591      return this;
7592    }
7593
7594    public boolean hasUseContext() { 
7595      if (this.useContext == null)
7596        return false;
7597      for (UsageContext item : this.useContext)
7598        if (!item.isEmpty())
7599          return true;
7600      return false;
7601    }
7602
7603    public UsageContext addUseContext() { //3
7604      UsageContext t = new UsageContext();
7605      if (this.useContext == null)
7606        this.useContext = new ArrayList<UsageContext>();
7607      this.useContext.add(t);
7608      return t;
7609    }
7610
7611    public CapabilityStatement addUseContext(UsageContext t) { //3
7612      if (t == null)
7613        return this;
7614      if (this.useContext == null)
7615        this.useContext = new ArrayList<UsageContext>();
7616      this.useContext.add(t);
7617      return this;
7618    }
7619
7620    /**
7621     * @return The first repetition of repeating field {@link #useContext}, creating it if it does not already exist {3}
7622     */
7623    public UsageContext getUseContextFirstRep() { 
7624      if (getUseContext().isEmpty()) {
7625        addUseContext();
7626      }
7627      return getUseContext().get(0);
7628    }
7629
7630    /**
7631     * @return {@link #jurisdiction} (A legal or geographic region in which the capability statement is intended to be used.)
7632     */
7633    public List<CodeableConcept> getJurisdiction() { 
7634      if (this.jurisdiction == null)
7635        this.jurisdiction = new ArrayList<CodeableConcept>();
7636      return this.jurisdiction;
7637    }
7638
7639    /**
7640     * @return Returns a reference to <code>this</code> for easy method chaining
7641     */
7642    public CapabilityStatement setJurisdiction(List<CodeableConcept> theJurisdiction) { 
7643      this.jurisdiction = theJurisdiction;
7644      return this;
7645    }
7646
7647    public boolean hasJurisdiction() { 
7648      if (this.jurisdiction == null)
7649        return false;
7650      for (CodeableConcept item : this.jurisdiction)
7651        if (!item.isEmpty())
7652          return true;
7653      return false;
7654    }
7655
7656    public CodeableConcept addJurisdiction() { //3
7657      CodeableConcept t = new CodeableConcept();
7658      if (this.jurisdiction == null)
7659        this.jurisdiction = new ArrayList<CodeableConcept>();
7660      this.jurisdiction.add(t);
7661      return t;
7662    }
7663
7664    public CapabilityStatement addJurisdiction(CodeableConcept t) { //3
7665      if (t == null)
7666        return this;
7667      if (this.jurisdiction == null)
7668        this.jurisdiction = new ArrayList<CodeableConcept>();
7669      this.jurisdiction.add(t);
7670      return this;
7671    }
7672
7673    /**
7674     * @return The first repetition of repeating field {@link #jurisdiction}, creating it if it does not already exist {3}
7675     */
7676    public CodeableConcept getJurisdictionFirstRep() { 
7677      if (getJurisdiction().isEmpty()) {
7678        addJurisdiction();
7679      }
7680      return getJurisdiction().get(0);
7681    }
7682
7683    /**
7684     * @return {@link #purpose} (Explanation of why this capability statement 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
7685     */
7686    public MarkdownType getPurposeElement() { 
7687      if (this.purpose == null)
7688        if (Configuration.errorOnAutoCreate())
7689          throw new Error("Attempt to auto-create CapabilityStatement.purpose");
7690        else if (Configuration.doAutoCreate())
7691          this.purpose = new MarkdownType(); // bb
7692      return this.purpose;
7693    }
7694
7695    public boolean hasPurposeElement() { 
7696      return this.purpose != null && !this.purpose.isEmpty();
7697    }
7698
7699    public boolean hasPurpose() { 
7700      return this.purpose != null && !this.purpose.isEmpty();
7701    }
7702
7703    /**
7704     * @param value {@link #purpose} (Explanation of why this capability statement 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
7705     */
7706    public CapabilityStatement setPurposeElement(MarkdownType value) { 
7707      this.purpose = value;
7708      return this;
7709    }
7710
7711    /**
7712     * @return Explanation of why this capability statement is needed and why it has been designed as it has.
7713     */
7714    public String getPurpose() { 
7715      return this.purpose == null ? null : this.purpose.getValue();
7716    }
7717
7718    /**
7719     * @param value Explanation of why this capability statement is needed and why it has been designed as it has.
7720     */
7721    public CapabilityStatement setPurpose(String value) { 
7722      if (Utilities.noString(value))
7723        this.purpose = null;
7724      else {
7725        if (this.purpose == null)
7726          this.purpose = new MarkdownType();
7727        this.purpose.setValue(value);
7728      }
7729      return this;
7730    }
7731
7732    /**
7733     * @return {@link #copyright} (A copyright statement relating to the capability statement and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value
7734     */
7735    public MarkdownType getCopyrightElement() { 
7736      if (this.copyright == null)
7737        if (Configuration.errorOnAutoCreate())
7738          throw new Error("Attempt to auto-create CapabilityStatement.copyright");
7739        else if (Configuration.doAutoCreate())
7740          this.copyright = new MarkdownType(); // bb
7741      return this.copyright;
7742    }
7743
7744    public boolean hasCopyrightElement() { 
7745      return this.copyright != null && !this.copyright.isEmpty();
7746    }
7747
7748    public boolean hasCopyright() { 
7749      return this.copyright != null && !this.copyright.isEmpty();
7750    }
7751
7752    /**
7753     * @param value {@link #copyright} (A copyright statement relating to the capability statement and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value
7754     */
7755    public CapabilityStatement setCopyrightElement(MarkdownType value) { 
7756      this.copyright = value;
7757      return this;
7758    }
7759
7760    /**
7761     * @return A copyright statement relating to the capability statement and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement.
7762     */
7763    public String getCopyright() { 
7764      return this.copyright == null ? null : this.copyright.getValue();
7765    }
7766
7767    /**
7768     * @param value A copyright statement relating to the capability statement and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement.
7769     */
7770    public CapabilityStatement setCopyright(String value) { 
7771      if (Utilities.noString(value))
7772        this.copyright = null;
7773      else {
7774        if (this.copyright == null)
7775          this.copyright = new MarkdownType();
7776        this.copyright.setValue(value);
7777      }
7778      return this;
7779    }
7780
7781    /**
7782     * @return {@link #copyrightLabel} (A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved').). This is the underlying object with id, value and extensions. The accessor "getCopyrightLabel" gives direct access to the value
7783     */
7784    public StringType getCopyrightLabelElement() { 
7785      if (this.copyrightLabel == null)
7786        if (Configuration.errorOnAutoCreate())
7787          throw new Error("Attempt to auto-create CapabilityStatement.copyrightLabel");
7788        else if (Configuration.doAutoCreate())
7789          this.copyrightLabel = new StringType(); // bb
7790      return this.copyrightLabel;
7791    }
7792
7793    public boolean hasCopyrightLabelElement() { 
7794      return this.copyrightLabel != null && !this.copyrightLabel.isEmpty();
7795    }
7796
7797    public boolean hasCopyrightLabel() { 
7798      return this.copyrightLabel != null && !this.copyrightLabel.isEmpty();
7799    }
7800
7801    /**
7802     * @param value {@link #copyrightLabel} (A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved').). This is the underlying object with id, value and extensions. The accessor "getCopyrightLabel" gives direct access to the value
7803     */
7804    public CapabilityStatement setCopyrightLabelElement(StringType value) { 
7805      this.copyrightLabel = value;
7806      return this;
7807    }
7808
7809    /**
7810     * @return A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved').
7811     */
7812    public String getCopyrightLabel() { 
7813      return this.copyrightLabel == null ? null : this.copyrightLabel.getValue();
7814    }
7815
7816    /**
7817     * @param value A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved').
7818     */
7819    public CapabilityStatement setCopyrightLabel(String value) { 
7820      if (Utilities.noString(value))
7821        this.copyrightLabel = null;
7822      else {
7823        if (this.copyrightLabel == null)
7824          this.copyrightLabel = new StringType();
7825        this.copyrightLabel.setValue(value);
7826      }
7827      return this;
7828    }
7829
7830    /**
7831     * @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
7832     */
7833    public Enumeration<CapabilityStatementKind> getKindElement() { 
7834      if (this.kind == null)
7835        if (Configuration.errorOnAutoCreate())
7836          throw new Error("Attempt to auto-create CapabilityStatement.kind");
7837        else if (Configuration.doAutoCreate())
7838          this.kind = new Enumeration<CapabilityStatementKind>(new CapabilityStatementKindEnumFactory()); // bb
7839      return this.kind;
7840    }
7841
7842    public boolean hasKindElement() { 
7843      return this.kind != null && !this.kind.isEmpty();
7844    }
7845
7846    public boolean hasKind() { 
7847      return this.kind != null && !this.kind.isEmpty();
7848    }
7849
7850    /**
7851     * @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
7852     */
7853    public CapabilityStatement setKindElement(Enumeration<CapabilityStatementKind> value) { 
7854      this.kind = value;
7855      return this;
7856    }
7857
7858    /**
7859     * @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).
7860     */
7861    public CapabilityStatementKind getKind() { 
7862      return this.kind == null ? null : this.kind.getValue();
7863    }
7864
7865    /**
7866     * @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).
7867     */
7868    public CapabilityStatement setKind(CapabilityStatementKind value) { 
7869        if (this.kind == null)
7870          this.kind = new Enumeration<CapabilityStatementKind>(new CapabilityStatementKindEnumFactory());
7871        this.kind.setValue(value);
7872      return this;
7873    }
7874
7875    /**
7876     * @return {@link #instantiates} (Reference to a canonical URL of another CapabilityStatement that this software implements. This capability statement is a published API description that corresponds to a business service. The server may actually implement a subset of the capability statement it claims to implement, so the capability statement must specify the full capability details.)
7877     */
7878    public List<CanonicalType> getInstantiates() { 
7879      if (this.instantiates == null)
7880        this.instantiates = new ArrayList<CanonicalType>();
7881      return this.instantiates;
7882    }
7883
7884    /**
7885     * @return Returns a reference to <code>this</code> for easy method chaining
7886     */
7887    public CapabilityStatement setInstantiates(List<CanonicalType> theInstantiates) { 
7888      this.instantiates = theInstantiates;
7889      return this;
7890    }
7891
7892    public boolean hasInstantiates() { 
7893      if (this.instantiates == null)
7894        return false;
7895      for (CanonicalType item : this.instantiates)
7896        if (!item.isEmpty())
7897          return true;
7898      return false;
7899    }
7900
7901    /**
7902     * @return {@link #instantiates} (Reference to a canonical URL of another CapabilityStatement that this software implements. This capability statement is a published API description that corresponds to a business service. The server may actually implement a subset of the capability statement it claims to implement, so the capability statement must specify the full capability details.)
7903     */
7904    public CanonicalType addInstantiatesElement() {//2 
7905      CanonicalType t = new CanonicalType();
7906      if (this.instantiates == null)
7907        this.instantiates = new ArrayList<CanonicalType>();
7908      this.instantiates.add(t);
7909      return t;
7910    }
7911
7912    /**
7913     * @param value {@link #instantiates} (Reference to a canonical URL of another CapabilityStatement that this software implements. This capability statement is a published API description that corresponds to a business service. The server may actually implement a subset of the capability statement it claims to implement, so the capability statement must specify the full capability details.)
7914     */
7915    public CapabilityStatement addInstantiates(String value) { //1
7916      CanonicalType t = new CanonicalType();
7917      t.setValue(value);
7918      if (this.instantiates == null)
7919        this.instantiates = new ArrayList<CanonicalType>();
7920      this.instantiates.add(t);
7921      return this;
7922    }
7923
7924    /**
7925     * @param value {@link #instantiates} (Reference to a canonical URL of another CapabilityStatement that this software implements. This capability statement is a published API description that corresponds to a business service. The server may actually implement a subset of the capability statement it claims to implement, so the capability statement must specify the full capability details.)
7926     */
7927    public boolean hasInstantiates(String value) { 
7928      if (this.instantiates == null)
7929        return false;
7930      for (CanonicalType v : this.instantiates)
7931        if (v.getValue().equals(value)) // canonical
7932          return true;
7933      return false;
7934    }
7935
7936    /**
7937     * @return {@link #imports} (Reference to a canonical URL of another CapabilityStatement that this software adds to. The capability statement automatically includes everything in the other statement, and it is not duplicated, though the server may repeat the same resources, interactions and operations to add additional details to them.)
7938     */
7939    public List<CanonicalType> getImports() { 
7940      if (this.imports == null)
7941        this.imports = new ArrayList<CanonicalType>();
7942      return this.imports;
7943    }
7944
7945    /**
7946     * @return Returns a reference to <code>this</code> for easy method chaining
7947     */
7948    public CapabilityStatement setImports(List<CanonicalType> theImports) { 
7949      this.imports = theImports;
7950      return this;
7951    }
7952
7953    public boolean hasImports() { 
7954      if (this.imports == null)
7955        return false;
7956      for (CanonicalType item : this.imports)
7957        if (!item.isEmpty())
7958          return true;
7959      return false;
7960    }
7961
7962    /**
7963     * @return {@link #imports} (Reference to a canonical URL of another CapabilityStatement that this software adds to. The capability statement automatically includes everything in the other statement, and it is not duplicated, though the server may repeat the same resources, interactions and operations to add additional details to them.)
7964     */
7965    public CanonicalType addImportsElement() {//2 
7966      CanonicalType t = new CanonicalType();
7967      if (this.imports == null)
7968        this.imports = new ArrayList<CanonicalType>();
7969      this.imports.add(t);
7970      return t;
7971    }
7972
7973    /**
7974     * @param value {@link #imports} (Reference to a canonical URL of another CapabilityStatement that this software adds to. The capability statement automatically includes everything in the other statement, and it is not duplicated, though the server may repeat the same resources, interactions and operations to add additional details to them.)
7975     */
7976    public CapabilityStatement addImports(String value) { //1
7977      CanonicalType t = new CanonicalType();
7978      t.setValue(value);
7979      if (this.imports == null)
7980        this.imports = new ArrayList<CanonicalType>();
7981      this.imports.add(t);
7982      return this;
7983    }
7984
7985    /**
7986     * @param value {@link #imports} (Reference to a canonical URL of another CapabilityStatement that this software adds to. The capability statement automatically includes everything in the other statement, and it is not duplicated, though the server may repeat the same resources, interactions and operations to add additional details to them.)
7987     */
7988    public boolean hasImports(String value) { 
7989      if (this.imports == null)
7990        return false;
7991      for (CanonicalType v : this.imports)
7992        if (v.getValue().equals(value)) // canonical
7993          return true;
7994      return false;
7995    }
7996
7997    /**
7998     * @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.)
7999     */
8000    public CapabilityStatementSoftwareComponent getSoftware() { 
8001      if (this.software == null)
8002        if (Configuration.errorOnAutoCreate())
8003          throw new Error("Attempt to auto-create CapabilityStatement.software");
8004        else if (Configuration.doAutoCreate())
8005          this.software = new CapabilityStatementSoftwareComponent(); // cc
8006      return this.software;
8007    }
8008
8009    public boolean hasSoftware() { 
8010      return this.software != null && !this.software.isEmpty();
8011    }
8012
8013    /**
8014     * @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.)
8015     */
8016    public CapabilityStatement setSoftware(CapabilityStatementSoftwareComponent value) { 
8017      this.software = value;
8018      return this;
8019    }
8020
8021    /**
8022     * @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.)
8023     */
8024    public CapabilityStatementImplementationComponent getImplementation() { 
8025      if (this.implementation == null)
8026        if (Configuration.errorOnAutoCreate())
8027          throw new Error("Attempt to auto-create CapabilityStatement.implementation");
8028        else if (Configuration.doAutoCreate())
8029          this.implementation = new CapabilityStatementImplementationComponent(); // cc
8030      return this.implementation;
8031    }
8032
8033    public boolean hasImplementation() { 
8034      return this.implementation != null && !this.implementation.isEmpty();
8035    }
8036
8037    /**
8038     * @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.)
8039     */
8040    public CapabilityStatement setImplementation(CapabilityStatementImplementationComponent value) { 
8041      this.implementation = value;
8042      return this;
8043    }
8044
8045    /**
8046     * @return {@link #fhirVersion} (The version of the FHIR specification that this CapabilityStatement describes (which SHALL be the same as the FHIR version of the CapabilityStatement itself). There is no default value.). This is the underlying object with id, value and extensions. The accessor "getFhirVersion" gives direct access to the value
8047     */
8048    public Enumeration<FHIRVersion> getFhirVersionElement() { 
8049      if (this.fhirVersion == null)
8050        if (Configuration.errorOnAutoCreate())
8051          throw new Error("Attempt to auto-create CapabilityStatement.fhirVersion");
8052        else if (Configuration.doAutoCreate())
8053          this.fhirVersion = new Enumeration<FHIRVersion>(new FHIRVersionEnumFactory()); // bb
8054      return this.fhirVersion;
8055    }
8056
8057    public boolean hasFhirVersionElement() { 
8058      return this.fhirVersion != null && !this.fhirVersion.isEmpty();
8059    }
8060
8061    public boolean hasFhirVersion() { 
8062      return this.fhirVersion != null && !this.fhirVersion.isEmpty();
8063    }
8064
8065    /**
8066     * @param value {@link #fhirVersion} (The version of the FHIR specification that this CapabilityStatement describes (which SHALL be the same as the FHIR version of the CapabilityStatement itself). There is no default value.). This is the underlying object with id, value and extensions. The accessor "getFhirVersion" gives direct access to the value
8067     */
8068    public CapabilityStatement setFhirVersionElement(Enumeration<FHIRVersion> value) { 
8069      this.fhirVersion = value;
8070      return this;
8071    }
8072
8073    /**
8074     * @return The version of the FHIR specification that this CapabilityStatement describes (which SHALL be the same as the FHIR version of the CapabilityStatement itself). There is no default value.
8075     */
8076    public FHIRVersion getFhirVersion() { 
8077      return this.fhirVersion == null ? null : this.fhirVersion.getValue();
8078    }
8079
8080    /**
8081     * @param value The version of the FHIR specification that this CapabilityStatement describes (which SHALL be the same as the FHIR version of the CapabilityStatement itself). There is no default value.
8082     */
8083    public CapabilityStatement setFhirVersion(FHIRVersion value) { 
8084        if (this.fhirVersion == null)
8085          this.fhirVersion = new Enumeration<FHIRVersion>(new FHIRVersionEnumFactory());
8086        this.fhirVersion.setValue(value);
8087      return this;
8088    }
8089
8090    /**
8091     * @return {@link #format} (A list of the formats supported by this implementation using their content types.)
8092     */
8093    public List<CodeType> getFormat() { 
8094      if (this.format == null)
8095        this.format = new ArrayList<CodeType>();
8096      return this.format;
8097    }
8098
8099    /**
8100     * @return Returns a reference to <code>this</code> for easy method chaining
8101     */
8102    public CapabilityStatement setFormat(List<CodeType> theFormat) { 
8103      this.format = theFormat;
8104      return this;
8105    }
8106
8107    public boolean hasFormat() { 
8108      if (this.format == null)
8109        return false;
8110      for (CodeType item : this.format)
8111        if (!item.isEmpty())
8112          return true;
8113      return false;
8114    }
8115
8116    /**
8117     * @return {@link #format} (A list of the formats supported by this implementation using their content types.)
8118     */
8119    public CodeType addFormatElement() {//2 
8120      CodeType t = new CodeType();
8121      if (this.format == null)
8122        this.format = new ArrayList<CodeType>();
8123      this.format.add(t);
8124      return t;
8125    }
8126
8127    /**
8128     * @param value {@link #format} (A list of the formats supported by this implementation using their content types.)
8129     */
8130    public CapabilityStatement addFormat(String value) { //1
8131      CodeType t = new CodeType();
8132      t.setValue(value);
8133      if (this.format == null)
8134        this.format = new ArrayList<CodeType>();
8135      this.format.add(t);
8136      return this;
8137    }
8138
8139    /**
8140     * @param value {@link #format} (A list of the formats supported by this implementation using their content types.)
8141     */
8142    public boolean hasFormat(String value) { 
8143      if (this.format == null)
8144        return false;
8145      for (CodeType v : this.format)
8146        if (v.getValue().equals(value)) // code
8147          return true;
8148      return false;
8149    }
8150
8151    /**
8152     * @return {@link #patchFormat} (A list of the patch formats supported by this implementation using their content types.)
8153     */
8154    public List<CodeType> getPatchFormat() { 
8155      if (this.patchFormat == null)
8156        this.patchFormat = new ArrayList<CodeType>();
8157      return this.patchFormat;
8158    }
8159
8160    /**
8161     * @return Returns a reference to <code>this</code> for easy method chaining
8162     */
8163    public CapabilityStatement setPatchFormat(List<CodeType> thePatchFormat) { 
8164      this.patchFormat = thePatchFormat;
8165      return this;
8166    }
8167
8168    public boolean hasPatchFormat() { 
8169      if (this.patchFormat == null)
8170        return false;
8171      for (CodeType item : this.patchFormat)
8172        if (!item.isEmpty())
8173          return true;
8174      return false;
8175    }
8176
8177    /**
8178     * @return {@link #patchFormat} (A list of the patch formats supported by this implementation using their content types.)
8179     */
8180    public CodeType addPatchFormatElement() {//2 
8181      CodeType t = new CodeType();
8182      if (this.patchFormat == null)
8183        this.patchFormat = new ArrayList<CodeType>();
8184      this.patchFormat.add(t);
8185      return t;
8186    }
8187
8188    /**
8189     * @param value {@link #patchFormat} (A list of the patch formats supported by this implementation using their content types.)
8190     */
8191    public CapabilityStatement addPatchFormat(String value) { //1
8192      CodeType t = new CodeType();
8193      t.setValue(value);
8194      if (this.patchFormat == null)
8195        this.patchFormat = new ArrayList<CodeType>();
8196      this.patchFormat.add(t);
8197      return this;
8198    }
8199
8200    /**
8201     * @param value {@link #patchFormat} (A list of the patch formats supported by this implementation using their content types.)
8202     */
8203    public boolean hasPatchFormat(String value) { 
8204      if (this.patchFormat == null)
8205        return false;
8206      for (CodeType v : this.patchFormat)
8207        if (v.getValue().equals(value)) // code
8208          return true;
8209      return false;
8210    }
8211
8212    /**
8213     * @return {@link #acceptLanguage} (A list of the languages supported by this implementation that are usefully supported in the ```Accept-Language``` header.)
8214     */
8215    public List<CodeType> getAcceptLanguage() { 
8216      if (this.acceptLanguage == null)
8217        this.acceptLanguage = new ArrayList<CodeType>();
8218      return this.acceptLanguage;
8219    }
8220
8221    /**
8222     * @return Returns a reference to <code>this</code> for easy method chaining
8223     */
8224    public CapabilityStatement setAcceptLanguage(List<CodeType> theAcceptLanguage) { 
8225      this.acceptLanguage = theAcceptLanguage;
8226      return this;
8227    }
8228
8229    public boolean hasAcceptLanguage() { 
8230      if (this.acceptLanguage == null)
8231        return false;
8232      for (CodeType item : this.acceptLanguage)
8233        if (!item.isEmpty())
8234          return true;
8235      return false;
8236    }
8237
8238    /**
8239     * @return {@link #acceptLanguage} (A list of the languages supported by this implementation that are usefully supported in the ```Accept-Language``` header.)
8240     */
8241    public CodeType addAcceptLanguageElement() {//2 
8242      CodeType t = new CodeType();
8243      if (this.acceptLanguage == null)
8244        this.acceptLanguage = new ArrayList<CodeType>();
8245      this.acceptLanguage.add(t);
8246      return t;
8247    }
8248
8249    /**
8250     * @param value {@link #acceptLanguage} (A list of the languages supported by this implementation that are usefully supported in the ```Accept-Language``` header.)
8251     */
8252    public CapabilityStatement addAcceptLanguage(String value) { //1
8253      CodeType t = new CodeType();
8254      t.setValue(value);
8255      if (this.acceptLanguage == null)
8256        this.acceptLanguage = new ArrayList<CodeType>();
8257      this.acceptLanguage.add(t);
8258      return this;
8259    }
8260
8261    /**
8262     * @param value {@link #acceptLanguage} (A list of the languages supported by this implementation that are usefully supported in the ```Accept-Language``` header.)
8263     */
8264    public boolean hasAcceptLanguage(String value) { 
8265      if (this.acceptLanguage == null)
8266        return false;
8267      for (CodeType v : this.acceptLanguage)
8268        if (v.getValue().equals(value)) // code
8269          return true;
8270      return false;
8271    }
8272
8273    /**
8274     * @return {@link #implementationGuide} (A list of implementation guides that the server does (or should) support in their entirety.)
8275     */
8276    public List<CanonicalType> getImplementationGuide() { 
8277      if (this.implementationGuide == null)
8278        this.implementationGuide = new ArrayList<CanonicalType>();
8279      return this.implementationGuide;
8280    }
8281
8282    /**
8283     * @return Returns a reference to <code>this</code> for easy method chaining
8284     */
8285    public CapabilityStatement setImplementationGuide(List<CanonicalType> theImplementationGuide) { 
8286      this.implementationGuide = theImplementationGuide;
8287      return this;
8288    }
8289
8290    public boolean hasImplementationGuide() { 
8291      if (this.implementationGuide == null)
8292        return false;
8293      for (CanonicalType item : this.implementationGuide)
8294        if (!item.isEmpty())
8295          return true;
8296      return false;
8297    }
8298
8299    /**
8300     * @return {@link #implementationGuide} (A list of implementation guides that the server does (or should) support in their entirety.)
8301     */
8302    public CanonicalType addImplementationGuideElement() {//2 
8303      CanonicalType t = new CanonicalType();
8304      if (this.implementationGuide == null)
8305        this.implementationGuide = new ArrayList<CanonicalType>();
8306      this.implementationGuide.add(t);
8307      return t;
8308    }
8309
8310    /**
8311     * @param value {@link #implementationGuide} (A list of implementation guides that the server does (or should) support in their entirety.)
8312     */
8313    public CapabilityStatement addImplementationGuide(String value) { //1
8314      CanonicalType t = new CanonicalType();
8315      t.setValue(value);
8316      if (this.implementationGuide == null)
8317        this.implementationGuide = new ArrayList<CanonicalType>();
8318      this.implementationGuide.add(t);
8319      return this;
8320    }
8321
8322    /**
8323     * @param value {@link #implementationGuide} (A list of implementation guides that the server does (or should) support in their entirety.)
8324     */
8325    public boolean hasImplementationGuide(String value) { 
8326      if (this.implementationGuide == null)
8327        return false;
8328      for (CanonicalType v : this.implementationGuide)
8329        if (v.getValue().equals(value)) // canonical
8330          return true;
8331      return false;
8332    }
8333
8334    /**
8335     * @return {@link #rest} (A definition of the restful capabilities of the solution, if any.)
8336     */
8337    public List<CapabilityStatementRestComponent> getRest() { 
8338      if (this.rest == null)
8339        this.rest = new ArrayList<CapabilityStatementRestComponent>();
8340      return this.rest;
8341    }
8342
8343    /**
8344     * @return Returns a reference to <code>this</code> for easy method chaining
8345     */
8346    public CapabilityStatement setRest(List<CapabilityStatementRestComponent> theRest) { 
8347      this.rest = theRest;
8348      return this;
8349    }
8350
8351    public boolean hasRest() { 
8352      if (this.rest == null)
8353        return false;
8354      for (CapabilityStatementRestComponent item : this.rest)
8355        if (!item.isEmpty())
8356          return true;
8357      return false;
8358    }
8359
8360    public CapabilityStatementRestComponent addRest() { //3
8361      CapabilityStatementRestComponent t = new CapabilityStatementRestComponent();
8362      if (this.rest == null)
8363        this.rest = new ArrayList<CapabilityStatementRestComponent>();
8364      this.rest.add(t);
8365      return t;
8366    }
8367
8368    public CapabilityStatement addRest(CapabilityStatementRestComponent t) { //3
8369      if (t == null)
8370        return this;
8371      if (this.rest == null)
8372        this.rest = new ArrayList<CapabilityStatementRestComponent>();
8373      this.rest.add(t);
8374      return this;
8375    }
8376
8377    /**
8378     * @return The first repetition of repeating field {@link #rest}, creating it if it does not already exist {3}
8379     */
8380    public CapabilityStatementRestComponent getRestFirstRep() { 
8381      if (getRest().isEmpty()) {
8382        addRest();
8383      }
8384      return getRest().get(0);
8385    }
8386
8387    /**
8388     * @return {@link #messaging} (A description of the messaging capabilities of the solution.)
8389     */
8390    public List<CapabilityStatementMessagingComponent> getMessaging() { 
8391      if (this.messaging == null)
8392        this.messaging = new ArrayList<CapabilityStatementMessagingComponent>();
8393      return this.messaging;
8394    }
8395
8396    /**
8397     * @return Returns a reference to <code>this</code> for easy method chaining
8398     */
8399    public CapabilityStatement setMessaging(List<CapabilityStatementMessagingComponent> theMessaging) { 
8400      this.messaging = theMessaging;
8401      return this;
8402    }
8403
8404    public boolean hasMessaging() { 
8405      if (this.messaging == null)
8406        return false;
8407      for (CapabilityStatementMessagingComponent item : this.messaging)
8408        if (!item.isEmpty())
8409          return true;
8410      return false;
8411    }
8412
8413    public CapabilityStatementMessagingComponent addMessaging() { //3
8414      CapabilityStatementMessagingComponent t = new CapabilityStatementMessagingComponent();
8415      if (this.messaging == null)
8416        this.messaging = new ArrayList<CapabilityStatementMessagingComponent>();
8417      this.messaging.add(t);
8418      return t;
8419    }
8420
8421    public CapabilityStatement addMessaging(CapabilityStatementMessagingComponent t) { //3
8422      if (t == null)
8423        return this;
8424      if (this.messaging == null)
8425        this.messaging = new ArrayList<CapabilityStatementMessagingComponent>();
8426      this.messaging.add(t);
8427      return this;
8428    }
8429
8430    /**
8431     * @return The first repetition of repeating field {@link #messaging}, creating it if it does not already exist {3}
8432     */
8433    public CapabilityStatementMessagingComponent getMessagingFirstRep() { 
8434      if (getMessaging().isEmpty()) {
8435        addMessaging();
8436      }
8437      return getMessaging().get(0);
8438    }
8439
8440    /**
8441     * @return {@link #document} (A document definition.)
8442     */
8443    public List<CapabilityStatementDocumentComponent> getDocument() { 
8444      if (this.document == null)
8445        this.document = new ArrayList<CapabilityStatementDocumentComponent>();
8446      return this.document;
8447    }
8448
8449    /**
8450     * @return Returns a reference to <code>this</code> for easy method chaining
8451     */
8452    public CapabilityStatement setDocument(List<CapabilityStatementDocumentComponent> theDocument) { 
8453      this.document = theDocument;
8454      return this;
8455    }
8456
8457    public boolean hasDocument() { 
8458      if (this.document == null)
8459        return false;
8460      for (CapabilityStatementDocumentComponent item : this.document)
8461        if (!item.isEmpty())
8462          return true;
8463      return false;
8464    }
8465
8466    public CapabilityStatementDocumentComponent addDocument() { //3
8467      CapabilityStatementDocumentComponent t = new CapabilityStatementDocumentComponent();
8468      if (this.document == null)
8469        this.document = new ArrayList<CapabilityStatementDocumentComponent>();
8470      this.document.add(t);
8471      return t;
8472    }
8473
8474    public CapabilityStatement addDocument(CapabilityStatementDocumentComponent t) { //3
8475      if (t == null)
8476        return this;
8477      if (this.document == null)
8478        this.document = new ArrayList<CapabilityStatementDocumentComponent>();
8479      this.document.add(t);
8480      return this;
8481    }
8482
8483    /**
8484     * @return The first repetition of repeating field {@link #document}, creating it if it does not already exist {3}
8485     */
8486    public CapabilityStatementDocumentComponent getDocumentFirstRep() { 
8487      if (getDocument().isEmpty()) {
8488        addDocument();
8489      }
8490      return getDocument().get(0);
8491    }
8492
8493      protected void listChildren(List<Property> children) {
8494        super.listChildren(children);
8495        children.add(new Property("url", "uri", "An absolute URI that is used to identify this capability statement 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 an authoritative instance of this capability statement is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement is stored on different servers.", 0, 1, url));
8496        children.add(new Property("identifier", "Identifier", "A formal identifier that is used to identify this CapabilityStatement when it is represented in other formats, or referenced in a specification, model, design or an instance.", 0, java.lang.Integer.MAX_VALUE, identifier));
8497        children.add(new Property("version", "string", "The identifier that is used to identify this version of the capability statement when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement 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));
8498        children.add(new Property("versionAlgorithm[x]", "string|Coding", "Indicates the mechanism used to compare versions to determine which is more current.", 0, 1, versionAlgorithm));
8499        children.add(new Property("name", "string", "A natural language name identifying the capability statement. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name));
8500        children.add(new Property("title", "string", "A short, descriptive, user-friendly title for the capability statement.", 0, 1, title));
8501        children.add(new Property("status", "code", "The status of this capability statement. Enables tracking the life-cycle of the content.", 0, 1, status));
8502        children.add(new Property("experimental", "boolean", "A Boolean value to indicate that this capability statement is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.", 0, 1, experimental));
8503        children.add(new Property("date", "dateTime", "The date  (and optionally time) when the capability statement was last significantly changed. 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 statement changes.", 0, 1, date));
8504        children.add(new Property("publisher", "string", "The name of the organization or individual responsible for the release and ongoing maintenance of the capability statement.", 0, 1, publisher));
8505        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));
8506        children.add(new Property("description", "markdown", "A free text natural language description of the capability statement 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));
8507        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 statement instances.", 0, java.lang.Integer.MAX_VALUE, useContext));
8508        children.add(new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the capability statement is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction));
8509        children.add(new Property("purpose", "markdown", "Explanation of why this capability statement is needed and why it has been designed as it has.", 0, 1, purpose));
8510        children.add(new Property("copyright", "markdown", "A copyright statement relating to the capability statement and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement.", 0, 1, copyright));
8511        children.add(new Property("copyrightLabel", "string", "A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved').", 0, 1, copyrightLabel));
8512        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));
8513        children.add(new Property("instantiates", "canonical(CapabilityStatement)", "Reference to a canonical URL of another CapabilityStatement that this software implements. This capability statement is a published API description that corresponds to a business service. The server may actually implement a subset of the capability statement it claims to implement, so the capability statement must specify the full capability details.", 0, java.lang.Integer.MAX_VALUE, instantiates));
8514        children.add(new Property("imports", "canonical(CapabilityStatement)", "Reference to a canonical URL of another CapabilityStatement that this software adds to. The capability statement automatically includes everything in the other statement, and it is not duplicated, though the server may repeat the same resources, interactions and operations to add additional details to them.", 0, java.lang.Integer.MAX_VALUE, imports));
8515        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));
8516        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));
8517        children.add(new Property("fhirVersion", "code", "The version of the FHIR specification that this CapabilityStatement describes (which SHALL be the same as the FHIR version of the CapabilityStatement itself). There is no default value.", 0, 1, fhirVersion));
8518        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));
8519        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));
8520        children.add(new Property("acceptLanguage", "code", "A list of the languages supported by this implementation that are usefully supported in the ```Accept-Language``` header.", 0, java.lang.Integer.MAX_VALUE, acceptLanguage));
8521        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));
8522        children.add(new Property("rest", "", "A definition of the restful capabilities of the solution, if any.", 0, java.lang.Integer.MAX_VALUE, rest));
8523        children.add(new Property("messaging", "", "A description of the messaging capabilities of the solution.", 0, java.lang.Integer.MAX_VALUE, messaging));
8524        children.add(new Property("document", "", "A document definition.", 0, java.lang.Integer.MAX_VALUE, document));
8525      }
8526
8527      @Override
8528      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
8529        switch (_hash) {
8530        case 116079: /*url*/  return new Property("url", "uri", "An absolute URI that is used to identify this capability statement 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 an authoritative instance of this capability statement is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the capability statement is stored on different servers.", 0, 1, url);
8531        case -1618432855: /*identifier*/  return new Property("identifier", "Identifier", "A formal identifier that is used to identify this CapabilityStatement when it is represented in other formats, or referenced in a specification, model, design or an instance.", 0, java.lang.Integer.MAX_VALUE, identifier);
8532        case 351608024: /*version*/  return new Property("version", "string", "The identifier that is used to identify this version of the capability statement when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the capability statement 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);
8533        case -115699031: /*versionAlgorithm[x]*/  return new Property("versionAlgorithm[x]", "string|Coding", "Indicates the mechanism used to compare versions to determine which is more current.", 0, 1, versionAlgorithm);
8534        case 1508158071: /*versionAlgorithm*/  return new Property("versionAlgorithm[x]", "string|Coding", "Indicates the mechanism used to compare versions to determine which is more current.", 0, 1, versionAlgorithm);
8535        case 1836908904: /*versionAlgorithmString*/  return new Property("versionAlgorithm[x]", "string", "Indicates the mechanism used to compare versions to determine which is more current.", 0, 1, versionAlgorithm);
8536        case 1373807809: /*versionAlgorithmCoding*/  return new Property("versionAlgorithm[x]", "Coding", "Indicates the mechanism used to compare versions to determine which is more current.", 0, 1, versionAlgorithm);
8537        case 3373707: /*name*/  return new Property("name", "string", "A natural language name identifying the capability statement. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name);
8538        case 110371416: /*title*/  return new Property("title", "string", "A short, descriptive, user-friendly title for the capability statement.", 0, 1, title);
8539        case -892481550: /*status*/  return new Property("status", "code", "The status of this capability statement. Enables tracking the life-cycle of the content.", 0, 1, status);
8540        case -404562712: /*experimental*/  return new Property("experimental", "boolean", "A Boolean value to indicate that this capability statement is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.", 0, 1, experimental);
8541        case 3076014: /*date*/  return new Property("date", "dateTime", "The date  (and optionally time) when the capability statement was last significantly changed. 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 statement changes.", 0, 1, date);
8542        case 1447404028: /*publisher*/  return new Property("publisher", "string", "The name of the organization or individual responsible for the release and ongoing maintenance of the capability statement.", 0, 1, publisher);
8543        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);
8544        case -1724546052: /*description*/  return new Property("description", "markdown", "A free text natural language description of the capability statement 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);
8545        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 statement instances.", 0, java.lang.Integer.MAX_VALUE, useContext);
8546        case -507075711: /*jurisdiction*/  return new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the capability statement is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction);
8547        case -220463842: /*purpose*/  return new Property("purpose", "markdown", "Explanation of why this capability statement is needed and why it has been designed as it has.", 0, 1, purpose);
8548        case 1522889671: /*copyright*/  return new Property("copyright", "markdown", "A copyright statement relating to the capability statement and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the capability statement.", 0, 1, copyright);
8549        case 765157229: /*copyrightLabel*/  return new Property("copyrightLabel", "string", "A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved').", 0, 1, copyrightLabel);
8550        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);
8551        case -246883639: /*instantiates*/  return new Property("instantiates", "canonical(CapabilityStatement)", "Reference to a canonical URL of another CapabilityStatement that this software implements. This capability statement is a published API description that corresponds to a business service. The server may actually implement a subset of the capability statement it claims to implement, so the capability statement must specify the full capability details.", 0, java.lang.Integer.MAX_VALUE, instantiates);
8552        case 1926037870: /*imports*/  return new Property("imports", "canonical(CapabilityStatement)", "Reference to a canonical URL of another CapabilityStatement that this software adds to. The capability statement automatically includes everything in the other statement, and it is not duplicated, though the server may repeat the same resources, interactions and operations to add additional details to them.", 0, java.lang.Integer.MAX_VALUE, imports);
8553        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);
8554        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);
8555        case 461006061: /*fhirVersion*/  return new Property("fhirVersion", "code", "The version of the FHIR specification that this CapabilityStatement describes (which SHALL be the same as the FHIR version of the CapabilityStatement itself). There is no default value.", 0, 1, fhirVersion);
8556        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);
8557        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);
8558        case 1014178944: /*acceptLanguage*/  return new Property("acceptLanguage", "code", "A list of the languages supported by this implementation that are usefully supported in the ```Accept-Language``` header.", 0, java.lang.Integer.MAX_VALUE, acceptLanguage);
8559        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);
8560        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);
8561        case -1440008444: /*messaging*/  return new Property("messaging", "", "A description of the messaging capabilities of the solution.", 0, java.lang.Integer.MAX_VALUE, messaging);
8562        case 861720859: /*document*/  return new Property("document", "", "A document definition.", 0, java.lang.Integer.MAX_VALUE, document);
8563        default: return super.getNamedProperty(_hash, _name, _checkValid);
8564        }
8565
8566      }
8567
8568      @Override
8569      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
8570        switch (hash) {
8571        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType
8572        case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier
8573        case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType
8574        case 1508158071: /*versionAlgorithm*/ return this.versionAlgorithm == null ? new Base[0] : new Base[] {this.versionAlgorithm}; // DataType
8575        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
8576        case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType
8577        case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<PublicationStatus>
8578        case -404562712: /*experimental*/ return this.experimental == null ? new Base[0] : new Base[] {this.experimental}; // BooleanType
8579        case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType
8580        case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType
8581        case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail
8582        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType
8583        case -669707736: /*useContext*/ return this.useContext == null ? new Base[0] : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext
8584        case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept
8585        case -220463842: /*purpose*/ return this.purpose == null ? new Base[0] : new Base[] {this.purpose}; // MarkdownType
8586        case 1522889671: /*copyright*/ return this.copyright == null ? new Base[0] : new Base[] {this.copyright}; // MarkdownType
8587        case 765157229: /*copyrightLabel*/ return this.copyrightLabel == null ? new Base[0] : new Base[] {this.copyrightLabel}; // StringType
8588        case 3292052: /*kind*/ return this.kind == null ? new Base[0] : new Base[] {this.kind}; // Enumeration<CapabilityStatementKind>
8589        case -246883639: /*instantiates*/ return this.instantiates == null ? new Base[0] : this.instantiates.toArray(new Base[this.instantiates.size()]); // CanonicalType
8590        case 1926037870: /*imports*/ return this.imports == null ? new Base[0] : this.imports.toArray(new Base[this.imports.size()]); // CanonicalType
8591        case 1319330215: /*software*/ return this.software == null ? new Base[0] : new Base[] {this.software}; // CapabilityStatementSoftwareComponent
8592        case 1683336114: /*implementation*/ return this.implementation == null ? new Base[0] : new Base[] {this.implementation}; // CapabilityStatementImplementationComponent
8593        case 461006061: /*fhirVersion*/ return this.fhirVersion == null ? new Base[0] : new Base[] {this.fhirVersion}; // Enumeration<FHIRVersion>
8594        case -1268779017: /*format*/ return this.format == null ? new Base[0] : this.format.toArray(new Base[this.format.size()]); // CodeType
8595        case 172338783: /*patchFormat*/ return this.patchFormat == null ? new Base[0] : this.patchFormat.toArray(new Base[this.patchFormat.size()]); // CodeType
8596        case 1014178944: /*acceptLanguage*/ return this.acceptLanguage == null ? new Base[0] : this.acceptLanguage.toArray(new Base[this.acceptLanguage.size()]); // CodeType
8597        case 156966506: /*implementationGuide*/ return this.implementationGuide == null ? new Base[0] : this.implementationGuide.toArray(new Base[this.implementationGuide.size()]); // CanonicalType
8598        case 3496916: /*rest*/ return this.rest == null ? new Base[0] : this.rest.toArray(new Base[this.rest.size()]); // CapabilityStatementRestComponent
8599        case -1440008444: /*messaging*/ return this.messaging == null ? new Base[0] : this.messaging.toArray(new Base[this.messaging.size()]); // CapabilityStatementMessagingComponent
8600        case 861720859: /*document*/ return this.document == null ? new Base[0] : this.document.toArray(new Base[this.document.size()]); // CapabilityStatementDocumentComponent
8601        default: return super.getProperty(hash, name, checkValid);
8602        }
8603
8604      }
8605
8606      @Override
8607      public Base setProperty(int hash, String name, Base value) throws FHIRException {
8608        switch (hash) {
8609        case 116079: // url
8610          this.url = TypeConvertor.castToUri(value); // UriType
8611          return value;
8612        case -1618432855: // identifier
8613          this.getIdentifier().add(TypeConvertor.castToIdentifier(value)); // Identifier
8614          return value;
8615        case 351608024: // version
8616          this.version = TypeConvertor.castToString(value); // StringType
8617          return value;
8618        case 1508158071: // versionAlgorithm
8619          this.versionAlgorithm = TypeConvertor.castToType(value); // DataType
8620          return value;
8621        case 3373707: // name
8622          this.name = TypeConvertor.castToString(value); // StringType
8623          return value;
8624        case 110371416: // title
8625          this.title = TypeConvertor.castToString(value); // StringType
8626          return value;
8627        case -892481550: // status
8628          value = new PublicationStatusEnumFactory().fromType(TypeConvertor.castToCode(value));
8629          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
8630          return value;
8631        case -404562712: // experimental
8632          this.experimental = TypeConvertor.castToBoolean(value); // BooleanType
8633          return value;
8634        case 3076014: // date
8635          this.date = TypeConvertor.castToDateTime(value); // DateTimeType
8636          return value;
8637        case 1447404028: // publisher
8638          this.publisher = TypeConvertor.castToString(value); // StringType
8639          return value;
8640        case 951526432: // contact
8641          this.getContact().add(TypeConvertor.castToContactDetail(value)); // ContactDetail
8642          return value;
8643        case -1724546052: // description
8644          this.description = TypeConvertor.castToMarkdown(value); // MarkdownType
8645          return value;
8646        case -669707736: // useContext
8647          this.getUseContext().add(TypeConvertor.castToUsageContext(value)); // UsageContext
8648          return value;
8649        case -507075711: // jurisdiction
8650          this.getJurisdiction().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept
8651          return value;
8652        case -220463842: // purpose
8653          this.purpose = TypeConvertor.castToMarkdown(value); // MarkdownType
8654          return value;
8655        case 1522889671: // copyright
8656          this.copyright = TypeConvertor.castToMarkdown(value); // MarkdownType
8657          return value;
8658        case 765157229: // copyrightLabel
8659          this.copyrightLabel = TypeConvertor.castToString(value); // StringType
8660          return value;
8661        case 3292052: // kind
8662          value = new CapabilityStatementKindEnumFactory().fromType(TypeConvertor.castToCode(value));
8663          this.kind = (Enumeration) value; // Enumeration<CapabilityStatementKind>
8664          return value;
8665        case -246883639: // instantiates
8666          this.getInstantiates().add(TypeConvertor.castToCanonical(value)); // CanonicalType
8667          return value;
8668        case 1926037870: // imports
8669          this.getImports().add(TypeConvertor.castToCanonical(value)); // CanonicalType
8670          return value;
8671        case 1319330215: // software
8672          this.software = (CapabilityStatementSoftwareComponent) value; // CapabilityStatementSoftwareComponent
8673          return value;
8674        case 1683336114: // implementation
8675          this.implementation = (CapabilityStatementImplementationComponent) value; // CapabilityStatementImplementationComponent
8676          return value;
8677        case 461006061: // fhirVersion
8678          value = new FHIRVersionEnumFactory().fromType(TypeConvertor.castToCode(value));
8679          this.fhirVersion = (Enumeration) value; // Enumeration<FHIRVersion>
8680          return value;
8681        case -1268779017: // format
8682          this.getFormat().add(TypeConvertor.castToCode(value)); // CodeType
8683          return value;
8684        case 172338783: // patchFormat
8685          this.getPatchFormat().add(TypeConvertor.castToCode(value)); // CodeType
8686          return value;
8687        case 1014178944: // acceptLanguage
8688          this.getAcceptLanguage().add(TypeConvertor.castToCode(value)); // CodeType
8689          return value;
8690        case 156966506: // implementationGuide
8691          this.getImplementationGuide().add(TypeConvertor.castToCanonical(value)); // CanonicalType
8692          return value;
8693        case 3496916: // rest
8694          this.getRest().add((CapabilityStatementRestComponent) value); // CapabilityStatementRestComponent
8695          return value;
8696        case -1440008444: // messaging
8697          this.getMessaging().add((CapabilityStatementMessagingComponent) value); // CapabilityStatementMessagingComponent
8698          return value;
8699        case 861720859: // document
8700          this.getDocument().add((CapabilityStatementDocumentComponent) value); // CapabilityStatementDocumentComponent
8701          return value;
8702        default: return super.setProperty(hash, name, value);
8703        }
8704
8705      }
8706
8707      @Override
8708      public Base setProperty(String name, Base value) throws FHIRException {
8709        if (name.equals("url")) {
8710          this.url = TypeConvertor.castToUri(value); // UriType
8711        } else if (name.equals("identifier")) {
8712          this.getIdentifier().add(TypeConvertor.castToIdentifier(value));
8713        } else if (name.equals("version")) {
8714          this.version = TypeConvertor.castToString(value); // StringType
8715        } else if (name.equals("versionAlgorithm[x]")) {
8716          this.versionAlgorithm = TypeConvertor.castToType(value); // DataType
8717        } else if (name.equals("name")) {
8718          this.name = TypeConvertor.castToString(value); // StringType
8719        } else if (name.equals("title")) {
8720          this.title = TypeConvertor.castToString(value); // StringType
8721        } else if (name.equals("status")) {
8722          value = new PublicationStatusEnumFactory().fromType(TypeConvertor.castToCode(value));
8723          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
8724        } else if (name.equals("experimental")) {
8725          this.experimental = TypeConvertor.castToBoolean(value); // BooleanType
8726        } else if (name.equals("date")) {
8727          this.date = TypeConvertor.castToDateTime(value); // DateTimeType
8728        } else if (name.equals("publisher")) {
8729          this.publisher = TypeConvertor.castToString(value); // StringType
8730        } else if (name.equals("contact")) {
8731          this.getContact().add(TypeConvertor.castToContactDetail(value));
8732        } else if (name.equals("description")) {
8733          this.description = TypeConvertor.castToMarkdown(value); // MarkdownType
8734        } else if (name.equals("useContext")) {
8735          this.getUseContext().add(TypeConvertor.castToUsageContext(value));
8736        } else if (name.equals("jurisdiction")) {
8737          this.getJurisdiction().add(TypeConvertor.castToCodeableConcept(value));
8738        } else if (name.equals("purpose")) {
8739          this.purpose = TypeConvertor.castToMarkdown(value); // MarkdownType
8740        } else if (name.equals("copyright")) {
8741          this.copyright = TypeConvertor.castToMarkdown(value); // MarkdownType
8742        } else if (name.equals("copyrightLabel")) {
8743          this.copyrightLabel = TypeConvertor.castToString(value); // StringType
8744        } else if (name.equals("kind")) {
8745          value = new CapabilityStatementKindEnumFactory().fromType(TypeConvertor.castToCode(value));
8746          this.kind = (Enumeration) value; // Enumeration<CapabilityStatementKind>
8747        } else if (name.equals("instantiates")) {
8748          this.getInstantiates().add(TypeConvertor.castToCanonical(value));
8749        } else if (name.equals("imports")) {
8750          this.getImports().add(TypeConvertor.castToCanonical(value));
8751        } else if (name.equals("software")) {
8752          this.software = (CapabilityStatementSoftwareComponent) value; // CapabilityStatementSoftwareComponent
8753        } else if (name.equals("implementation")) {
8754          this.implementation = (CapabilityStatementImplementationComponent) value; // CapabilityStatementImplementationComponent
8755        } else if (name.equals("fhirVersion")) {
8756          value = new FHIRVersionEnumFactory().fromType(TypeConvertor.castToCode(value));
8757          this.fhirVersion = (Enumeration) value; // Enumeration<FHIRVersion>
8758        } else if (name.equals("format")) {
8759          this.getFormat().add(TypeConvertor.castToCode(value));
8760        } else if (name.equals("patchFormat")) {
8761          this.getPatchFormat().add(TypeConvertor.castToCode(value));
8762        } else if (name.equals("acceptLanguage")) {
8763          this.getAcceptLanguage().add(TypeConvertor.castToCode(value));
8764        } else if (name.equals("implementationGuide")) {
8765          this.getImplementationGuide().add(TypeConvertor.castToCanonical(value));
8766        } else if (name.equals("rest")) {
8767          this.getRest().add((CapabilityStatementRestComponent) value);
8768        } else if (name.equals("messaging")) {
8769          this.getMessaging().add((CapabilityStatementMessagingComponent) value);
8770        } else if (name.equals("document")) {
8771          this.getDocument().add((CapabilityStatementDocumentComponent) value);
8772        } else
8773          return super.setProperty(name, value);
8774        return value;
8775      }
8776
8777      @Override
8778      public Base makeProperty(int hash, String name) throws FHIRException {
8779        switch (hash) {
8780        case 116079:  return getUrlElement();
8781        case -1618432855:  return addIdentifier(); 
8782        case 351608024:  return getVersionElement();
8783        case -115699031:  return getVersionAlgorithm();
8784        case 1508158071:  return getVersionAlgorithm();
8785        case 3373707:  return getNameElement();
8786        case 110371416:  return getTitleElement();
8787        case -892481550:  return getStatusElement();
8788        case -404562712:  return getExperimentalElement();
8789        case 3076014:  return getDateElement();
8790        case 1447404028:  return getPublisherElement();
8791        case 951526432:  return addContact(); 
8792        case -1724546052:  return getDescriptionElement();
8793        case -669707736:  return addUseContext(); 
8794        case -507075711:  return addJurisdiction(); 
8795        case -220463842:  return getPurposeElement();
8796        case 1522889671:  return getCopyrightElement();
8797        case 765157229:  return getCopyrightLabelElement();
8798        case 3292052:  return getKindElement();
8799        case -246883639:  return addInstantiatesElement();
8800        case 1926037870:  return addImportsElement();
8801        case 1319330215:  return getSoftware();
8802        case 1683336114:  return getImplementation();
8803        case 461006061:  return getFhirVersionElement();
8804        case -1268779017:  return addFormatElement();
8805        case 172338783:  return addPatchFormatElement();
8806        case 1014178944:  return addAcceptLanguageElement();
8807        case 156966506:  return addImplementationGuideElement();
8808        case 3496916:  return addRest(); 
8809        case -1440008444:  return addMessaging(); 
8810        case 861720859:  return addDocument(); 
8811        default: return super.makeProperty(hash, name);
8812        }
8813
8814      }
8815
8816      @Override
8817      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
8818        switch (hash) {
8819        case 116079: /*url*/ return new String[] {"uri"};
8820        case -1618432855: /*identifier*/ return new String[] {"Identifier"};
8821        case 351608024: /*version*/ return new String[] {"string"};
8822        case 1508158071: /*versionAlgorithm*/ return new String[] {"string", "Coding"};
8823        case 3373707: /*name*/ return new String[] {"string"};
8824        case 110371416: /*title*/ return new String[] {"string"};
8825        case -892481550: /*status*/ return new String[] {"code"};
8826        case -404562712: /*experimental*/ return new String[] {"boolean"};
8827        case 3076014: /*date*/ return new String[] {"dateTime"};
8828        case 1447404028: /*publisher*/ return new String[] {"string"};
8829        case 951526432: /*contact*/ return new String[] {"ContactDetail"};
8830        case -1724546052: /*description*/ return new String[] {"markdown"};
8831        case -669707736: /*useContext*/ return new String[] {"UsageContext"};
8832        case -507075711: /*jurisdiction*/ return new String[] {"CodeableConcept"};
8833        case -220463842: /*purpose*/ return new String[] {"markdown"};
8834        case 1522889671: /*copyright*/ return new String[] {"markdown"};
8835        case 765157229: /*copyrightLabel*/ return new String[] {"string"};
8836        case 3292052: /*kind*/ return new String[] {"code"};
8837        case -246883639: /*instantiates*/ return new String[] {"canonical"};
8838        case 1926037870: /*imports*/ return new String[] {"canonical"};
8839        case 1319330215: /*software*/ return new String[] {};
8840        case 1683336114: /*implementation*/ return new String[] {};
8841        case 461006061: /*fhirVersion*/ return new String[] {"code"};
8842        case -1268779017: /*format*/ return new String[] {"code"};
8843        case 172338783: /*patchFormat*/ return new String[] {"code"};
8844        case 1014178944: /*acceptLanguage*/ return new String[] {"code"};
8845        case 156966506: /*implementationGuide*/ return new String[] {"canonical"};
8846        case 3496916: /*rest*/ return new String[] {};
8847        case -1440008444: /*messaging*/ return new String[] {};
8848        case 861720859: /*document*/ return new String[] {};
8849        default: return super.getTypesForProperty(hash, name);
8850        }
8851
8852      }
8853
8854      @Override
8855      public Base addChild(String name) throws FHIRException {
8856        if (name.equals("url")) {
8857          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.url");
8858        }
8859        else if (name.equals("identifier")) {
8860          return addIdentifier();
8861        }
8862        else if (name.equals("version")) {
8863          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.version");
8864        }
8865        else if (name.equals("versionAlgorithmString")) {
8866          this.versionAlgorithm = new StringType();
8867          return this.versionAlgorithm;
8868        }
8869        else if (name.equals("versionAlgorithmCoding")) {
8870          this.versionAlgorithm = new Coding();
8871          return this.versionAlgorithm;
8872        }
8873        else if (name.equals("name")) {
8874          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.name");
8875        }
8876        else if (name.equals("title")) {
8877          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.title");
8878        }
8879        else if (name.equals("status")) {
8880          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.status");
8881        }
8882        else if (name.equals("experimental")) {
8883          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.experimental");
8884        }
8885        else if (name.equals("date")) {
8886          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.date");
8887        }
8888        else if (name.equals("publisher")) {
8889          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.publisher");
8890        }
8891        else if (name.equals("contact")) {
8892          return addContact();
8893        }
8894        else if (name.equals("description")) {
8895          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.description");
8896        }
8897        else if (name.equals("useContext")) {
8898          return addUseContext();
8899        }
8900        else if (name.equals("jurisdiction")) {
8901          return addJurisdiction();
8902        }
8903        else if (name.equals("purpose")) {
8904          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.purpose");
8905        }
8906        else if (name.equals("copyright")) {
8907          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.copyright");
8908        }
8909        else if (name.equals("copyrightLabel")) {
8910          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.copyrightLabel");
8911        }
8912        else if (name.equals("kind")) {
8913          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.kind");
8914        }
8915        else if (name.equals("instantiates")) {
8916          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.instantiates");
8917        }
8918        else if (name.equals("imports")) {
8919          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.imports");
8920        }
8921        else if (name.equals("software")) {
8922          this.software = new CapabilityStatementSoftwareComponent();
8923          return this.software;
8924        }
8925        else if (name.equals("implementation")) {
8926          this.implementation = new CapabilityStatementImplementationComponent();
8927          return this.implementation;
8928        }
8929        else if (name.equals("fhirVersion")) {
8930          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.fhirVersion");
8931        }
8932        else if (name.equals("format")) {
8933          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.format");
8934        }
8935        else if (name.equals("patchFormat")) {
8936          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.patchFormat");
8937        }
8938        else if (name.equals("acceptLanguage")) {
8939          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.acceptLanguage");
8940        }
8941        else if (name.equals("implementationGuide")) {
8942          throw new FHIRException("Cannot call addChild on a singleton property CapabilityStatement.implementationGuide");
8943        }
8944        else if (name.equals("rest")) {
8945          return addRest();
8946        }
8947        else if (name.equals("messaging")) {
8948          return addMessaging();
8949        }
8950        else if (name.equals("document")) {
8951          return addDocument();
8952        }
8953        else
8954          return super.addChild(name);
8955      }
8956
8957  public String fhirType() {
8958    return "CapabilityStatement";
8959
8960  }
8961
8962      public CapabilityStatement copy() {
8963        CapabilityStatement dst = new CapabilityStatement();
8964        copyValues(dst);
8965        return dst;
8966      }
8967
8968      public void copyValues(CapabilityStatement dst) {
8969        super.copyValues(dst);
8970        dst.url = url == null ? null : url.copy();
8971        if (identifier != null) {
8972          dst.identifier = new ArrayList<Identifier>();
8973          for (Identifier i : identifier)
8974            dst.identifier.add(i.copy());
8975        };
8976        dst.version = version == null ? null : version.copy();
8977        dst.versionAlgorithm = versionAlgorithm == null ? null : versionAlgorithm.copy();
8978        dst.name = name == null ? null : name.copy();
8979        dst.title = title == null ? null : title.copy();
8980        dst.status = status == null ? null : status.copy();
8981        dst.experimental = experimental == null ? null : experimental.copy();
8982        dst.date = date == null ? null : date.copy();
8983        dst.publisher = publisher == null ? null : publisher.copy();
8984        if (contact != null) {
8985          dst.contact = new ArrayList<ContactDetail>();
8986          for (ContactDetail i : contact)
8987            dst.contact.add(i.copy());
8988        };
8989        dst.description = description == null ? null : description.copy();
8990        if (useContext != null) {
8991          dst.useContext = new ArrayList<UsageContext>();
8992          for (UsageContext i : useContext)
8993            dst.useContext.add(i.copy());
8994        };
8995        if (jurisdiction != null) {
8996          dst.jurisdiction = new ArrayList<CodeableConcept>();
8997          for (CodeableConcept i : jurisdiction)
8998            dst.jurisdiction.add(i.copy());
8999        };
9000        dst.purpose = purpose == null ? null : purpose.copy();
9001        dst.copyright = copyright == null ? null : copyright.copy();
9002        dst.copyrightLabel = copyrightLabel == null ? null : copyrightLabel.copy();
9003        dst.kind = kind == null ? null : kind.copy();
9004        if (instantiates != null) {
9005          dst.instantiates = new ArrayList<CanonicalType>();
9006          for (CanonicalType i : instantiates)
9007            dst.instantiates.add(i.copy());
9008        };
9009        if (imports != null) {
9010          dst.imports = new ArrayList<CanonicalType>();
9011          for (CanonicalType i : imports)
9012            dst.imports.add(i.copy());
9013        };
9014        dst.software = software == null ? null : software.copy();
9015        dst.implementation = implementation == null ? null : implementation.copy();
9016        dst.fhirVersion = fhirVersion == null ? null : fhirVersion.copy();
9017        if (format != null) {
9018          dst.format = new ArrayList<CodeType>();
9019          for (CodeType i : format)
9020            dst.format.add(i.copy());
9021        };
9022        if (patchFormat != null) {
9023          dst.patchFormat = new ArrayList<CodeType>();
9024          for (CodeType i : patchFormat)
9025            dst.patchFormat.add(i.copy());
9026        };
9027        if (acceptLanguage != null) {
9028          dst.acceptLanguage = new ArrayList<CodeType>();
9029          for (CodeType i : acceptLanguage)
9030            dst.acceptLanguage.add(i.copy());
9031        };
9032        if (implementationGuide != null) {
9033          dst.implementationGuide = new ArrayList<CanonicalType>();
9034          for (CanonicalType i : implementationGuide)
9035            dst.implementationGuide.add(i.copy());
9036        };
9037        if (rest != null) {
9038          dst.rest = new ArrayList<CapabilityStatementRestComponent>();
9039          for (CapabilityStatementRestComponent i : rest)
9040            dst.rest.add(i.copy());
9041        };
9042        if (messaging != null) {
9043          dst.messaging = new ArrayList<CapabilityStatementMessagingComponent>();
9044          for (CapabilityStatementMessagingComponent i : messaging)
9045            dst.messaging.add(i.copy());
9046        };
9047        if (document != null) {
9048          dst.document = new ArrayList<CapabilityStatementDocumentComponent>();
9049          for (CapabilityStatementDocumentComponent i : document)
9050            dst.document.add(i.copy());
9051        };
9052      }
9053
9054      protected CapabilityStatement typedCopy() {
9055        return copy();
9056      }
9057
9058      @Override
9059      public boolean equalsDeep(Base other_) {
9060        if (!super.equalsDeep(other_))
9061          return false;
9062        if (!(other_ instanceof CapabilityStatement))
9063          return false;
9064        CapabilityStatement o = (CapabilityStatement) other_;
9065        return compareDeep(url, o.url, true) && compareDeep(identifier, o.identifier, true) && compareDeep(version, o.version, true)
9066           && compareDeep(versionAlgorithm, o.versionAlgorithm, true) && compareDeep(name, o.name, true) && compareDeep(title, o.title, true)
9067           && compareDeep(status, o.status, true) && compareDeep(experimental, o.experimental, true) && compareDeep(date, o.date, true)
9068           && compareDeep(publisher, o.publisher, true) && compareDeep(contact, o.contact, true) && compareDeep(description, o.description, true)
9069           && compareDeep(useContext, o.useContext, true) && compareDeep(jurisdiction, o.jurisdiction, true)
9070           && compareDeep(purpose, o.purpose, true) && compareDeep(copyright, o.copyright, true) && compareDeep(copyrightLabel, o.copyrightLabel, true)
9071           && compareDeep(kind, o.kind, true) && compareDeep(instantiates, o.instantiates, true) && compareDeep(imports, o.imports, true)
9072           && compareDeep(software, o.software, true) && compareDeep(implementation, o.implementation, true)
9073           && compareDeep(fhirVersion, o.fhirVersion, true) && compareDeep(format, o.format, true) && compareDeep(patchFormat, o.patchFormat, true)
9074           && compareDeep(acceptLanguage, o.acceptLanguage, true) && compareDeep(implementationGuide, o.implementationGuide, true)
9075           && compareDeep(rest, o.rest, true) && compareDeep(messaging, o.messaging, true) && compareDeep(document, o.document, true)
9076          ;
9077      }
9078
9079      @Override
9080      public boolean equalsShallow(Base other_) {
9081        if (!super.equalsShallow(other_))
9082          return false;
9083        if (!(other_ instanceof CapabilityStatement))
9084          return false;
9085        CapabilityStatement o = (CapabilityStatement) other_;
9086        return compareValues(url, o.url, true) && compareValues(version, o.version, true) && compareValues(name, o.name, true)
9087           && compareValues(title, o.title, true) && compareValues(status, o.status, true) && compareValues(experimental, o.experimental, true)
9088           && compareValues(date, o.date, true) && compareValues(publisher, o.publisher, true) && compareValues(description, o.description, true)
9089           && compareValues(purpose, o.purpose, true) && compareValues(copyright, o.copyright, true) && compareValues(copyrightLabel, o.copyrightLabel, true)
9090           && compareValues(kind, o.kind, true) && compareValues(instantiates, o.instantiates, true) && compareValues(imports, o.imports, true)
9091           && compareValues(fhirVersion, o.fhirVersion, true) && compareValues(format, o.format, true) && compareValues(patchFormat, o.patchFormat, true)
9092           && compareValues(acceptLanguage, o.acceptLanguage, true) && compareValues(implementationGuide, o.implementationGuide, true)
9093          ;
9094      }
9095
9096      public boolean isEmpty() {
9097        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(url, identifier, version
9098          , versionAlgorithm, name, title, status, experimental, date, publisher, contact
9099          , description, useContext, jurisdiction, purpose, copyright, copyrightLabel, kind
9100          , instantiates, imports, software, implementation, fhirVersion, format, patchFormat
9101          , acceptLanguage, implementationGuide, rest, messaging, document);
9102      }
9103
9104  @Override
9105  public ResourceType getResourceType() {
9106    return ResourceType.CapabilityStatement;
9107   }
9108
9109 /**
9110   * Search parameter: <b>context-quantity</b>
9111   * <p>
9112   * Description: <b>Multiple Resources: 
9113
9114* [ActivityDefinition](activitydefinition.html): A quantity- or range-valued use context assigned to the activity definition
9115* [ActorDefinition](actordefinition.html): A quantity- or range-valued use context assigned to the Actor Definition
9116* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement
9117* [ChargeItemDefinition](chargeitemdefinition.html): A quantity- or range-valued use context assigned to the charge item definition
9118* [Citation](citation.html): A quantity- or range-valued use context assigned to the citation
9119* [CodeSystem](codesystem.html): A quantity- or range-valued use context assigned to the code system
9120* [CompartmentDefinition](compartmentdefinition.html): A quantity- or range-valued use context assigned to the compartment definition
9121* [ConceptMap](conceptmap.html): A quantity- or range-valued use context assigned to the concept map
9122* [ConditionDefinition](conditiondefinition.html): A quantity- or range-valued use context assigned to the condition definition
9123* [EventDefinition](eventdefinition.html): A quantity- or range-valued use context assigned to the event definition
9124* [Evidence](evidence.html): A quantity- or range-valued use context assigned to the evidence
9125* [EvidenceReport](evidencereport.html): A quantity- or range-valued use context assigned to the evidence report
9126* [EvidenceVariable](evidencevariable.html): A quantity- or range-valued use context assigned to the evidence variable
9127* [ExampleScenario](examplescenario.html): A quantity- or range-valued use context assigned to the example scenario
9128* [GraphDefinition](graphdefinition.html): A quantity- or range-valued use context assigned to the graph definition
9129* [ImplementationGuide](implementationguide.html): A quantity- or range-valued use context assigned to the implementation guide
9130* [Library](library.html): A quantity- or range-valued use context assigned to the library
9131* [Measure](measure.html): A quantity- or range-valued use context assigned to the measure
9132* [MessageDefinition](messagedefinition.html): A quantity- or range-valued use context assigned to the message definition
9133* [NamingSystem](namingsystem.html): A quantity- or range-valued use context assigned to the naming system
9134* [OperationDefinition](operationdefinition.html): A quantity- or range-valued use context assigned to the operation definition
9135* [PlanDefinition](plandefinition.html): A quantity- or range-valued use context assigned to the plan definition
9136* [Questionnaire](questionnaire.html): A quantity- or range-valued use context assigned to the questionnaire
9137* [Requirements](requirements.html): A quantity- or range-valued use context assigned to the requirements
9138* [SearchParameter](searchparameter.html): A quantity- or range-valued use context assigned to the search parameter
9139* [StructureDefinition](structuredefinition.html): A quantity- or range-valued use context assigned to the structure definition
9140* [StructureMap](structuremap.html): A quantity- or range-valued use context assigned to the structure map
9141* [TerminologyCapabilities](terminologycapabilities.html): A quantity- or range-valued use context assigned to the terminology capabilities
9142* [TestScript](testscript.html): A quantity- or range-valued use context assigned to the test script
9143* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set
9144</b><br>
9145   * Type: <b>quantity</b><br>
9146   * Path: <b>(ActivityDefinition.useContext.value.ofType(Quantity)) | (ActivityDefinition.useContext.value.ofType(Range)) | (ActorDefinition.useContext.value.ofType(Quantity)) | (ActorDefinition.useContext.value.ofType(Range)) | (CapabilityStatement.useContext.value.ofType(Quantity)) | (CapabilityStatement.useContext.value.ofType(Range)) | (ChargeItemDefinition.useContext.value.ofType(Quantity)) | (ChargeItemDefinition.useContext.value.ofType(Range)) | (Citation.useContext.value.ofType(Quantity)) | (Citation.useContext.value.ofType(Range)) | (CodeSystem.useContext.value.ofType(Quantity)) | (CodeSystem.useContext.value.ofType(Range)) | (CompartmentDefinition.useContext.value.ofType(Quantity)) | (CompartmentDefinition.useContext.value.ofType(Range)) | (ConceptMap.useContext.value.ofType(Quantity)) | (ConceptMap.useContext.value.ofType(Range)) | (ConditionDefinition.useContext.value.ofType(Quantity)) | (ConditionDefinition.useContext.value.ofType(Range)) | (EventDefinition.useContext.value.ofType(Quantity)) | (EventDefinition.useContext.value.ofType(Range)) | (Evidence.useContext.value.ofType(Quantity)) | (Evidence.useContext.value.ofType(Range)) | (EvidenceReport.useContext.value.ofType(Quantity)) | (EvidenceReport.useContext.value.ofType(Range)) | (EvidenceVariable.useContext.value.ofType(Quantity)) | (EvidenceVariable.useContext.value.ofType(Range)) | (ExampleScenario.useContext.value.ofType(Quantity)) | (ExampleScenario.useContext.value.ofType(Range)) | (GraphDefinition.useContext.value.ofType(Quantity)) | (GraphDefinition.useContext.value.ofType(Range)) | (ImplementationGuide.useContext.value.ofType(Quantity)) | (ImplementationGuide.useContext.value.ofType(Range)) | (Library.useContext.value.ofType(Quantity)) | (Library.useContext.value.ofType(Range)) | (Measure.useContext.value.ofType(Quantity)) | (Measure.useContext.value.ofType(Range)) | (MessageDefinition.useContext.value.ofType(Quantity)) | (MessageDefinition.useContext.value.ofType(Range)) | (NamingSystem.useContext.value.ofType(Quantity)) | (NamingSystem.useContext.value.ofType(Range)) | (OperationDefinition.useContext.value.ofType(Quantity)) | (OperationDefinition.useContext.value.ofType(Range)) | (PlanDefinition.useContext.value.ofType(Quantity)) | (PlanDefinition.useContext.value.ofType(Range)) | (Questionnaire.useContext.value.ofType(Quantity)) | (Questionnaire.useContext.value.ofType(Range)) | (Requirements.useContext.value.ofType(Quantity)) | (Requirements.useContext.value.ofType(Range)) | (SearchParameter.useContext.value.ofType(Quantity)) | (SearchParameter.useContext.value.ofType(Range)) | (StructureDefinition.useContext.value.ofType(Quantity)) | (StructureDefinition.useContext.value.ofType(Range)) | (StructureMap.useContext.value.ofType(Quantity)) | (StructureMap.useContext.value.ofType(Range)) | (TerminologyCapabilities.useContext.value.ofType(Quantity)) | (TerminologyCapabilities.useContext.value.ofType(Range)) | (TestScript.useContext.value.ofType(Quantity)) | (TestScript.useContext.value.ofType(Range)) | (ValueSet.useContext.value.ofType(Quantity)) | (ValueSet.useContext.value.ofType(Range))</b><br>
9147   * </p>
9148   */
9149  @SearchParamDefinition(name="context-quantity", path="(ActivityDefinition.useContext.value.ofType(Quantity)) | (ActivityDefinition.useContext.value.ofType(Range)) | (ActorDefinition.useContext.value.ofType(Quantity)) | (ActorDefinition.useContext.value.ofType(Range)) | (CapabilityStatement.useContext.value.ofType(Quantity)) | (CapabilityStatement.useContext.value.ofType(Range)) | (ChargeItemDefinition.useContext.value.ofType(Quantity)) | (ChargeItemDefinition.useContext.value.ofType(Range)) | (Citation.useContext.value.ofType(Quantity)) | (Citation.useContext.value.ofType(Range)) | (CodeSystem.useContext.value.ofType(Quantity)) | (CodeSystem.useContext.value.ofType(Range)) | (CompartmentDefinition.useContext.value.ofType(Quantity)) | (CompartmentDefinition.useContext.value.ofType(Range)) | (ConceptMap.useContext.value.ofType(Quantity)) | (ConceptMap.useContext.value.ofType(Range)) | (ConditionDefinition.useContext.value.ofType(Quantity)) | (ConditionDefinition.useContext.value.ofType(Range)) | (EventDefinition.useContext.value.ofType(Quantity)) | (EventDefinition.useContext.value.ofType(Range)) | (Evidence.useContext.value.ofType(Quantity)) | (Evidence.useContext.value.ofType(Range)) | (EvidenceReport.useContext.value.ofType(Quantity)) | (EvidenceReport.useContext.value.ofType(Range)) | (EvidenceVariable.useContext.value.ofType(Quantity)) | (EvidenceVariable.useContext.value.ofType(Range)) | (ExampleScenario.useContext.value.ofType(Quantity)) | (ExampleScenario.useContext.value.ofType(Range)) | (GraphDefinition.useContext.value.ofType(Quantity)) | (GraphDefinition.useContext.value.ofType(Range)) | (ImplementationGuide.useContext.value.ofType(Quantity)) | (ImplementationGuide.useContext.value.ofType(Range)) | (Library.useContext.value.ofType(Quantity)) | (Library.useContext.value.ofType(Range)) | (Measure.useContext.value.ofType(Quantity)) | (Measure.useContext.value.ofType(Range)) | (MessageDefinition.useContext.value.ofType(Quantity)) | (MessageDefinition.useContext.value.ofType(Range)) | (NamingSystem.useContext.value.ofType(Quantity)) | (NamingSystem.useContext.value.ofType(Range)) | (OperationDefinition.useContext.value.ofType(Quantity)) | (OperationDefinition.useContext.value.ofType(Range)) | (PlanDefinition.useContext.value.ofType(Quantity)) | (PlanDefinition.useContext.value.ofType(Range)) | (Questionnaire.useContext.value.ofType(Quantity)) | (Questionnaire.useContext.value.ofType(Range)) | (Requirements.useContext.value.ofType(Quantity)) | (Requirements.useContext.value.ofType(Range)) | (SearchParameter.useContext.value.ofType(Quantity)) | (SearchParameter.useContext.value.ofType(Range)) | (StructureDefinition.useContext.value.ofType(Quantity)) | (StructureDefinition.useContext.value.ofType(Range)) | (StructureMap.useContext.value.ofType(Quantity)) | (StructureMap.useContext.value.ofType(Range)) | (TerminologyCapabilities.useContext.value.ofType(Quantity)) | (TerminologyCapabilities.useContext.value.ofType(Range)) | (TestScript.useContext.value.ofType(Quantity)) | (TestScript.useContext.value.ofType(Range)) | (ValueSet.useContext.value.ofType(Quantity)) | (ValueSet.useContext.value.ofType(Range))", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): A quantity- or range-valued use context assigned to the activity definition\r\n* [ActorDefinition](actordefinition.html): A quantity- or range-valued use context assigned to the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): A quantity- or range-valued use context assigned to the charge item definition\r\n* [Citation](citation.html): A quantity- or range-valued use context assigned to the citation\r\n* [CodeSystem](codesystem.html): A quantity- or range-valued use context assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A quantity- or range-valued use context assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A quantity- or range-valued use context assigned to the concept map\r\n* [ConditionDefinition](conditiondefinition.html): A quantity- or range-valued use context assigned to the condition definition\r\n* [EventDefinition](eventdefinition.html): A quantity- or range-valued use context assigned to the event definition\r\n* [Evidence](evidence.html): A quantity- or range-valued use context assigned to the evidence\r\n* [EvidenceReport](evidencereport.html): A quantity- or range-valued use context assigned to the evidence report\r\n* [EvidenceVariable](evidencevariable.html): A quantity- or range-valued use context assigned to the evidence variable\r\n* [ExampleScenario](examplescenario.html): A quantity- or range-valued use context assigned to the example scenario\r\n* [GraphDefinition](graphdefinition.html): A quantity- or range-valued use context assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A quantity- or range-valued use context assigned to the implementation guide\r\n* [Library](library.html): A quantity- or range-valued use context assigned to the library\r\n* [Measure](measure.html): A quantity- or range-valued use context assigned to the measure\r\n* [MessageDefinition](messagedefinition.html): A quantity- or range-valued use context assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A quantity- or range-valued use context assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A quantity- or range-valued use context assigned to the operation definition\r\n* [PlanDefinition](plandefinition.html): A quantity- or range-valued use context assigned to the plan definition\r\n* [Questionnaire](questionnaire.html): A quantity- or range-valued use context assigned to the questionnaire\r\n* [Requirements](requirements.html): A quantity- or range-valued use context assigned to the requirements\r\n* [SearchParameter](searchparameter.html): A quantity- or range-valued use context assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A quantity- or range-valued use context assigned to the structure definition\r\n* [StructureMap](structuremap.html): A quantity- or range-valued use context assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A quantity- or range-valued use context assigned to the terminology capabilities\r\n* [TestScript](testscript.html): A quantity- or range-valued use context assigned to the test script\r\n* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set\r\n", type="quantity" )
9150  public static final String SP_CONTEXT_QUANTITY = "context-quantity";
9151 /**
9152   * <b>Fluent Client</b> search parameter constant for <b>context-quantity</b>
9153   * <p>
9154   * Description: <b>Multiple Resources: 
9155
9156* [ActivityDefinition](activitydefinition.html): A quantity- or range-valued use context assigned to the activity definition
9157* [ActorDefinition](actordefinition.html): A quantity- or range-valued use context assigned to the Actor Definition
9158* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement
9159* [ChargeItemDefinition](chargeitemdefinition.html): A quantity- or range-valued use context assigned to the charge item definition
9160* [Citation](citation.html): A quantity- or range-valued use context assigned to the citation
9161* [CodeSystem](codesystem.html): A quantity- or range-valued use context assigned to the code system
9162* [CompartmentDefinition](compartmentdefinition.html): A quantity- or range-valued use context assigned to the compartment definition
9163* [ConceptMap](conceptmap.html): A quantity- or range-valued use context assigned to the concept map
9164* [ConditionDefinition](conditiondefinition.html): A quantity- or range-valued use context assigned to the condition definition
9165* [EventDefinition](eventdefinition.html): A quantity- or range-valued use context assigned to the event definition
9166* [Evidence](evidence.html): A quantity- or range-valued use context assigned to the evidence
9167* [EvidenceReport](evidencereport.html): A quantity- or range-valued use context assigned to the evidence report
9168* [EvidenceVariable](evidencevariable.html): A quantity- or range-valued use context assigned to the evidence variable
9169* [ExampleScenario](examplescenario.html): A quantity- or range-valued use context assigned to the example scenario
9170* [GraphDefinition](graphdefinition.html): A quantity- or range-valued use context assigned to the graph definition
9171* [ImplementationGuide](implementationguide.html): A quantity- or range-valued use context assigned to the implementation guide
9172* [Library](library.html): A quantity- or range-valued use context assigned to the library
9173* [Measure](measure.html): A quantity- or range-valued use context assigned to the measure
9174* [MessageDefinition](messagedefinition.html): A quantity- or range-valued use context assigned to the message definition
9175* [NamingSystem](namingsystem.html): A quantity- or range-valued use context assigned to the naming system
9176* [OperationDefinition](operationdefinition.html): A quantity- or range-valued use context assigned to the operation definition
9177* [PlanDefinition](plandefinition.html): A quantity- or range-valued use context assigned to the plan definition
9178* [Questionnaire](questionnaire.html): A quantity- or range-valued use context assigned to the questionnaire
9179* [Requirements](requirements.html): A quantity- or range-valued use context assigned to the requirements
9180* [SearchParameter](searchparameter.html): A quantity- or range-valued use context assigned to the search parameter
9181* [StructureDefinition](structuredefinition.html): A quantity- or range-valued use context assigned to the structure definition
9182* [StructureMap](structuremap.html): A quantity- or range-valued use context assigned to the structure map
9183* [TerminologyCapabilities](terminologycapabilities.html): A quantity- or range-valued use context assigned to the terminology capabilities
9184* [TestScript](testscript.html): A quantity- or range-valued use context assigned to the test script
9185* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set
9186</b><br>
9187   * Type: <b>quantity</b><br>
9188   * Path: <b>(ActivityDefinition.useContext.value.ofType(Quantity)) | (ActivityDefinition.useContext.value.ofType(Range)) | (ActorDefinition.useContext.value.ofType(Quantity)) | (ActorDefinition.useContext.value.ofType(Range)) | (CapabilityStatement.useContext.value.ofType(Quantity)) | (CapabilityStatement.useContext.value.ofType(Range)) | (ChargeItemDefinition.useContext.value.ofType(Quantity)) | (ChargeItemDefinition.useContext.value.ofType(Range)) | (Citation.useContext.value.ofType(Quantity)) | (Citation.useContext.value.ofType(Range)) | (CodeSystem.useContext.value.ofType(Quantity)) | (CodeSystem.useContext.value.ofType(Range)) | (CompartmentDefinition.useContext.value.ofType(Quantity)) | (CompartmentDefinition.useContext.value.ofType(Range)) | (ConceptMap.useContext.value.ofType(Quantity)) | (ConceptMap.useContext.value.ofType(Range)) | (ConditionDefinition.useContext.value.ofType(Quantity)) | (ConditionDefinition.useContext.value.ofType(Range)) | (EventDefinition.useContext.value.ofType(Quantity)) | (EventDefinition.useContext.value.ofType(Range)) | (Evidence.useContext.value.ofType(Quantity)) | (Evidence.useContext.value.ofType(Range)) | (EvidenceReport.useContext.value.ofType(Quantity)) | (EvidenceReport.useContext.value.ofType(Range)) | (EvidenceVariable.useContext.value.ofType(Quantity)) | (EvidenceVariable.useContext.value.ofType(Range)) | (ExampleScenario.useContext.value.ofType(Quantity)) | (ExampleScenario.useContext.value.ofType(Range)) | (GraphDefinition.useContext.value.ofType(Quantity)) | (GraphDefinition.useContext.value.ofType(Range)) | (ImplementationGuide.useContext.value.ofType(Quantity)) | (ImplementationGuide.useContext.value.ofType(Range)) | (Library.useContext.value.ofType(Quantity)) | (Library.useContext.value.ofType(Range)) | (Measure.useContext.value.ofType(Quantity)) | (Measure.useContext.value.ofType(Range)) | (MessageDefinition.useContext.value.ofType(Quantity)) | (MessageDefinition.useContext.value.ofType(Range)) | (NamingSystem.useContext.value.ofType(Quantity)) | (NamingSystem.useContext.value.ofType(Range)) | (OperationDefinition.useContext.value.ofType(Quantity)) | (OperationDefinition.useContext.value.ofType(Range)) | (PlanDefinition.useContext.value.ofType(Quantity)) | (PlanDefinition.useContext.value.ofType(Range)) | (Questionnaire.useContext.value.ofType(Quantity)) | (Questionnaire.useContext.value.ofType(Range)) | (Requirements.useContext.value.ofType(Quantity)) | (Requirements.useContext.value.ofType(Range)) | (SearchParameter.useContext.value.ofType(Quantity)) | (SearchParameter.useContext.value.ofType(Range)) | (StructureDefinition.useContext.value.ofType(Quantity)) | (StructureDefinition.useContext.value.ofType(Range)) | (StructureMap.useContext.value.ofType(Quantity)) | (StructureMap.useContext.value.ofType(Range)) | (TerminologyCapabilities.useContext.value.ofType(Quantity)) | (TerminologyCapabilities.useContext.value.ofType(Range)) | (TestScript.useContext.value.ofType(Quantity)) | (TestScript.useContext.value.ofType(Range)) | (ValueSet.useContext.value.ofType(Quantity)) | (ValueSet.useContext.value.ofType(Range))</b><br>
9189   * </p>
9190   */
9191  public static final ca.uhn.fhir.rest.gclient.QuantityClientParam CONTEXT_QUANTITY = new ca.uhn.fhir.rest.gclient.QuantityClientParam(SP_CONTEXT_QUANTITY);
9192
9193 /**
9194   * Search parameter: <b>context-type-quantity</b>
9195   * <p>
9196   * Description: <b>Multiple Resources: 
9197
9198* [ActivityDefinition](activitydefinition.html): A use context type and quantity- or range-based value assigned to the activity definition
9199* [ActorDefinition](actordefinition.html): A use context type and quantity- or range-based value assigned to the Actor Definition
9200* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement
9201* [ChargeItemDefinition](chargeitemdefinition.html): A use context type and quantity- or range-based value assigned to the charge item definition
9202* [Citation](citation.html): A use context type and quantity- or range-based value assigned to the citation
9203* [CodeSystem](codesystem.html): A use context type and quantity- or range-based value assigned to the code system
9204* [CompartmentDefinition](compartmentdefinition.html): A use context type and quantity- or range-based value assigned to the compartment definition
9205* [ConceptMap](conceptmap.html): A use context type and quantity- or range-based value assigned to the concept map
9206* [ConditionDefinition](conditiondefinition.html): A use context type and quantity- or range-based value assigned to the condition definition
9207* [EventDefinition](eventdefinition.html): A use context type and quantity- or range-based value assigned to the event definition
9208* [Evidence](evidence.html): A use context type and quantity- or range-based value assigned to the evidence
9209* [EvidenceReport](evidencereport.html): A use context type and quantity- or range-based value assigned to the evidence report
9210* [EvidenceVariable](evidencevariable.html): A use context type and quantity- or range-based value assigned to the evidence variable
9211* [ExampleScenario](examplescenario.html): A use context type and quantity- or range-based value assigned to the example scenario
9212* [GraphDefinition](graphdefinition.html): A use context type and quantity- or range-based value assigned to the graph definition
9213* [ImplementationGuide](implementationguide.html): A use context type and quantity- or range-based value assigned to the implementation guide
9214* [Library](library.html): A use context type and quantity- or range-based value assigned to the library
9215* [Measure](measure.html): A use context type and quantity- or range-based value assigned to the measure
9216* [MessageDefinition](messagedefinition.html): A use context type and quantity- or range-based value assigned to the message definition
9217* [NamingSystem](namingsystem.html): A use context type and quantity- or range-based value assigned to the naming system
9218* [OperationDefinition](operationdefinition.html): A use context type and quantity- or range-based value assigned to the operation definition
9219* [PlanDefinition](plandefinition.html): A use context type and quantity- or range-based value assigned to the plan definition
9220* [Questionnaire](questionnaire.html): A use context type and quantity- or range-based value assigned to the questionnaire
9221* [Requirements](requirements.html): A use context type and quantity- or range-based value assigned to the requirements
9222* [SearchParameter](searchparameter.html): A use context type and quantity- or range-based value assigned to the search parameter
9223* [StructureDefinition](structuredefinition.html): A use context type and quantity- or range-based value assigned to the structure definition
9224* [StructureMap](structuremap.html): A use context type and quantity- or range-based value assigned to the structure map
9225* [TerminologyCapabilities](terminologycapabilities.html): A use context type and quantity- or range-based value assigned to the terminology capabilities
9226* [TestScript](testscript.html): A use context type and quantity- or range-based value assigned to the test script
9227* [ValueSet](valueset.html): A use context type and quantity- or range-based value assigned to the value set
9228</b><br>
9229   * Type: <b>composite</b><br>
9230   * Path: <b>ActivityDefinition.useContext | ActorDefinition.useContext | CapabilityStatement.useContext | ChargeItemDefinition.useContext | Citation.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | ConditionDefinition.useContext | EventDefinition.useContext | Evidence.useContext | EvidenceReport.useContext | EvidenceVariable.useContext | ExampleScenario.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | Library.useContext | Measure.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | PlanDefinition.useContext | Questionnaire.useContext | Requirements.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | TestScript.useContext | ValueSet.useContext</b><br>
9231   * </p>
9232   */
9233  @SearchParamDefinition(name="context-type-quantity", path="ActivityDefinition.useContext | ActorDefinition.useContext | CapabilityStatement.useContext | ChargeItemDefinition.useContext | Citation.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | ConditionDefinition.useContext | EventDefinition.useContext | Evidence.useContext | EvidenceReport.useContext | EvidenceVariable.useContext | ExampleScenario.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | Library.useContext | Measure.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | PlanDefinition.useContext | Questionnaire.useContext | Requirements.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | TestScript.useContext | ValueSet.useContext", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): A use context type and quantity- or range-based value assigned to the activity definition\r\n* [ActorDefinition](actordefinition.html): A use context type and quantity- or range-based value assigned to the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): A use context type and quantity- or range-based value assigned to the charge item definition\r\n* [Citation](citation.html): A use context type and quantity- or range-based value assigned to the citation\r\n* [CodeSystem](codesystem.html): A use context type and quantity- or range-based value assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A use context type and quantity- or range-based value assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A use context type and quantity- or range-based value assigned to the concept map\r\n* [ConditionDefinition](conditiondefinition.html): A use context type and quantity- or range-based value assigned to the condition definition\r\n* [EventDefinition](eventdefinition.html): A use context type and quantity- or range-based value assigned to the event definition\r\n* [Evidence](evidence.html): A use context type and quantity- or range-based value assigned to the evidence\r\n* [EvidenceReport](evidencereport.html): A use context type and quantity- or range-based value assigned to the evidence report\r\n* [EvidenceVariable](evidencevariable.html): A use context type and quantity- or range-based value assigned to the evidence variable\r\n* [ExampleScenario](examplescenario.html): A use context type and quantity- or range-based value assigned to the example scenario\r\n* [GraphDefinition](graphdefinition.html): A use context type and quantity- or range-based value assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A use context type and quantity- or range-based value assigned to the implementation guide\r\n* [Library](library.html): A use context type and quantity- or range-based value assigned to the library\r\n* [Measure](measure.html): A use context type and quantity- or range-based value assigned to the measure\r\n* [MessageDefinition](messagedefinition.html): A use context type and quantity- or range-based value assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A use context type and quantity- or range-based value assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A use context type and quantity- or range-based value assigned to the operation definition\r\n* [PlanDefinition](plandefinition.html): A use context type and quantity- or range-based value assigned to the plan definition\r\n* [Questionnaire](questionnaire.html): A use context type and quantity- or range-based value assigned to the questionnaire\r\n* [Requirements](requirements.html): A use context type and quantity- or range-based value assigned to the requirements\r\n* [SearchParameter](searchparameter.html): A use context type and quantity- or range-based value assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A use context type and quantity- or range-based value assigned to the structure definition\r\n* [StructureMap](structuremap.html): A use context type and quantity- or range-based value assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A use context type and quantity- or range-based value assigned to the terminology capabilities\r\n* [TestScript](testscript.html): A use context type and quantity- or range-based value assigned to the test script\r\n* [ValueSet](valueset.html): A use context type and quantity- or range-based value assigned to the value set\r\n", type="composite", compositeOf={"context-type", "context-quantity"} )
9234  public static final String SP_CONTEXT_TYPE_QUANTITY = "context-type-quantity";
9235 /**
9236   * <b>Fluent Client</b> search parameter constant for <b>context-type-quantity</b>
9237   * <p>
9238   * Description: <b>Multiple Resources: 
9239
9240* [ActivityDefinition](activitydefinition.html): A use context type and quantity- or range-based value assigned to the activity definition
9241* [ActorDefinition](actordefinition.html): A use context type and quantity- or range-based value assigned to the Actor Definition
9242* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement
9243* [ChargeItemDefinition](chargeitemdefinition.html): A use context type and quantity- or range-based value assigned to the charge item definition
9244* [Citation](citation.html): A use context type and quantity- or range-based value assigned to the citation
9245* [CodeSystem](codesystem.html): A use context type and quantity- or range-based value assigned to the code system
9246* [CompartmentDefinition](compartmentdefinition.html): A use context type and quantity- or range-based value assigned to the compartment definition
9247* [ConceptMap](conceptmap.html): A use context type and quantity- or range-based value assigned to the concept map
9248* [ConditionDefinition](conditiondefinition.html): A use context type and quantity- or range-based value assigned to the condition definition
9249* [EventDefinition](eventdefinition.html): A use context type and quantity- or range-based value assigned to the event definition
9250* [Evidence](evidence.html): A use context type and quantity- or range-based value assigned to the evidence
9251* [EvidenceReport](evidencereport.html): A use context type and quantity- or range-based value assigned to the evidence report
9252* [EvidenceVariable](evidencevariable.html): A use context type and quantity- or range-based value assigned to the evidence variable
9253* [ExampleScenario](examplescenario.html): A use context type and quantity- or range-based value assigned to the example scenario
9254* [GraphDefinition](graphdefinition.html): A use context type and quantity- or range-based value assigned to the graph definition
9255* [ImplementationGuide](implementationguide.html): A use context type and quantity- or range-based value assigned to the implementation guide
9256* [Library](library.html): A use context type and quantity- or range-based value assigned to the library
9257* [Measure](measure.html): A use context type and quantity- or range-based value assigned to the measure
9258* [MessageDefinition](messagedefinition.html): A use context type and quantity- or range-based value assigned to the message definition
9259* [NamingSystem](namingsystem.html): A use context type and quantity- or range-based value assigned to the naming system
9260* [OperationDefinition](operationdefinition.html): A use context type and quantity- or range-based value assigned to the operation definition
9261* [PlanDefinition](plandefinition.html): A use context type and quantity- or range-based value assigned to the plan definition
9262* [Questionnaire](questionnaire.html): A use context type and quantity- or range-based value assigned to the questionnaire
9263* [Requirements](requirements.html): A use context type and quantity- or range-based value assigned to the requirements
9264* [SearchParameter](searchparameter.html): A use context type and quantity- or range-based value assigned to the search parameter
9265* [StructureDefinition](structuredefinition.html): A use context type and quantity- or range-based value assigned to the structure definition
9266* [StructureMap](structuremap.html): A use context type and quantity- or range-based value assigned to the structure map
9267* [TerminologyCapabilities](terminologycapabilities.html): A use context type and quantity- or range-based value assigned to the terminology capabilities
9268* [TestScript](testscript.html): A use context type and quantity- or range-based value assigned to the test script
9269* [ValueSet](valueset.html): A use context type and quantity- or range-based value assigned to the value set
9270</b><br>
9271   * Type: <b>composite</b><br>
9272   * Path: <b>ActivityDefinition.useContext | ActorDefinition.useContext | CapabilityStatement.useContext | ChargeItemDefinition.useContext | Citation.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | ConditionDefinition.useContext | EventDefinition.useContext | Evidence.useContext | EvidenceReport.useContext | EvidenceVariable.useContext | ExampleScenario.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | Library.useContext | Measure.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | PlanDefinition.useContext | Questionnaire.useContext | Requirements.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | TestScript.useContext | ValueSet.useContext</b><br>
9273   * </p>
9274   */
9275  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);
9276
9277 /**
9278   * Search parameter: <b>context-type-value</b>
9279   * <p>
9280   * Description: <b>Multiple Resources: 
9281
9282* [ActivityDefinition](activitydefinition.html): A use context type and value assigned to the activity definition
9283* [ActorDefinition](actordefinition.html): A use context type and value assigned to the Actor Definition
9284* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement
9285* [ChargeItemDefinition](chargeitemdefinition.html): A use context type and value assigned to the charge item definition
9286* [Citation](citation.html): A use context type and value assigned to the citation
9287* [CodeSystem](codesystem.html): A use context type and value assigned to the code system
9288* [CompartmentDefinition](compartmentdefinition.html): A use context type and value assigned to the compartment definition
9289* [ConceptMap](conceptmap.html): A use context type and value assigned to the concept map
9290* [ConditionDefinition](conditiondefinition.html): A use context type and value assigned to the condition definition
9291* [EventDefinition](eventdefinition.html): A use context type and value assigned to the event definition
9292* [Evidence](evidence.html): A use context type and value assigned to the evidence
9293* [EvidenceReport](evidencereport.html): A use context type and value assigned to the evidence report
9294* [EvidenceVariable](evidencevariable.html): A use context type and value assigned to the evidence variable
9295* [ExampleScenario](examplescenario.html): A use context type and value assigned to the example scenario
9296* [GraphDefinition](graphdefinition.html): A use context type and value assigned to the graph definition
9297* [ImplementationGuide](implementationguide.html): A use context type and value assigned to the implementation guide
9298* [Library](library.html): A use context type and value assigned to the library
9299* [Measure](measure.html): A use context type and value assigned to the measure
9300* [MessageDefinition](messagedefinition.html): A use context type and value assigned to the message definition
9301* [NamingSystem](namingsystem.html): A use context type and value assigned to the naming system
9302* [OperationDefinition](operationdefinition.html): A use context type and value assigned to the operation definition
9303* [PlanDefinition](plandefinition.html): A use context type and value assigned to the plan definition
9304* [Questionnaire](questionnaire.html): A use context type and value assigned to the questionnaire
9305* [Requirements](requirements.html): A use context type and value assigned to the requirements
9306* [SearchParameter](searchparameter.html): A use context type and value assigned to the search parameter
9307* [StructureDefinition](structuredefinition.html): A use context type and value assigned to the structure definition
9308* [StructureMap](structuremap.html): A use context type and value assigned to the structure map
9309* [TerminologyCapabilities](terminologycapabilities.html): A use context type and value assigned to the terminology capabilities
9310* [TestScript](testscript.html): A use context type and value assigned to the test script
9311* [ValueSet](valueset.html): A use context type and value assigned to the value set
9312</b><br>
9313   * Type: <b>composite</b><br>
9314   * Path: <b>ActivityDefinition.useContext | ActorDefinition.useContext | CapabilityStatement.useContext | ChargeItemDefinition.useContext | Citation.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | ConditionDefinition.useContext | EventDefinition.useContext | Evidence.useContext | EvidenceReport.useContext | EvidenceVariable.useContext | ExampleScenario.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | Library.useContext | Measure.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | PlanDefinition.useContext | Questionnaire.useContext | Requirements.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | TestScript.useContext | ValueSet.useContext</b><br>
9315   * </p>
9316   */
9317  @SearchParamDefinition(name="context-type-value", path="ActivityDefinition.useContext | ActorDefinition.useContext | CapabilityStatement.useContext | ChargeItemDefinition.useContext | Citation.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | ConditionDefinition.useContext | EventDefinition.useContext | Evidence.useContext | EvidenceReport.useContext | EvidenceVariable.useContext | ExampleScenario.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | Library.useContext | Measure.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | PlanDefinition.useContext | Questionnaire.useContext | Requirements.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | TestScript.useContext | ValueSet.useContext", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): A use context type and value assigned to the activity definition\r\n* [ActorDefinition](actordefinition.html): A use context type and value assigned to the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): A use context type and value assigned to the charge item definition\r\n* [Citation](citation.html): A use context type and value assigned to the citation\r\n* [CodeSystem](codesystem.html): A use context type and value assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A use context type and value assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A use context type and value assigned to the concept map\r\n* [ConditionDefinition](conditiondefinition.html): A use context type and value assigned to the condition definition\r\n* [EventDefinition](eventdefinition.html): A use context type and value assigned to the event definition\r\n* [Evidence](evidence.html): A use context type and value assigned to the evidence\r\n* [EvidenceReport](evidencereport.html): A use context type and value assigned to the evidence report\r\n* [EvidenceVariable](evidencevariable.html): A use context type and value assigned to the evidence variable\r\n* [ExampleScenario](examplescenario.html): A use context type and value assigned to the example scenario\r\n* [GraphDefinition](graphdefinition.html): A use context type and value assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A use context type and value assigned to the implementation guide\r\n* [Library](library.html): A use context type and value assigned to the library\r\n* [Measure](measure.html): A use context type and value assigned to the measure\r\n* [MessageDefinition](messagedefinition.html): A use context type and value assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A use context type and value assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A use context type and value assigned to the operation definition\r\n* [PlanDefinition](plandefinition.html): A use context type and value assigned to the plan definition\r\n* [Questionnaire](questionnaire.html): A use context type and value assigned to the questionnaire\r\n* [Requirements](requirements.html): A use context type and value assigned to the requirements\r\n* [SearchParameter](searchparameter.html): A use context type and value assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A use context type and value assigned to the structure definition\r\n* [StructureMap](structuremap.html): A use context type and value assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A use context type and value assigned to the terminology capabilities\r\n* [TestScript](testscript.html): A use context type and value assigned to the test script\r\n* [ValueSet](valueset.html): A use context type and value assigned to the value set\r\n", type="composite", compositeOf={"context-type", "context"} )
9318  public static final String SP_CONTEXT_TYPE_VALUE = "context-type-value";
9319 /**
9320   * <b>Fluent Client</b> search parameter constant for <b>context-type-value</b>
9321   * <p>
9322   * Description: <b>Multiple Resources: 
9323
9324* [ActivityDefinition](activitydefinition.html): A use context type and value assigned to the activity definition
9325* [ActorDefinition](actordefinition.html): A use context type and value assigned to the Actor Definition
9326* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement
9327* [ChargeItemDefinition](chargeitemdefinition.html): A use context type and value assigned to the charge item definition
9328* [Citation](citation.html): A use context type and value assigned to the citation
9329* [CodeSystem](codesystem.html): A use context type and value assigned to the code system
9330* [CompartmentDefinition](compartmentdefinition.html): A use context type and value assigned to the compartment definition
9331* [ConceptMap](conceptmap.html): A use context type and value assigned to the concept map
9332* [ConditionDefinition](conditiondefinition.html): A use context type and value assigned to the condition definition
9333* [EventDefinition](eventdefinition.html): A use context type and value assigned to the event definition
9334* [Evidence](evidence.html): A use context type and value assigned to the evidence
9335* [EvidenceReport](evidencereport.html): A use context type and value assigned to the evidence report
9336* [EvidenceVariable](evidencevariable.html): A use context type and value assigned to the evidence variable
9337* [ExampleScenario](examplescenario.html): A use context type and value assigned to the example scenario
9338* [GraphDefinition](graphdefinition.html): A use context type and value assigned to the graph definition
9339* [ImplementationGuide](implementationguide.html): A use context type and value assigned to the implementation guide
9340* [Library](library.html): A use context type and value assigned to the library
9341* [Measure](measure.html): A use context type and value assigned to the measure
9342* [MessageDefinition](messagedefinition.html): A use context type and value assigned to the message definition
9343* [NamingSystem](namingsystem.html): A use context type and value assigned to the naming system
9344* [OperationDefinition](operationdefinition.html): A use context type and value assigned to the operation definition
9345* [PlanDefinition](plandefinition.html): A use context type and value assigned to the plan definition
9346* [Questionnaire](questionnaire.html): A use context type and value assigned to the questionnaire
9347* [Requirements](requirements.html): A use context type and value assigned to the requirements
9348* [SearchParameter](searchparameter.html): A use context type and value assigned to the search parameter
9349* [StructureDefinition](structuredefinition.html): A use context type and value assigned to the structure definition
9350* [StructureMap](structuremap.html): A use context type and value assigned to the structure map
9351* [TerminologyCapabilities](terminologycapabilities.html): A use context type and value assigned to the terminology capabilities
9352* [TestScript](testscript.html): A use context type and value assigned to the test script
9353* [ValueSet](valueset.html): A use context type and value assigned to the value set
9354</b><br>
9355   * Type: <b>composite</b><br>
9356   * Path: <b>ActivityDefinition.useContext | ActorDefinition.useContext | CapabilityStatement.useContext | ChargeItemDefinition.useContext | Citation.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | ConditionDefinition.useContext | EventDefinition.useContext | Evidence.useContext | EvidenceReport.useContext | EvidenceVariable.useContext | ExampleScenario.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | Library.useContext | Measure.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | PlanDefinition.useContext | Questionnaire.useContext | Requirements.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | TestScript.useContext | ValueSet.useContext</b><br>
9357   * </p>
9358   */
9359  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);
9360
9361 /**
9362   * Search parameter: <b>context-type</b>
9363   * <p>
9364   * Description: <b>Multiple Resources: 
9365
9366* [ActivityDefinition](activitydefinition.html): A type of use context assigned to the activity definition
9367* [ActorDefinition](actordefinition.html): A type of use context assigned to the Actor Definition
9368* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement
9369* [ChargeItemDefinition](chargeitemdefinition.html): A type of use context assigned to the charge item definition
9370* [Citation](citation.html): A type of use context assigned to the citation
9371* [CodeSystem](codesystem.html): A type of use context assigned to the code system
9372* [CompartmentDefinition](compartmentdefinition.html): A type of use context assigned to the compartment definition
9373* [ConceptMap](conceptmap.html): A type of use context assigned to the concept map
9374* [ConditionDefinition](conditiondefinition.html): A type of use context assigned to the condition definition
9375* [EventDefinition](eventdefinition.html): A type of use context assigned to the event definition
9376* [Evidence](evidence.html): A type of use context assigned to the evidence
9377* [EvidenceReport](evidencereport.html): A type of use context assigned to the evidence report
9378* [EvidenceVariable](evidencevariable.html): A type of use context assigned to the evidence variable
9379* [ExampleScenario](examplescenario.html): A type of use context assigned to the example scenario
9380* [GraphDefinition](graphdefinition.html): A type of use context assigned to the graph definition
9381* [ImplementationGuide](implementationguide.html): A type of use context assigned to the implementation guide
9382* [Library](library.html): A type of use context assigned to the library
9383* [Measure](measure.html): A type of use context assigned to the measure
9384* [MessageDefinition](messagedefinition.html): A type of use context assigned to the message definition
9385* [NamingSystem](namingsystem.html): A type of use context assigned to the naming system
9386* [OperationDefinition](operationdefinition.html): A type of use context assigned to the operation definition
9387* [PlanDefinition](plandefinition.html): A type of use context assigned to the plan definition
9388* [Questionnaire](questionnaire.html): A type of use context assigned to the questionnaire
9389* [Requirements](requirements.html): A type of use context assigned to the requirements
9390* [SearchParameter](searchparameter.html): A type of use context assigned to the search parameter
9391* [StructureDefinition](structuredefinition.html): A type of use context assigned to the structure definition
9392* [StructureMap](structuremap.html): A type of use context assigned to the structure map
9393* [TerminologyCapabilities](terminologycapabilities.html): A type of use context assigned to the terminology capabilities
9394* [TestScript](testscript.html): A type of use context assigned to the test script
9395* [ValueSet](valueset.html): A type of use context assigned to the value set
9396</b><br>
9397   * Type: <b>token</b><br>
9398   * Path: <b>ActivityDefinition.useContext.code | ActorDefinition.useContext.code | CapabilityStatement.useContext.code | ChargeItemDefinition.useContext.code | Citation.useContext.code | CodeSystem.useContext.code | CompartmentDefinition.useContext.code | ConceptMap.useContext.code | ConditionDefinition.useContext.code | EventDefinition.useContext.code | Evidence.useContext.code | EvidenceReport.useContext.code | EvidenceVariable.useContext.code | ExampleScenario.useContext.code | GraphDefinition.useContext.code | ImplementationGuide.useContext.code | Library.useContext.code | Measure.useContext.code | MessageDefinition.useContext.code | NamingSystem.useContext.code | OperationDefinition.useContext.code | PlanDefinition.useContext.code | Questionnaire.useContext.code | Requirements.useContext.code | SearchParameter.useContext.code | StructureDefinition.useContext.code | StructureMap.useContext.code | TerminologyCapabilities.useContext.code | TestScript.useContext.code | ValueSet.useContext.code</b><br>
9399   * </p>
9400   */
9401  @SearchParamDefinition(name="context-type", path="ActivityDefinition.useContext.code | ActorDefinition.useContext.code | CapabilityStatement.useContext.code | ChargeItemDefinition.useContext.code | Citation.useContext.code | CodeSystem.useContext.code | CompartmentDefinition.useContext.code | ConceptMap.useContext.code | ConditionDefinition.useContext.code | EventDefinition.useContext.code | Evidence.useContext.code | EvidenceReport.useContext.code | EvidenceVariable.useContext.code | ExampleScenario.useContext.code | GraphDefinition.useContext.code | ImplementationGuide.useContext.code | Library.useContext.code | Measure.useContext.code | MessageDefinition.useContext.code | NamingSystem.useContext.code | OperationDefinition.useContext.code | PlanDefinition.useContext.code | Questionnaire.useContext.code | Requirements.useContext.code | SearchParameter.useContext.code | StructureDefinition.useContext.code | StructureMap.useContext.code | TerminologyCapabilities.useContext.code | TestScript.useContext.code | ValueSet.useContext.code", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): A type of use context assigned to the activity definition\r\n* [ActorDefinition](actordefinition.html): A type of use context assigned to the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): A type of use context assigned to the charge item definition\r\n* [Citation](citation.html): A type of use context assigned to the citation\r\n* [CodeSystem](codesystem.html): A type of use context assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A type of use context assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A type of use context assigned to the concept map\r\n* [ConditionDefinition](conditiondefinition.html): A type of use context assigned to the condition definition\r\n* [EventDefinition](eventdefinition.html): A type of use context assigned to the event definition\r\n* [Evidence](evidence.html): A type of use context assigned to the evidence\r\n* [EvidenceReport](evidencereport.html): A type of use context assigned to the evidence report\r\n* [EvidenceVariable](evidencevariable.html): A type of use context assigned to the evidence variable\r\n* [ExampleScenario](examplescenario.html): A type of use context assigned to the example scenario\r\n* [GraphDefinition](graphdefinition.html): A type of use context assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A type of use context assigned to the implementation guide\r\n* [Library](library.html): A type of use context assigned to the library\r\n* [Measure](measure.html): A type of use context assigned to the measure\r\n* [MessageDefinition](messagedefinition.html): A type of use context assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A type of use context assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A type of use context assigned to the operation definition\r\n* [PlanDefinition](plandefinition.html): A type of use context assigned to the plan definition\r\n* [Questionnaire](questionnaire.html): A type of use context assigned to the questionnaire\r\n* [Requirements](requirements.html): A type of use context assigned to the requirements\r\n* [SearchParameter](searchparameter.html): A type of use context assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A type of use context assigned to the structure definition\r\n* [StructureMap](structuremap.html): A type of use context assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A type of use context assigned to the terminology capabilities\r\n* [TestScript](testscript.html): A type of use context assigned to the test script\r\n* [ValueSet](valueset.html): A type of use context assigned to the value set\r\n", type="token" )
9402  public static final String SP_CONTEXT_TYPE = "context-type";
9403 /**
9404   * <b>Fluent Client</b> search parameter constant for <b>context-type</b>
9405   * <p>
9406   * Description: <b>Multiple Resources: 
9407
9408* [ActivityDefinition](activitydefinition.html): A type of use context assigned to the activity definition
9409* [ActorDefinition](actordefinition.html): A type of use context assigned to the Actor Definition
9410* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement
9411* [ChargeItemDefinition](chargeitemdefinition.html): A type of use context assigned to the charge item definition
9412* [Citation](citation.html): A type of use context assigned to the citation
9413* [CodeSystem](codesystem.html): A type of use context assigned to the code system
9414* [CompartmentDefinition](compartmentdefinition.html): A type of use context assigned to the compartment definition
9415* [ConceptMap](conceptmap.html): A type of use context assigned to the concept map
9416* [ConditionDefinition](conditiondefinition.html): A type of use context assigned to the condition definition
9417* [EventDefinition](eventdefinition.html): A type of use context assigned to the event definition
9418* [Evidence](evidence.html): A type of use context assigned to the evidence
9419* [EvidenceReport](evidencereport.html): A type of use context assigned to the evidence report
9420* [EvidenceVariable](evidencevariable.html): A type of use context assigned to the evidence variable
9421* [ExampleScenario](examplescenario.html): A type of use context assigned to the example scenario
9422* [GraphDefinition](graphdefinition.html): A type of use context assigned to the graph definition
9423* [ImplementationGuide](implementationguide.html): A type of use context assigned to the implementation guide
9424* [Library](library.html): A type of use context assigned to the library
9425* [Measure](measure.html): A type of use context assigned to the measure
9426* [MessageDefinition](messagedefinition.html): A type of use context assigned to the message definition
9427* [NamingSystem](namingsystem.html): A type of use context assigned to the naming system
9428* [OperationDefinition](operationdefinition.html): A type of use context assigned to the operation definition
9429* [PlanDefinition](plandefinition.html): A type of use context assigned to the plan definition
9430* [Questionnaire](questionnaire.html): A type of use context assigned to the questionnaire
9431* [Requirements](requirements.html): A type of use context assigned to the requirements
9432* [SearchParameter](searchparameter.html): A type of use context assigned to the search parameter
9433* [StructureDefinition](structuredefinition.html): A type of use context assigned to the structure definition
9434* [StructureMap](structuremap.html): A type of use context assigned to the structure map
9435* [TerminologyCapabilities](terminologycapabilities.html): A type of use context assigned to the terminology capabilities
9436* [TestScript](testscript.html): A type of use context assigned to the test script
9437* [ValueSet](valueset.html): A type of use context assigned to the value set
9438</b><br>
9439   * Type: <b>token</b><br>
9440   * Path: <b>ActivityDefinition.useContext.code | ActorDefinition.useContext.code | CapabilityStatement.useContext.code | ChargeItemDefinition.useContext.code | Citation.useContext.code | CodeSystem.useContext.code | CompartmentDefinition.useContext.code | ConceptMap.useContext.code | ConditionDefinition.useContext.code | EventDefinition.useContext.code | Evidence.useContext.code | EvidenceReport.useContext.code | EvidenceVariable.useContext.code | ExampleScenario.useContext.code | GraphDefinition.useContext.code | ImplementationGuide.useContext.code | Library.useContext.code | Measure.useContext.code | MessageDefinition.useContext.code | NamingSystem.useContext.code | OperationDefinition.useContext.code | PlanDefinition.useContext.code | Questionnaire.useContext.code | Requirements.useContext.code | SearchParameter.useContext.code | StructureDefinition.useContext.code | StructureMap.useContext.code | TerminologyCapabilities.useContext.code | TestScript.useContext.code | ValueSet.useContext.code</b><br>
9441   * </p>
9442   */
9443  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT_TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT_TYPE);
9444
9445 /**
9446   * Search parameter: <b>context</b>
9447   * <p>
9448   * Description: <b>Multiple Resources: 
9449
9450* [ActivityDefinition](activitydefinition.html): A use context assigned to the activity definition
9451* [ActorDefinition](actordefinition.html): A use context assigned to the Actor Definition
9452* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement
9453* [ChargeItemDefinition](chargeitemdefinition.html): A use context assigned to the charge item definition
9454* [Citation](citation.html): A use context assigned to the citation
9455* [CodeSystem](codesystem.html): A use context assigned to the code system
9456* [CompartmentDefinition](compartmentdefinition.html): A use context assigned to the compartment definition
9457* [ConceptMap](conceptmap.html): A use context assigned to the concept map
9458* [ConditionDefinition](conditiondefinition.html): A use context assigned to the condition definition
9459* [EventDefinition](eventdefinition.html): A use context assigned to the event definition
9460* [Evidence](evidence.html): A use context assigned to the evidence
9461* [EvidenceReport](evidencereport.html): A use context assigned to the evidence report
9462* [EvidenceVariable](evidencevariable.html): A use context assigned to the evidence variable
9463* [ExampleScenario](examplescenario.html): A use context assigned to the example scenario
9464* [GraphDefinition](graphdefinition.html): A use context assigned to the graph definition
9465* [ImplementationGuide](implementationguide.html): A use context assigned to the implementation guide
9466* [Library](library.html): A use context assigned to the library
9467* [Measure](measure.html): A use context assigned to the measure
9468* [MessageDefinition](messagedefinition.html): A use context assigned to the message definition
9469* [NamingSystem](namingsystem.html): A use context assigned to the naming system
9470* [OperationDefinition](operationdefinition.html): A use context assigned to the operation definition
9471* [PlanDefinition](plandefinition.html): A use context assigned to the plan definition
9472* [Questionnaire](questionnaire.html): A use context assigned to the questionnaire
9473* [Requirements](requirements.html): A use context assigned to the requirements
9474* [SearchParameter](searchparameter.html): A use context assigned to the search parameter
9475* [StructureDefinition](structuredefinition.html): A use context assigned to the structure definition
9476* [StructureMap](structuremap.html): A use context assigned to the structure map
9477* [TerminologyCapabilities](terminologycapabilities.html): A use context assigned to the terminology capabilities
9478* [TestScript](testscript.html): A use context assigned to the test script
9479* [ValueSet](valueset.html): A use context assigned to the value set
9480</b><br>
9481   * Type: <b>token</b><br>
9482   * Path: <b>(ActivityDefinition.useContext.value.ofType(CodeableConcept)) | (ActorDefinition.useContext.value.ofType(CodeableConcept)) | (CapabilityStatement.useContext.value.ofType(CodeableConcept)) | (ChargeItemDefinition.useContext.value.ofType(CodeableConcept)) | (Citation.useContext.value.ofType(CodeableConcept)) | (CodeSystem.useContext.value.ofType(CodeableConcept)) | (CompartmentDefinition.useContext.value.ofType(CodeableConcept)) | (ConceptMap.useContext.value.ofType(CodeableConcept)) | (ConditionDefinition.useContext.value.ofType(CodeableConcept)) | (EventDefinition.useContext.value.ofType(CodeableConcept)) | (Evidence.useContext.value.ofType(CodeableConcept)) | (EvidenceReport.useContext.value.ofType(CodeableConcept)) | (EvidenceVariable.useContext.value.ofType(CodeableConcept)) | (ExampleScenario.useContext.value.ofType(CodeableConcept)) | (GraphDefinition.useContext.value.ofType(CodeableConcept)) | (ImplementationGuide.useContext.value.ofType(CodeableConcept)) | (Library.useContext.value.ofType(CodeableConcept)) | (Measure.useContext.value.ofType(CodeableConcept)) | (MessageDefinition.useContext.value.ofType(CodeableConcept)) | (NamingSystem.useContext.value.ofType(CodeableConcept)) | (OperationDefinition.useContext.value.ofType(CodeableConcept)) | (PlanDefinition.useContext.value.ofType(CodeableConcept)) | (Questionnaire.useContext.value.ofType(CodeableConcept)) | (Requirements.useContext.value.ofType(CodeableConcept)) | (SearchParameter.useContext.value.ofType(CodeableConcept)) | (StructureDefinition.useContext.value.ofType(CodeableConcept)) | (StructureMap.useContext.value.ofType(CodeableConcept)) | (TerminologyCapabilities.useContext.value.ofType(CodeableConcept)) | (TestScript.useContext.value.ofType(CodeableConcept)) | (ValueSet.useContext.value.ofType(CodeableConcept))</b><br>
9483   * </p>
9484   */
9485  @SearchParamDefinition(name="context", path="(ActivityDefinition.useContext.value.ofType(CodeableConcept)) | (ActorDefinition.useContext.value.ofType(CodeableConcept)) | (CapabilityStatement.useContext.value.ofType(CodeableConcept)) | (ChargeItemDefinition.useContext.value.ofType(CodeableConcept)) | (Citation.useContext.value.ofType(CodeableConcept)) | (CodeSystem.useContext.value.ofType(CodeableConcept)) | (CompartmentDefinition.useContext.value.ofType(CodeableConcept)) | (ConceptMap.useContext.value.ofType(CodeableConcept)) | (ConditionDefinition.useContext.value.ofType(CodeableConcept)) | (EventDefinition.useContext.value.ofType(CodeableConcept)) | (Evidence.useContext.value.ofType(CodeableConcept)) | (EvidenceReport.useContext.value.ofType(CodeableConcept)) | (EvidenceVariable.useContext.value.ofType(CodeableConcept)) | (ExampleScenario.useContext.value.ofType(CodeableConcept)) | (GraphDefinition.useContext.value.ofType(CodeableConcept)) | (ImplementationGuide.useContext.value.ofType(CodeableConcept)) | (Library.useContext.value.ofType(CodeableConcept)) | (Measure.useContext.value.ofType(CodeableConcept)) | (MessageDefinition.useContext.value.ofType(CodeableConcept)) | (NamingSystem.useContext.value.ofType(CodeableConcept)) | (OperationDefinition.useContext.value.ofType(CodeableConcept)) | (PlanDefinition.useContext.value.ofType(CodeableConcept)) | (Questionnaire.useContext.value.ofType(CodeableConcept)) | (Requirements.useContext.value.ofType(CodeableConcept)) | (SearchParameter.useContext.value.ofType(CodeableConcept)) | (StructureDefinition.useContext.value.ofType(CodeableConcept)) | (StructureMap.useContext.value.ofType(CodeableConcept)) | (TerminologyCapabilities.useContext.value.ofType(CodeableConcept)) | (TestScript.useContext.value.ofType(CodeableConcept)) | (ValueSet.useContext.value.ofType(CodeableConcept))", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): A use context assigned to the activity definition\r\n* [ActorDefinition](actordefinition.html): A use context assigned to the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): A use context assigned to the charge item definition\r\n* [Citation](citation.html): A use context assigned to the citation\r\n* [CodeSystem](codesystem.html): A use context assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A use context assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A use context assigned to the concept map\r\n* [ConditionDefinition](conditiondefinition.html): A use context assigned to the condition definition\r\n* [EventDefinition](eventdefinition.html): A use context assigned to the event definition\r\n* [Evidence](evidence.html): A use context assigned to the evidence\r\n* [EvidenceReport](evidencereport.html): A use context assigned to the evidence report\r\n* [EvidenceVariable](evidencevariable.html): A use context assigned to the evidence variable\r\n* [ExampleScenario](examplescenario.html): A use context assigned to the example scenario\r\n* [GraphDefinition](graphdefinition.html): A use context assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A use context assigned to the implementation guide\r\n* [Library](library.html): A use context assigned to the library\r\n* [Measure](measure.html): A use context assigned to the measure\r\n* [MessageDefinition](messagedefinition.html): A use context assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A use context assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A use context assigned to the operation definition\r\n* [PlanDefinition](plandefinition.html): A use context assigned to the plan definition\r\n* [Questionnaire](questionnaire.html): A use context assigned to the questionnaire\r\n* [Requirements](requirements.html): A use context assigned to the requirements\r\n* [SearchParameter](searchparameter.html): A use context assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A use context assigned to the structure definition\r\n* [StructureMap](structuremap.html): A use context assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A use context assigned to the terminology capabilities\r\n* [TestScript](testscript.html): A use context assigned to the test script\r\n* [ValueSet](valueset.html): A use context assigned to the value set\r\n", type="token" )
9486  public static final String SP_CONTEXT = "context";
9487 /**
9488   * <b>Fluent Client</b> search parameter constant for <b>context</b>
9489   * <p>
9490   * Description: <b>Multiple Resources: 
9491
9492* [ActivityDefinition](activitydefinition.html): A use context assigned to the activity definition
9493* [ActorDefinition](actordefinition.html): A use context assigned to the Actor Definition
9494* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement
9495* [ChargeItemDefinition](chargeitemdefinition.html): A use context assigned to the charge item definition
9496* [Citation](citation.html): A use context assigned to the citation
9497* [CodeSystem](codesystem.html): A use context assigned to the code system
9498* [CompartmentDefinition](compartmentdefinition.html): A use context assigned to the compartment definition
9499* [ConceptMap](conceptmap.html): A use context assigned to the concept map
9500* [ConditionDefinition](conditiondefinition.html): A use context assigned to the condition definition
9501* [EventDefinition](eventdefinition.html): A use context assigned to the event definition
9502* [Evidence](evidence.html): A use context assigned to the evidence
9503* [EvidenceReport](evidencereport.html): A use context assigned to the evidence report
9504* [EvidenceVariable](evidencevariable.html): A use context assigned to the evidence variable
9505* [ExampleScenario](examplescenario.html): A use context assigned to the example scenario
9506* [GraphDefinition](graphdefinition.html): A use context assigned to the graph definition
9507* [ImplementationGuide](implementationguide.html): A use context assigned to the implementation guide
9508* [Library](library.html): A use context assigned to the library
9509* [Measure](measure.html): A use context assigned to the measure
9510* [MessageDefinition](messagedefinition.html): A use context assigned to the message definition
9511* [NamingSystem](namingsystem.html): A use context assigned to the naming system
9512* [OperationDefinition](operationdefinition.html): A use context assigned to the operation definition
9513* [PlanDefinition](plandefinition.html): A use context assigned to the plan definition
9514* [Questionnaire](questionnaire.html): A use context assigned to the questionnaire
9515* [Requirements](requirements.html): A use context assigned to the requirements
9516* [SearchParameter](searchparameter.html): A use context assigned to the search parameter
9517* [StructureDefinition](structuredefinition.html): A use context assigned to the structure definition
9518* [StructureMap](structuremap.html): A use context assigned to the structure map
9519* [TerminologyCapabilities](terminologycapabilities.html): A use context assigned to the terminology capabilities
9520* [TestScript](testscript.html): A use context assigned to the test script
9521* [ValueSet](valueset.html): A use context assigned to the value set
9522</b><br>
9523   * Type: <b>token</b><br>
9524   * Path: <b>(ActivityDefinition.useContext.value.ofType(CodeableConcept)) | (ActorDefinition.useContext.value.ofType(CodeableConcept)) | (CapabilityStatement.useContext.value.ofType(CodeableConcept)) | (ChargeItemDefinition.useContext.value.ofType(CodeableConcept)) | (Citation.useContext.value.ofType(CodeableConcept)) | (CodeSystem.useContext.value.ofType(CodeableConcept)) | (CompartmentDefinition.useContext.value.ofType(CodeableConcept)) | (ConceptMap.useContext.value.ofType(CodeableConcept)) | (ConditionDefinition.useContext.value.ofType(CodeableConcept)) | (EventDefinition.useContext.value.ofType(CodeableConcept)) | (Evidence.useContext.value.ofType(CodeableConcept)) | (EvidenceReport.useContext.value.ofType(CodeableConcept)) | (EvidenceVariable.useContext.value.ofType(CodeableConcept)) | (ExampleScenario.useContext.value.ofType(CodeableConcept)) | (GraphDefinition.useContext.value.ofType(CodeableConcept)) | (ImplementationGuide.useContext.value.ofType(CodeableConcept)) | (Library.useContext.value.ofType(CodeableConcept)) | (Measure.useContext.value.ofType(CodeableConcept)) | (MessageDefinition.useContext.value.ofType(CodeableConcept)) | (NamingSystem.useContext.value.ofType(CodeableConcept)) | (OperationDefinition.useContext.value.ofType(CodeableConcept)) | (PlanDefinition.useContext.value.ofType(CodeableConcept)) | (Questionnaire.useContext.value.ofType(CodeableConcept)) | (Requirements.useContext.value.ofType(CodeableConcept)) | (SearchParameter.useContext.value.ofType(CodeableConcept)) | (StructureDefinition.useContext.value.ofType(CodeableConcept)) | (StructureMap.useContext.value.ofType(CodeableConcept)) | (TerminologyCapabilities.useContext.value.ofType(CodeableConcept)) | (TestScript.useContext.value.ofType(CodeableConcept)) | (ValueSet.useContext.value.ofType(CodeableConcept))</b><br>
9525   * </p>
9526   */
9527  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT);
9528
9529 /**
9530   * Search parameter: <b>date</b>
9531   * <p>
9532   * Description: <b>Multiple Resources: 
9533
9534* [ActivityDefinition](activitydefinition.html): The activity definition publication date
9535* [ActorDefinition](actordefinition.html): The Actor Definition publication date
9536* [CapabilityStatement](capabilitystatement.html): The capability statement publication date
9537* [ChargeItemDefinition](chargeitemdefinition.html): The charge item definition publication date
9538* [Citation](citation.html): The citation publication date
9539* [CodeSystem](codesystem.html): The code system publication date
9540* [CompartmentDefinition](compartmentdefinition.html): The compartment definition publication date
9541* [ConceptMap](conceptmap.html): The concept map publication date
9542* [ConditionDefinition](conditiondefinition.html): The condition definition publication date
9543* [EventDefinition](eventdefinition.html): The event definition publication date
9544* [Evidence](evidence.html): The evidence publication date
9545* [EvidenceVariable](evidencevariable.html): The evidence variable publication date
9546* [ExampleScenario](examplescenario.html): The example scenario publication date
9547* [GraphDefinition](graphdefinition.html): The graph definition publication date
9548* [ImplementationGuide](implementationguide.html): The implementation guide publication date
9549* [Library](library.html): The library publication date
9550* [Measure](measure.html): The measure publication date
9551* [MessageDefinition](messagedefinition.html): The message definition publication date
9552* [NamingSystem](namingsystem.html): The naming system publication date
9553* [OperationDefinition](operationdefinition.html): The operation definition publication date
9554* [PlanDefinition](plandefinition.html): The plan definition publication date
9555* [Questionnaire](questionnaire.html): The questionnaire publication date
9556* [Requirements](requirements.html): The requirements publication date
9557* [SearchParameter](searchparameter.html): The search parameter publication date
9558* [StructureDefinition](structuredefinition.html): The structure definition publication date
9559* [StructureMap](structuremap.html): The structure map publication date
9560* [SubscriptionTopic](subscriptiontopic.html): Date status first applied
9561* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date
9562* [TestScript](testscript.html): The test script publication date
9563* [ValueSet](valueset.html): The value set publication date
9564</b><br>
9565   * Type: <b>date</b><br>
9566   * Path: <b>ActivityDefinition.date | ActorDefinition.date | CapabilityStatement.date | ChargeItemDefinition.date | Citation.date | CodeSystem.date | CompartmentDefinition.date | ConceptMap.date | ConditionDefinition.date | EventDefinition.date | Evidence.date | EvidenceVariable.date | ExampleScenario.date | GraphDefinition.date | ImplementationGuide.date | Library.date | Measure.date | MessageDefinition.date | NamingSystem.date | OperationDefinition.date | PlanDefinition.date | Questionnaire.date | Requirements.date | SearchParameter.date | StructureDefinition.date | StructureMap.date | SubscriptionTopic.date | TerminologyCapabilities.date | TestScript.date | ValueSet.date</b><br>
9567   * </p>
9568   */
9569  @SearchParamDefinition(name="date", path="ActivityDefinition.date | ActorDefinition.date | CapabilityStatement.date | ChargeItemDefinition.date | Citation.date | CodeSystem.date | CompartmentDefinition.date | ConceptMap.date | ConditionDefinition.date | EventDefinition.date | Evidence.date | EvidenceVariable.date | ExampleScenario.date | GraphDefinition.date | ImplementationGuide.date | Library.date | Measure.date | MessageDefinition.date | NamingSystem.date | OperationDefinition.date | PlanDefinition.date | Questionnaire.date | Requirements.date | SearchParameter.date | StructureDefinition.date | StructureMap.date | SubscriptionTopic.date | TerminologyCapabilities.date | TestScript.date | ValueSet.date", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): The activity definition publication date\r\n* [ActorDefinition](actordefinition.html): The Actor Definition publication date\r\n* [CapabilityStatement](capabilitystatement.html): The capability statement publication date\r\n* [ChargeItemDefinition](chargeitemdefinition.html): The charge item definition publication date\r\n* [Citation](citation.html): The citation publication date\r\n* [CodeSystem](codesystem.html): The code system publication date\r\n* [CompartmentDefinition](compartmentdefinition.html): The compartment definition publication date\r\n* [ConceptMap](conceptmap.html): The concept map publication date\r\n* [ConditionDefinition](conditiondefinition.html): The condition definition publication date\r\n* [EventDefinition](eventdefinition.html): The event definition publication date\r\n* [Evidence](evidence.html): The evidence publication date\r\n* [EvidenceVariable](evidencevariable.html): The evidence variable publication date\r\n* [ExampleScenario](examplescenario.html): The example scenario publication date\r\n* [GraphDefinition](graphdefinition.html): The graph definition publication date\r\n* [ImplementationGuide](implementationguide.html): The implementation guide publication date\r\n* [Library](library.html): The library publication date\r\n* [Measure](measure.html): The measure publication date\r\n* [MessageDefinition](messagedefinition.html): The message definition publication date\r\n* [NamingSystem](namingsystem.html): The naming system publication date\r\n* [OperationDefinition](operationdefinition.html): The operation definition publication date\r\n* [PlanDefinition](plandefinition.html): The plan definition publication date\r\n* [Questionnaire](questionnaire.html): The questionnaire publication date\r\n* [Requirements](requirements.html): The requirements publication date\r\n* [SearchParameter](searchparameter.html): The search parameter publication date\r\n* [StructureDefinition](structuredefinition.html): The structure definition publication date\r\n* [StructureMap](structuremap.html): The structure map publication date\r\n* [SubscriptionTopic](subscriptiontopic.html): Date status first applied\r\n* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date\r\n* [TestScript](testscript.html): The test script publication date\r\n* [ValueSet](valueset.html): The value set publication date\r\n", type="date" )
9570  public static final String SP_DATE = "date";
9571 /**
9572   * <b>Fluent Client</b> search parameter constant for <b>date</b>
9573   * <p>
9574   * Description: <b>Multiple Resources: 
9575
9576* [ActivityDefinition](activitydefinition.html): The activity definition publication date
9577* [ActorDefinition](actordefinition.html): The Actor Definition publication date
9578* [CapabilityStatement](capabilitystatement.html): The capability statement publication date
9579* [ChargeItemDefinition](chargeitemdefinition.html): The charge item definition publication date
9580* [Citation](citation.html): The citation publication date
9581* [CodeSystem](codesystem.html): The code system publication date
9582* [CompartmentDefinition](compartmentdefinition.html): The compartment definition publication date
9583* [ConceptMap](conceptmap.html): The concept map publication date
9584* [ConditionDefinition](conditiondefinition.html): The condition definition publication date
9585* [EventDefinition](eventdefinition.html): The event definition publication date
9586* [Evidence](evidence.html): The evidence publication date
9587* [EvidenceVariable](evidencevariable.html): The evidence variable publication date
9588* [ExampleScenario](examplescenario.html): The example scenario publication date
9589* [GraphDefinition](graphdefinition.html): The graph definition publication date
9590* [ImplementationGuide](implementationguide.html): The implementation guide publication date
9591* [Library](library.html): The library publication date
9592* [Measure](measure.html): The measure publication date
9593* [MessageDefinition](messagedefinition.html): The message definition publication date
9594* [NamingSystem](namingsystem.html): The naming system publication date
9595* [OperationDefinition](operationdefinition.html): The operation definition publication date
9596* [PlanDefinition](plandefinition.html): The plan definition publication date
9597* [Questionnaire](questionnaire.html): The questionnaire publication date
9598* [Requirements](requirements.html): The requirements publication date
9599* [SearchParameter](searchparameter.html): The search parameter publication date
9600* [StructureDefinition](structuredefinition.html): The structure definition publication date
9601* [StructureMap](structuremap.html): The structure map publication date
9602* [SubscriptionTopic](subscriptiontopic.html): Date status first applied
9603* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date
9604* [TestScript](testscript.html): The test script publication date
9605* [ValueSet](valueset.html): The value set publication date
9606</b><br>
9607   * Type: <b>date</b><br>
9608   * Path: <b>ActivityDefinition.date | ActorDefinition.date | CapabilityStatement.date | ChargeItemDefinition.date | Citation.date | CodeSystem.date | CompartmentDefinition.date | ConceptMap.date | ConditionDefinition.date | EventDefinition.date | Evidence.date | EvidenceVariable.date | ExampleScenario.date | GraphDefinition.date | ImplementationGuide.date | Library.date | Measure.date | MessageDefinition.date | NamingSystem.date | OperationDefinition.date | PlanDefinition.date | Questionnaire.date | Requirements.date | SearchParameter.date | StructureDefinition.date | StructureMap.date | SubscriptionTopic.date | TerminologyCapabilities.date | TestScript.date | ValueSet.date</b><br>
9609   * </p>
9610   */
9611  public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE);
9612
9613 /**
9614   * Search parameter: <b>description</b>
9615   * <p>
9616   * Description: <b>Multiple Resources: 
9617
9618* [ActivityDefinition](activitydefinition.html): The description of the activity definition
9619* [ActorDefinition](actordefinition.html): The description of the Actor Definition
9620* [CapabilityStatement](capabilitystatement.html): The description of the capability statement
9621* [ChargeItemDefinition](chargeitemdefinition.html): The description of the charge item definition
9622* [Citation](citation.html): The description of the citation
9623* [CodeSystem](codesystem.html): The description of the code system
9624* [CompartmentDefinition](compartmentdefinition.html): The description of the compartment definition
9625* [ConceptMap](conceptmap.html): The description of the concept map
9626* [ConditionDefinition](conditiondefinition.html): The description of the condition definition
9627* [EventDefinition](eventdefinition.html): The description of the event definition
9628* [Evidence](evidence.html): The description of the evidence
9629* [EvidenceVariable](evidencevariable.html): The description of the evidence variable
9630* [GraphDefinition](graphdefinition.html): The description of the graph definition
9631* [ImplementationGuide](implementationguide.html): The description of the implementation guide
9632* [Library](library.html): The description of the library
9633* [Measure](measure.html): The description of the measure
9634* [MessageDefinition](messagedefinition.html): The description of the message definition
9635* [NamingSystem](namingsystem.html): The description of the naming system
9636* [OperationDefinition](operationdefinition.html): The description of the operation definition
9637* [PlanDefinition](plandefinition.html): The description of the plan definition
9638* [Questionnaire](questionnaire.html): The description of the questionnaire
9639* [Requirements](requirements.html): The description of the requirements
9640* [SearchParameter](searchparameter.html): The description of the search parameter
9641* [StructureDefinition](structuredefinition.html): The description of the structure definition
9642* [StructureMap](structuremap.html): The description of the structure map
9643* [TerminologyCapabilities](terminologycapabilities.html): The description of the terminology capabilities
9644* [TestScript](testscript.html): The description of the test script
9645* [ValueSet](valueset.html): The description of the value set
9646</b><br>
9647   * Type: <b>string</b><br>
9648   * Path: <b>ActivityDefinition.description | ActorDefinition.description | CapabilityStatement.description | ChargeItemDefinition.description | Citation.description | CodeSystem.description | CompartmentDefinition.description | ConceptMap.description | ConditionDefinition.description | EventDefinition.description | Evidence.description | EvidenceVariable.description | GraphDefinition.description | ImplementationGuide.description | Library.description | Measure.description | MessageDefinition.description | NamingSystem.description | OperationDefinition.description | PlanDefinition.description | Questionnaire.description | Requirements.description | SearchParameter.description | StructureDefinition.description | StructureMap.description | TerminologyCapabilities.description | TestScript.description | ValueSet.description</b><br>
9649   * </p>
9650   */
9651  @SearchParamDefinition(name="description", path="ActivityDefinition.description | ActorDefinition.description | CapabilityStatement.description | ChargeItemDefinition.description | Citation.description | CodeSystem.description | CompartmentDefinition.description | ConceptMap.description | ConditionDefinition.description | EventDefinition.description | Evidence.description | EvidenceVariable.description | GraphDefinition.description | ImplementationGuide.description | Library.description | Measure.description | MessageDefinition.description | NamingSystem.description | OperationDefinition.description | PlanDefinition.description | Questionnaire.description | Requirements.description | SearchParameter.description | StructureDefinition.description | StructureMap.description | TerminologyCapabilities.description | TestScript.description | ValueSet.description", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): The description of the activity definition\r\n* [ActorDefinition](actordefinition.html): The description of the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): The description of the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): The description of the charge item definition\r\n* [Citation](citation.html): The description of the citation\r\n* [CodeSystem](codesystem.html): The description of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): The description of the compartment definition\r\n* [ConceptMap](conceptmap.html): The description of the concept map\r\n* [ConditionDefinition](conditiondefinition.html): The description of the condition definition\r\n* [EventDefinition](eventdefinition.html): The description of the event definition\r\n* [Evidence](evidence.html): The description of the evidence\r\n* [EvidenceVariable](evidencevariable.html): The description of the evidence variable\r\n* [GraphDefinition](graphdefinition.html): The description of the graph definition\r\n* [ImplementationGuide](implementationguide.html): The description of the implementation guide\r\n* [Library](library.html): The description of the library\r\n* [Measure](measure.html): The description of the measure\r\n* [MessageDefinition](messagedefinition.html): The description of the message definition\r\n* [NamingSystem](namingsystem.html): The description of the naming system\r\n* [OperationDefinition](operationdefinition.html): The description of the operation definition\r\n* [PlanDefinition](plandefinition.html): The description of the plan definition\r\n* [Questionnaire](questionnaire.html): The description of the questionnaire\r\n* [Requirements](requirements.html): The description of the requirements\r\n* [SearchParameter](searchparameter.html): The description of the search parameter\r\n* [StructureDefinition](structuredefinition.html): The description of the structure definition\r\n* [StructureMap](structuremap.html): The description of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): The description of the terminology capabilities\r\n* [TestScript](testscript.html): The description of the test script\r\n* [ValueSet](valueset.html): The description of the value set\r\n", type="string" )
9652  public static final String SP_DESCRIPTION = "description";
9653 /**
9654   * <b>Fluent Client</b> search parameter constant for <b>description</b>
9655   * <p>
9656   * Description: <b>Multiple Resources: 
9657
9658* [ActivityDefinition](activitydefinition.html): The description of the activity definition
9659* [ActorDefinition](actordefinition.html): The description of the Actor Definition
9660* [CapabilityStatement](capabilitystatement.html): The description of the capability statement
9661* [ChargeItemDefinition](chargeitemdefinition.html): The description of the charge item definition
9662* [Citation](citation.html): The description of the citation
9663* [CodeSystem](codesystem.html): The description of the code system
9664* [CompartmentDefinition](compartmentdefinition.html): The description of the compartment definition
9665* [ConceptMap](conceptmap.html): The description of the concept map
9666* [ConditionDefinition](conditiondefinition.html): The description of the condition definition
9667* [EventDefinition](eventdefinition.html): The description of the event definition
9668* [Evidence](evidence.html): The description of the evidence
9669* [EvidenceVariable](evidencevariable.html): The description of the evidence variable
9670* [GraphDefinition](graphdefinition.html): The description of the graph definition
9671* [ImplementationGuide](implementationguide.html): The description of the implementation guide
9672* [Library](library.html): The description of the library
9673* [Measure](measure.html): The description of the measure
9674* [MessageDefinition](messagedefinition.html): The description of the message definition
9675* [NamingSystem](namingsystem.html): The description of the naming system
9676* [OperationDefinition](operationdefinition.html): The description of the operation definition
9677* [PlanDefinition](plandefinition.html): The description of the plan definition
9678* [Questionnaire](questionnaire.html): The description of the questionnaire
9679* [Requirements](requirements.html): The description of the requirements
9680* [SearchParameter](searchparameter.html): The description of the search parameter
9681* [StructureDefinition](structuredefinition.html): The description of the structure definition
9682* [StructureMap](structuremap.html): The description of the structure map
9683* [TerminologyCapabilities](terminologycapabilities.html): The description of the terminology capabilities
9684* [TestScript](testscript.html): The description of the test script
9685* [ValueSet](valueset.html): The description of the value set
9686</b><br>
9687   * Type: <b>string</b><br>
9688   * Path: <b>ActivityDefinition.description | ActorDefinition.description | CapabilityStatement.description | ChargeItemDefinition.description | Citation.description | CodeSystem.description | CompartmentDefinition.description | ConceptMap.description | ConditionDefinition.description | EventDefinition.description | Evidence.description | EvidenceVariable.description | GraphDefinition.description | ImplementationGuide.description | Library.description | Measure.description | MessageDefinition.description | NamingSystem.description | OperationDefinition.description | PlanDefinition.description | Questionnaire.description | Requirements.description | SearchParameter.description | StructureDefinition.description | StructureMap.description | TerminologyCapabilities.description | TestScript.description | ValueSet.description</b><br>
9689   * </p>
9690   */
9691  public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION);
9692
9693 /**
9694   * Search parameter: <b>identifier</b>
9695   * <p>
9696   * Description: <b>Multiple Resources: 
9697
9698* [ActivityDefinition](activitydefinition.html): External identifier for the activity definition
9699* [ActorDefinition](actordefinition.html): External identifier for the Actor Definition
9700* [CapabilityStatement](capabilitystatement.html): External identifier for the capability statement
9701* [ChargeItemDefinition](chargeitemdefinition.html): External identifier for the charge item definition
9702* [Citation](citation.html): External identifier for the citation
9703* [CodeSystem](codesystem.html): External identifier for the code system
9704* [ConceptMap](conceptmap.html): External identifier for the concept map
9705* [ConditionDefinition](conditiondefinition.html): External identifier for the condition definition
9706* [EventDefinition](eventdefinition.html): External identifier for the event definition
9707* [Evidence](evidence.html): External identifier for the evidence
9708* [EvidenceReport](evidencereport.html): External identifier for the evidence report
9709* [EvidenceVariable](evidencevariable.html): External identifier for the evidence variable
9710* [ExampleScenario](examplescenario.html): External identifier for the example scenario
9711* [GraphDefinition](graphdefinition.html): External identifier for the graph definition
9712* [ImplementationGuide](implementationguide.html): External identifier for the implementation guide
9713* [Library](library.html): External identifier for the library
9714* [Measure](measure.html): External identifier for the measure
9715* [MedicationKnowledge](medicationknowledge.html): Business identifier for this medication
9716* [MessageDefinition](messagedefinition.html): External identifier for the message definition
9717* [NamingSystem](namingsystem.html): External identifier for the naming system
9718* [ObservationDefinition](observationdefinition.html): The unique identifier associated with the specimen definition
9719* [OperationDefinition](operationdefinition.html): External identifier for the search parameter
9720* [PlanDefinition](plandefinition.html): External identifier for the plan definition
9721* [Questionnaire](questionnaire.html): External identifier for the questionnaire
9722* [Requirements](requirements.html): External identifier for the requirements
9723* [SearchParameter](searchparameter.html): External identifier for the search parameter
9724* [SpecimenDefinition](specimendefinition.html): The unique identifier associated with the SpecimenDefinition
9725* [StructureDefinition](structuredefinition.html): External identifier for the structure definition
9726* [StructureMap](structuremap.html): External identifier for the structure map
9727* [SubscriptionTopic](subscriptiontopic.html): Business Identifier for SubscriptionTopic
9728* [TerminologyCapabilities](terminologycapabilities.html): External identifier for the terminology capabilities
9729* [TestPlan](testplan.html): An identifier for the test plan
9730* [TestScript](testscript.html): External identifier for the test script
9731* [ValueSet](valueset.html): External identifier for the value set
9732</b><br>
9733   * Type: <b>token</b><br>
9734   * Path: <b>ActivityDefinition.identifier | ActorDefinition.identifier | CapabilityStatement.identifier | ChargeItemDefinition.identifier | Citation.identifier | CodeSystem.identifier | ConceptMap.identifier | ConditionDefinition.identifier | EventDefinition.identifier | Evidence.identifier | EvidenceReport.identifier | EvidenceVariable.identifier | ExampleScenario.identifier | GraphDefinition.identifier | ImplementationGuide.identifier | Library.identifier | Measure.identifier | MedicationKnowledge.identifier | MessageDefinition.identifier | NamingSystem.identifier | ObservationDefinition.identifier | OperationDefinition.identifier | PlanDefinition.identifier | Questionnaire.identifier | Requirements.identifier | SearchParameter.identifier | SpecimenDefinition.identifier | StructureDefinition.identifier | StructureMap.identifier | SubscriptionTopic.identifier | TerminologyCapabilities.identifier | TestPlan.identifier | TestScript.identifier | ValueSet.identifier</b><br>
9735   * </p>
9736   */
9737  @SearchParamDefinition(name="identifier", path="ActivityDefinition.identifier | ActorDefinition.identifier | CapabilityStatement.identifier | ChargeItemDefinition.identifier | Citation.identifier | CodeSystem.identifier | ConceptMap.identifier | ConditionDefinition.identifier | EventDefinition.identifier | Evidence.identifier | EvidenceReport.identifier | EvidenceVariable.identifier | ExampleScenario.identifier | GraphDefinition.identifier | ImplementationGuide.identifier | Library.identifier | Measure.identifier | MedicationKnowledge.identifier | MessageDefinition.identifier | NamingSystem.identifier | ObservationDefinition.identifier | OperationDefinition.identifier | PlanDefinition.identifier | Questionnaire.identifier | Requirements.identifier | SearchParameter.identifier | SpecimenDefinition.identifier | StructureDefinition.identifier | StructureMap.identifier | SubscriptionTopic.identifier | TerminologyCapabilities.identifier | TestPlan.identifier | TestScript.identifier | ValueSet.identifier", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): External identifier for the activity definition\r\n* [ActorDefinition](actordefinition.html): External identifier for the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): External identifier for the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): External identifier for the charge item definition\r\n* [Citation](citation.html): External identifier for the citation\r\n* [CodeSystem](codesystem.html): External identifier for the code system\r\n* [ConceptMap](conceptmap.html): External identifier for the concept map\r\n* [ConditionDefinition](conditiondefinition.html): External identifier for the condition definition\r\n* [EventDefinition](eventdefinition.html): External identifier for the event definition\r\n* [Evidence](evidence.html): External identifier for the evidence\r\n* [EvidenceReport](evidencereport.html): External identifier for the evidence report\r\n* [EvidenceVariable](evidencevariable.html): External identifier for the evidence variable\r\n* [ExampleScenario](examplescenario.html): External identifier for the example scenario\r\n* [GraphDefinition](graphdefinition.html): External identifier for the graph definition\r\n* [ImplementationGuide](implementationguide.html): External identifier for the implementation guide\r\n* [Library](library.html): External identifier for the library\r\n* [Measure](measure.html): External identifier for the measure\r\n* [MedicationKnowledge](medicationknowledge.html): Business identifier for this medication\r\n* [MessageDefinition](messagedefinition.html): External identifier for the message definition\r\n* [NamingSystem](namingsystem.html): External identifier for the naming system\r\n* [ObservationDefinition](observationdefinition.html): The unique identifier associated with the specimen definition\r\n* [OperationDefinition](operationdefinition.html): External identifier for the search parameter\r\n* [PlanDefinition](plandefinition.html): External identifier for the plan definition\r\n* [Questionnaire](questionnaire.html): External identifier for the questionnaire\r\n* [Requirements](requirements.html): External identifier for the requirements\r\n* [SearchParameter](searchparameter.html): External identifier for the search parameter\r\n* [SpecimenDefinition](specimendefinition.html): The unique identifier associated with the SpecimenDefinition\r\n* [StructureDefinition](structuredefinition.html): External identifier for the structure definition\r\n* [StructureMap](structuremap.html): External identifier for the structure map\r\n* [SubscriptionTopic](subscriptiontopic.html): Business Identifier for SubscriptionTopic\r\n* [TerminologyCapabilities](terminologycapabilities.html): External identifier for the terminology capabilities\r\n* [TestPlan](testplan.html): An identifier for the test plan\r\n* [TestScript](testscript.html): External identifier for the test script\r\n* [ValueSet](valueset.html): External identifier for the value set\r\n", type="token" )
9738  public static final String SP_IDENTIFIER = "identifier";
9739 /**
9740   * <b>Fluent Client</b> search parameter constant for <b>identifier</b>
9741   * <p>
9742   * Description: <b>Multiple Resources: 
9743
9744* [ActivityDefinition](activitydefinition.html): External identifier for the activity definition
9745* [ActorDefinition](actordefinition.html): External identifier for the Actor Definition
9746* [CapabilityStatement](capabilitystatement.html): External identifier for the capability statement
9747* [ChargeItemDefinition](chargeitemdefinition.html): External identifier for the charge item definition
9748* [Citation](citation.html): External identifier for the citation
9749* [CodeSystem](codesystem.html): External identifier for the code system
9750* [ConceptMap](conceptmap.html): External identifier for the concept map
9751* [ConditionDefinition](conditiondefinition.html): External identifier for the condition definition
9752* [EventDefinition](eventdefinition.html): External identifier for the event definition
9753* [Evidence](evidence.html): External identifier for the evidence
9754* [EvidenceReport](evidencereport.html): External identifier for the evidence report
9755* [EvidenceVariable](evidencevariable.html): External identifier for the evidence variable
9756* [ExampleScenario](examplescenario.html): External identifier for the example scenario
9757* [GraphDefinition](graphdefinition.html): External identifier for the graph definition
9758* [ImplementationGuide](implementationguide.html): External identifier for the implementation guide
9759* [Library](library.html): External identifier for the library
9760* [Measure](measure.html): External identifier for the measure
9761* [MedicationKnowledge](medicationknowledge.html): Business identifier for this medication
9762* [MessageDefinition](messagedefinition.html): External identifier for the message definition
9763* [NamingSystem](namingsystem.html): External identifier for the naming system
9764* [ObservationDefinition](observationdefinition.html): The unique identifier associated with the specimen definition
9765* [OperationDefinition](operationdefinition.html): External identifier for the search parameter
9766* [PlanDefinition](plandefinition.html): External identifier for the plan definition
9767* [Questionnaire](questionnaire.html): External identifier for the questionnaire
9768* [Requirements](requirements.html): External identifier for the requirements
9769* [SearchParameter](searchparameter.html): External identifier for the search parameter
9770* [SpecimenDefinition](specimendefinition.html): The unique identifier associated with the SpecimenDefinition
9771* [StructureDefinition](structuredefinition.html): External identifier for the structure definition
9772* [StructureMap](structuremap.html): External identifier for the structure map
9773* [SubscriptionTopic](subscriptiontopic.html): Business Identifier for SubscriptionTopic
9774* [TerminologyCapabilities](terminologycapabilities.html): External identifier for the terminology capabilities
9775* [TestPlan](testplan.html): An identifier for the test plan
9776* [TestScript](testscript.html): External identifier for the test script
9777* [ValueSet](valueset.html): External identifier for the value set
9778</b><br>
9779   * Type: <b>token</b><br>
9780   * Path: <b>ActivityDefinition.identifier | ActorDefinition.identifier | CapabilityStatement.identifier | ChargeItemDefinition.identifier | Citation.identifier | CodeSystem.identifier | ConceptMap.identifier | ConditionDefinition.identifier | EventDefinition.identifier | Evidence.identifier | EvidenceReport.identifier | EvidenceVariable.identifier | ExampleScenario.identifier | GraphDefinition.identifier | ImplementationGuide.identifier | Library.identifier | Measure.identifier | MedicationKnowledge.identifier | MessageDefinition.identifier | NamingSystem.identifier | ObservationDefinition.identifier | OperationDefinition.identifier | PlanDefinition.identifier | Questionnaire.identifier | Requirements.identifier | SearchParameter.identifier | SpecimenDefinition.identifier | StructureDefinition.identifier | StructureMap.identifier | SubscriptionTopic.identifier | TerminologyCapabilities.identifier | TestPlan.identifier | TestScript.identifier | ValueSet.identifier</b><br>
9781   * </p>
9782   */
9783  public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER);
9784
9785 /**
9786   * Search parameter: <b>jurisdiction</b>
9787   * <p>
9788   * Description: <b>Multiple Resources: 
9789
9790* [ActivityDefinition](activitydefinition.html): Intended jurisdiction for the activity definition
9791* [ActorDefinition](actordefinition.html): Intended jurisdiction for the Actor Definition
9792* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement
9793* [ChargeItemDefinition](chargeitemdefinition.html): Intended jurisdiction for the charge item definition
9794* [Citation](citation.html): Intended jurisdiction for the citation
9795* [CodeSystem](codesystem.html): Intended jurisdiction for the code system
9796* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map
9797* [ConditionDefinition](conditiondefinition.html): Intended jurisdiction for the condition definition
9798* [EventDefinition](eventdefinition.html): Intended jurisdiction for the event definition
9799* [ExampleScenario](examplescenario.html): Intended jurisdiction for the example scenario
9800* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition
9801* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide
9802* [Library](library.html): Intended jurisdiction for the library
9803* [Measure](measure.html): Intended jurisdiction for the measure
9804* [MessageDefinition](messagedefinition.html): Intended jurisdiction for the message definition
9805* [NamingSystem](namingsystem.html): Intended jurisdiction for the naming system
9806* [OperationDefinition](operationdefinition.html): Intended jurisdiction for the operation definition
9807* [PlanDefinition](plandefinition.html): Intended jurisdiction for the plan definition
9808* [Questionnaire](questionnaire.html): Intended jurisdiction for the questionnaire
9809* [Requirements](requirements.html): Intended jurisdiction for the requirements
9810* [SearchParameter](searchparameter.html): Intended jurisdiction for the search parameter
9811* [StructureDefinition](structuredefinition.html): Intended jurisdiction for the structure definition
9812* [StructureMap](structuremap.html): Intended jurisdiction for the structure map
9813* [TerminologyCapabilities](terminologycapabilities.html): Intended jurisdiction for the terminology capabilities
9814* [TestScript](testscript.html): Intended jurisdiction for the test script
9815* [ValueSet](valueset.html): Intended jurisdiction for the value set
9816</b><br>
9817   * Type: <b>token</b><br>
9818   * Path: <b>ActivityDefinition.jurisdiction | ActorDefinition.jurisdiction | CapabilityStatement.jurisdiction | ChargeItemDefinition.jurisdiction | Citation.jurisdiction | CodeSystem.jurisdiction | ConceptMap.jurisdiction | ConditionDefinition.jurisdiction | EventDefinition.jurisdiction | ExampleScenario.jurisdiction | GraphDefinition.jurisdiction | ImplementationGuide.jurisdiction | Library.jurisdiction | Measure.jurisdiction | MessageDefinition.jurisdiction | NamingSystem.jurisdiction | OperationDefinition.jurisdiction | PlanDefinition.jurisdiction | Questionnaire.jurisdiction | Requirements.jurisdiction | SearchParameter.jurisdiction | StructureDefinition.jurisdiction | StructureMap.jurisdiction | TerminologyCapabilities.jurisdiction | TestScript.jurisdiction | ValueSet.jurisdiction</b><br>
9819   * </p>
9820   */
9821  @SearchParamDefinition(name="jurisdiction", path="ActivityDefinition.jurisdiction | ActorDefinition.jurisdiction | CapabilityStatement.jurisdiction | ChargeItemDefinition.jurisdiction | Citation.jurisdiction | CodeSystem.jurisdiction | ConceptMap.jurisdiction | ConditionDefinition.jurisdiction | EventDefinition.jurisdiction | ExampleScenario.jurisdiction | GraphDefinition.jurisdiction | ImplementationGuide.jurisdiction | Library.jurisdiction | Measure.jurisdiction | MessageDefinition.jurisdiction | NamingSystem.jurisdiction | OperationDefinition.jurisdiction | PlanDefinition.jurisdiction | Questionnaire.jurisdiction | Requirements.jurisdiction | SearchParameter.jurisdiction | StructureDefinition.jurisdiction | StructureMap.jurisdiction | TerminologyCapabilities.jurisdiction | TestScript.jurisdiction | ValueSet.jurisdiction", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): Intended jurisdiction for the activity definition\r\n* [ActorDefinition](actordefinition.html): Intended jurisdiction for the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): Intended jurisdiction for the charge item definition\r\n* [Citation](citation.html): Intended jurisdiction for the citation\r\n* [CodeSystem](codesystem.html): Intended jurisdiction for the code system\r\n* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map\r\n* [ConditionDefinition](conditiondefinition.html): Intended jurisdiction for the condition definition\r\n* [EventDefinition](eventdefinition.html): Intended jurisdiction for the event definition\r\n* [ExampleScenario](examplescenario.html): Intended jurisdiction for the example scenario\r\n* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition\r\n* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide\r\n* [Library](library.html): Intended jurisdiction for the library\r\n* [Measure](measure.html): Intended jurisdiction for the measure\r\n* [MessageDefinition](messagedefinition.html): Intended jurisdiction for the message definition\r\n* [NamingSystem](namingsystem.html): Intended jurisdiction for the naming system\r\n* [OperationDefinition](operationdefinition.html): Intended jurisdiction for the operation definition\r\n* [PlanDefinition](plandefinition.html): Intended jurisdiction for the plan definition\r\n* [Questionnaire](questionnaire.html): Intended jurisdiction for the questionnaire\r\n* [Requirements](requirements.html): Intended jurisdiction for the requirements\r\n* [SearchParameter](searchparameter.html): Intended jurisdiction for the search parameter\r\n* [StructureDefinition](structuredefinition.html): Intended jurisdiction for the structure definition\r\n* [StructureMap](structuremap.html): Intended jurisdiction for the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): Intended jurisdiction for the terminology capabilities\r\n* [TestScript](testscript.html): Intended jurisdiction for the test script\r\n* [ValueSet](valueset.html): Intended jurisdiction for the value set\r\n", type="token" )
9822  public static final String SP_JURISDICTION = "jurisdiction";
9823 /**
9824   * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b>
9825   * <p>
9826   * Description: <b>Multiple Resources: 
9827
9828* [ActivityDefinition](activitydefinition.html): Intended jurisdiction for the activity definition
9829* [ActorDefinition](actordefinition.html): Intended jurisdiction for the Actor Definition
9830* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement
9831* [ChargeItemDefinition](chargeitemdefinition.html): Intended jurisdiction for the charge item definition
9832* [Citation](citation.html): Intended jurisdiction for the citation
9833* [CodeSystem](codesystem.html): Intended jurisdiction for the code system
9834* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map
9835* [ConditionDefinition](conditiondefinition.html): Intended jurisdiction for the condition definition
9836* [EventDefinition](eventdefinition.html): Intended jurisdiction for the event definition
9837* [ExampleScenario](examplescenario.html): Intended jurisdiction for the example scenario
9838* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition
9839* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide
9840* [Library](library.html): Intended jurisdiction for the library
9841* [Measure](measure.html): Intended jurisdiction for the measure
9842* [MessageDefinition](messagedefinition.html): Intended jurisdiction for the message definition
9843* [NamingSystem](namingsystem.html): Intended jurisdiction for the naming system
9844* [OperationDefinition](operationdefinition.html): Intended jurisdiction for the operation definition
9845* [PlanDefinition](plandefinition.html): Intended jurisdiction for the plan definition
9846* [Questionnaire](questionnaire.html): Intended jurisdiction for the questionnaire
9847* [Requirements](requirements.html): Intended jurisdiction for the requirements
9848* [SearchParameter](searchparameter.html): Intended jurisdiction for the search parameter
9849* [StructureDefinition](structuredefinition.html): Intended jurisdiction for the structure definition
9850* [StructureMap](structuremap.html): Intended jurisdiction for the structure map
9851* [TerminologyCapabilities](terminologycapabilities.html): Intended jurisdiction for the terminology capabilities
9852* [TestScript](testscript.html): Intended jurisdiction for the test script
9853* [ValueSet](valueset.html): Intended jurisdiction for the value set
9854</b><br>
9855   * Type: <b>token</b><br>
9856   * Path: <b>ActivityDefinition.jurisdiction | ActorDefinition.jurisdiction | CapabilityStatement.jurisdiction | ChargeItemDefinition.jurisdiction | Citation.jurisdiction | CodeSystem.jurisdiction | ConceptMap.jurisdiction | ConditionDefinition.jurisdiction | EventDefinition.jurisdiction | ExampleScenario.jurisdiction | GraphDefinition.jurisdiction | ImplementationGuide.jurisdiction | Library.jurisdiction | Measure.jurisdiction | MessageDefinition.jurisdiction | NamingSystem.jurisdiction | OperationDefinition.jurisdiction | PlanDefinition.jurisdiction | Questionnaire.jurisdiction | Requirements.jurisdiction | SearchParameter.jurisdiction | StructureDefinition.jurisdiction | StructureMap.jurisdiction | TerminologyCapabilities.jurisdiction | TestScript.jurisdiction | ValueSet.jurisdiction</b><br>
9857   * </p>
9858   */
9859  public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_JURISDICTION);
9860
9861 /**
9862   * Search parameter: <b>name</b>
9863   * <p>
9864   * Description: <b>Multiple Resources: 
9865
9866* [ActivityDefinition](activitydefinition.html): Computationally friendly name of the activity definition
9867* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement
9868* [Citation](citation.html): Computationally friendly name of the citation
9869* [CodeSystem](codesystem.html): Computationally friendly name of the code system
9870* [CompartmentDefinition](compartmentdefinition.html): Computationally friendly name of the compartment definition
9871* [ConceptMap](conceptmap.html): Computationally friendly name of the concept map
9872* [ConditionDefinition](conditiondefinition.html): Computationally friendly name of the condition definition
9873* [EventDefinition](eventdefinition.html): Computationally friendly name of the event definition
9874* [EvidenceVariable](evidencevariable.html): Computationally friendly name of the evidence variable
9875* [ExampleScenario](examplescenario.html): Computationally friendly name of the example scenario
9876* [GraphDefinition](graphdefinition.html): Computationally friendly name of the graph definition
9877* [ImplementationGuide](implementationguide.html): Computationally friendly name of the implementation guide
9878* [Library](library.html): Computationally friendly name of the library
9879* [Measure](measure.html): Computationally friendly name of the measure
9880* [MessageDefinition](messagedefinition.html): Computationally friendly name of the message definition
9881* [NamingSystem](namingsystem.html): Computationally friendly name of the naming system
9882* [OperationDefinition](operationdefinition.html): Computationally friendly name of the operation definition
9883* [PlanDefinition](plandefinition.html): Computationally friendly name of the plan definition
9884* [Questionnaire](questionnaire.html): Computationally friendly name of the questionnaire
9885* [Requirements](requirements.html): Computationally friendly name of the requirements
9886* [SearchParameter](searchparameter.html): Computationally friendly name of the search parameter
9887* [StructureDefinition](structuredefinition.html): Computationally friendly name of the structure definition
9888* [StructureMap](structuremap.html): Computationally friendly name of the structure map
9889* [TerminologyCapabilities](terminologycapabilities.html): Computationally friendly name of the terminology capabilities
9890* [TestScript](testscript.html): Computationally friendly name of the test script
9891* [ValueSet](valueset.html): Computationally friendly name of the value set
9892</b><br>
9893   * Type: <b>string</b><br>
9894   * Path: <b>ActivityDefinition.name | CapabilityStatement.name | Citation.name | CodeSystem.name | CompartmentDefinition.name | ConceptMap.name | ConditionDefinition.name | EventDefinition.name | EvidenceVariable.name | ExampleScenario.name | GraphDefinition.name | ImplementationGuide.name | Library.name | Measure.name | MessageDefinition.name | NamingSystem.name | OperationDefinition.name | PlanDefinition.name | Questionnaire.name | Requirements.name | SearchParameter.name | StructureDefinition.name | StructureMap.name | TerminologyCapabilities.name | TestScript.name | ValueSet.name</b><br>
9895   * </p>
9896   */
9897  @SearchParamDefinition(name="name", path="ActivityDefinition.name | CapabilityStatement.name | Citation.name | CodeSystem.name | CompartmentDefinition.name | ConceptMap.name | ConditionDefinition.name | EventDefinition.name | EvidenceVariable.name | ExampleScenario.name | GraphDefinition.name | ImplementationGuide.name | Library.name | Measure.name | MessageDefinition.name | NamingSystem.name | OperationDefinition.name | PlanDefinition.name | Questionnaire.name | Requirements.name | SearchParameter.name | StructureDefinition.name | StructureMap.name | TerminologyCapabilities.name | TestScript.name | ValueSet.name", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): Computationally friendly name of the activity definition\r\n* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement\r\n* [Citation](citation.html): Computationally friendly name of the citation\r\n* [CodeSystem](codesystem.html): Computationally friendly name of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): Computationally friendly name of the compartment definition\r\n* [ConceptMap](conceptmap.html): Computationally friendly name of the concept map\r\n* [ConditionDefinition](conditiondefinition.html): Computationally friendly name of the condition definition\r\n* [EventDefinition](eventdefinition.html): Computationally friendly name of the event definition\r\n* [EvidenceVariable](evidencevariable.html): Computationally friendly name of the evidence variable\r\n* [ExampleScenario](examplescenario.html): Computationally friendly name of the example scenario\r\n* [GraphDefinition](graphdefinition.html): Computationally friendly name of the graph definition\r\n* [ImplementationGuide](implementationguide.html): Computationally friendly name of the implementation guide\r\n* [Library](library.html): Computationally friendly name of the library\r\n* [Measure](measure.html): Computationally friendly name of the measure\r\n* [MessageDefinition](messagedefinition.html): Computationally friendly name of the message definition\r\n* [NamingSystem](namingsystem.html): Computationally friendly name of the naming system\r\n* [OperationDefinition](operationdefinition.html): Computationally friendly name of the operation definition\r\n* [PlanDefinition](plandefinition.html): Computationally friendly name of the plan definition\r\n* [Questionnaire](questionnaire.html): Computationally friendly name of the questionnaire\r\n* [Requirements](requirements.html): Computationally friendly name of the requirements\r\n* [SearchParameter](searchparameter.html): Computationally friendly name of the search parameter\r\n* [StructureDefinition](structuredefinition.html): Computationally friendly name of the structure definition\r\n* [StructureMap](structuremap.html): Computationally friendly name of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): Computationally friendly name of the terminology capabilities\r\n* [TestScript](testscript.html): Computationally friendly name of the test script\r\n* [ValueSet](valueset.html): Computationally friendly name of the value set\r\n", type="string" )
9898  public static final String SP_NAME = "name";
9899 /**
9900   * <b>Fluent Client</b> search parameter constant for <b>name</b>
9901   * <p>
9902   * Description: <b>Multiple Resources: 
9903
9904* [ActivityDefinition](activitydefinition.html): Computationally friendly name of the activity definition
9905* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement
9906* [Citation](citation.html): Computationally friendly name of the citation
9907* [CodeSystem](codesystem.html): Computationally friendly name of the code system
9908* [CompartmentDefinition](compartmentdefinition.html): Computationally friendly name of the compartment definition
9909* [ConceptMap](conceptmap.html): Computationally friendly name of the concept map
9910* [ConditionDefinition](conditiondefinition.html): Computationally friendly name of the condition definition
9911* [EventDefinition](eventdefinition.html): Computationally friendly name of the event definition
9912* [EvidenceVariable](evidencevariable.html): Computationally friendly name of the evidence variable
9913* [ExampleScenario](examplescenario.html): Computationally friendly name of the example scenario
9914* [GraphDefinition](graphdefinition.html): Computationally friendly name of the graph definition
9915* [ImplementationGuide](implementationguide.html): Computationally friendly name of the implementation guide
9916* [Library](library.html): Computationally friendly name of the library
9917* [Measure](measure.html): Computationally friendly name of the measure
9918* [MessageDefinition](messagedefinition.html): Computationally friendly name of the message definition
9919* [NamingSystem](namingsystem.html): Computationally friendly name of the naming system
9920* [OperationDefinition](operationdefinition.html): Computationally friendly name of the operation definition
9921* [PlanDefinition](plandefinition.html): Computationally friendly name of the plan definition
9922* [Questionnaire](questionnaire.html): Computationally friendly name of the questionnaire
9923* [Requirements](requirements.html): Computationally friendly name of the requirements
9924* [SearchParameter](searchparameter.html): Computationally friendly name of the search parameter
9925* [StructureDefinition](structuredefinition.html): Computationally friendly name of the structure definition
9926* [StructureMap](structuremap.html): Computationally friendly name of the structure map
9927* [TerminologyCapabilities](terminologycapabilities.html): Computationally friendly name of the terminology capabilities
9928* [TestScript](testscript.html): Computationally friendly name of the test script
9929* [ValueSet](valueset.html): Computationally friendly name of the value set
9930</b><br>
9931   * Type: <b>string</b><br>
9932   * Path: <b>ActivityDefinition.name | CapabilityStatement.name | Citation.name | CodeSystem.name | CompartmentDefinition.name | ConceptMap.name | ConditionDefinition.name | EventDefinition.name | EvidenceVariable.name | ExampleScenario.name | GraphDefinition.name | ImplementationGuide.name | Library.name | Measure.name | MessageDefinition.name | NamingSystem.name | OperationDefinition.name | PlanDefinition.name | Questionnaire.name | Requirements.name | SearchParameter.name | StructureDefinition.name | StructureMap.name | TerminologyCapabilities.name | TestScript.name | ValueSet.name</b><br>
9933   * </p>
9934   */
9935  public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME);
9936
9937 /**
9938   * Search parameter: <b>publisher</b>
9939   * <p>
9940   * Description: <b>Multiple Resources: 
9941
9942* [ActivityDefinition](activitydefinition.html): Name of the publisher of the activity definition
9943* [ActorDefinition](actordefinition.html): Name of the publisher of the Actor Definition
9944* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement
9945* [ChargeItemDefinition](chargeitemdefinition.html): Name of the publisher of the charge item definition
9946* [Citation](citation.html): Name of the publisher of the citation
9947* [CodeSystem](codesystem.html): Name of the publisher of the code system
9948* [CompartmentDefinition](compartmentdefinition.html): Name of the publisher of the compartment definition
9949* [ConceptMap](conceptmap.html): Name of the publisher of the concept map
9950* [ConditionDefinition](conditiondefinition.html): Name of the publisher of the condition definition
9951* [EventDefinition](eventdefinition.html): Name of the publisher of the event definition
9952* [Evidence](evidence.html): Name of the publisher of the evidence
9953* [EvidenceReport](evidencereport.html): Name of the publisher of the evidence report
9954* [EvidenceVariable](evidencevariable.html): Name of the publisher of the evidence variable
9955* [ExampleScenario](examplescenario.html): Name of the publisher of the example scenario
9956* [GraphDefinition](graphdefinition.html): Name of the publisher of the graph definition
9957* [ImplementationGuide](implementationguide.html): Name of the publisher of the implementation guide
9958* [Library](library.html): Name of the publisher of the library
9959* [Measure](measure.html): Name of the publisher of the measure
9960* [MessageDefinition](messagedefinition.html): Name of the publisher of the message definition
9961* [NamingSystem](namingsystem.html): Name of the publisher of the naming system
9962* [OperationDefinition](operationdefinition.html): Name of the publisher of the operation definition
9963* [PlanDefinition](plandefinition.html): Name of the publisher of the plan definition
9964* [Questionnaire](questionnaire.html): Name of the publisher of the questionnaire
9965* [Requirements](requirements.html): Name of the publisher of the requirements
9966* [SearchParameter](searchparameter.html): Name of the publisher of the search parameter
9967* [StructureDefinition](structuredefinition.html): Name of the publisher of the structure definition
9968* [StructureMap](structuremap.html): Name of the publisher of the structure map
9969* [TerminologyCapabilities](terminologycapabilities.html): Name of the publisher of the terminology capabilities
9970* [TestScript](testscript.html): Name of the publisher of the test script
9971* [ValueSet](valueset.html): Name of the publisher of the value set
9972</b><br>
9973   * Type: <b>string</b><br>
9974   * Path: <b>ActivityDefinition.publisher | ActorDefinition.publisher | CapabilityStatement.publisher | ChargeItemDefinition.publisher | Citation.publisher | CodeSystem.publisher | CompartmentDefinition.publisher | ConceptMap.publisher | ConditionDefinition.publisher | EventDefinition.publisher | Evidence.publisher | EvidenceReport.publisher | EvidenceVariable.publisher | ExampleScenario.publisher | GraphDefinition.publisher | ImplementationGuide.publisher | Library.publisher | Measure.publisher | MessageDefinition.publisher | NamingSystem.publisher | OperationDefinition.publisher | PlanDefinition.publisher | Questionnaire.publisher | Requirements.publisher | SearchParameter.publisher | StructureDefinition.publisher | StructureMap.publisher | TerminologyCapabilities.publisher | TestScript.publisher | ValueSet.publisher</b><br>
9975   * </p>
9976   */
9977  @SearchParamDefinition(name="publisher", path="ActivityDefinition.publisher | ActorDefinition.publisher | CapabilityStatement.publisher | ChargeItemDefinition.publisher | Citation.publisher | CodeSystem.publisher | CompartmentDefinition.publisher | ConceptMap.publisher | ConditionDefinition.publisher | EventDefinition.publisher | Evidence.publisher | EvidenceReport.publisher | EvidenceVariable.publisher | ExampleScenario.publisher | GraphDefinition.publisher | ImplementationGuide.publisher | Library.publisher | Measure.publisher | MessageDefinition.publisher | NamingSystem.publisher | OperationDefinition.publisher | PlanDefinition.publisher | Questionnaire.publisher | Requirements.publisher | SearchParameter.publisher | StructureDefinition.publisher | StructureMap.publisher | TerminologyCapabilities.publisher | TestScript.publisher | ValueSet.publisher", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): Name of the publisher of the activity definition\r\n* [ActorDefinition](actordefinition.html): Name of the publisher of the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): Name of the publisher of the charge item definition\r\n* [Citation](citation.html): Name of the publisher of the citation\r\n* [CodeSystem](codesystem.html): Name of the publisher of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): Name of the publisher of the compartment definition\r\n* [ConceptMap](conceptmap.html): Name of the publisher of the concept map\r\n* [ConditionDefinition](conditiondefinition.html): Name of the publisher of the condition definition\r\n* [EventDefinition](eventdefinition.html): Name of the publisher of the event definition\r\n* [Evidence](evidence.html): Name of the publisher of the evidence\r\n* [EvidenceReport](evidencereport.html): Name of the publisher of the evidence report\r\n* [EvidenceVariable](evidencevariable.html): Name of the publisher of the evidence variable\r\n* [ExampleScenario](examplescenario.html): Name of the publisher of the example scenario\r\n* [GraphDefinition](graphdefinition.html): Name of the publisher of the graph definition\r\n* [ImplementationGuide](implementationguide.html): Name of the publisher of the implementation guide\r\n* [Library](library.html): Name of the publisher of the library\r\n* [Measure](measure.html): Name of the publisher of the measure\r\n* [MessageDefinition](messagedefinition.html): Name of the publisher of the message definition\r\n* [NamingSystem](namingsystem.html): Name of the publisher of the naming system\r\n* [OperationDefinition](operationdefinition.html): Name of the publisher of the operation definition\r\n* [PlanDefinition](plandefinition.html): Name of the publisher of the plan definition\r\n* [Questionnaire](questionnaire.html): Name of the publisher of the questionnaire\r\n* [Requirements](requirements.html): Name of the publisher of the requirements\r\n* [SearchParameter](searchparameter.html): Name of the publisher of the search parameter\r\n* [StructureDefinition](structuredefinition.html): Name of the publisher of the structure definition\r\n* [StructureMap](structuremap.html): Name of the publisher of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): Name of the publisher of the terminology capabilities\r\n* [TestScript](testscript.html): Name of the publisher of the test script\r\n* [ValueSet](valueset.html): Name of the publisher of the value set\r\n", type="string" )
9978  public static final String SP_PUBLISHER = "publisher";
9979 /**
9980   * <b>Fluent Client</b> search parameter constant for <b>publisher</b>
9981   * <p>
9982   * Description: <b>Multiple Resources: 
9983
9984* [ActivityDefinition](activitydefinition.html): Name of the publisher of the activity definition
9985* [ActorDefinition](actordefinition.html): Name of the publisher of the Actor Definition
9986* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement
9987* [ChargeItemDefinition](chargeitemdefinition.html): Name of the publisher of the charge item definition
9988* [Citation](citation.html): Name of the publisher of the citation
9989* [CodeSystem](codesystem.html): Name of the publisher of the code system
9990* [CompartmentDefinition](compartmentdefinition.html): Name of the publisher of the compartment definition
9991* [ConceptMap](conceptmap.html): Name of the publisher of the concept map
9992* [ConditionDefinition](conditiondefinition.html): Name of the publisher of the condition definition
9993* [EventDefinition](eventdefinition.html): Name of the publisher of the event definition
9994* [Evidence](evidence.html): Name of the publisher of the evidence
9995* [EvidenceReport](evidencereport.html): Name of the publisher of the evidence report
9996* [EvidenceVariable](evidencevariable.html): Name of the publisher of the evidence variable
9997* [ExampleScenario](examplescenario.html): Name of the publisher of the example scenario
9998* [GraphDefinition](graphdefinition.html): Name of the publisher of the graph definition
9999* [ImplementationGuide](implementationguide.html): Name of the publisher of the implementation guide
10000* [Library](library.html): Name of the publisher of the library
10001* [Measure](measure.html): Name of the publisher of the measure
10002* [MessageDefinition](messagedefinition.html): Name of the publisher of the message definition
10003* [NamingSystem](namingsystem.html): Name of the publisher of the naming system
10004* [OperationDefinition](operationdefinition.html): Name of the publisher of the operation definition
10005* [PlanDefinition](plandefinition.html): Name of the publisher of the plan definition
10006* [Questionnaire](questionnaire.html): Name of the publisher of the questionnaire
10007* [Requirements](requirements.html): Name of the publisher of the requirements
10008* [SearchParameter](searchparameter.html): Name of the publisher of the search parameter
10009* [StructureDefinition](structuredefinition.html): Name of the publisher of the structure definition
10010* [StructureMap](structuremap.html): Name of the publisher of the structure map
10011* [TerminologyCapabilities](terminologycapabilities.html): Name of the publisher of the terminology capabilities
10012* [TestScript](testscript.html): Name of the publisher of the test script
10013* [ValueSet](valueset.html): Name of the publisher of the value set
10014</b><br>
10015   * Type: <b>string</b><br>
10016   * Path: <b>ActivityDefinition.publisher | ActorDefinition.publisher | CapabilityStatement.publisher | ChargeItemDefinition.publisher | Citation.publisher | CodeSystem.publisher | CompartmentDefinition.publisher | ConceptMap.publisher | ConditionDefinition.publisher | EventDefinition.publisher | Evidence.publisher | EvidenceReport.publisher | EvidenceVariable.publisher | ExampleScenario.publisher | GraphDefinition.publisher | ImplementationGuide.publisher | Library.publisher | Measure.publisher | MessageDefinition.publisher | NamingSystem.publisher | OperationDefinition.publisher | PlanDefinition.publisher | Questionnaire.publisher | Requirements.publisher | SearchParameter.publisher | StructureDefinition.publisher | StructureMap.publisher | TerminologyCapabilities.publisher | TestScript.publisher | ValueSet.publisher</b><br>
10017   * </p>
10018   */
10019  public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_PUBLISHER);
10020
10021 /**
10022   * Search parameter: <b>status</b>
10023   * <p>
10024   * Description: <b>Multiple Resources: 
10025
10026* [ActivityDefinition](activitydefinition.html): The current status of the activity definition
10027* [ActorDefinition](actordefinition.html): The current status of the Actor Definition
10028* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement
10029* [ChargeItemDefinition](chargeitemdefinition.html): The current status of the charge item definition
10030* [Citation](citation.html): The current status of the citation
10031* [CodeSystem](codesystem.html): The current status of the code system
10032* [CompartmentDefinition](compartmentdefinition.html): The current status of the compartment definition
10033* [ConceptMap](conceptmap.html): The current status of the concept map
10034* [ConditionDefinition](conditiondefinition.html): The current status of the condition definition
10035* [EventDefinition](eventdefinition.html): The current status of the event definition
10036* [Evidence](evidence.html): The current status of the evidence
10037* [EvidenceReport](evidencereport.html): The current status of the evidence report
10038* [EvidenceVariable](evidencevariable.html): The current status of the evidence variable
10039* [ExampleScenario](examplescenario.html): The current status of the example scenario
10040* [GraphDefinition](graphdefinition.html): The current status of the graph definition
10041* [ImplementationGuide](implementationguide.html): The current status of the implementation guide
10042* [Library](library.html): The current status of the library
10043* [Measure](measure.html): The current status of the measure
10044* [MedicationKnowledge](medicationknowledge.html): active | inactive | entered-in-error
10045* [MessageDefinition](messagedefinition.html): The current status of the message definition
10046* [NamingSystem](namingsystem.html): The current status of the naming system
10047* [ObservationDefinition](observationdefinition.html): Publication status of the ObservationDefinition: draft, active, retired, unknown
10048* [OperationDefinition](operationdefinition.html): The current status of the operation definition
10049* [PlanDefinition](plandefinition.html): The current status of the plan definition
10050* [Questionnaire](questionnaire.html): The current status of the questionnaire
10051* [Requirements](requirements.html): The current status of the requirements
10052* [SearchParameter](searchparameter.html): The current status of the search parameter
10053* [SpecimenDefinition](specimendefinition.html): Publication status of the SpecimenDefinition: draft, active, retired, unknown
10054* [StructureDefinition](structuredefinition.html): The current status of the structure definition
10055* [StructureMap](structuremap.html): The current status of the structure map
10056* [SubscriptionTopic](subscriptiontopic.html): draft | active | retired | unknown
10057* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities
10058* [TestPlan](testplan.html): The current status of the test plan
10059* [TestScript](testscript.html): The current status of the test script
10060* [ValueSet](valueset.html): The current status of the value set
10061</b><br>
10062   * Type: <b>token</b><br>
10063   * Path: <b>ActivityDefinition.status | ActorDefinition.status | CapabilityStatement.status | ChargeItemDefinition.status | Citation.status | CodeSystem.status | CompartmentDefinition.status | ConceptMap.status | ConditionDefinition.status | EventDefinition.status | Evidence.status | EvidenceReport.status | EvidenceVariable.status | ExampleScenario.status | GraphDefinition.status | ImplementationGuide.status | Library.status | Measure.status | MedicationKnowledge.status | MessageDefinition.status | NamingSystem.status | ObservationDefinition.status | OperationDefinition.status | PlanDefinition.status | Questionnaire.status | Requirements.status | SearchParameter.status | SpecimenDefinition.status | StructureDefinition.status | StructureMap.status | SubscriptionTopic.status | TerminologyCapabilities.status | TestPlan.status | TestScript.status | ValueSet.status</b><br>
10064   * </p>
10065   */
10066  @SearchParamDefinition(name="status", path="ActivityDefinition.status | ActorDefinition.status | CapabilityStatement.status | ChargeItemDefinition.status | Citation.status | CodeSystem.status | CompartmentDefinition.status | ConceptMap.status | ConditionDefinition.status | EventDefinition.status | Evidence.status | EvidenceReport.status | EvidenceVariable.status | ExampleScenario.status | GraphDefinition.status | ImplementationGuide.status | Library.status | Measure.status | MedicationKnowledge.status | MessageDefinition.status | NamingSystem.status | ObservationDefinition.status | OperationDefinition.status | PlanDefinition.status | Questionnaire.status | Requirements.status | SearchParameter.status | SpecimenDefinition.status | StructureDefinition.status | StructureMap.status | SubscriptionTopic.status | TerminologyCapabilities.status | TestPlan.status | TestScript.status | ValueSet.status", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): The current status of the activity definition\r\n* [ActorDefinition](actordefinition.html): The current status of the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): The current status of the charge item definition\r\n* [Citation](citation.html): The current status of the citation\r\n* [CodeSystem](codesystem.html): The current status of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): The current status of the compartment definition\r\n* [ConceptMap](conceptmap.html): The current status of the concept map\r\n* [ConditionDefinition](conditiondefinition.html): The current status of the condition definition\r\n* [EventDefinition](eventdefinition.html): The current status of the event definition\r\n* [Evidence](evidence.html): The current status of the evidence\r\n* [EvidenceReport](evidencereport.html): The current status of the evidence report\r\n* [EvidenceVariable](evidencevariable.html): The current status of the evidence variable\r\n* [ExampleScenario](examplescenario.html): The current status of the example scenario\r\n* [GraphDefinition](graphdefinition.html): The current status of the graph definition\r\n* [ImplementationGuide](implementationguide.html): The current status of the implementation guide\r\n* [Library](library.html): The current status of the library\r\n* [Measure](measure.html): The current status of the measure\r\n* [MedicationKnowledge](medicationknowledge.html): active | inactive | entered-in-error\r\n* [MessageDefinition](messagedefinition.html): The current status of the message definition\r\n* [NamingSystem](namingsystem.html): The current status of the naming system\r\n* [ObservationDefinition](observationdefinition.html): Publication status of the ObservationDefinition: draft, active, retired, unknown\r\n* [OperationDefinition](operationdefinition.html): The current status of the operation definition\r\n* [PlanDefinition](plandefinition.html): The current status of the plan definition\r\n* [Questionnaire](questionnaire.html): The current status of the questionnaire\r\n* [Requirements](requirements.html): The current status of the requirements\r\n* [SearchParameter](searchparameter.html): The current status of the search parameter\r\n* [SpecimenDefinition](specimendefinition.html): Publication status of the SpecimenDefinition: draft, active, retired, unknown\r\n* [StructureDefinition](structuredefinition.html): The current status of the structure definition\r\n* [StructureMap](structuremap.html): The current status of the structure map\r\n* [SubscriptionTopic](subscriptiontopic.html): draft | active | retired | unknown\r\n* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities\r\n* [TestPlan](testplan.html): The current status of the test plan\r\n* [TestScript](testscript.html): The current status of the test script\r\n* [ValueSet](valueset.html): The current status of the value set\r\n", type="token" )
10067  public static final String SP_STATUS = "status";
10068 /**
10069   * <b>Fluent Client</b> search parameter constant for <b>status</b>
10070   * <p>
10071   * Description: <b>Multiple Resources: 
10072
10073* [ActivityDefinition](activitydefinition.html): The current status of the activity definition
10074* [ActorDefinition](actordefinition.html): The current status of the Actor Definition
10075* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement
10076* [ChargeItemDefinition](chargeitemdefinition.html): The current status of the charge item definition
10077* [Citation](citation.html): The current status of the citation
10078* [CodeSystem](codesystem.html): The current status of the code system
10079* [CompartmentDefinition](compartmentdefinition.html): The current status of the compartment definition
10080* [ConceptMap](conceptmap.html): The current status of the concept map
10081* [ConditionDefinition](conditiondefinition.html): The current status of the condition definition
10082* [EventDefinition](eventdefinition.html): The current status of the event definition
10083* [Evidence](evidence.html): The current status of the evidence
10084* [EvidenceReport](evidencereport.html): The current status of the evidence report
10085* [EvidenceVariable](evidencevariable.html): The current status of the evidence variable
10086* [ExampleScenario](examplescenario.html): The current status of the example scenario
10087* [GraphDefinition](graphdefinition.html): The current status of the graph definition
10088* [ImplementationGuide](implementationguide.html): The current status of the implementation guide
10089* [Library](library.html): The current status of the library
10090* [Measure](measure.html): The current status of the measure
10091* [MedicationKnowledge](medicationknowledge.html): active | inactive | entered-in-error
10092* [MessageDefinition](messagedefinition.html): The current status of the message definition
10093* [NamingSystem](namingsystem.html): The current status of the naming system
10094* [ObservationDefinition](observationdefinition.html): Publication status of the ObservationDefinition: draft, active, retired, unknown
10095* [OperationDefinition](operationdefinition.html): The current status of the operation definition
10096* [PlanDefinition](plandefinition.html): The current status of the plan definition
10097* [Questionnaire](questionnaire.html): The current status of the questionnaire
10098* [Requirements](requirements.html): The current status of the requirements
10099* [SearchParameter](searchparameter.html): The current status of the search parameter
10100* [SpecimenDefinition](specimendefinition.html): Publication status of the SpecimenDefinition: draft, active, retired, unknown
10101* [StructureDefinition](structuredefinition.html): The current status of the structure definition
10102* [StructureMap](structuremap.html): The current status of the structure map
10103* [SubscriptionTopic](subscriptiontopic.html): draft | active | retired | unknown
10104* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities
10105* [TestPlan](testplan.html): The current status of the test plan
10106* [TestScript](testscript.html): The current status of the test script
10107* [ValueSet](valueset.html): The current status of the value set
10108</b><br>
10109   * Type: <b>token</b><br>
10110   * Path: <b>ActivityDefinition.status | ActorDefinition.status | CapabilityStatement.status | ChargeItemDefinition.status | Citation.status | CodeSystem.status | CompartmentDefinition.status | ConceptMap.status | ConditionDefinition.status | EventDefinition.status | Evidence.status | EvidenceReport.status | EvidenceVariable.status | ExampleScenario.status | GraphDefinition.status | ImplementationGuide.status | Library.status | Measure.status | MedicationKnowledge.status | MessageDefinition.status | NamingSystem.status | ObservationDefinition.status | OperationDefinition.status | PlanDefinition.status | Questionnaire.status | Requirements.status | SearchParameter.status | SpecimenDefinition.status | StructureDefinition.status | StructureMap.status | SubscriptionTopic.status | TerminologyCapabilities.status | TestPlan.status | TestScript.status | ValueSet.status</b><br>
10111   * </p>
10112   */
10113  public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS);
10114
10115 /**
10116   * Search parameter: <b>title</b>
10117   * <p>
10118   * Description: <b>Multiple Resources: 
10119
10120* [ActivityDefinition](activitydefinition.html): The human-friendly name of the activity definition
10121* [ActorDefinition](actordefinition.html): The human-friendly name of the Actor Definition
10122* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement
10123* [ChargeItemDefinition](chargeitemdefinition.html): The human-friendly name of the charge item definition
10124* [Citation](citation.html): The human-friendly name of the citation
10125* [CodeSystem](codesystem.html): The human-friendly name of the code system
10126* [ConceptMap](conceptmap.html): The human-friendly name of the concept map
10127* [ConditionDefinition](conditiondefinition.html): The human-friendly name of the condition definition
10128* [EventDefinition](eventdefinition.html): The human-friendly name of the event definition
10129* [Evidence](evidence.html): The human-friendly name of the evidence
10130* [EvidenceVariable](evidencevariable.html): The human-friendly name of the evidence variable
10131* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide
10132* [Library](library.html): The human-friendly name of the library
10133* [Measure](measure.html): The human-friendly name of the measure
10134* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition
10135* [ObservationDefinition](observationdefinition.html): Human-friendly name of the ObservationDefinition
10136* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition
10137* [PlanDefinition](plandefinition.html): The human-friendly name of the plan definition
10138* [Questionnaire](questionnaire.html): The human-friendly name of the questionnaire
10139* [Requirements](requirements.html): The human-friendly name of the requirements
10140* [SpecimenDefinition](specimendefinition.html): Human-friendly name of the SpecimenDefinition
10141* [StructureDefinition](structuredefinition.html): The human-friendly name of the structure definition
10142* [StructureMap](structuremap.html): The human-friendly name of the structure map
10143* [SubscriptionTopic](subscriptiontopic.html): Name for this SubscriptionTopic (Human friendly)
10144* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities
10145* [TestScript](testscript.html): The human-friendly name of the test script
10146* [ValueSet](valueset.html): The human-friendly name of the value set
10147</b><br>
10148   * Type: <b>string</b><br>
10149   * Path: <b>ActivityDefinition.title | ActorDefinition.title | CapabilityStatement.title | ChargeItemDefinition.title | Citation.title | CodeSystem.title | ConceptMap.title | ConditionDefinition.title | EventDefinition.title | Evidence.title | EvidenceVariable.title | ImplementationGuide.title | Library.title | Measure.title | MessageDefinition.title | ObservationDefinition.title | OperationDefinition.title | PlanDefinition.title | Questionnaire.title | Requirements.title | SpecimenDefinition.title | StructureDefinition.title | StructureMap.title | SubscriptionTopic.title | TerminologyCapabilities.title | TestScript.title | ValueSet.title</b><br>
10150   * </p>
10151   */
10152  @SearchParamDefinition(name="title", path="ActivityDefinition.title | ActorDefinition.title | CapabilityStatement.title | ChargeItemDefinition.title | Citation.title | CodeSystem.title | ConceptMap.title | ConditionDefinition.title | EventDefinition.title | Evidence.title | EvidenceVariable.title | ImplementationGuide.title | Library.title | Measure.title | MessageDefinition.title | ObservationDefinition.title | OperationDefinition.title | PlanDefinition.title | Questionnaire.title | Requirements.title | SpecimenDefinition.title | StructureDefinition.title | StructureMap.title | SubscriptionTopic.title | TerminologyCapabilities.title | TestScript.title | ValueSet.title", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): The human-friendly name of the activity definition\r\n* [ActorDefinition](actordefinition.html): The human-friendly name of the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): The human-friendly name of the charge item definition\r\n* [Citation](citation.html): The human-friendly name of the citation\r\n* [CodeSystem](codesystem.html): The human-friendly name of the code system\r\n* [ConceptMap](conceptmap.html): The human-friendly name of the concept map\r\n* [ConditionDefinition](conditiondefinition.html): The human-friendly name of the condition definition\r\n* [EventDefinition](eventdefinition.html): The human-friendly name of the event definition\r\n* [Evidence](evidence.html): The human-friendly name of the evidence\r\n* [EvidenceVariable](evidencevariable.html): The human-friendly name of the evidence variable\r\n* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide\r\n* [Library](library.html): The human-friendly name of the library\r\n* [Measure](measure.html): The human-friendly name of the measure\r\n* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition\r\n* [ObservationDefinition](observationdefinition.html): Human-friendly name of the ObservationDefinition\r\n* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition\r\n* [PlanDefinition](plandefinition.html): The human-friendly name of the plan definition\r\n* [Questionnaire](questionnaire.html): The human-friendly name of the questionnaire\r\n* [Requirements](requirements.html): The human-friendly name of the requirements\r\n* [SpecimenDefinition](specimendefinition.html): Human-friendly name of the SpecimenDefinition\r\n* [StructureDefinition](structuredefinition.html): The human-friendly name of the structure definition\r\n* [StructureMap](structuremap.html): The human-friendly name of the structure map\r\n* [SubscriptionTopic](subscriptiontopic.html): Name for this SubscriptionTopic (Human friendly)\r\n* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities\r\n* [TestScript](testscript.html): The human-friendly name of the test script\r\n* [ValueSet](valueset.html): The human-friendly name of the value set\r\n", type="string" )
10153  public static final String SP_TITLE = "title";
10154 /**
10155   * <b>Fluent Client</b> search parameter constant for <b>title</b>
10156   * <p>
10157   * Description: <b>Multiple Resources: 
10158
10159* [ActivityDefinition](activitydefinition.html): The human-friendly name of the activity definition
10160* [ActorDefinition](actordefinition.html): The human-friendly name of the Actor Definition
10161* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement
10162* [ChargeItemDefinition](chargeitemdefinition.html): The human-friendly name of the charge item definition
10163* [Citation](citation.html): The human-friendly name of the citation
10164* [CodeSystem](codesystem.html): The human-friendly name of the code system
10165* [ConceptMap](conceptmap.html): The human-friendly name of the concept map
10166* [ConditionDefinition](conditiondefinition.html): The human-friendly name of the condition definition
10167* [EventDefinition](eventdefinition.html): The human-friendly name of the event definition
10168* [Evidence](evidence.html): The human-friendly name of the evidence
10169* [EvidenceVariable](evidencevariable.html): The human-friendly name of the evidence variable
10170* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide
10171* [Library](library.html): The human-friendly name of the library
10172* [Measure](measure.html): The human-friendly name of the measure
10173* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition
10174* [ObservationDefinition](observationdefinition.html): Human-friendly name of the ObservationDefinition
10175* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition
10176* [PlanDefinition](plandefinition.html): The human-friendly name of the plan definition
10177* [Questionnaire](questionnaire.html): The human-friendly name of the questionnaire
10178* [Requirements](requirements.html): The human-friendly name of the requirements
10179* [SpecimenDefinition](specimendefinition.html): Human-friendly name of the SpecimenDefinition
10180* [StructureDefinition](structuredefinition.html): The human-friendly name of the structure definition
10181* [StructureMap](structuremap.html): The human-friendly name of the structure map
10182* [SubscriptionTopic](subscriptiontopic.html): Name for this SubscriptionTopic (Human friendly)
10183* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities
10184* [TestScript](testscript.html): The human-friendly name of the test script
10185* [ValueSet](valueset.html): The human-friendly name of the value set
10186</b><br>
10187   * Type: <b>string</b><br>
10188   * Path: <b>ActivityDefinition.title | ActorDefinition.title | CapabilityStatement.title | ChargeItemDefinition.title | Citation.title | CodeSystem.title | ConceptMap.title | ConditionDefinition.title | EventDefinition.title | Evidence.title | EvidenceVariable.title | ImplementationGuide.title | Library.title | Measure.title | MessageDefinition.title | ObservationDefinition.title | OperationDefinition.title | PlanDefinition.title | Questionnaire.title | Requirements.title | SpecimenDefinition.title | StructureDefinition.title | StructureMap.title | SubscriptionTopic.title | TerminologyCapabilities.title | TestScript.title | ValueSet.title</b><br>
10189   * </p>
10190   */
10191  public static final ca.uhn.fhir.rest.gclient.StringClientParam TITLE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_TITLE);
10192
10193 /**
10194   * Search parameter: <b>url</b>
10195   * <p>
10196   * Description: <b>Multiple Resources: 
10197
10198* [ActivityDefinition](activitydefinition.html): The uri that identifies the activity definition
10199* [ActorDefinition](actordefinition.html): The uri that identifies the Actor Definition
10200* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement
10201* [ChargeItemDefinition](chargeitemdefinition.html): The uri that identifies the charge item definition
10202* [Citation](citation.html): The uri that identifies the citation
10203* [CodeSystem](codesystem.html): The uri that identifies the code system
10204* [CompartmentDefinition](compartmentdefinition.html): The uri that identifies the compartment definition
10205* [ConceptMap](conceptmap.html): The URI that identifies the concept map
10206* [ConditionDefinition](conditiondefinition.html): The uri that identifies the condition definition
10207* [EventDefinition](eventdefinition.html): The uri that identifies the event definition
10208* [Evidence](evidence.html): The uri that identifies the evidence
10209* [EvidenceReport](evidencereport.html): The uri that identifies the evidence report
10210* [EvidenceVariable](evidencevariable.html): The uri that identifies the evidence variable
10211* [ExampleScenario](examplescenario.html): The uri that identifies the example scenario
10212* [GraphDefinition](graphdefinition.html): The uri that identifies the graph definition
10213* [ImplementationGuide](implementationguide.html): The uri that identifies the implementation guide
10214* [Library](library.html): The uri that identifies the library
10215* [Measure](measure.html): The uri that identifies the measure
10216* [MessageDefinition](messagedefinition.html): The uri that identifies the message definition
10217* [NamingSystem](namingsystem.html): The uri that identifies the naming system
10218* [ObservationDefinition](observationdefinition.html): The uri that identifies the observation definition
10219* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition
10220* [PlanDefinition](plandefinition.html): The uri that identifies the plan definition
10221* [Questionnaire](questionnaire.html): The uri that identifies the questionnaire
10222* [Requirements](requirements.html): The uri that identifies the requirements
10223* [SearchParameter](searchparameter.html): The uri that identifies the search parameter
10224* [SpecimenDefinition](specimendefinition.html): The uri that identifies the specimen definition
10225* [StructureDefinition](structuredefinition.html): The uri that identifies the structure definition
10226* [StructureMap](structuremap.html): The uri that identifies the structure map
10227* [SubscriptionTopic](subscriptiontopic.html): Logical canonical URL to reference this SubscriptionTopic (globally unique)
10228* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities
10229* [TestPlan](testplan.html): The uri that identifies the test plan
10230* [TestScript](testscript.html): The uri that identifies the test script
10231* [ValueSet](valueset.html): The uri that identifies the value set
10232</b><br>
10233   * Type: <b>uri</b><br>
10234   * Path: <b>ActivityDefinition.url | ActorDefinition.url | CapabilityStatement.url | ChargeItemDefinition.url | Citation.url | CodeSystem.url | CompartmentDefinition.url | ConceptMap.url | ConditionDefinition.url | EventDefinition.url | Evidence.url | EvidenceReport.url | EvidenceVariable.url | ExampleScenario.url | GraphDefinition.url | ImplementationGuide.url | Library.url | Measure.url | MessageDefinition.url | NamingSystem.url | ObservationDefinition.url | OperationDefinition.url | PlanDefinition.url | Questionnaire.url | Requirements.url | SearchParameter.url | SpecimenDefinition.url | StructureDefinition.url | StructureMap.url | SubscriptionTopic.url | TerminologyCapabilities.url | TestPlan.url | TestScript.url | ValueSet.url</b><br>
10235   * </p>
10236   */
10237  @SearchParamDefinition(name="url", path="ActivityDefinition.url | ActorDefinition.url | CapabilityStatement.url | ChargeItemDefinition.url | Citation.url | CodeSystem.url | CompartmentDefinition.url | ConceptMap.url | ConditionDefinition.url | EventDefinition.url | Evidence.url | EvidenceReport.url | EvidenceVariable.url | ExampleScenario.url | GraphDefinition.url | ImplementationGuide.url | Library.url | Measure.url | MessageDefinition.url | NamingSystem.url | ObservationDefinition.url | OperationDefinition.url | PlanDefinition.url | Questionnaire.url | Requirements.url | SearchParameter.url | SpecimenDefinition.url | StructureDefinition.url | StructureMap.url | SubscriptionTopic.url | TerminologyCapabilities.url | TestPlan.url | TestScript.url | ValueSet.url", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): The uri that identifies the activity definition\r\n* [ActorDefinition](actordefinition.html): The uri that identifies the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): The uri that identifies the charge item definition\r\n* [Citation](citation.html): The uri that identifies the citation\r\n* [CodeSystem](codesystem.html): The uri that identifies the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): The uri that identifies the compartment definition\r\n* [ConceptMap](conceptmap.html): The URI that identifies the concept map\r\n* [ConditionDefinition](conditiondefinition.html): The uri that identifies the condition definition\r\n* [EventDefinition](eventdefinition.html): The uri that identifies the event definition\r\n* [Evidence](evidence.html): The uri that identifies the evidence\r\n* [EvidenceReport](evidencereport.html): The uri that identifies the evidence report\r\n* [EvidenceVariable](evidencevariable.html): The uri that identifies the evidence variable\r\n* [ExampleScenario](examplescenario.html): The uri that identifies the example scenario\r\n* [GraphDefinition](graphdefinition.html): The uri that identifies the graph definition\r\n* [ImplementationGuide](implementationguide.html): The uri that identifies the implementation guide\r\n* [Library](library.html): The uri that identifies the library\r\n* [Measure](measure.html): The uri that identifies the measure\r\n* [MessageDefinition](messagedefinition.html): The uri that identifies the message definition\r\n* [NamingSystem](namingsystem.html): The uri that identifies the naming system\r\n* [ObservationDefinition](observationdefinition.html): The uri that identifies the observation definition\r\n* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition\r\n* [PlanDefinition](plandefinition.html): The uri that identifies the plan definition\r\n* [Questionnaire](questionnaire.html): The uri that identifies the questionnaire\r\n* [Requirements](requirements.html): The uri that identifies the requirements\r\n* [SearchParameter](searchparameter.html): The uri that identifies the search parameter\r\n* [SpecimenDefinition](specimendefinition.html): The uri that identifies the specimen definition\r\n* [StructureDefinition](structuredefinition.html): The uri that identifies the structure definition\r\n* [StructureMap](structuremap.html): The uri that identifies the structure map\r\n* [SubscriptionTopic](subscriptiontopic.html): Logical canonical URL to reference this SubscriptionTopic (globally unique)\r\n* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities\r\n* [TestPlan](testplan.html): The uri that identifies the test plan\r\n* [TestScript](testscript.html): The uri that identifies the test script\r\n* [ValueSet](valueset.html): The uri that identifies the value set\r\n", type="uri" )
10238  public static final String SP_URL = "url";
10239 /**
10240   * <b>Fluent Client</b> search parameter constant for <b>url</b>
10241   * <p>
10242   * Description: <b>Multiple Resources: 
10243
10244* [ActivityDefinition](activitydefinition.html): The uri that identifies the activity definition
10245* [ActorDefinition](actordefinition.html): The uri that identifies the Actor Definition
10246* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement
10247* [ChargeItemDefinition](chargeitemdefinition.html): The uri that identifies the charge item definition
10248* [Citation](citation.html): The uri that identifies the citation
10249* [CodeSystem](codesystem.html): The uri that identifies the code system
10250* [CompartmentDefinition](compartmentdefinition.html): The uri that identifies the compartment definition
10251* [ConceptMap](conceptmap.html): The URI that identifies the concept map
10252* [ConditionDefinition](conditiondefinition.html): The uri that identifies the condition definition
10253* [EventDefinition](eventdefinition.html): The uri that identifies the event definition
10254* [Evidence](evidence.html): The uri that identifies the evidence
10255* [EvidenceReport](evidencereport.html): The uri that identifies the evidence report
10256* [EvidenceVariable](evidencevariable.html): The uri that identifies the evidence variable
10257* [ExampleScenario](examplescenario.html): The uri that identifies the example scenario
10258* [GraphDefinition](graphdefinition.html): The uri that identifies the graph definition
10259* [ImplementationGuide](implementationguide.html): The uri that identifies the implementation guide
10260* [Library](library.html): The uri that identifies the library
10261* [Measure](measure.html): The uri that identifies the measure
10262* [MessageDefinition](messagedefinition.html): The uri that identifies the message definition
10263* [NamingSystem](namingsystem.html): The uri that identifies the naming system
10264* [ObservationDefinition](observationdefinition.html): The uri that identifies the observation definition
10265* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition
10266* [PlanDefinition](plandefinition.html): The uri that identifies the plan definition
10267* [Questionnaire](questionnaire.html): The uri that identifies the questionnaire
10268* [Requirements](requirements.html): The uri that identifies the requirements
10269* [SearchParameter](searchparameter.html): The uri that identifies the search parameter
10270* [SpecimenDefinition](specimendefinition.html): The uri that identifies the specimen definition
10271* [StructureDefinition](structuredefinition.html): The uri that identifies the structure definition
10272* [StructureMap](structuremap.html): The uri that identifies the structure map
10273* [SubscriptionTopic](subscriptiontopic.html): Logical canonical URL to reference this SubscriptionTopic (globally unique)
10274* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities
10275* [TestPlan](testplan.html): The uri that identifies the test plan
10276* [TestScript](testscript.html): The uri that identifies the test script
10277* [ValueSet](valueset.html): The uri that identifies the value set
10278</b><br>
10279   * Type: <b>uri</b><br>
10280   * Path: <b>ActivityDefinition.url | ActorDefinition.url | CapabilityStatement.url | ChargeItemDefinition.url | Citation.url | CodeSystem.url | CompartmentDefinition.url | ConceptMap.url | ConditionDefinition.url | EventDefinition.url | Evidence.url | EvidenceReport.url | EvidenceVariable.url | ExampleScenario.url | GraphDefinition.url | ImplementationGuide.url | Library.url | Measure.url | MessageDefinition.url | NamingSystem.url | ObservationDefinition.url | OperationDefinition.url | PlanDefinition.url | Questionnaire.url | Requirements.url | SearchParameter.url | SpecimenDefinition.url | StructureDefinition.url | StructureMap.url | SubscriptionTopic.url | TerminologyCapabilities.url | TestPlan.url | TestScript.url | ValueSet.url</b><br>
10281   * </p>
10282   */
10283  public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL);
10284
10285 /**
10286   * Search parameter: <b>version</b>
10287   * <p>
10288   * Description: <b>Multiple Resources: 
10289
10290* [ActivityDefinition](activitydefinition.html): The business version of the activity definition
10291* [ActorDefinition](actordefinition.html): The business version of the Actor Definition
10292* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement
10293* [ChargeItemDefinition](chargeitemdefinition.html): The business version of the charge item definition
10294* [Citation](citation.html): The business version of the citation
10295* [CodeSystem](codesystem.html): The business version of the code system
10296* [CompartmentDefinition](compartmentdefinition.html): The business version of the compartment definition
10297* [ConceptMap](conceptmap.html): The business version of the concept map
10298* [ConditionDefinition](conditiondefinition.html): The business version of the condition definition
10299* [EventDefinition](eventdefinition.html): The business version of the event definition
10300* [Evidence](evidence.html): The business version of the evidence
10301* [EvidenceVariable](evidencevariable.html): The business version of the evidence variable
10302* [ExampleScenario](examplescenario.html): The business version of the example scenario
10303* [GraphDefinition](graphdefinition.html): The business version of the graph definition
10304* [ImplementationGuide](implementationguide.html): The business version of the implementation guide
10305* [Library](library.html): The business version of the library
10306* [Measure](measure.html): The business version of the measure
10307* [MessageDefinition](messagedefinition.html): The business version of the message definition
10308* [NamingSystem](namingsystem.html): The business version of the naming system
10309* [OperationDefinition](operationdefinition.html): The business version of the operation definition
10310* [PlanDefinition](plandefinition.html): The business version of the plan definition
10311* [Questionnaire](questionnaire.html): The business version of the questionnaire
10312* [Requirements](requirements.html): The business version of the requirements
10313* [SearchParameter](searchparameter.html): The business version of the search parameter
10314* [StructureDefinition](structuredefinition.html): The business version of the structure definition
10315* [StructureMap](structuremap.html): The business version of the structure map
10316* [SubscriptionTopic](subscriptiontopic.html): Business version of the SubscriptionTopic
10317* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities
10318* [TestScript](testscript.html): The business version of the test script
10319* [ValueSet](valueset.html): The business version of the value set
10320</b><br>
10321   * Type: <b>token</b><br>
10322   * Path: <b>ActivityDefinition.version | ActorDefinition.version | CapabilityStatement.version | ChargeItemDefinition.version | Citation.version | CodeSystem.version | CompartmentDefinition.version | ConceptMap.version | ConditionDefinition.version | EventDefinition.version | Evidence.version | EvidenceVariable.version | ExampleScenario.version | GraphDefinition.version | ImplementationGuide.version | Library.version | Measure.version | MessageDefinition.version | NamingSystem.version | OperationDefinition.version | PlanDefinition.version | Questionnaire.version | Requirements.version | SearchParameter.version | StructureDefinition.version | StructureMap.version | SubscriptionTopic.version | TerminologyCapabilities.version | TestScript.version | ValueSet.version</b><br>
10323   * </p>
10324   */
10325  @SearchParamDefinition(name="version", path="ActivityDefinition.version | ActorDefinition.version | CapabilityStatement.version | ChargeItemDefinition.version | Citation.version | CodeSystem.version | CompartmentDefinition.version | ConceptMap.version | ConditionDefinition.version | EventDefinition.version | Evidence.version | EvidenceVariable.version | ExampleScenario.version | GraphDefinition.version | ImplementationGuide.version | Library.version | Measure.version | MessageDefinition.version | NamingSystem.version | OperationDefinition.version | PlanDefinition.version | Questionnaire.version | Requirements.version | SearchParameter.version | StructureDefinition.version | StructureMap.version | SubscriptionTopic.version | TerminologyCapabilities.version | TestScript.version | ValueSet.version", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): The business version of the activity definition\r\n* [ActorDefinition](actordefinition.html): The business version of the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): The business version of the charge item definition\r\n* [Citation](citation.html): The business version of the citation\r\n* [CodeSystem](codesystem.html): The business version of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): The business version of the compartment definition\r\n* [ConceptMap](conceptmap.html): The business version of the concept map\r\n* [ConditionDefinition](conditiondefinition.html): The business version of the condition definition\r\n* [EventDefinition](eventdefinition.html): The business version of the event definition\r\n* [Evidence](evidence.html): The business version of the evidence\r\n* [EvidenceVariable](evidencevariable.html): The business version of the evidence variable\r\n* [ExampleScenario](examplescenario.html): The business version of the example scenario\r\n* [GraphDefinition](graphdefinition.html): The business version of the graph definition\r\n* [ImplementationGuide](implementationguide.html): The business version of the implementation guide\r\n* [Library](library.html): The business version of the library\r\n* [Measure](measure.html): The business version of the measure\r\n* [MessageDefinition](messagedefinition.html): The business version of the message definition\r\n* [NamingSystem](namingsystem.html): The business version of the naming system\r\n* [OperationDefinition](operationdefinition.html): The business version of the operation definition\r\n* [PlanDefinition](plandefinition.html): The business version of the plan definition\r\n* [Questionnaire](questionnaire.html): The business version of the questionnaire\r\n* [Requirements](requirements.html): The business version of the requirements\r\n* [SearchParameter](searchparameter.html): The business version of the search parameter\r\n* [StructureDefinition](structuredefinition.html): The business version of the structure definition\r\n* [StructureMap](structuremap.html): The business version of the structure map\r\n* [SubscriptionTopic](subscriptiontopic.html): Business version of the SubscriptionTopic\r\n* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities\r\n* [TestScript](testscript.html): The business version of the test script\r\n* [ValueSet](valueset.html): The business version of the value set\r\n", type="token" )
10326  public static final String SP_VERSION = "version";
10327 /**
10328   * <b>Fluent Client</b> search parameter constant for <b>version</b>
10329   * <p>
10330   * Description: <b>Multiple Resources: 
10331
10332* [ActivityDefinition](activitydefinition.html): The business version of the activity definition
10333* [ActorDefinition](actordefinition.html): The business version of the Actor Definition
10334* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement
10335* [ChargeItemDefinition](chargeitemdefinition.html): The business version of the charge item definition
10336* [Citation](citation.html): The business version of the citation
10337* [CodeSystem](codesystem.html): The business version of the code system
10338* [CompartmentDefinition](compartmentdefinition.html): The business version of the compartment definition
10339* [ConceptMap](conceptmap.html): The business version of the concept map
10340* [ConditionDefinition](conditiondefinition.html): The business version of the condition definition
10341* [EventDefinition](eventdefinition.html): The business version of the event definition
10342* [Evidence](evidence.html): The business version of the evidence
10343* [EvidenceVariable](evidencevariable.html): The business version of the evidence variable
10344* [ExampleScenario](examplescenario.html): The business version of the example scenario
10345* [GraphDefinition](graphdefinition.html): The business version of the graph definition
10346* [ImplementationGuide](implementationguide.html): The business version of the implementation guide
10347* [Library](library.html): The business version of the library
10348* [Measure](measure.html): The business version of the measure
10349* [MessageDefinition](messagedefinition.html): The business version of the message definition
10350* [NamingSystem](namingsystem.html): The business version of the naming system
10351* [OperationDefinition](operationdefinition.html): The business version of the operation definition
10352* [PlanDefinition](plandefinition.html): The business version of the plan definition
10353* [Questionnaire](questionnaire.html): The business version of the questionnaire
10354* [Requirements](requirements.html): The business version of the requirements
10355* [SearchParameter](searchparameter.html): The business version of the search parameter
10356* [StructureDefinition](structuredefinition.html): The business version of the structure definition
10357* [StructureMap](structuremap.html): The business version of the structure map
10358* [SubscriptionTopic](subscriptiontopic.html): Business version of the SubscriptionTopic
10359* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities
10360* [TestScript](testscript.html): The business version of the test script
10361* [ValueSet](valueset.html): The business version of the value set
10362</b><br>
10363   * Type: <b>token</b><br>
10364   * Path: <b>ActivityDefinition.version | ActorDefinition.version | CapabilityStatement.version | ChargeItemDefinition.version | Citation.version | CodeSystem.version | CompartmentDefinition.version | ConceptMap.version | ConditionDefinition.version | EventDefinition.version | Evidence.version | EvidenceVariable.version | ExampleScenario.version | GraphDefinition.version | ImplementationGuide.version | Library.version | Measure.version | MessageDefinition.version | NamingSystem.version | OperationDefinition.version | PlanDefinition.version | Questionnaire.version | Requirements.version | SearchParameter.version | StructureDefinition.version | StructureMap.version | SubscriptionTopic.version | TerminologyCapabilities.version | TestScript.version | ValueSet.version</b><br>
10365   * </p>
10366   */
10367  public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VERSION);
10368
10369 /**
10370   * Search parameter: <b>fhirversion</b>
10371   * <p>
10372   * Description: <b>The version of FHIR</b><br>
10373   * Type: <b>token</b><br>
10374   * Path: <b>CapabilityStatement.fhirVersion</b><br>
10375   * </p>
10376   */
10377  @SearchParamDefinition(name="fhirversion", path="CapabilityStatement.fhirVersion", description="The version of FHIR", type="token" )
10378  public static final String SP_FHIRVERSION = "fhirversion";
10379 /**
10380   * <b>Fluent Client</b> search parameter constant for <b>fhirversion</b>
10381   * <p>
10382   * Description: <b>The version of FHIR</b><br>
10383   * Type: <b>token</b><br>
10384   * Path: <b>CapabilityStatement.fhirVersion</b><br>
10385   * </p>
10386   */
10387  public static final ca.uhn.fhir.rest.gclient.TokenClientParam FHIRVERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_FHIRVERSION);
10388
10389 /**
10390   * Search parameter: <b>format</b>
10391   * <p>
10392   * Description: <b>formats supported (xml | json | ttl | mime type)</b><br>
10393   * Type: <b>token</b><br>
10394   * Path: <b>CapabilityStatement.format</b><br>
10395   * </p>
10396   */
10397  @SearchParamDefinition(name="format", path="CapabilityStatement.format", description="formats supported (xml | json | ttl | mime type)", type="token" )
10398  public static final String SP_FORMAT = "format";
10399 /**
10400   * <b>Fluent Client</b> search parameter constant for <b>format</b>
10401   * <p>
10402   * Description: <b>formats supported (xml | json | ttl | mime type)</b><br>
10403   * Type: <b>token</b><br>
10404   * Path: <b>CapabilityStatement.format</b><br>
10405   * </p>
10406   */
10407  public static final ca.uhn.fhir.rest.gclient.TokenClientParam FORMAT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_FORMAT);
10408
10409 /**
10410   * Search parameter: <b>guide</b>
10411   * <p>
10412   * Description: <b>Implementation guides supported</b><br>
10413   * Type: <b>reference</b><br>
10414   * Path: <b>CapabilityStatement.implementationGuide</b><br>
10415   * </p>
10416   */
10417  @SearchParamDefinition(name="guide", path="CapabilityStatement.implementationGuide", description="Implementation guides supported", type="reference", target={ImplementationGuide.class } )
10418  public static final String SP_GUIDE = "guide";
10419 /**
10420   * <b>Fluent Client</b> search parameter constant for <b>guide</b>
10421   * <p>
10422   * Description: <b>Implementation guides supported</b><br>
10423   * Type: <b>reference</b><br>
10424   * Path: <b>CapabilityStatement.implementationGuide</b><br>
10425   * </p>
10426   */
10427  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam GUIDE = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_GUIDE);
10428
10429/**
10430   * Constant for fluent queries to be used to add include statements. Specifies
10431   * the path value of "<b>CapabilityStatement:guide</b>".
10432   */
10433  public static final ca.uhn.fhir.model.api.Include INCLUDE_GUIDE = new ca.uhn.fhir.model.api.Include("CapabilityStatement:guide").toLocked();
10434
10435 /**
10436   * Search parameter: <b>mode</b>
10437   * <p>
10438   * Description: <b>Mode - restful (server/client) or messaging (sender/receiver)</b><br>
10439   * Type: <b>token</b><br>
10440   * Path: <b>CapabilityStatement.rest.mode</b><br>
10441   * </p>
10442   */
10443  @SearchParamDefinition(name="mode", path="CapabilityStatement.rest.mode", description="Mode - restful (server/client) or messaging (sender/receiver)", type="token" )
10444  public static final String SP_MODE = "mode";
10445 /**
10446   * <b>Fluent Client</b> search parameter constant for <b>mode</b>
10447   * <p>
10448   * Description: <b>Mode - restful (server/client) or messaging (sender/receiver)</b><br>
10449   * Type: <b>token</b><br>
10450   * Path: <b>CapabilityStatement.rest.mode</b><br>
10451   * </p>
10452   */
10453  public static final ca.uhn.fhir.rest.gclient.TokenClientParam MODE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_MODE);
10454
10455 /**
10456   * Search parameter: <b>resource-profile</b>
10457   * <p>
10458   * Description: <b>A profile id invoked in a capability statement</b><br>
10459   * Type: <b>reference</b><br>
10460   * Path: <b>CapabilityStatement.rest.resource.profile</b><br>
10461   * </p>
10462   */
10463  @SearchParamDefinition(name="resource-profile", path="CapabilityStatement.rest.resource.profile", description="A profile id invoked in a capability statement", type="reference", target={StructureDefinition.class } )
10464  public static final String SP_RESOURCE_PROFILE = "resource-profile";
10465 /**
10466   * <b>Fluent Client</b> search parameter constant for <b>resource-profile</b>
10467   * <p>
10468   * Description: <b>A profile id invoked in a capability statement</b><br>
10469   * Type: <b>reference</b><br>
10470   * Path: <b>CapabilityStatement.rest.resource.profile</b><br>
10471   * </p>
10472   */
10473  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam RESOURCE_PROFILE = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_RESOURCE_PROFILE);
10474
10475/**
10476   * Constant for fluent queries to be used to add include statements. Specifies
10477   * the path value of "<b>CapabilityStatement:resource-profile</b>".
10478   */
10479  public static final ca.uhn.fhir.model.api.Include INCLUDE_RESOURCE_PROFILE = new ca.uhn.fhir.model.api.Include("CapabilityStatement:resource-profile").toLocked();
10480
10481 /**
10482   * Search parameter: <b>resource</b>
10483   * <p>
10484   * Description: <b>Name of a resource mentioned in a capability statement</b><br>
10485   * Type: <b>token</b><br>
10486   * Path: <b>CapabilityStatement.rest.resource.type</b><br>
10487   * </p>
10488   */
10489  @SearchParamDefinition(name="resource", path="CapabilityStatement.rest.resource.type", description="Name of a resource mentioned in a capability statement", type="token" )
10490  public static final String SP_RESOURCE = "resource";
10491 /**
10492   * <b>Fluent Client</b> search parameter constant for <b>resource</b>
10493   * <p>
10494   * Description: <b>Name of a resource mentioned in a capability statement</b><br>
10495   * Type: <b>token</b><br>
10496   * Path: <b>CapabilityStatement.rest.resource.type</b><br>
10497   * </p>
10498   */
10499  public static final ca.uhn.fhir.rest.gclient.TokenClientParam RESOURCE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_RESOURCE);
10500
10501 /**
10502   * Search parameter: <b>security-service</b>
10503   * <p>
10504   * Description: <b>OAuth | SMART-on-FHIR | NTLM | Basic | Kerberos | Certificates</b><br>
10505   * Type: <b>token</b><br>
10506   * Path: <b>CapabilityStatement.rest.security.service</b><br>
10507   * </p>
10508   */
10509  @SearchParamDefinition(name="security-service", path="CapabilityStatement.rest.security.service", description="OAuth | SMART-on-FHIR | NTLM | Basic | Kerberos | Certificates", type="token" )
10510  public static final String SP_SECURITY_SERVICE = "security-service";
10511 /**
10512   * <b>Fluent Client</b> search parameter constant for <b>security-service</b>
10513   * <p>
10514   * Description: <b>OAuth | SMART-on-FHIR | NTLM | Basic | Kerberos | Certificates</b><br>
10515   * Type: <b>token</b><br>
10516   * Path: <b>CapabilityStatement.rest.security.service</b><br>
10517   * </p>
10518   */
10519  public static final ca.uhn.fhir.rest.gclient.TokenClientParam SECURITY_SERVICE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_SECURITY_SERVICE);
10520
10521 /**
10522   * Search parameter: <b>software</b>
10523   * <p>
10524   * Description: <b>Part of the name of a software application</b><br>
10525   * Type: <b>string</b><br>
10526   * Path: <b>CapabilityStatement.software.name</b><br>
10527   * </p>
10528   */
10529  @SearchParamDefinition(name="software", path="CapabilityStatement.software.name", description="Part of the name of a software application", type="string" )
10530  public static final String SP_SOFTWARE = "software";
10531 /**
10532   * <b>Fluent Client</b> search parameter constant for <b>software</b>
10533   * <p>
10534   * Description: <b>Part of the name of a software application</b><br>
10535   * Type: <b>string</b><br>
10536   * Path: <b>CapabilityStatement.software.name</b><br>
10537   * </p>
10538   */
10539  public static final ca.uhn.fhir.rest.gclient.StringClientParam SOFTWARE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_SOFTWARE);
10540
10541 /**
10542   * Search parameter: <b>supported-profile</b>
10543   * <p>
10544   * Description: <b>Profiles for use cases supported</b><br>
10545   * Type: <b>reference</b><br>
10546   * Path: <b>CapabilityStatement.rest.resource.supportedProfile</b><br>
10547   * </p>
10548   */
10549  @SearchParamDefinition(name="supported-profile", path="CapabilityStatement.rest.resource.supportedProfile", description="Profiles for use cases supported", type="reference", target={StructureDefinition.class } )
10550  public static final String SP_SUPPORTED_PROFILE = "supported-profile";
10551 /**
10552   * <b>Fluent Client</b> search parameter constant for <b>supported-profile</b>
10553   * <p>
10554   * Description: <b>Profiles for use cases supported</b><br>
10555   * Type: <b>reference</b><br>
10556   * Path: <b>CapabilityStatement.rest.resource.supportedProfile</b><br>
10557   * </p>
10558   */
10559  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SUPPORTED_PROFILE = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_SUPPORTED_PROFILE);
10560
10561/**
10562   * Constant for fluent queries to be used to add include statements. Specifies
10563   * the path value of "<b>CapabilityStatement:supported-profile</b>".
10564   */
10565  public static final ca.uhn.fhir.model.api.Include INCLUDE_SUPPORTED_PROFILE = new ca.uhn.fhir.model.api.Include("CapabilityStatement:supported-profile").toLocked();
10566
10567// Manual code (from Configuration.txt):
10568
10569// end addition
10570
10571}
10572