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