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
070/**
071 * A definition of a FHIR structure. This resource is used to describe the underlying resources, data types defined in FHIR, and also for describing extensions and constraints on resources and data types.
072 */
073@ResourceDef(name="StructureDefinition", profile="http://hl7.org/fhir/StructureDefinition/StructureDefinition")
074public class StructureDefinition extends CanonicalResource {
075
076    public enum ExtensionContextType {
077        /**
078         * The context is all elements that match the FHIRPath query found in the expression.
079         */
080        FHIRPATH, 
081        /**
082         * The context is any element that has an ElementDefinition.id that matches that found in the expression. This includes ElementDefinition Ids that have slicing identifiers. The full path for the element is [url]#[elementid]. If there is no #, the Element id is one defined in the base specification.
083         */
084        ELEMENT, 
085        /**
086         * The context is a particular extension from a particular StructureDefinition, and the expression is just a uri that identifies the extension.
087         */
088        EXTENSION, 
089        /**
090         * added to help the parsers with the generic types
091         */
092        NULL;
093        public static ExtensionContextType fromCode(String codeString) throws FHIRException {
094            if (codeString == null || "".equals(codeString))
095                return null;
096        if ("fhirpath".equals(codeString))
097          return FHIRPATH;
098        if ("element".equals(codeString))
099          return ELEMENT;
100        if ("extension".equals(codeString))
101          return EXTENSION;
102        if (Configuration.isAcceptInvalidEnums())
103          return null;
104        else
105          throw new FHIRException("Unknown ExtensionContextType code '"+codeString+"'");
106        }
107        public String toCode() {
108          switch (this) {
109            case FHIRPATH: return "fhirpath";
110            case ELEMENT: return "element";
111            case EXTENSION: return "extension";
112            default: return "?";
113          }
114        }
115        public String getSystem() {
116          switch (this) {
117            case FHIRPATH: return "http://hl7.org/fhir/extension-context-type";
118            case ELEMENT: return "http://hl7.org/fhir/extension-context-type";
119            case EXTENSION: return "http://hl7.org/fhir/extension-context-type";
120            default: return "?";
121          }
122        }
123        public String getDefinition() {
124          switch (this) {
125            case FHIRPATH: return "The context is all elements that match the FHIRPath query found in the expression.";
126            case ELEMENT: return "The context is any element that has an ElementDefinition.id that matches that found in the expression. This includes ElementDefinition Ids that have slicing identifiers. The full path for the element is [url]#[elementid]. If there is no #, the Element id is one defined in the base specification.";
127            case EXTENSION: return "The context is a particular extension from a particular StructureDefinition, and the expression is just a uri that identifies the extension.";
128            default: return "?";
129          }
130        }
131        public String getDisplay() {
132          switch (this) {
133            case FHIRPATH: return "FHIRPath";
134            case ELEMENT: return "Element ID";
135            case EXTENSION: return "Extension URL";
136            default: return "?";
137          }
138        }
139    }
140
141  public static class ExtensionContextTypeEnumFactory implements EnumFactory<ExtensionContextType> {
142    public ExtensionContextType fromCode(String codeString) throws IllegalArgumentException {
143      if (codeString == null || "".equals(codeString))
144            if (codeString == null || "".equals(codeString))
145                return null;
146        if ("fhirpath".equals(codeString))
147          return ExtensionContextType.FHIRPATH;
148        if ("element".equals(codeString))
149          return ExtensionContextType.ELEMENT;
150        if ("extension".equals(codeString))
151          return ExtensionContextType.EXTENSION;
152        throw new IllegalArgumentException("Unknown ExtensionContextType code '"+codeString+"'");
153        }
154        public Enumeration<ExtensionContextType> fromType(Base code) throws FHIRException {
155          if (code == null)
156            return null;
157          if (code.isEmpty())
158            return new Enumeration<ExtensionContextType>(this);
159          String codeString = ((PrimitiveType) code).asStringValue();
160          if (codeString == null || "".equals(codeString))
161            return null;
162        if ("fhirpath".equals(codeString))
163          return new Enumeration<ExtensionContextType>(this, ExtensionContextType.FHIRPATH);
164        if ("element".equals(codeString))
165          return new Enumeration<ExtensionContextType>(this, ExtensionContextType.ELEMENT);
166        if ("extension".equals(codeString))
167          return new Enumeration<ExtensionContextType>(this, ExtensionContextType.EXTENSION);
168        throw new FHIRException("Unknown ExtensionContextType code '"+codeString+"'");
169        }
170    public String toCode(ExtensionContextType code) {
171      if (code == ExtensionContextType.FHIRPATH)
172        return "fhirpath";
173      if (code == ExtensionContextType.ELEMENT)
174        return "element";
175      if (code == ExtensionContextType.EXTENSION)
176        return "extension";
177      return "?";
178      }
179    public String toSystem(ExtensionContextType code) {
180      return code.getSystem();
181      }
182    }
183
184    public enum StructureDefinitionKind {
185        /**
186         * A primitive type that has a value and an extension. These can be used throughout complex datatype, Resource and extension definitions. Only the base specification can define primitive types.
187         */
188        PRIMITIVETYPE, 
189        /**
190         * A  complex structure that defines a set of data elements that is suitable for use in 'resources'. The base specification defines a number of complex types, and other specifications can define additional types. These structures do not have a maintained identity.
191         */
192        COMPLEXTYPE, 
193        /**
194         * A 'resource' - a directed acyclic graph of elements that aggregrates other types into an identifiable entity. The base FHIR resources are defined by the FHIR specification itself but other 'resources' can be defined in additional specifications (though these will not be recognised as 'resources' by the FHIR specification (i.e. they do not get end-points etc, or act as the targets of references in FHIR defined resources - though other specificatiosn can treat them this way).
195         */
196        RESOURCE, 
197        /**
198         * A pattern or a template that is not intended to be a real resource or complex type.
199         */
200        LOGICAL, 
201        /**
202         * added to help the parsers with the generic types
203         */
204        NULL;
205        public static StructureDefinitionKind fromCode(String codeString) throws FHIRException {
206            if (codeString == null || "".equals(codeString))
207                return null;
208        if ("primitive-type".equals(codeString))
209          return PRIMITIVETYPE;
210        if ("complex-type".equals(codeString))
211          return COMPLEXTYPE;
212        if ("resource".equals(codeString))
213          return RESOURCE;
214        if ("logical".equals(codeString))
215          return LOGICAL;
216        if (Configuration.isAcceptInvalidEnums())
217          return null;
218        else
219          throw new FHIRException("Unknown StructureDefinitionKind code '"+codeString+"'");
220        }
221        public String toCode() {
222          switch (this) {
223            case PRIMITIVETYPE: return "primitive-type";
224            case COMPLEXTYPE: return "complex-type";
225            case RESOURCE: return "resource";
226            case LOGICAL: return "logical";
227            default: return "?";
228          }
229        }
230        public String getSystem() {
231          switch (this) {
232            case PRIMITIVETYPE: return "http://hl7.org/fhir/structure-definition-kind";
233            case COMPLEXTYPE: return "http://hl7.org/fhir/structure-definition-kind";
234            case RESOURCE: return "http://hl7.org/fhir/structure-definition-kind";
235            case LOGICAL: return "http://hl7.org/fhir/structure-definition-kind";
236            default: return "?";
237          }
238        }
239        public String getDefinition() {
240          switch (this) {
241            case PRIMITIVETYPE: return "A primitive type that has a value and an extension. These can be used throughout complex datatype, Resource and extension definitions. Only the base specification can define primitive types.";
242            case COMPLEXTYPE: return "A  complex structure that defines a set of data elements that is suitable for use in 'resources'. The base specification defines a number of complex types, and other specifications can define additional types. These structures do not have a maintained identity.";
243            case RESOURCE: return "A 'resource' - a directed acyclic graph of elements that aggregrates other types into an identifiable entity. The base FHIR resources are defined by the FHIR specification itself but other 'resources' can be defined in additional specifications (though these will not be recognised as 'resources' by the FHIR specification (i.e. they do not get end-points etc, or act as the targets of references in FHIR defined resources - though other specificatiosn can treat them this way).";
244            case LOGICAL: return "A pattern or a template that is not intended to be a real resource or complex type.";
245            default: return "?";
246          }
247        }
248        public String getDisplay() {
249          switch (this) {
250            case PRIMITIVETYPE: return "Primitive Data Type";
251            case COMPLEXTYPE: return "Complex Data Type";
252            case RESOURCE: return "Resource";
253            case LOGICAL: return "Logical";
254            default: return "?";
255          }
256        }
257    }
258
259  public static class StructureDefinitionKindEnumFactory implements EnumFactory<StructureDefinitionKind> {
260    public StructureDefinitionKind fromCode(String codeString) throws IllegalArgumentException {
261      if (codeString == null || "".equals(codeString))
262            if (codeString == null || "".equals(codeString))
263                return null;
264        if ("primitive-type".equals(codeString))
265          return StructureDefinitionKind.PRIMITIVETYPE;
266        if ("complex-type".equals(codeString))
267          return StructureDefinitionKind.COMPLEXTYPE;
268        if ("resource".equals(codeString))
269          return StructureDefinitionKind.RESOURCE;
270        if ("logical".equals(codeString))
271          return StructureDefinitionKind.LOGICAL;
272        throw new IllegalArgumentException("Unknown StructureDefinitionKind code '"+codeString+"'");
273        }
274        public Enumeration<StructureDefinitionKind> fromType(Base code) throws FHIRException {
275          if (code == null)
276            return null;
277          if (code.isEmpty())
278            return new Enumeration<StructureDefinitionKind>(this);
279          String codeString = ((PrimitiveType) code).asStringValue();
280          if (codeString == null || "".equals(codeString))
281            return null;
282        if ("primitive-type".equals(codeString))
283          return new Enumeration<StructureDefinitionKind>(this, StructureDefinitionKind.PRIMITIVETYPE);
284        if ("complex-type".equals(codeString))
285          return new Enumeration<StructureDefinitionKind>(this, StructureDefinitionKind.COMPLEXTYPE);
286        if ("resource".equals(codeString))
287          return new Enumeration<StructureDefinitionKind>(this, StructureDefinitionKind.RESOURCE);
288        if ("logical".equals(codeString))
289          return new Enumeration<StructureDefinitionKind>(this, StructureDefinitionKind.LOGICAL);
290        throw new FHIRException("Unknown StructureDefinitionKind code '"+codeString+"'");
291        }
292    public String toCode(StructureDefinitionKind code) {
293      if (code == StructureDefinitionKind.PRIMITIVETYPE)
294        return "primitive-type";
295      if (code == StructureDefinitionKind.COMPLEXTYPE)
296        return "complex-type";
297      if (code == StructureDefinitionKind.RESOURCE)
298        return "resource";
299      if (code == StructureDefinitionKind.LOGICAL)
300        return "logical";
301      return "?";
302      }
303    public String toSystem(StructureDefinitionKind code) {
304      return code.getSystem();
305      }
306    }
307
308    public enum TypeDerivationRule {
309        /**
310         * This definition defines a new type that adds additional elements to the base type.
311         */
312        SPECIALIZATION, 
313        /**
314         * This definition adds additional rules to an existing concrete type.
315         */
316        CONSTRAINT, 
317        /**
318         * added to help the parsers with the generic types
319         */
320        NULL;
321        public static TypeDerivationRule fromCode(String codeString) throws FHIRException {
322            if (codeString == null || "".equals(codeString))
323                return null;
324        if ("specialization".equals(codeString))
325          return SPECIALIZATION;
326        if ("constraint".equals(codeString))
327          return CONSTRAINT;
328        if (Configuration.isAcceptInvalidEnums())
329          return null;
330        else
331          throw new FHIRException("Unknown TypeDerivationRule code '"+codeString+"'");
332        }
333        public String toCode() {
334          switch (this) {
335            case SPECIALIZATION: return "specialization";
336            case CONSTRAINT: return "constraint";
337            default: return "?";
338          }
339        }
340        public String getSystem() {
341          switch (this) {
342            case SPECIALIZATION: return "http://hl7.org/fhir/type-derivation-rule";
343            case CONSTRAINT: return "http://hl7.org/fhir/type-derivation-rule";
344            default: return "?";
345          }
346        }
347        public String getDefinition() {
348          switch (this) {
349            case SPECIALIZATION: return "This definition defines a new type that adds additional elements to the base type.";
350            case CONSTRAINT: return "This definition adds additional rules to an existing concrete type.";
351            default: return "?";
352          }
353        }
354        public String getDisplay() {
355          switch (this) {
356            case SPECIALIZATION: return "Specialization";
357            case CONSTRAINT: return "Constraint";
358            default: return "?";
359          }
360        }
361    }
362
363  public static class TypeDerivationRuleEnumFactory implements EnumFactory<TypeDerivationRule> {
364    public TypeDerivationRule fromCode(String codeString) throws IllegalArgumentException {
365      if (codeString == null || "".equals(codeString))
366            if (codeString == null || "".equals(codeString))
367                return null;
368        if ("specialization".equals(codeString))
369          return TypeDerivationRule.SPECIALIZATION;
370        if ("constraint".equals(codeString))
371          return TypeDerivationRule.CONSTRAINT;
372        throw new IllegalArgumentException("Unknown TypeDerivationRule code '"+codeString+"'");
373        }
374        public Enumeration<TypeDerivationRule> fromType(Base code) throws FHIRException {
375          if (code == null)
376            return null;
377          if (code.isEmpty())
378            return new Enumeration<TypeDerivationRule>(this);
379          String codeString = ((PrimitiveType) code).asStringValue();
380          if (codeString == null || "".equals(codeString))
381            return null;
382        if ("specialization".equals(codeString))
383          return new Enumeration<TypeDerivationRule>(this, TypeDerivationRule.SPECIALIZATION);
384        if ("constraint".equals(codeString))
385          return new Enumeration<TypeDerivationRule>(this, TypeDerivationRule.CONSTRAINT);
386        throw new FHIRException("Unknown TypeDerivationRule code '"+codeString+"'");
387        }
388    public String toCode(TypeDerivationRule code) {
389      if (code == TypeDerivationRule.SPECIALIZATION)
390        return "specialization";
391      if (code == TypeDerivationRule.CONSTRAINT)
392        return "constraint";
393      return "?";
394      }
395    public String toSystem(TypeDerivationRule code) {
396      return code.getSystem();
397      }
398    }
399
400    @Block()
401    public static class StructureDefinitionMappingComponent extends BackboneElement implements IBaseBackboneElement {
402        /**
403         * An Internal id that is used to identify this mapping set when specific mappings are made.
404         */
405        @Child(name = "identity", type = {IdType.class}, order=1, min=1, max=1, modifier=false, summary=false)
406        @Description(shortDefinition="Internal id when this mapping is used", formalDefinition="An Internal id that is used to identify this mapping set when specific mappings are made." )
407        protected IdType identity;
408
409        /**
410         * An absolute URI that identifies the specification that this mapping is expressed to.
411         */
412        @Child(name = "uri", type = {UriType.class}, order=2, min=0, max=1, modifier=false, summary=false)
413        @Description(shortDefinition="Identifies what this mapping refers to", formalDefinition="An absolute URI that identifies the specification that this mapping is expressed to." )
414        protected UriType uri;
415
416        /**
417         * A name for the specification that is being mapped to.
418         */
419        @Child(name = "name", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=false)
420        @Description(shortDefinition="Names what this mapping refers to", formalDefinition="A name for the specification that is being mapped to." )
421        protected StringType name;
422
423        /**
424         * Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.
425         */
426        @Child(name = "comment", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=false)
427        @Description(shortDefinition="Versions, Issues, Scope limitations etc.", formalDefinition="Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage." )
428        protected StringType comment;
429
430        private static final long serialVersionUID = 9610265L;
431
432    /**
433     * Constructor
434     */
435      public StructureDefinitionMappingComponent() {
436        super();
437      }
438
439    /**
440     * Constructor
441     */
442      public StructureDefinitionMappingComponent(String identity) {
443        super();
444        this.setIdentity(identity);
445      }
446
447        /**
448         * @return {@link #identity} (An Internal id that is used to identify this mapping set when specific mappings are made.). This is the underlying object with id, value and extensions. The accessor "getIdentity" gives direct access to the value
449         */
450        public IdType getIdentityElement() { 
451          if (this.identity == null)
452            if (Configuration.errorOnAutoCreate())
453              throw new Error("Attempt to auto-create StructureDefinitionMappingComponent.identity");
454            else if (Configuration.doAutoCreate())
455              this.identity = new IdType(); // bb
456          return this.identity;
457        }
458
459        public boolean hasIdentityElement() { 
460          return this.identity != null && !this.identity.isEmpty();
461        }
462
463        public boolean hasIdentity() { 
464          return this.identity != null && !this.identity.isEmpty();
465        }
466
467        /**
468         * @param value {@link #identity} (An Internal id that is used to identify this mapping set when specific mappings are made.). This is the underlying object with id, value and extensions. The accessor "getIdentity" gives direct access to the value
469         */
470        public StructureDefinitionMappingComponent setIdentityElement(IdType value) { 
471          this.identity = value;
472          return this;
473        }
474
475        /**
476         * @return An Internal id that is used to identify this mapping set when specific mappings are made.
477         */
478        public String getIdentity() { 
479          return this.identity == null ? null : this.identity.getValue();
480        }
481
482        /**
483         * @param value An Internal id that is used to identify this mapping set when specific mappings are made.
484         */
485        public StructureDefinitionMappingComponent setIdentity(String value) { 
486            if (this.identity == null)
487              this.identity = new IdType();
488            this.identity.setValue(value);
489          return this;
490        }
491
492        /**
493         * @return {@link #uri} (An absolute URI that identifies the specification that this mapping is expressed to.). This is the underlying object with id, value and extensions. The accessor "getUri" gives direct access to the value
494         */
495        public UriType getUriElement() { 
496          if (this.uri == null)
497            if (Configuration.errorOnAutoCreate())
498              throw new Error("Attempt to auto-create StructureDefinitionMappingComponent.uri");
499            else if (Configuration.doAutoCreate())
500              this.uri = new UriType(); // bb
501          return this.uri;
502        }
503
504        public boolean hasUriElement() { 
505          return this.uri != null && !this.uri.isEmpty();
506        }
507
508        public boolean hasUri() { 
509          return this.uri != null && !this.uri.isEmpty();
510        }
511
512        /**
513         * @param value {@link #uri} (An absolute URI that identifies the specification that this mapping is expressed to.). This is the underlying object with id, value and extensions. The accessor "getUri" gives direct access to the value
514         */
515        public StructureDefinitionMappingComponent setUriElement(UriType value) { 
516          this.uri = value;
517          return this;
518        }
519
520        /**
521         * @return An absolute URI that identifies the specification that this mapping is expressed to.
522         */
523        public String getUri() { 
524          return this.uri == null ? null : this.uri.getValue();
525        }
526
527        /**
528         * @param value An absolute URI that identifies the specification that this mapping is expressed to.
529         */
530        public StructureDefinitionMappingComponent setUri(String value) { 
531          if (Utilities.noString(value))
532            this.uri = null;
533          else {
534            if (this.uri == null)
535              this.uri = new UriType();
536            this.uri.setValue(value);
537          }
538          return this;
539        }
540
541        /**
542         * @return {@link #name} (A name for the specification that is being mapped to.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
543         */
544        public StringType getNameElement() { 
545          if (this.name == null)
546            if (Configuration.errorOnAutoCreate())
547              throw new Error("Attempt to auto-create StructureDefinitionMappingComponent.name");
548            else if (Configuration.doAutoCreate())
549              this.name = new StringType(); // bb
550          return this.name;
551        }
552
553        public boolean hasNameElement() { 
554          return this.name != null && !this.name.isEmpty();
555        }
556
557        public boolean hasName() { 
558          return this.name != null && !this.name.isEmpty();
559        }
560
561        /**
562         * @param value {@link #name} (A name for the specification that is being mapped to.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
563         */
564        public StructureDefinitionMappingComponent setNameElement(StringType value) { 
565          this.name = value;
566          return this;
567        }
568
569        /**
570         * @return A name for the specification that is being mapped to.
571         */
572        public String getName() { 
573          return this.name == null ? null : this.name.getValue();
574        }
575
576        /**
577         * @param value A name for the specification that is being mapped to.
578         */
579        public StructureDefinitionMappingComponent setName(String value) { 
580          if (Utilities.noString(value))
581            this.name = null;
582          else {
583            if (this.name == null)
584              this.name = new StringType();
585            this.name.setValue(value);
586          }
587          return this;
588        }
589
590        /**
591         * @return {@link #comment} (Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.). This is the underlying object with id, value and extensions. The accessor "getComment" gives direct access to the value
592         */
593        public StringType getCommentElement() { 
594          if (this.comment == null)
595            if (Configuration.errorOnAutoCreate())
596              throw new Error("Attempt to auto-create StructureDefinitionMappingComponent.comment");
597            else if (Configuration.doAutoCreate())
598              this.comment = new StringType(); // bb
599          return this.comment;
600        }
601
602        public boolean hasCommentElement() { 
603          return this.comment != null && !this.comment.isEmpty();
604        }
605
606        public boolean hasComment() { 
607          return this.comment != null && !this.comment.isEmpty();
608        }
609
610        /**
611         * @param value {@link #comment} (Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.). This is the underlying object with id, value and extensions. The accessor "getComment" gives direct access to the value
612         */
613        public StructureDefinitionMappingComponent setCommentElement(StringType value) { 
614          this.comment = value;
615          return this;
616        }
617
618        /**
619         * @return Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.
620         */
621        public String getComment() { 
622          return this.comment == null ? null : this.comment.getValue();
623        }
624
625        /**
626         * @param value Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.
627         */
628        public StructureDefinitionMappingComponent setComment(String value) { 
629          if (Utilities.noString(value))
630            this.comment = null;
631          else {
632            if (this.comment == null)
633              this.comment = new StringType();
634            this.comment.setValue(value);
635          }
636          return this;
637        }
638
639        protected void listChildren(List<Property> children) {
640          super.listChildren(children);
641          children.add(new Property("identity", "id", "An Internal id that is used to identify this mapping set when specific mappings are made.", 0, 1, identity));
642          children.add(new Property("uri", "uri", "An absolute URI that identifies the specification that this mapping is expressed to.", 0, 1, uri));
643          children.add(new Property("name", "string", "A name for the specification that is being mapped to.", 0, 1, name));
644          children.add(new Property("comment", "string", "Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.", 0, 1, comment));
645        }
646
647        @Override
648        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
649          switch (_hash) {
650          case -135761730: /*identity*/  return new Property("identity", "id", "An Internal id that is used to identify this mapping set when specific mappings are made.", 0, 1, identity);
651          case 116076: /*uri*/  return new Property("uri", "uri", "An absolute URI that identifies the specification that this mapping is expressed to.", 0, 1, uri);
652          case 3373707: /*name*/  return new Property("name", "string", "A name for the specification that is being mapped to.", 0, 1, name);
653          case 950398559: /*comment*/  return new Property("comment", "string", "Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.", 0, 1, comment);
654          default: return super.getNamedProperty(_hash, _name, _checkValid);
655          }
656
657        }
658
659      @Override
660      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
661        switch (hash) {
662        case -135761730: /*identity*/ return this.identity == null ? new Base[0] : new Base[] {this.identity}; // IdType
663        case 116076: /*uri*/ return this.uri == null ? new Base[0] : new Base[] {this.uri}; // UriType
664        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
665        case 950398559: /*comment*/ return this.comment == null ? new Base[0] : new Base[] {this.comment}; // StringType
666        default: return super.getProperty(hash, name, checkValid);
667        }
668
669      }
670
671      @Override
672      public Base setProperty(int hash, String name, Base value) throws FHIRException {
673        switch (hash) {
674        case -135761730: // identity
675          this.identity = TypeConvertor.castToId(value); // IdType
676          return value;
677        case 116076: // uri
678          this.uri = TypeConvertor.castToUri(value); // UriType
679          return value;
680        case 3373707: // name
681          this.name = TypeConvertor.castToString(value); // StringType
682          return value;
683        case 950398559: // comment
684          this.comment = TypeConvertor.castToString(value); // StringType
685          return value;
686        default: return super.setProperty(hash, name, value);
687        }
688
689      }
690
691      @Override
692      public Base setProperty(String name, Base value) throws FHIRException {
693        if (name.equals("identity")) {
694          this.identity = TypeConvertor.castToId(value); // IdType
695        } else if (name.equals("uri")) {
696          this.uri = TypeConvertor.castToUri(value); // UriType
697        } else if (name.equals("name")) {
698          this.name = TypeConvertor.castToString(value); // StringType
699        } else if (name.equals("comment")) {
700          this.comment = TypeConvertor.castToString(value); // StringType
701        } else
702          return super.setProperty(name, value);
703        return value;
704      }
705
706      @Override
707      public Base makeProperty(int hash, String name) throws FHIRException {
708        switch (hash) {
709        case -135761730:  return getIdentityElement();
710        case 116076:  return getUriElement();
711        case 3373707:  return getNameElement();
712        case 950398559:  return getCommentElement();
713        default: return super.makeProperty(hash, name);
714        }
715
716      }
717
718      @Override
719      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
720        switch (hash) {
721        case -135761730: /*identity*/ return new String[] {"id"};
722        case 116076: /*uri*/ return new String[] {"uri"};
723        case 3373707: /*name*/ return new String[] {"string"};
724        case 950398559: /*comment*/ return new String[] {"string"};
725        default: return super.getTypesForProperty(hash, name);
726        }
727
728      }
729
730      @Override
731      public Base addChild(String name) throws FHIRException {
732        if (name.equals("identity")) {
733          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.mapping.identity");
734        }
735        else if (name.equals("uri")) {
736          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.mapping.uri");
737        }
738        else if (name.equals("name")) {
739          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.mapping.name");
740        }
741        else if (name.equals("comment")) {
742          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.mapping.comment");
743        }
744        else
745          return super.addChild(name);
746      }
747
748      public StructureDefinitionMappingComponent copy() {
749        StructureDefinitionMappingComponent dst = new StructureDefinitionMappingComponent();
750        copyValues(dst);
751        return dst;
752      }
753
754      public void copyValues(StructureDefinitionMappingComponent dst) {
755        super.copyValues(dst);
756        dst.identity = identity == null ? null : identity.copy();
757        dst.uri = uri == null ? null : uri.copy();
758        dst.name = name == null ? null : name.copy();
759        dst.comment = comment == null ? null : comment.copy();
760      }
761
762      @Override
763      public boolean equalsDeep(Base other_) {
764        if (!super.equalsDeep(other_))
765          return false;
766        if (!(other_ instanceof StructureDefinitionMappingComponent))
767          return false;
768        StructureDefinitionMappingComponent o = (StructureDefinitionMappingComponent) other_;
769        return compareDeep(identity, o.identity, true) && compareDeep(uri, o.uri, true) && compareDeep(name, o.name, true)
770           && compareDeep(comment, o.comment, true);
771      }
772
773      @Override
774      public boolean equalsShallow(Base other_) {
775        if (!super.equalsShallow(other_))
776          return false;
777        if (!(other_ instanceof StructureDefinitionMappingComponent))
778          return false;
779        StructureDefinitionMappingComponent o = (StructureDefinitionMappingComponent) other_;
780        return compareValues(identity, o.identity, true) && compareValues(uri, o.uri, true) && compareValues(name, o.name, true)
781           && compareValues(comment, o.comment, true);
782      }
783
784      public boolean isEmpty() {
785        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identity, uri, name, comment
786          );
787      }
788
789  public String fhirType() {
790    return "StructureDefinition.mapping";
791
792  }
793
794  }
795
796    @Block()
797    public static class StructureDefinitionContextComponent extends BackboneElement implements IBaseBackboneElement {
798        /**
799         * Defines how to interpret the expression that defines what the context of the extension is.
800         */
801        @Child(name = "type", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true)
802        @Description(shortDefinition="fhirpath | element | extension", formalDefinition="Defines how to interpret the expression that defines what the context of the extension is." )
803        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/extension-context-type")
804        protected Enumeration<ExtensionContextType> type;
805
806        /**
807         * An expression that defines where an extension can be used in resources.
808         */
809        @Child(name = "expression", type = {StringType.class}, order=2, min=1, max=1, modifier=false, summary=true)
810        @Description(shortDefinition="Where the extension can be used in instances", formalDefinition="An expression that defines where an extension can be used in resources." )
811        protected StringType expression;
812
813        private static final long serialVersionUID = 1958074856L;
814
815    /**
816     * Constructor
817     */
818      public StructureDefinitionContextComponent() {
819        super();
820      }
821
822    /**
823     * Constructor
824     */
825      public StructureDefinitionContextComponent(ExtensionContextType type, String expression) {
826        super();
827        this.setType(type);
828        this.setExpression(expression);
829      }
830
831        /**
832         * @return {@link #type} (Defines how to interpret the expression that defines what the context of the extension is.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
833         */
834        public Enumeration<ExtensionContextType> getTypeElement() { 
835          if (this.type == null)
836            if (Configuration.errorOnAutoCreate())
837              throw new Error("Attempt to auto-create StructureDefinitionContextComponent.type");
838            else if (Configuration.doAutoCreate())
839              this.type = new Enumeration<ExtensionContextType>(new ExtensionContextTypeEnumFactory()); // bb
840          return this.type;
841        }
842
843        public boolean hasTypeElement() { 
844          return this.type != null && !this.type.isEmpty();
845        }
846
847        public boolean hasType() { 
848          return this.type != null && !this.type.isEmpty();
849        }
850
851        /**
852         * @param value {@link #type} (Defines how to interpret the expression that defines what the context of the extension is.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
853         */
854        public StructureDefinitionContextComponent setTypeElement(Enumeration<ExtensionContextType> value) { 
855          this.type = value;
856          return this;
857        }
858
859        /**
860         * @return Defines how to interpret the expression that defines what the context of the extension is.
861         */
862        public ExtensionContextType getType() { 
863          return this.type == null ? null : this.type.getValue();
864        }
865
866        /**
867         * @param value Defines how to interpret the expression that defines what the context of the extension is.
868         */
869        public StructureDefinitionContextComponent setType(ExtensionContextType value) { 
870            if (this.type == null)
871              this.type = new Enumeration<ExtensionContextType>(new ExtensionContextTypeEnumFactory());
872            this.type.setValue(value);
873          return this;
874        }
875
876        /**
877         * @return {@link #expression} (An expression that defines where an extension can be used in resources.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value
878         */
879        public StringType getExpressionElement() { 
880          if (this.expression == null)
881            if (Configuration.errorOnAutoCreate())
882              throw new Error("Attempt to auto-create StructureDefinitionContextComponent.expression");
883            else if (Configuration.doAutoCreate())
884              this.expression = new StringType(); // bb
885          return this.expression;
886        }
887
888        public boolean hasExpressionElement() { 
889          return this.expression != null && !this.expression.isEmpty();
890        }
891
892        public boolean hasExpression() { 
893          return this.expression != null && !this.expression.isEmpty();
894        }
895
896        /**
897         * @param value {@link #expression} (An expression that defines where an extension can be used in resources.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value
898         */
899        public StructureDefinitionContextComponent setExpressionElement(StringType value) { 
900          this.expression = value;
901          return this;
902        }
903
904        /**
905         * @return An expression that defines where an extension can be used in resources.
906         */
907        public String getExpression() { 
908          return this.expression == null ? null : this.expression.getValue();
909        }
910
911        /**
912         * @param value An expression that defines where an extension can be used in resources.
913         */
914        public StructureDefinitionContextComponent setExpression(String value) { 
915            if (this.expression == null)
916              this.expression = new StringType();
917            this.expression.setValue(value);
918          return this;
919        }
920
921        protected void listChildren(List<Property> children) {
922          super.listChildren(children);
923          children.add(new Property("type", "code", "Defines how to interpret the expression that defines what the context of the extension is.", 0, 1, type));
924          children.add(new Property("expression", "string", "An expression that defines where an extension can be used in resources.", 0, 1, expression));
925        }
926
927        @Override
928        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
929          switch (_hash) {
930          case 3575610: /*type*/  return new Property("type", "code", "Defines how to interpret the expression that defines what the context of the extension is.", 0, 1, type);
931          case -1795452264: /*expression*/  return new Property("expression", "string", "An expression that defines where an extension can be used in resources.", 0, 1, expression);
932          default: return super.getNamedProperty(_hash, _name, _checkValid);
933          }
934
935        }
936
937      @Override
938      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
939        switch (hash) {
940        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<ExtensionContextType>
941        case -1795452264: /*expression*/ return this.expression == null ? new Base[0] : new Base[] {this.expression}; // StringType
942        default: return super.getProperty(hash, name, checkValid);
943        }
944
945      }
946
947      @Override
948      public Base setProperty(int hash, String name, Base value) throws FHIRException {
949        switch (hash) {
950        case 3575610: // type
951          value = new ExtensionContextTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
952          this.type = (Enumeration) value; // Enumeration<ExtensionContextType>
953          return value;
954        case -1795452264: // expression
955          this.expression = TypeConvertor.castToString(value); // StringType
956          return value;
957        default: return super.setProperty(hash, name, value);
958        }
959
960      }
961
962      @Override
963      public Base setProperty(String name, Base value) throws FHIRException {
964        if (name.equals("type")) {
965          value = new ExtensionContextTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
966          this.type = (Enumeration) value; // Enumeration<ExtensionContextType>
967        } else if (name.equals("expression")) {
968          this.expression = TypeConvertor.castToString(value); // StringType
969        } else
970          return super.setProperty(name, value);
971        return value;
972      }
973
974      @Override
975      public Base makeProperty(int hash, String name) throws FHIRException {
976        switch (hash) {
977        case 3575610:  return getTypeElement();
978        case -1795452264:  return getExpressionElement();
979        default: return super.makeProperty(hash, name);
980        }
981
982      }
983
984      @Override
985      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
986        switch (hash) {
987        case 3575610: /*type*/ return new String[] {"code"};
988        case -1795452264: /*expression*/ return new String[] {"string"};
989        default: return super.getTypesForProperty(hash, name);
990        }
991
992      }
993
994      @Override
995      public Base addChild(String name) throws FHIRException {
996        if (name.equals("type")) {
997          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.context.type");
998        }
999        else if (name.equals("expression")) {
1000          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.context.expression");
1001        }
1002        else
1003          return super.addChild(name);
1004      }
1005
1006      public StructureDefinitionContextComponent copy() {
1007        StructureDefinitionContextComponent dst = new StructureDefinitionContextComponent();
1008        copyValues(dst);
1009        return dst;
1010      }
1011
1012      public void copyValues(StructureDefinitionContextComponent dst) {
1013        super.copyValues(dst);
1014        dst.type = type == null ? null : type.copy();
1015        dst.expression = expression == null ? null : expression.copy();
1016      }
1017
1018      @Override
1019      public boolean equalsDeep(Base other_) {
1020        if (!super.equalsDeep(other_))
1021          return false;
1022        if (!(other_ instanceof StructureDefinitionContextComponent))
1023          return false;
1024        StructureDefinitionContextComponent o = (StructureDefinitionContextComponent) other_;
1025        return compareDeep(type, o.type, true) && compareDeep(expression, o.expression, true);
1026      }
1027
1028      @Override
1029      public boolean equalsShallow(Base other_) {
1030        if (!super.equalsShallow(other_))
1031          return false;
1032        if (!(other_ instanceof StructureDefinitionContextComponent))
1033          return false;
1034        StructureDefinitionContextComponent o = (StructureDefinitionContextComponent) other_;
1035        return compareValues(type, o.type, true) && compareValues(expression, o.expression, true);
1036      }
1037
1038      public boolean isEmpty() {
1039        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, expression);
1040      }
1041
1042  public String fhirType() {
1043    return "StructureDefinition.context";
1044
1045  }
1046
1047  }
1048
1049    @Block()
1050    public static class StructureDefinitionSnapshotComponent extends BackboneElement implements IBaseBackboneElement {
1051        /**
1052         * Captures constraints on each element within the resource.
1053         */
1054        @Child(name = "element", type = {ElementDefinition.class}, order=1, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1055        @Description(shortDefinition="Definition of elements in the resource (if no StructureDefinition)", formalDefinition="Captures constraints on each element within the resource." )
1056        protected List<ElementDefinition> element;
1057
1058        private static final long serialVersionUID = 53896641L;
1059
1060    /**
1061     * Constructor
1062     */
1063      public StructureDefinitionSnapshotComponent() {
1064        super();
1065      }
1066
1067    /**
1068     * Constructor
1069     */
1070      public StructureDefinitionSnapshotComponent(ElementDefinition element) {
1071        super();
1072        this.addElement(element);
1073      }
1074
1075        /**
1076         * @return {@link #element} (Captures constraints on each element within the resource.)
1077         */
1078        public List<ElementDefinition> getElement() { 
1079          if (this.element == null)
1080            this.element = new ArrayList<ElementDefinition>();
1081          return this.element;
1082        }
1083
1084        /**
1085         * @return Returns a reference to <code>this</code> for easy method chaining
1086         */
1087        public StructureDefinitionSnapshotComponent setElement(List<ElementDefinition> theElement) { 
1088          this.element = theElement;
1089          return this;
1090        }
1091
1092        public boolean hasElement() { 
1093          if (this.element == null)
1094            return false;
1095          for (ElementDefinition item : this.element)
1096            if (!item.isEmpty())
1097              return true;
1098          return false;
1099        }
1100
1101        public ElementDefinition addElement() { //3
1102          ElementDefinition t = new ElementDefinition();
1103          if (this.element == null)
1104            this.element = new ArrayList<ElementDefinition>();
1105          this.element.add(t);
1106          return t;
1107        }
1108
1109        public StructureDefinitionSnapshotComponent addElement(ElementDefinition t) { //3
1110          if (t == null)
1111            return this;
1112          if (this.element == null)
1113            this.element = new ArrayList<ElementDefinition>();
1114          this.element.add(t);
1115          return this;
1116        }
1117
1118        /**
1119         * @return The first repetition of repeating field {@link #element}, creating it if it does not already exist {3}
1120         */
1121        public ElementDefinition getElementFirstRep() { 
1122          if (getElement().isEmpty()) {
1123            addElement();
1124          }
1125          return getElement().get(0);
1126        }
1127
1128        protected void listChildren(List<Property> children) {
1129          super.listChildren(children);
1130          children.add(new Property("element", "ElementDefinition", "Captures constraints on each element within the resource.", 0, java.lang.Integer.MAX_VALUE, element));
1131        }
1132
1133        @Override
1134        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1135          switch (_hash) {
1136          case -1662836996: /*element*/  return new Property("element", "ElementDefinition", "Captures constraints on each element within the resource.", 0, java.lang.Integer.MAX_VALUE, element);
1137          default: return super.getNamedProperty(_hash, _name, _checkValid);
1138          }
1139
1140        }
1141
1142      @Override
1143      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1144        switch (hash) {
1145        case -1662836996: /*element*/ return this.element == null ? new Base[0] : this.element.toArray(new Base[this.element.size()]); // ElementDefinition
1146        default: return super.getProperty(hash, name, checkValid);
1147        }
1148
1149      }
1150
1151      @Override
1152      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1153        switch (hash) {
1154        case -1662836996: // element
1155          this.getElement().add(TypeConvertor.castToElementDefinition(value)); // ElementDefinition
1156          return value;
1157        default: return super.setProperty(hash, name, value);
1158        }
1159
1160      }
1161
1162      @Override
1163      public Base setProperty(String name, Base value) throws FHIRException {
1164        if (name.equals("element")) {
1165          this.getElement().add(TypeConvertor.castToElementDefinition(value));
1166        } else
1167          return super.setProperty(name, value);
1168        return value;
1169      }
1170
1171      @Override
1172      public Base makeProperty(int hash, String name) throws FHIRException {
1173        switch (hash) {
1174        case -1662836996:  return addElement(); 
1175        default: return super.makeProperty(hash, name);
1176        }
1177
1178      }
1179
1180      @Override
1181      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1182        switch (hash) {
1183        case -1662836996: /*element*/ return new String[] {"ElementDefinition"};
1184        default: return super.getTypesForProperty(hash, name);
1185        }
1186
1187      }
1188
1189      @Override
1190      public Base addChild(String name) throws FHIRException {
1191        if (name.equals("element")) {
1192          return addElement();
1193        }
1194        else
1195          return super.addChild(name);
1196      }
1197
1198      public StructureDefinitionSnapshotComponent copy() {
1199        StructureDefinitionSnapshotComponent dst = new StructureDefinitionSnapshotComponent();
1200        copyValues(dst);
1201        return dst;
1202      }
1203
1204      public void copyValues(StructureDefinitionSnapshotComponent dst) {
1205        super.copyValues(dst);
1206        if (element != null) {
1207          dst.element = new ArrayList<ElementDefinition>();
1208          for (ElementDefinition i : element)
1209            dst.element.add(i.copy());
1210        };
1211      }
1212
1213      @Override
1214      public boolean equalsDeep(Base other_) {
1215        if (!super.equalsDeep(other_))
1216          return false;
1217        if (!(other_ instanceof StructureDefinitionSnapshotComponent))
1218          return false;
1219        StructureDefinitionSnapshotComponent o = (StructureDefinitionSnapshotComponent) other_;
1220        return compareDeep(element, o.element, true);
1221      }
1222
1223      @Override
1224      public boolean equalsShallow(Base other_) {
1225        if (!super.equalsShallow(other_))
1226          return false;
1227        if (!(other_ instanceof StructureDefinitionSnapshotComponent))
1228          return false;
1229        StructureDefinitionSnapshotComponent o = (StructureDefinitionSnapshotComponent) other_;
1230        return true;
1231      }
1232
1233      public boolean isEmpty() {
1234        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(element);
1235      }
1236
1237  public String fhirType() {
1238    return "StructureDefinition.snapshot";
1239
1240  }
1241
1242  }
1243
1244    @Block()
1245    public static class StructureDefinitionDifferentialComponent extends BackboneElement implements IBaseBackboneElement {
1246        /**
1247         * Captures constraints on each element within the resource.
1248         */
1249        @Child(name = "element", type = {ElementDefinition.class}, order=1, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1250        @Description(shortDefinition="Definition of elements in the resource (if no StructureDefinition)", formalDefinition="Captures constraints on each element within the resource." )
1251        protected List<ElementDefinition> element;
1252
1253        private static final long serialVersionUID = 53896641L;
1254
1255    /**
1256     * Constructor
1257     */
1258      public StructureDefinitionDifferentialComponent() {
1259        super();
1260      }
1261
1262    /**
1263     * Constructor
1264     */
1265      public StructureDefinitionDifferentialComponent(ElementDefinition element) {
1266        super();
1267        this.addElement(element);
1268      }
1269
1270        /**
1271         * @return {@link #element} (Captures constraints on each element within the resource.)
1272         */
1273        public List<ElementDefinition> getElement() { 
1274          if (this.element == null)
1275            this.element = new ArrayList<ElementDefinition>();
1276          return this.element;
1277        }
1278
1279        /**
1280         * @return Returns a reference to <code>this</code> for easy method chaining
1281         */
1282        public StructureDefinitionDifferentialComponent setElement(List<ElementDefinition> theElement) { 
1283          this.element = theElement;
1284          return this;
1285        }
1286
1287        public boolean hasElement() { 
1288          if (this.element == null)
1289            return false;
1290          for (ElementDefinition item : this.element)
1291            if (!item.isEmpty())
1292              return true;
1293          return false;
1294        }
1295
1296        public ElementDefinition addElement() { //3
1297          ElementDefinition t = new ElementDefinition();
1298          if (this.element == null)
1299            this.element = new ArrayList<ElementDefinition>();
1300          this.element.add(t);
1301          return t;
1302        }
1303
1304        public StructureDefinitionDifferentialComponent addElement(ElementDefinition t) { //3
1305          if (t == null)
1306            return this;
1307          if (this.element == null)
1308            this.element = new ArrayList<ElementDefinition>();
1309          this.element.add(t);
1310          return this;
1311        }
1312
1313        /**
1314         * @return The first repetition of repeating field {@link #element}, creating it if it does not already exist {3}
1315         */
1316        public ElementDefinition getElementFirstRep() { 
1317          if (getElement().isEmpty()) {
1318            addElement();
1319          }
1320          return getElement().get(0);
1321        }
1322
1323        protected void listChildren(List<Property> children) {
1324          super.listChildren(children);
1325          children.add(new Property("element", "ElementDefinition", "Captures constraints on each element within the resource.", 0, java.lang.Integer.MAX_VALUE, element));
1326        }
1327
1328        @Override
1329        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1330          switch (_hash) {
1331          case -1662836996: /*element*/  return new Property("element", "ElementDefinition", "Captures constraints on each element within the resource.", 0, java.lang.Integer.MAX_VALUE, element);
1332          default: return super.getNamedProperty(_hash, _name, _checkValid);
1333          }
1334
1335        }
1336
1337      @Override
1338      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1339        switch (hash) {
1340        case -1662836996: /*element*/ return this.element == null ? new Base[0] : this.element.toArray(new Base[this.element.size()]); // ElementDefinition
1341        default: return super.getProperty(hash, name, checkValid);
1342        }
1343
1344      }
1345
1346      @Override
1347      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1348        switch (hash) {
1349        case -1662836996: // element
1350          this.getElement().add(TypeConvertor.castToElementDefinition(value)); // ElementDefinition
1351          return value;
1352        default: return super.setProperty(hash, name, value);
1353        }
1354
1355      }
1356
1357      @Override
1358      public Base setProperty(String name, Base value) throws FHIRException {
1359        if (name.equals("element")) {
1360          this.getElement().add(TypeConvertor.castToElementDefinition(value));
1361        } else
1362          return super.setProperty(name, value);
1363        return value;
1364      }
1365
1366      @Override
1367      public Base makeProperty(int hash, String name) throws FHIRException {
1368        switch (hash) {
1369        case -1662836996:  return addElement(); 
1370        default: return super.makeProperty(hash, name);
1371        }
1372
1373      }
1374
1375      @Override
1376      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1377        switch (hash) {
1378        case -1662836996: /*element*/ return new String[] {"ElementDefinition"};
1379        default: return super.getTypesForProperty(hash, name);
1380        }
1381
1382      }
1383
1384      @Override
1385      public Base addChild(String name) throws FHIRException {
1386        if (name.equals("element")) {
1387          return addElement();
1388        }
1389        else
1390          return super.addChild(name);
1391      }
1392
1393      public StructureDefinitionDifferentialComponent copy() {
1394        StructureDefinitionDifferentialComponent dst = new StructureDefinitionDifferentialComponent();
1395        copyValues(dst);
1396        return dst;
1397      }
1398
1399      public void copyValues(StructureDefinitionDifferentialComponent dst) {
1400        super.copyValues(dst);
1401        if (element != null) {
1402          dst.element = new ArrayList<ElementDefinition>();
1403          for (ElementDefinition i : element)
1404            dst.element.add(i.copy());
1405        };
1406      }
1407
1408      @Override
1409      public boolean equalsDeep(Base other_) {
1410        if (!super.equalsDeep(other_))
1411          return false;
1412        if (!(other_ instanceof StructureDefinitionDifferentialComponent))
1413          return false;
1414        StructureDefinitionDifferentialComponent o = (StructureDefinitionDifferentialComponent) other_;
1415        return compareDeep(element, o.element, true);
1416      }
1417
1418      @Override
1419      public boolean equalsShallow(Base other_) {
1420        if (!super.equalsShallow(other_))
1421          return false;
1422        if (!(other_ instanceof StructureDefinitionDifferentialComponent))
1423          return false;
1424        StructureDefinitionDifferentialComponent o = (StructureDefinitionDifferentialComponent) other_;
1425        return true;
1426      }
1427
1428      public boolean isEmpty() {
1429        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(element);
1430      }
1431
1432  public String fhirType() {
1433    return "StructureDefinition.differential";
1434
1435  }
1436
1437  }
1438
1439    /**
1440     * An absolute URI that is used to identify this structure definition 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 structure definition is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the structure definition is stored on different servers.
1441     */
1442    @Child(name = "url", type = {UriType.class}, order=0, min=1, max=1, modifier=false, summary=true)
1443    @Description(shortDefinition="Canonical identifier for this structure definition, represented as a URI (globally unique)", formalDefinition="An absolute URI that is used to identify this structure definition 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 structure definition is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the structure definition is stored on different servers." )
1444    protected UriType url;
1445
1446    /**
1447     * A formal identifier that is used to identify this structure definition when it is represented in other formats, or referenced in a specification, model, design or an instance.
1448     */
1449    @Child(name = "identifier", type = {Identifier.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1450    @Description(shortDefinition="Additional identifier for the structure definition", formalDefinition="A formal identifier that is used to identify this structure definition when it is represented in other formats, or referenced in a specification, model, design or an instance." )
1451    protected List<Identifier> identifier;
1452
1453    /**
1454     * The identifier that is used to identify this version of the structure definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure definition 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.
1455     */
1456    @Child(name = "version", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true)
1457    @Description(shortDefinition="Business version of the structure definition", formalDefinition="The identifier that is used to identify this version of the structure definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure definition 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." )
1458    protected StringType version;
1459
1460    /**
1461     * A natural language name identifying the structure definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.
1462     */
1463    @Child(name = "name", type = {StringType.class}, order=3, min=1, max=1, modifier=false, summary=true)
1464    @Description(shortDefinition="Name for this structure definition (computer friendly)", formalDefinition="A natural language name identifying the structure definition. This name should be usable as an identifier for the module by machine processing applications such as code generation." )
1465    protected StringType name;
1466
1467    /**
1468     * A short, descriptive, user-friendly title for the structure definition.
1469     */
1470    @Child(name = "title", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=true)
1471    @Description(shortDefinition="Name for this structure definition (human friendly)", formalDefinition="A short, descriptive, user-friendly title for the structure definition." )
1472    protected StringType title;
1473
1474    /**
1475     * The status of this structure definition. Enables tracking the life-cycle of the content.
1476     */
1477    @Child(name = "status", type = {CodeType.class}, order=5, min=1, max=1, modifier=true, summary=true)
1478    @Description(shortDefinition="draft | active | retired | unknown", formalDefinition="The status of this structure definition. Enables tracking the life-cycle of the content." )
1479    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/publication-status")
1480    protected Enumeration<PublicationStatus> status;
1481
1482    /**
1483     * A Boolean value to indicate that this structure definition is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.
1484     */
1485    @Child(name = "experimental", type = {BooleanType.class}, order=6, min=0, max=1, modifier=false, summary=true)
1486    @Description(shortDefinition="For testing purposes, not real usage", formalDefinition="A Boolean value to indicate that this structure definition is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage." )
1487    protected BooleanType experimental;
1488
1489    /**
1490     * The date  (and optionally time) when the structure definition 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 structure definition changes.
1491     */
1492    @Child(name = "date", type = {DateTimeType.class}, order=7, min=0, max=1, modifier=false, summary=true)
1493    @Description(shortDefinition="Date last changed", formalDefinition="The date  (and optionally time) when the structure definition 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 structure definition changes." )
1494    protected DateTimeType date;
1495
1496    /**
1497     * The name of the organization or individual that published the structure definition.
1498     */
1499    @Child(name = "publisher", type = {StringType.class}, order=8, min=0, max=1, modifier=false, summary=true)
1500    @Description(shortDefinition="Name of the publisher (organization or individual)", formalDefinition="The name of the organization or individual that published the structure definition." )
1501    protected StringType publisher;
1502
1503    /**
1504     * Contact details to assist a user in finding and communicating with the publisher.
1505     */
1506    @Child(name = "contact", type = {ContactDetail.class}, order=9, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1507    @Description(shortDefinition="Contact details for the publisher", formalDefinition="Contact details to assist a user in finding and communicating with the publisher." )
1508    protected List<ContactDetail> contact;
1509
1510    /**
1511     * A free text natural language description of the structure definition from a consumer's perspective.
1512     */
1513    @Child(name = "description", type = {MarkdownType.class}, order=10, min=0, max=1, modifier=false, summary=false)
1514    @Description(shortDefinition="Natural language description of the structure definition", formalDefinition="A free text natural language description of the structure definition from a consumer's perspective." )
1515    protected MarkdownType description;
1516
1517    /**
1518     * 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 structure definition instances.
1519     */
1520    @Child(name = "useContext", type = {UsageContext.class}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1521    @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 structure definition instances." )
1522    protected List<UsageContext> useContext;
1523
1524    /**
1525     * A legal or geographic region in which the structure definition is intended to be used.
1526     */
1527    @Child(name = "jurisdiction", type = {CodeableConcept.class}, order=12, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1528    @Description(shortDefinition="Intended jurisdiction for structure definition (if applicable)", formalDefinition="A legal or geographic region in which the structure definition is intended to be used." )
1529    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/jurisdiction")
1530    protected List<CodeableConcept> jurisdiction;
1531
1532    /**
1533     * Explanation of why this structure definition is needed and why it has been designed as it has.
1534     */
1535    @Child(name = "purpose", type = {MarkdownType.class}, order=13, min=0, max=1, modifier=false, summary=false)
1536    @Description(shortDefinition="Why this structure definition is defined", formalDefinition="Explanation of why this structure definition is needed and why it has been designed as it has." )
1537    protected MarkdownType purpose;
1538
1539    /**
1540     * A copyright statement relating to the structure definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure definition.
1541     */
1542    @Child(name = "copyright", type = {MarkdownType.class}, order=14, min=0, max=1, modifier=false, summary=false)
1543    @Description(shortDefinition="Use and/or publishing restrictions", formalDefinition="A copyright statement relating to the structure definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure definition." )
1544    protected MarkdownType copyright;
1545
1546    /**
1547     * A set of key words or terms from external terminologies that may be used to assist with indexing and searching of templates nby describing the use of this structure definition, or the content it describes.
1548     */
1549    @Child(name = "keyword", type = {Coding.class}, order=15, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1550    @Description(shortDefinition="Assist with indexing and finding", formalDefinition="A set of key words or terms from external terminologies that may be used to assist with indexing and searching of templates nby describing the use of this structure definition, or the content it describes." )
1551    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/definition-use")
1552    protected List<Coding> keyword;
1553
1554    /**
1555     * The version of the FHIR specification on which this StructureDefinition is based - this is the formal version of the specification, without the revision number, e.g. [publication].[major].[minor], which is 4.2.0. for this version.
1556     */
1557    @Child(name = "fhirVersion", type = {CodeType.class}, order=16, min=0, max=1, modifier=false, summary=true)
1558    @Description(shortDefinition="FHIR Version this StructureDefinition targets", formalDefinition="The version of the FHIR specification on which this StructureDefinition is based - this is the formal version of the specification, without the revision number, e.g. [publication].[major].[minor], which is 4.2.0. for this version." )
1559    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/FHIR-version")
1560    protected Enumeration<FHIRVersion> fhirVersion;
1561
1562    /**
1563     * An external specification that the content is mapped to.
1564     */
1565    @Child(name = "mapping", type = {}, order=17, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1566    @Description(shortDefinition="External specification that the content is mapped to", formalDefinition="An external specification that the content is mapped to." )
1567    protected List<StructureDefinitionMappingComponent> mapping;
1568
1569    /**
1570     * Defines the kind of structure that this definition is describing.
1571     */
1572    @Child(name = "kind", type = {CodeType.class}, order=18, min=1, max=1, modifier=false, summary=true)
1573    @Description(shortDefinition="primitive-type | complex-type | resource | logical", formalDefinition="Defines the kind of structure that this definition is describing." )
1574    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/structure-definition-kind")
1575    protected Enumeration<StructureDefinitionKind> kind;
1576
1577    /**
1578     * Whether structure this definition describes is abstract or not  - that is, whether the structure is not intended to be instantiated. For Resources and Data types, abstract types will never be exchanged  between systems.
1579     */
1580    @Child(name = "abstract", type = {BooleanType.class}, order=19, min=1, max=1, modifier=false, summary=true)
1581    @Description(shortDefinition="Whether the structure is abstract", formalDefinition="Whether structure this definition describes is abstract or not  - that is, whether the structure is not intended to be instantiated. For Resources and Data types, abstract types will never be exchanged  between systems." )
1582    protected BooleanType abstract_;
1583
1584    /**
1585     * Identifies the types of resource or data type elements to which the extension can be applied.
1586     */
1587    @Child(name = "context", type = {}, order=20, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1588    @Description(shortDefinition="If an extension, where it can be used in instances", formalDefinition="Identifies the types of resource or data type elements to which the extension can be applied." )
1589    protected List<StructureDefinitionContextComponent> context;
1590
1591    /**
1592     * A set of rules as FHIRPath Invariants about when the extension can be used (e.g. co-occurrence variants for the extension). All the rules must be true.
1593     */
1594    @Child(name = "contextInvariant", type = {StringType.class}, order=21, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1595    @Description(shortDefinition="FHIRPath invariants - when the extension can be used", formalDefinition="A set of rules as FHIRPath Invariants about when the extension can be used (e.g. co-occurrence variants for the extension). All the rules must be true." )
1596    protected List<StringType> contextInvariant;
1597
1598    /**
1599     * The type this structure describes. If the derivation kind is 'specialization' then this is the master definition for a type, and there is always one of these (a data type, an extension, a resource, including abstract ones). Otherwise the structure definition is a constraint on the stated type (and in this case, the type cannot be an abstract type).  References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. "string" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.
1600     */
1601    @Child(name = "type", type = {UriType.class}, order=22, min=1, max=1, modifier=false, summary=true)
1602    @Description(shortDefinition="Type defined or constrained by this structure", formalDefinition="The type this structure describes. If the derivation kind is 'specialization' then this is the master definition for a type, and there is always one of these (a data type, an extension, a resource, including abstract ones). Otherwise the structure definition is a constraint on the stated type (and in this case, the type cannot be an abstract type).  References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. \"string\" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models." )
1603    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/defined-types")
1604    protected UriType type;
1605
1606    /**
1607     * An absolute URI that is the base structure from which this type is derived, either by specialization or constraint.
1608     */
1609    @Child(name = "baseDefinition", type = {CanonicalType.class}, order=23, min=0, max=1, modifier=false, summary=true)
1610    @Description(shortDefinition="Definition that this type is constrained/specialized from", formalDefinition="An absolute URI that is the base structure from which this type is derived, either by specialization or constraint." )
1611    protected CanonicalType baseDefinition;
1612
1613    /**
1614     * How the type relates to the baseDefinition.
1615     */
1616    @Child(name = "derivation", type = {CodeType.class}, order=24, min=0, max=1, modifier=false, summary=true)
1617    @Description(shortDefinition="specialization | constraint - How relates to base definition", formalDefinition="How the type relates to the baseDefinition." )
1618    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/type-derivation-rule")
1619    protected Enumeration<TypeDerivationRule> derivation;
1620
1621    /**
1622     * A snapshot view is expressed in a standalone form that can be used and interpreted without considering the base StructureDefinition.
1623     */
1624    @Child(name = "snapshot", type = {}, order=25, min=0, max=1, modifier=false, summary=false)
1625    @Description(shortDefinition="Snapshot view of the structure", formalDefinition="A snapshot view is expressed in a standalone form that can be used and interpreted without considering the base StructureDefinition." )
1626    protected StructureDefinitionSnapshotComponent snapshot;
1627
1628    /**
1629     * A differential view is expressed relative to the base StructureDefinition - a statement of differences that it applies.
1630     */
1631    @Child(name = "differential", type = {}, order=26, min=0, max=1, modifier=false, summary=false)
1632    @Description(shortDefinition="Differential view of the structure", formalDefinition="A differential view is expressed relative to the base StructureDefinition - a statement of differences that it applies." )
1633    protected StructureDefinitionDifferentialComponent differential;
1634
1635    private static final long serialVersionUID = -101902378L;
1636
1637  /**
1638   * Constructor
1639   */
1640    public StructureDefinition() {
1641      super();
1642    }
1643
1644  /**
1645   * Constructor
1646   */
1647    public StructureDefinition(String url, String name, PublicationStatus status, StructureDefinitionKind kind, boolean abstract_, String type) {
1648      super();
1649      this.setUrl(url);
1650      this.setName(name);
1651      this.setStatus(status);
1652      this.setKind(kind);
1653      this.setAbstract(abstract_);
1654      this.setType(type);
1655    }
1656
1657    /**
1658     * @return {@link #url} (An absolute URI that is used to identify this structure definition 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 structure definition is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the structure definition is stored on different servers.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
1659     */
1660    public UriType getUrlElement() { 
1661      if (this.url == null)
1662        if (Configuration.errorOnAutoCreate())
1663          throw new Error("Attempt to auto-create StructureDefinition.url");
1664        else if (Configuration.doAutoCreate())
1665          this.url = new UriType(); // bb
1666      return this.url;
1667    }
1668
1669    public boolean hasUrlElement() { 
1670      return this.url != null && !this.url.isEmpty();
1671    }
1672
1673    public boolean hasUrl() { 
1674      return this.url != null && !this.url.isEmpty();
1675    }
1676
1677    /**
1678     * @param value {@link #url} (An absolute URI that is used to identify this structure definition 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 structure definition is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the structure definition is stored on different servers.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
1679     */
1680    public StructureDefinition setUrlElement(UriType value) { 
1681      this.url = value;
1682      return this;
1683    }
1684
1685    /**
1686     * @return An absolute URI that is used to identify this structure definition 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 structure definition is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the structure definition is stored on different servers.
1687     */
1688    public String getUrl() { 
1689      return this.url == null ? null : this.url.getValue();
1690    }
1691
1692    /**
1693     * @param value An absolute URI that is used to identify this structure definition 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 structure definition is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the structure definition is stored on different servers.
1694     */
1695    public StructureDefinition setUrl(String value) { 
1696        if (this.url == null)
1697          this.url = new UriType();
1698        this.url.setValue(value);
1699      return this;
1700    }
1701
1702    /**
1703     * @return {@link #identifier} (A formal identifier that is used to identify this structure definition when it is represented in other formats, or referenced in a specification, model, design or an instance.)
1704     */
1705    public List<Identifier> getIdentifier() { 
1706      if (this.identifier == null)
1707        this.identifier = new ArrayList<Identifier>();
1708      return this.identifier;
1709    }
1710
1711    /**
1712     * @return Returns a reference to <code>this</code> for easy method chaining
1713     */
1714    public StructureDefinition setIdentifier(List<Identifier> theIdentifier) { 
1715      this.identifier = theIdentifier;
1716      return this;
1717    }
1718
1719    public boolean hasIdentifier() { 
1720      if (this.identifier == null)
1721        return false;
1722      for (Identifier item : this.identifier)
1723        if (!item.isEmpty())
1724          return true;
1725      return false;
1726    }
1727
1728    public Identifier addIdentifier() { //3
1729      Identifier t = new Identifier();
1730      if (this.identifier == null)
1731        this.identifier = new ArrayList<Identifier>();
1732      this.identifier.add(t);
1733      return t;
1734    }
1735
1736    public StructureDefinition addIdentifier(Identifier t) { //3
1737      if (t == null)
1738        return this;
1739      if (this.identifier == null)
1740        this.identifier = new ArrayList<Identifier>();
1741      this.identifier.add(t);
1742      return this;
1743    }
1744
1745    /**
1746     * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist {3}
1747     */
1748    public Identifier getIdentifierFirstRep() { 
1749      if (getIdentifier().isEmpty()) {
1750        addIdentifier();
1751      }
1752      return getIdentifier().get(0);
1753    }
1754
1755    /**
1756     * @return {@link #version} (The identifier that is used to identify this version of the structure definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure definition 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
1757     */
1758    public StringType getVersionElement() { 
1759      if (this.version == null)
1760        if (Configuration.errorOnAutoCreate())
1761          throw new Error("Attempt to auto-create StructureDefinition.version");
1762        else if (Configuration.doAutoCreate())
1763          this.version = new StringType(); // bb
1764      return this.version;
1765    }
1766
1767    public boolean hasVersionElement() { 
1768      return this.version != null && !this.version.isEmpty();
1769    }
1770
1771    public boolean hasVersion() { 
1772      return this.version != null && !this.version.isEmpty();
1773    }
1774
1775    /**
1776     * @param value {@link #version} (The identifier that is used to identify this version of the structure definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure definition 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
1777     */
1778    public StructureDefinition setVersionElement(StringType value) { 
1779      this.version = value;
1780      return this;
1781    }
1782
1783    /**
1784     * @return The identifier that is used to identify this version of the structure definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure definition 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.
1785     */
1786    public String getVersion() { 
1787      return this.version == null ? null : this.version.getValue();
1788    }
1789
1790    /**
1791     * @param value The identifier that is used to identify this version of the structure definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure definition 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.
1792     */
1793    public StructureDefinition setVersion(String value) { 
1794      if (Utilities.noString(value))
1795        this.version = null;
1796      else {
1797        if (this.version == null)
1798          this.version = new StringType();
1799        this.version.setValue(value);
1800      }
1801      return this;
1802    }
1803
1804    /**
1805     * @return {@link #name} (A natural language name identifying the structure definition. 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
1806     */
1807    public StringType getNameElement() { 
1808      if (this.name == null)
1809        if (Configuration.errorOnAutoCreate())
1810          throw new Error("Attempt to auto-create StructureDefinition.name");
1811        else if (Configuration.doAutoCreate())
1812          this.name = new StringType(); // bb
1813      return this.name;
1814    }
1815
1816    public boolean hasNameElement() { 
1817      return this.name != null && !this.name.isEmpty();
1818    }
1819
1820    public boolean hasName() { 
1821      return this.name != null && !this.name.isEmpty();
1822    }
1823
1824    /**
1825     * @param value {@link #name} (A natural language name identifying the structure definition. 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
1826     */
1827    public StructureDefinition setNameElement(StringType value) { 
1828      this.name = value;
1829      return this;
1830    }
1831
1832    /**
1833     * @return A natural language name identifying the structure definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.
1834     */
1835    public String getName() { 
1836      return this.name == null ? null : this.name.getValue();
1837    }
1838
1839    /**
1840     * @param value A natural language name identifying the structure definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.
1841     */
1842    public StructureDefinition setName(String value) { 
1843        if (this.name == null)
1844          this.name = new StringType();
1845        this.name.setValue(value);
1846      return this;
1847    }
1848
1849    /**
1850     * @return {@link #title} (A short, descriptive, user-friendly title for the structure definition.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
1851     */
1852    public StringType getTitleElement() { 
1853      if (this.title == null)
1854        if (Configuration.errorOnAutoCreate())
1855          throw new Error("Attempt to auto-create StructureDefinition.title");
1856        else if (Configuration.doAutoCreate())
1857          this.title = new StringType(); // bb
1858      return this.title;
1859    }
1860
1861    public boolean hasTitleElement() { 
1862      return this.title != null && !this.title.isEmpty();
1863    }
1864
1865    public boolean hasTitle() { 
1866      return this.title != null && !this.title.isEmpty();
1867    }
1868
1869    /**
1870     * @param value {@link #title} (A short, descriptive, user-friendly title for the structure definition.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
1871     */
1872    public StructureDefinition setTitleElement(StringType value) { 
1873      this.title = value;
1874      return this;
1875    }
1876
1877    /**
1878     * @return A short, descriptive, user-friendly title for the structure definition.
1879     */
1880    public String getTitle() { 
1881      return this.title == null ? null : this.title.getValue();
1882    }
1883
1884    /**
1885     * @param value A short, descriptive, user-friendly title for the structure definition.
1886     */
1887    public StructureDefinition setTitle(String value) { 
1888      if (Utilities.noString(value))
1889        this.title = null;
1890      else {
1891        if (this.title == null)
1892          this.title = new StringType();
1893        this.title.setValue(value);
1894      }
1895      return this;
1896    }
1897
1898    /**
1899     * @return {@link #status} (The status of this structure definition. 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
1900     */
1901    public Enumeration<PublicationStatus> getStatusElement() { 
1902      if (this.status == null)
1903        if (Configuration.errorOnAutoCreate())
1904          throw new Error("Attempt to auto-create StructureDefinition.status");
1905        else if (Configuration.doAutoCreate())
1906          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb
1907      return this.status;
1908    }
1909
1910    public boolean hasStatusElement() { 
1911      return this.status != null && !this.status.isEmpty();
1912    }
1913
1914    public boolean hasStatus() { 
1915      return this.status != null && !this.status.isEmpty();
1916    }
1917
1918    /**
1919     * @param value {@link #status} (The status of this structure definition. 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
1920     */
1921    public StructureDefinition setStatusElement(Enumeration<PublicationStatus> value) { 
1922      this.status = value;
1923      return this;
1924    }
1925
1926    /**
1927     * @return The status of this structure definition. Enables tracking the life-cycle of the content.
1928     */
1929    public PublicationStatus getStatus() { 
1930      return this.status == null ? null : this.status.getValue();
1931    }
1932
1933    /**
1934     * @param value The status of this structure definition. Enables tracking the life-cycle of the content.
1935     */
1936    public StructureDefinition setStatus(PublicationStatus value) { 
1937        if (this.status == null)
1938          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory());
1939        this.status.setValue(value);
1940      return this;
1941    }
1942
1943    /**
1944     * @return {@link #experimental} (A Boolean value to indicate that this structure definition 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
1945     */
1946    public BooleanType getExperimentalElement() { 
1947      if (this.experimental == null)
1948        if (Configuration.errorOnAutoCreate())
1949          throw new Error("Attempt to auto-create StructureDefinition.experimental");
1950        else if (Configuration.doAutoCreate())
1951          this.experimental = new BooleanType(); // bb
1952      return this.experimental;
1953    }
1954
1955    public boolean hasExperimentalElement() { 
1956      return this.experimental != null && !this.experimental.isEmpty();
1957    }
1958
1959    public boolean hasExperimental() { 
1960      return this.experimental != null && !this.experimental.isEmpty();
1961    }
1962
1963    /**
1964     * @param value {@link #experimental} (A Boolean value to indicate that this structure definition 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
1965     */
1966    public StructureDefinition setExperimentalElement(BooleanType value) { 
1967      this.experimental = value;
1968      return this;
1969    }
1970
1971    /**
1972     * @return A Boolean value to indicate that this structure definition is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.
1973     */
1974    public boolean getExperimental() { 
1975      return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue();
1976    }
1977
1978    /**
1979     * @param value A Boolean value to indicate that this structure definition is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.
1980     */
1981    public StructureDefinition setExperimental(boolean value) { 
1982        if (this.experimental == null)
1983          this.experimental = new BooleanType();
1984        this.experimental.setValue(value);
1985      return this;
1986    }
1987
1988    /**
1989     * @return {@link #date} (The date  (and optionally time) when the structure definition 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 structure definition changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
1990     */
1991    public DateTimeType getDateElement() { 
1992      if (this.date == null)
1993        if (Configuration.errorOnAutoCreate())
1994          throw new Error("Attempt to auto-create StructureDefinition.date");
1995        else if (Configuration.doAutoCreate())
1996          this.date = new DateTimeType(); // bb
1997      return this.date;
1998    }
1999
2000    public boolean hasDateElement() { 
2001      return this.date != null && !this.date.isEmpty();
2002    }
2003
2004    public boolean hasDate() { 
2005      return this.date != null && !this.date.isEmpty();
2006    }
2007
2008    /**
2009     * @param value {@link #date} (The date  (and optionally time) when the structure definition 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 structure definition changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
2010     */
2011    public StructureDefinition setDateElement(DateTimeType value) { 
2012      this.date = value;
2013      return this;
2014    }
2015
2016    /**
2017     * @return The date  (and optionally time) when the structure definition 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 structure definition changes.
2018     */
2019    public Date getDate() { 
2020      return this.date == null ? null : this.date.getValue();
2021    }
2022
2023    /**
2024     * @param value The date  (and optionally time) when the structure definition 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 structure definition changes.
2025     */
2026    public StructureDefinition setDate(Date value) { 
2027      if (value == null)
2028        this.date = null;
2029      else {
2030        if (this.date == null)
2031          this.date = new DateTimeType();
2032        this.date.setValue(value);
2033      }
2034      return this;
2035    }
2036
2037    /**
2038     * @return {@link #publisher} (The name of the organization or individual that published the structure definition.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
2039     */
2040    public StringType getPublisherElement() { 
2041      if (this.publisher == null)
2042        if (Configuration.errorOnAutoCreate())
2043          throw new Error("Attempt to auto-create StructureDefinition.publisher");
2044        else if (Configuration.doAutoCreate())
2045          this.publisher = new StringType(); // bb
2046      return this.publisher;
2047    }
2048
2049    public boolean hasPublisherElement() { 
2050      return this.publisher != null && !this.publisher.isEmpty();
2051    }
2052
2053    public boolean hasPublisher() { 
2054      return this.publisher != null && !this.publisher.isEmpty();
2055    }
2056
2057    /**
2058     * @param value {@link #publisher} (The name of the organization or individual that published the structure definition.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
2059     */
2060    public StructureDefinition setPublisherElement(StringType value) { 
2061      this.publisher = value;
2062      return this;
2063    }
2064
2065    /**
2066     * @return The name of the organization or individual that published the structure definition.
2067     */
2068    public String getPublisher() { 
2069      return this.publisher == null ? null : this.publisher.getValue();
2070    }
2071
2072    /**
2073     * @param value The name of the organization or individual that published the structure definition.
2074     */
2075    public StructureDefinition setPublisher(String value) { 
2076      if (Utilities.noString(value))
2077        this.publisher = null;
2078      else {
2079        if (this.publisher == null)
2080          this.publisher = new StringType();
2081        this.publisher.setValue(value);
2082      }
2083      return this;
2084    }
2085
2086    /**
2087     * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.)
2088     */
2089    public List<ContactDetail> getContact() { 
2090      if (this.contact == null)
2091        this.contact = new ArrayList<ContactDetail>();
2092      return this.contact;
2093    }
2094
2095    /**
2096     * @return Returns a reference to <code>this</code> for easy method chaining
2097     */
2098    public StructureDefinition setContact(List<ContactDetail> theContact) { 
2099      this.contact = theContact;
2100      return this;
2101    }
2102
2103    public boolean hasContact() { 
2104      if (this.contact == null)
2105        return false;
2106      for (ContactDetail item : this.contact)
2107        if (!item.isEmpty())
2108          return true;
2109      return false;
2110    }
2111
2112    public ContactDetail addContact() { //3
2113      ContactDetail t = new ContactDetail();
2114      if (this.contact == null)
2115        this.contact = new ArrayList<ContactDetail>();
2116      this.contact.add(t);
2117      return t;
2118    }
2119
2120    public StructureDefinition addContact(ContactDetail t) { //3
2121      if (t == null)
2122        return this;
2123      if (this.contact == null)
2124        this.contact = new ArrayList<ContactDetail>();
2125      this.contact.add(t);
2126      return this;
2127    }
2128
2129    /**
2130     * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist {3}
2131     */
2132    public ContactDetail getContactFirstRep() { 
2133      if (getContact().isEmpty()) {
2134        addContact();
2135      }
2136      return getContact().get(0);
2137    }
2138
2139    /**
2140     * @return {@link #description} (A free text natural language description of the structure definition from a consumer's perspective.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
2141     */
2142    public MarkdownType getDescriptionElement() { 
2143      if (this.description == null)
2144        if (Configuration.errorOnAutoCreate())
2145          throw new Error("Attempt to auto-create StructureDefinition.description");
2146        else if (Configuration.doAutoCreate())
2147          this.description = new MarkdownType(); // bb
2148      return this.description;
2149    }
2150
2151    public boolean hasDescriptionElement() { 
2152      return this.description != null && !this.description.isEmpty();
2153    }
2154
2155    public boolean hasDescription() { 
2156      return this.description != null && !this.description.isEmpty();
2157    }
2158
2159    /**
2160     * @param value {@link #description} (A free text natural language description of the structure definition from a consumer's perspective.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
2161     */
2162    public StructureDefinition setDescriptionElement(MarkdownType value) { 
2163      this.description = value;
2164      return this;
2165    }
2166
2167    /**
2168     * @return A free text natural language description of the structure definition from a consumer's perspective.
2169     */
2170    public String getDescription() { 
2171      return this.description == null ? null : this.description.getValue();
2172    }
2173
2174    /**
2175     * @param value A free text natural language description of the structure definition from a consumer's perspective.
2176     */
2177    public StructureDefinition setDescription(String value) { 
2178      if (value == null)
2179        this.description = null;
2180      else {
2181        if (this.description == null)
2182          this.description = new MarkdownType();
2183        this.description.setValue(value);
2184      }
2185      return this;
2186    }
2187
2188    /**
2189     * @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 structure definition instances.)
2190     */
2191    public List<UsageContext> getUseContext() { 
2192      if (this.useContext == null)
2193        this.useContext = new ArrayList<UsageContext>();
2194      return this.useContext;
2195    }
2196
2197    /**
2198     * @return Returns a reference to <code>this</code> for easy method chaining
2199     */
2200    public StructureDefinition setUseContext(List<UsageContext> theUseContext) { 
2201      this.useContext = theUseContext;
2202      return this;
2203    }
2204
2205    public boolean hasUseContext() { 
2206      if (this.useContext == null)
2207        return false;
2208      for (UsageContext item : this.useContext)
2209        if (!item.isEmpty())
2210          return true;
2211      return false;
2212    }
2213
2214    public UsageContext addUseContext() { //3
2215      UsageContext t = new UsageContext();
2216      if (this.useContext == null)
2217        this.useContext = new ArrayList<UsageContext>();
2218      this.useContext.add(t);
2219      return t;
2220    }
2221
2222    public StructureDefinition addUseContext(UsageContext t) { //3
2223      if (t == null)
2224        return this;
2225      if (this.useContext == null)
2226        this.useContext = new ArrayList<UsageContext>();
2227      this.useContext.add(t);
2228      return this;
2229    }
2230
2231    /**
2232     * @return The first repetition of repeating field {@link #useContext}, creating it if it does not already exist {3}
2233     */
2234    public UsageContext getUseContextFirstRep() { 
2235      if (getUseContext().isEmpty()) {
2236        addUseContext();
2237      }
2238      return getUseContext().get(0);
2239    }
2240
2241    /**
2242     * @return {@link #jurisdiction} (A legal or geographic region in which the structure definition is intended to be used.)
2243     */
2244    public List<CodeableConcept> getJurisdiction() { 
2245      if (this.jurisdiction == null)
2246        this.jurisdiction = new ArrayList<CodeableConcept>();
2247      return this.jurisdiction;
2248    }
2249
2250    /**
2251     * @return Returns a reference to <code>this</code> for easy method chaining
2252     */
2253    public StructureDefinition setJurisdiction(List<CodeableConcept> theJurisdiction) { 
2254      this.jurisdiction = theJurisdiction;
2255      return this;
2256    }
2257
2258    public boolean hasJurisdiction() { 
2259      if (this.jurisdiction == null)
2260        return false;
2261      for (CodeableConcept item : this.jurisdiction)
2262        if (!item.isEmpty())
2263          return true;
2264      return false;
2265    }
2266
2267    public CodeableConcept addJurisdiction() { //3
2268      CodeableConcept t = new CodeableConcept();
2269      if (this.jurisdiction == null)
2270        this.jurisdiction = new ArrayList<CodeableConcept>();
2271      this.jurisdiction.add(t);
2272      return t;
2273    }
2274
2275    public StructureDefinition addJurisdiction(CodeableConcept t) { //3
2276      if (t == null)
2277        return this;
2278      if (this.jurisdiction == null)
2279        this.jurisdiction = new ArrayList<CodeableConcept>();
2280      this.jurisdiction.add(t);
2281      return this;
2282    }
2283
2284    /**
2285     * @return The first repetition of repeating field {@link #jurisdiction}, creating it if it does not already exist {3}
2286     */
2287    public CodeableConcept getJurisdictionFirstRep() { 
2288      if (getJurisdiction().isEmpty()) {
2289        addJurisdiction();
2290      }
2291      return getJurisdiction().get(0);
2292    }
2293
2294    /**
2295     * @return {@link #purpose} (Explanation of why this structure definition 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
2296     */
2297    public MarkdownType getPurposeElement() { 
2298      if (this.purpose == null)
2299        if (Configuration.errorOnAutoCreate())
2300          throw new Error("Attempt to auto-create StructureDefinition.purpose");
2301        else if (Configuration.doAutoCreate())
2302          this.purpose = new MarkdownType(); // bb
2303      return this.purpose;
2304    }
2305
2306    public boolean hasPurposeElement() { 
2307      return this.purpose != null && !this.purpose.isEmpty();
2308    }
2309
2310    public boolean hasPurpose() { 
2311      return this.purpose != null && !this.purpose.isEmpty();
2312    }
2313
2314    /**
2315     * @param value {@link #purpose} (Explanation of why this structure definition 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
2316     */
2317    public StructureDefinition setPurposeElement(MarkdownType value) { 
2318      this.purpose = value;
2319      return this;
2320    }
2321
2322    /**
2323     * @return Explanation of why this structure definition is needed and why it has been designed as it has.
2324     */
2325    public String getPurpose() { 
2326      return this.purpose == null ? null : this.purpose.getValue();
2327    }
2328
2329    /**
2330     * @param value Explanation of why this structure definition is needed and why it has been designed as it has.
2331     */
2332    public StructureDefinition setPurpose(String value) { 
2333      if (value == null)
2334        this.purpose = null;
2335      else {
2336        if (this.purpose == null)
2337          this.purpose = new MarkdownType();
2338        this.purpose.setValue(value);
2339      }
2340      return this;
2341    }
2342
2343    /**
2344     * @return {@link #copyright} (A copyright statement relating to the structure definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure definition.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value
2345     */
2346    public MarkdownType getCopyrightElement() { 
2347      if (this.copyright == null)
2348        if (Configuration.errorOnAutoCreate())
2349          throw new Error("Attempt to auto-create StructureDefinition.copyright");
2350        else if (Configuration.doAutoCreate())
2351          this.copyright = new MarkdownType(); // bb
2352      return this.copyright;
2353    }
2354
2355    public boolean hasCopyrightElement() { 
2356      return this.copyright != null && !this.copyright.isEmpty();
2357    }
2358
2359    public boolean hasCopyright() { 
2360      return this.copyright != null && !this.copyright.isEmpty();
2361    }
2362
2363    /**
2364     * @param value {@link #copyright} (A copyright statement relating to the structure definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure definition.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value
2365     */
2366    public StructureDefinition setCopyrightElement(MarkdownType value) { 
2367      this.copyright = value;
2368      return this;
2369    }
2370
2371    /**
2372     * @return A copyright statement relating to the structure definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure definition.
2373     */
2374    public String getCopyright() { 
2375      return this.copyright == null ? null : this.copyright.getValue();
2376    }
2377
2378    /**
2379     * @param value A copyright statement relating to the structure definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure definition.
2380     */
2381    public StructureDefinition setCopyright(String value) { 
2382      if (value == null)
2383        this.copyright = null;
2384      else {
2385        if (this.copyright == null)
2386          this.copyright = new MarkdownType();
2387        this.copyright.setValue(value);
2388      }
2389      return this;
2390    }
2391
2392    /**
2393     * @return {@link #keyword} (A set of key words or terms from external terminologies that may be used to assist with indexing and searching of templates nby describing the use of this structure definition, or the content it describes.)
2394     */
2395    public List<Coding> getKeyword() { 
2396      if (this.keyword == null)
2397        this.keyword = new ArrayList<Coding>();
2398      return this.keyword;
2399    }
2400
2401    /**
2402     * @return Returns a reference to <code>this</code> for easy method chaining
2403     */
2404    public StructureDefinition setKeyword(List<Coding> theKeyword) { 
2405      this.keyword = theKeyword;
2406      return this;
2407    }
2408
2409    public boolean hasKeyword() { 
2410      if (this.keyword == null)
2411        return false;
2412      for (Coding item : this.keyword)
2413        if (!item.isEmpty())
2414          return true;
2415      return false;
2416    }
2417
2418    public Coding addKeyword() { //3
2419      Coding t = new Coding();
2420      if (this.keyword == null)
2421        this.keyword = new ArrayList<Coding>();
2422      this.keyword.add(t);
2423      return t;
2424    }
2425
2426    public StructureDefinition addKeyword(Coding t) { //3
2427      if (t == null)
2428        return this;
2429      if (this.keyword == null)
2430        this.keyword = new ArrayList<Coding>();
2431      this.keyword.add(t);
2432      return this;
2433    }
2434
2435    /**
2436     * @return The first repetition of repeating field {@link #keyword}, creating it if it does not already exist {3}
2437     */
2438    public Coding getKeywordFirstRep() { 
2439      if (getKeyword().isEmpty()) {
2440        addKeyword();
2441      }
2442      return getKeyword().get(0);
2443    }
2444
2445    /**
2446     * @return {@link #fhirVersion} (The version of the FHIR specification on which this StructureDefinition is based - this is the formal version of the specification, without the revision number, e.g. [publication].[major].[minor], which is 4.2.0. for this version.). This is the underlying object with id, value and extensions. The accessor "getFhirVersion" gives direct access to the value
2447     */
2448    public Enumeration<FHIRVersion> getFhirVersionElement() { 
2449      if (this.fhirVersion == null)
2450        if (Configuration.errorOnAutoCreate())
2451          throw new Error("Attempt to auto-create StructureDefinition.fhirVersion");
2452        else if (Configuration.doAutoCreate())
2453          this.fhirVersion = new Enumeration<FHIRVersion>(new FHIRVersionEnumFactory()); // bb
2454      return this.fhirVersion;
2455    }
2456
2457    public boolean hasFhirVersionElement() { 
2458      return this.fhirVersion != null && !this.fhirVersion.isEmpty();
2459    }
2460
2461    public boolean hasFhirVersion() { 
2462      return this.fhirVersion != null && !this.fhirVersion.isEmpty();
2463    }
2464
2465    /**
2466     * @param value {@link #fhirVersion} (The version of the FHIR specification on which this StructureDefinition is based - this is the formal version of the specification, without the revision number, e.g. [publication].[major].[minor], which is 4.2.0. for this version.). This is the underlying object with id, value and extensions. The accessor "getFhirVersion" gives direct access to the value
2467     */
2468    public StructureDefinition setFhirVersionElement(Enumeration<FHIRVersion> value) { 
2469      this.fhirVersion = value;
2470      return this;
2471    }
2472
2473    /**
2474     * @return The version of the FHIR specification on which this StructureDefinition is based - this is the formal version of the specification, without the revision number, e.g. [publication].[major].[minor], which is 4.2.0. for this version.
2475     */
2476    public FHIRVersion getFhirVersion() { 
2477      return this.fhirVersion == null ? null : this.fhirVersion.getValue();
2478    }
2479
2480    /**
2481     * @param value The version of the FHIR specification on which this StructureDefinition is based - this is the formal version of the specification, without the revision number, e.g. [publication].[major].[minor], which is 4.2.0. for this version.
2482     */
2483    public StructureDefinition setFhirVersion(FHIRVersion value) { 
2484      if (value == null)
2485        this.fhirVersion = null;
2486      else {
2487        if (this.fhirVersion == null)
2488          this.fhirVersion = new Enumeration<FHIRVersion>(new FHIRVersionEnumFactory());
2489        this.fhirVersion.setValue(value);
2490      }
2491      return this;
2492    }
2493
2494    /**
2495     * @return {@link #mapping} (An external specification that the content is mapped to.)
2496     */
2497    public List<StructureDefinitionMappingComponent> getMapping() { 
2498      if (this.mapping == null)
2499        this.mapping = new ArrayList<StructureDefinitionMappingComponent>();
2500      return this.mapping;
2501    }
2502
2503    /**
2504     * @return Returns a reference to <code>this</code> for easy method chaining
2505     */
2506    public StructureDefinition setMapping(List<StructureDefinitionMappingComponent> theMapping) { 
2507      this.mapping = theMapping;
2508      return this;
2509    }
2510
2511    public boolean hasMapping() { 
2512      if (this.mapping == null)
2513        return false;
2514      for (StructureDefinitionMappingComponent item : this.mapping)
2515        if (!item.isEmpty())
2516          return true;
2517      return false;
2518    }
2519
2520    public StructureDefinitionMappingComponent addMapping() { //3
2521      StructureDefinitionMappingComponent t = new StructureDefinitionMappingComponent();
2522      if (this.mapping == null)
2523        this.mapping = new ArrayList<StructureDefinitionMappingComponent>();
2524      this.mapping.add(t);
2525      return t;
2526    }
2527
2528    public StructureDefinition addMapping(StructureDefinitionMappingComponent t) { //3
2529      if (t == null)
2530        return this;
2531      if (this.mapping == null)
2532        this.mapping = new ArrayList<StructureDefinitionMappingComponent>();
2533      this.mapping.add(t);
2534      return this;
2535    }
2536
2537    /**
2538     * @return The first repetition of repeating field {@link #mapping}, creating it if it does not already exist {3}
2539     */
2540    public StructureDefinitionMappingComponent getMappingFirstRep() { 
2541      if (getMapping().isEmpty()) {
2542        addMapping();
2543      }
2544      return getMapping().get(0);
2545    }
2546
2547    /**
2548     * @return {@link #kind} (Defines the kind of structure that this definition is describing.). This is the underlying object with id, value and extensions. The accessor "getKind" gives direct access to the value
2549     */
2550    public Enumeration<StructureDefinitionKind> getKindElement() { 
2551      if (this.kind == null)
2552        if (Configuration.errorOnAutoCreate())
2553          throw new Error("Attempt to auto-create StructureDefinition.kind");
2554        else if (Configuration.doAutoCreate())
2555          this.kind = new Enumeration<StructureDefinitionKind>(new StructureDefinitionKindEnumFactory()); // bb
2556      return this.kind;
2557    }
2558
2559    public boolean hasKindElement() { 
2560      return this.kind != null && !this.kind.isEmpty();
2561    }
2562
2563    public boolean hasKind() { 
2564      return this.kind != null && !this.kind.isEmpty();
2565    }
2566
2567    /**
2568     * @param value {@link #kind} (Defines the kind of structure that this definition is describing.). This is the underlying object with id, value and extensions. The accessor "getKind" gives direct access to the value
2569     */
2570    public StructureDefinition setKindElement(Enumeration<StructureDefinitionKind> value) { 
2571      this.kind = value;
2572      return this;
2573    }
2574
2575    /**
2576     * @return Defines the kind of structure that this definition is describing.
2577     */
2578    public StructureDefinitionKind getKind() { 
2579      return this.kind == null ? null : this.kind.getValue();
2580    }
2581
2582    /**
2583     * @param value Defines the kind of structure that this definition is describing.
2584     */
2585    public StructureDefinition setKind(StructureDefinitionKind value) { 
2586        if (this.kind == null)
2587          this.kind = new Enumeration<StructureDefinitionKind>(new StructureDefinitionKindEnumFactory());
2588        this.kind.setValue(value);
2589      return this;
2590    }
2591
2592    /**
2593     * @return {@link #abstract_} (Whether structure this definition describes is abstract or not  - that is, whether the structure is not intended to be instantiated. For Resources and Data types, abstract types will never be exchanged  between systems.). This is the underlying object with id, value and extensions. The accessor "getAbstract" gives direct access to the value
2594     */
2595    public BooleanType getAbstractElement() { 
2596      if (this.abstract_ == null)
2597        if (Configuration.errorOnAutoCreate())
2598          throw new Error("Attempt to auto-create StructureDefinition.abstract_");
2599        else if (Configuration.doAutoCreate())
2600          this.abstract_ = new BooleanType(); // bb
2601      return this.abstract_;
2602    }
2603
2604    public boolean hasAbstractElement() { 
2605      return this.abstract_ != null && !this.abstract_.isEmpty();
2606    }
2607
2608    public boolean hasAbstract() { 
2609      return this.abstract_ != null && !this.abstract_.isEmpty();
2610    }
2611
2612    /**
2613     * @param value {@link #abstract_} (Whether structure this definition describes is abstract or not  - that is, whether the structure is not intended to be instantiated. For Resources and Data types, abstract types will never be exchanged  between systems.). This is the underlying object with id, value and extensions. The accessor "getAbstract" gives direct access to the value
2614     */
2615    public StructureDefinition setAbstractElement(BooleanType value) { 
2616      this.abstract_ = value;
2617      return this;
2618    }
2619
2620    /**
2621     * @return Whether structure this definition describes is abstract or not  - that is, whether the structure is not intended to be instantiated. For Resources and Data types, abstract types will never be exchanged  between systems.
2622     */
2623    public boolean getAbstract() { 
2624      return this.abstract_ == null || this.abstract_.isEmpty() ? false : this.abstract_.getValue();
2625    }
2626
2627    /**
2628     * @param value Whether structure this definition describes is abstract or not  - that is, whether the structure is not intended to be instantiated. For Resources and Data types, abstract types will never be exchanged  between systems.
2629     */
2630    public StructureDefinition setAbstract(boolean value) { 
2631        if (this.abstract_ == null)
2632          this.abstract_ = new BooleanType();
2633        this.abstract_.setValue(value);
2634      return this;
2635    }
2636
2637    /**
2638     * @return {@link #context} (Identifies the types of resource or data type elements to which the extension can be applied.)
2639     */
2640    public List<StructureDefinitionContextComponent> getContext() { 
2641      if (this.context == null)
2642        this.context = new ArrayList<StructureDefinitionContextComponent>();
2643      return this.context;
2644    }
2645
2646    /**
2647     * @return Returns a reference to <code>this</code> for easy method chaining
2648     */
2649    public StructureDefinition setContext(List<StructureDefinitionContextComponent> theContext) { 
2650      this.context = theContext;
2651      return this;
2652    }
2653
2654    public boolean hasContext() { 
2655      if (this.context == null)
2656        return false;
2657      for (StructureDefinitionContextComponent item : this.context)
2658        if (!item.isEmpty())
2659          return true;
2660      return false;
2661    }
2662
2663    public StructureDefinitionContextComponent addContext() { //3
2664      StructureDefinitionContextComponent t = new StructureDefinitionContextComponent();
2665      if (this.context == null)
2666        this.context = new ArrayList<StructureDefinitionContextComponent>();
2667      this.context.add(t);
2668      return t;
2669    }
2670
2671    public StructureDefinition addContext(StructureDefinitionContextComponent t) { //3
2672      if (t == null)
2673        return this;
2674      if (this.context == null)
2675        this.context = new ArrayList<StructureDefinitionContextComponent>();
2676      this.context.add(t);
2677      return this;
2678    }
2679
2680    /**
2681     * @return The first repetition of repeating field {@link #context}, creating it if it does not already exist {3}
2682     */
2683    public StructureDefinitionContextComponent getContextFirstRep() { 
2684      if (getContext().isEmpty()) {
2685        addContext();
2686      }
2687      return getContext().get(0);
2688    }
2689
2690    /**
2691     * @return {@link #contextInvariant} (A set of rules as FHIRPath Invariants about when the extension can be used (e.g. co-occurrence variants for the extension). All the rules must be true.)
2692     */
2693    public List<StringType> getContextInvariant() { 
2694      if (this.contextInvariant == null)
2695        this.contextInvariant = new ArrayList<StringType>();
2696      return this.contextInvariant;
2697    }
2698
2699    /**
2700     * @return Returns a reference to <code>this</code> for easy method chaining
2701     */
2702    public StructureDefinition setContextInvariant(List<StringType> theContextInvariant) { 
2703      this.contextInvariant = theContextInvariant;
2704      return this;
2705    }
2706
2707    public boolean hasContextInvariant() { 
2708      if (this.contextInvariant == null)
2709        return false;
2710      for (StringType item : this.contextInvariant)
2711        if (!item.isEmpty())
2712          return true;
2713      return false;
2714    }
2715
2716    /**
2717     * @return {@link #contextInvariant} (A set of rules as FHIRPath Invariants about when the extension can be used (e.g. co-occurrence variants for the extension). All the rules must be true.)
2718     */
2719    public StringType addContextInvariantElement() {//2 
2720      StringType t = new StringType();
2721      if (this.contextInvariant == null)
2722        this.contextInvariant = new ArrayList<StringType>();
2723      this.contextInvariant.add(t);
2724      return t;
2725    }
2726
2727    /**
2728     * @param value {@link #contextInvariant} (A set of rules as FHIRPath Invariants about when the extension can be used (e.g. co-occurrence variants for the extension). All the rules must be true.)
2729     */
2730    public StructureDefinition addContextInvariant(String value) { //1
2731      StringType t = new StringType();
2732      t.setValue(value);
2733      if (this.contextInvariant == null)
2734        this.contextInvariant = new ArrayList<StringType>();
2735      this.contextInvariant.add(t);
2736      return this;
2737    }
2738
2739    /**
2740     * @param value {@link #contextInvariant} (A set of rules as FHIRPath Invariants about when the extension can be used (e.g. co-occurrence variants for the extension). All the rules must be true.)
2741     */
2742    public boolean hasContextInvariant(String value) { 
2743      if (this.contextInvariant == null)
2744        return false;
2745      for (StringType v : this.contextInvariant)
2746        if (v.getValue().equals(value)) // string
2747          return true;
2748      return false;
2749    }
2750
2751    /**
2752     * @return {@link #type} (The type this structure describes. If the derivation kind is 'specialization' then this is the master definition for a type, and there is always one of these (a data type, an extension, a resource, including abstract ones). Otherwise the structure definition is a constraint on the stated type (and in this case, the type cannot be an abstract type).  References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. "string" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
2753     */
2754    public UriType getTypeElement() { 
2755      if (this.type == null)
2756        if (Configuration.errorOnAutoCreate())
2757          throw new Error("Attempt to auto-create StructureDefinition.type");
2758        else if (Configuration.doAutoCreate())
2759          this.type = new UriType(); // bb
2760      return this.type;
2761    }
2762
2763    public boolean hasTypeElement() { 
2764      return this.type != null && !this.type.isEmpty();
2765    }
2766
2767    public boolean hasType() { 
2768      return this.type != null && !this.type.isEmpty();
2769    }
2770
2771    /**
2772     * @param value {@link #type} (The type this structure describes. If the derivation kind is 'specialization' then this is the master definition for a type, and there is always one of these (a data type, an extension, a resource, including abstract ones). Otherwise the structure definition is a constraint on the stated type (and in this case, the type cannot be an abstract type).  References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. "string" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
2773     */
2774    public StructureDefinition setTypeElement(UriType value) { 
2775      this.type = value;
2776      return this;
2777    }
2778
2779    /**
2780     * @return The type this structure describes. If the derivation kind is 'specialization' then this is the master definition for a type, and there is always one of these (a data type, an extension, a resource, including abstract ones). Otherwise the structure definition is a constraint on the stated type (and in this case, the type cannot be an abstract type).  References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. "string" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.
2781     */
2782    public String getType() { 
2783      return this.type == null ? null : this.type.getValue();
2784    }
2785
2786    /**
2787     * @param value The type this structure describes. If the derivation kind is 'specialization' then this is the master definition for a type, and there is always one of these (a data type, an extension, a resource, including abstract ones). Otherwise the structure definition is a constraint on the stated type (and in this case, the type cannot be an abstract type).  References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. "string" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.
2788     */
2789    public StructureDefinition setType(String value) { 
2790        if (this.type == null)
2791          this.type = new UriType();
2792        this.type.setValue(value);
2793      return this;
2794    }
2795
2796    /**
2797     * @return {@link #baseDefinition} (An absolute URI that is the base structure from which this type is derived, either by specialization or constraint.). This is the underlying object with id, value and extensions. The accessor "getBaseDefinition" gives direct access to the value
2798     */
2799    public CanonicalType getBaseDefinitionElement() { 
2800      if (this.baseDefinition == null)
2801        if (Configuration.errorOnAutoCreate())
2802          throw new Error("Attempt to auto-create StructureDefinition.baseDefinition");
2803        else if (Configuration.doAutoCreate())
2804          this.baseDefinition = new CanonicalType(); // bb
2805      return this.baseDefinition;
2806    }
2807
2808    public boolean hasBaseDefinitionElement() { 
2809      return this.baseDefinition != null && !this.baseDefinition.isEmpty();
2810    }
2811
2812    public boolean hasBaseDefinition() { 
2813      return this.baseDefinition != null && !this.baseDefinition.isEmpty();
2814    }
2815
2816    /**
2817     * @param value {@link #baseDefinition} (An absolute URI that is the base structure from which this type is derived, either by specialization or constraint.). This is the underlying object with id, value and extensions. The accessor "getBaseDefinition" gives direct access to the value
2818     */
2819    public StructureDefinition setBaseDefinitionElement(CanonicalType value) { 
2820      this.baseDefinition = value;
2821      return this;
2822    }
2823
2824    /**
2825     * @return An absolute URI that is the base structure from which this type is derived, either by specialization or constraint.
2826     */
2827    public String getBaseDefinition() { 
2828      return this.baseDefinition == null ? null : this.baseDefinition.getValue();
2829    }
2830
2831    /**
2832     * @param value An absolute URI that is the base structure from which this type is derived, either by specialization or constraint.
2833     */
2834    public StructureDefinition setBaseDefinition(String value) { 
2835      if (Utilities.noString(value))
2836        this.baseDefinition = null;
2837      else {
2838        if (this.baseDefinition == null)
2839          this.baseDefinition = new CanonicalType();
2840        this.baseDefinition.setValue(value);
2841      }
2842      return this;
2843    }
2844
2845    /**
2846     * @return {@link #derivation} (How the type relates to the baseDefinition.). This is the underlying object with id, value and extensions. The accessor "getDerivation" gives direct access to the value
2847     */
2848    public Enumeration<TypeDerivationRule> getDerivationElement() { 
2849      if (this.derivation == null)
2850        if (Configuration.errorOnAutoCreate())
2851          throw new Error("Attempt to auto-create StructureDefinition.derivation");
2852        else if (Configuration.doAutoCreate())
2853          this.derivation = new Enumeration<TypeDerivationRule>(new TypeDerivationRuleEnumFactory()); // bb
2854      return this.derivation;
2855    }
2856
2857    public boolean hasDerivationElement() { 
2858      return this.derivation != null && !this.derivation.isEmpty();
2859    }
2860
2861    public boolean hasDerivation() { 
2862      return this.derivation != null && !this.derivation.isEmpty();
2863    }
2864
2865    /**
2866     * @param value {@link #derivation} (How the type relates to the baseDefinition.). This is the underlying object with id, value and extensions. The accessor "getDerivation" gives direct access to the value
2867     */
2868    public StructureDefinition setDerivationElement(Enumeration<TypeDerivationRule> value) { 
2869      this.derivation = value;
2870      return this;
2871    }
2872
2873    /**
2874     * @return How the type relates to the baseDefinition.
2875     */
2876    public TypeDerivationRule getDerivation() { 
2877      return this.derivation == null ? null : this.derivation.getValue();
2878    }
2879
2880    /**
2881     * @param value How the type relates to the baseDefinition.
2882     */
2883    public StructureDefinition setDerivation(TypeDerivationRule value) { 
2884      if (value == null)
2885        this.derivation = null;
2886      else {
2887        if (this.derivation == null)
2888          this.derivation = new Enumeration<TypeDerivationRule>(new TypeDerivationRuleEnumFactory());
2889        this.derivation.setValue(value);
2890      }
2891      return this;
2892    }
2893
2894    /**
2895     * @return {@link #snapshot} (A snapshot view is expressed in a standalone form that can be used and interpreted without considering the base StructureDefinition.)
2896     */
2897    public StructureDefinitionSnapshotComponent getSnapshot() { 
2898      if (this.snapshot == null)
2899        if (Configuration.errorOnAutoCreate())
2900          throw new Error("Attempt to auto-create StructureDefinition.snapshot");
2901        else if (Configuration.doAutoCreate())
2902          this.snapshot = new StructureDefinitionSnapshotComponent(); // cc
2903      return this.snapshot;
2904    }
2905
2906    public boolean hasSnapshot() { 
2907      return this.snapshot != null && !this.snapshot.isEmpty();
2908    }
2909
2910    /**
2911     * @param value {@link #snapshot} (A snapshot view is expressed in a standalone form that can be used and interpreted without considering the base StructureDefinition.)
2912     */
2913    public StructureDefinition setSnapshot(StructureDefinitionSnapshotComponent value) { 
2914      this.snapshot = value;
2915      return this;
2916    }
2917
2918    /**
2919     * @return {@link #differential} (A differential view is expressed relative to the base StructureDefinition - a statement of differences that it applies.)
2920     */
2921    public StructureDefinitionDifferentialComponent getDifferential() { 
2922      if (this.differential == null)
2923        if (Configuration.errorOnAutoCreate())
2924          throw new Error("Attempt to auto-create StructureDefinition.differential");
2925        else if (Configuration.doAutoCreate())
2926          this.differential = new StructureDefinitionDifferentialComponent(); // cc
2927      return this.differential;
2928    }
2929
2930    public boolean hasDifferential() { 
2931      return this.differential != null && !this.differential.isEmpty();
2932    }
2933
2934    /**
2935     * @param value {@link #differential} (A differential view is expressed relative to the base StructureDefinition - a statement of differences that it applies.)
2936     */
2937    public StructureDefinition setDifferential(StructureDefinitionDifferentialComponent value) { 
2938      this.differential = value;
2939      return this;
2940    }
2941
2942      protected void listChildren(List<Property> children) {
2943        super.listChildren(children);
2944        children.add(new Property("url", "uri", "An absolute URI that is used to identify this structure definition 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 structure definition is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the structure definition is stored on different servers.", 0, 1, url));
2945        children.add(new Property("identifier", "Identifier", "A formal identifier that is used to identify this structure definition when it is represented in other formats, or referenced in a specification, model, design or an instance.", 0, java.lang.Integer.MAX_VALUE, identifier));
2946        children.add(new Property("version", "string", "The identifier that is used to identify this version of the structure definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure definition 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));
2947        children.add(new Property("name", "string", "A natural language name identifying the structure definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name));
2948        children.add(new Property("title", "string", "A short, descriptive, user-friendly title for the structure definition.", 0, 1, title));
2949        children.add(new Property("status", "code", "The status of this structure definition. Enables tracking the life-cycle of the content.", 0, 1, status));
2950        children.add(new Property("experimental", "boolean", "A Boolean value to indicate that this structure definition is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.", 0, 1, experimental));
2951        children.add(new Property("date", "dateTime", "The date  (and optionally time) when the structure definition 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 structure definition changes.", 0, 1, date));
2952        children.add(new Property("publisher", "string", "The name of the organization or individual that published the structure definition.", 0, 1, publisher));
2953        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));
2954        children.add(new Property("description", "markdown", "A free text natural language description of the structure definition from a consumer's perspective.", 0, 1, description));
2955        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 structure definition instances.", 0, java.lang.Integer.MAX_VALUE, useContext));
2956        children.add(new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the structure definition is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction));
2957        children.add(new Property("purpose", "markdown", "Explanation of why this structure definition is needed and why it has been designed as it has.", 0, 1, purpose));
2958        children.add(new Property("copyright", "markdown", "A copyright statement relating to the structure definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure definition.", 0, 1, copyright));
2959        children.add(new Property("keyword", "Coding", "A set of key words or terms from external terminologies that may be used to assist with indexing and searching of templates nby describing the use of this structure definition, or the content it describes.", 0, java.lang.Integer.MAX_VALUE, keyword));
2960        children.add(new Property("fhirVersion", "code", "The version of the FHIR specification on which this StructureDefinition is based - this is the formal version of the specification, without the revision number, e.g. [publication].[major].[minor], which is 4.2.0. for this version.", 0, 1, fhirVersion));
2961        children.add(new Property("mapping", "", "An external specification that the content is mapped to.", 0, java.lang.Integer.MAX_VALUE, mapping));
2962        children.add(new Property("kind", "code", "Defines the kind of structure that this definition is describing.", 0, 1, kind));
2963        children.add(new Property("abstract", "boolean", "Whether structure this definition describes is abstract or not  - that is, whether the structure is not intended to be instantiated. For Resources and Data types, abstract types will never be exchanged  between systems.", 0, 1, abstract_));
2964        children.add(new Property("context", "", "Identifies the types of resource or data type elements to which the extension can be applied.", 0, java.lang.Integer.MAX_VALUE, context));
2965        children.add(new Property("contextInvariant", "string", "A set of rules as FHIRPath Invariants about when the extension can be used (e.g. co-occurrence variants for the extension). All the rules must be true.", 0, java.lang.Integer.MAX_VALUE, contextInvariant));
2966        children.add(new Property("type", "uri", "The type this structure describes. If the derivation kind is 'specialization' then this is the master definition for a type, and there is always one of these (a data type, an extension, a resource, including abstract ones). Otherwise the structure definition is a constraint on the stated type (and in this case, the type cannot be an abstract type).  References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. \"string\" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.", 0, 1, type));
2967        children.add(new Property("baseDefinition", "canonical(StructureDefinition)", "An absolute URI that is the base structure from which this type is derived, either by specialization or constraint.", 0, 1, baseDefinition));
2968        children.add(new Property("derivation", "code", "How the type relates to the baseDefinition.", 0, 1, derivation));
2969        children.add(new Property("snapshot", "", "A snapshot view is expressed in a standalone form that can be used and interpreted without considering the base StructureDefinition.", 0, 1, snapshot));
2970        children.add(new Property("differential", "", "A differential view is expressed relative to the base StructureDefinition - a statement of differences that it applies.", 0, 1, differential));
2971      }
2972
2973      @Override
2974      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2975        switch (_hash) {
2976        case 116079: /*url*/  return new Property("url", "uri", "An absolute URI that is used to identify this structure definition 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 structure definition is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the structure definition is stored on different servers.", 0, 1, url);
2977        case -1618432855: /*identifier*/  return new Property("identifier", "Identifier", "A formal identifier that is used to identify this structure definition when it is represented in other formats, or referenced in a specification, model, design or an instance.", 0, java.lang.Integer.MAX_VALUE, identifier);
2978        case 351608024: /*version*/  return new Property("version", "string", "The identifier that is used to identify this version of the structure definition when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the structure definition 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);
2979        case 3373707: /*name*/  return new Property("name", "string", "A natural language name identifying the structure definition. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name);
2980        case 110371416: /*title*/  return new Property("title", "string", "A short, descriptive, user-friendly title for the structure definition.", 0, 1, title);
2981        case -892481550: /*status*/  return new Property("status", "code", "The status of this structure definition. Enables tracking the life-cycle of the content.", 0, 1, status);
2982        case -404562712: /*experimental*/  return new Property("experimental", "boolean", "A Boolean value to indicate that this structure definition is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.", 0, 1, experimental);
2983        case 3076014: /*date*/  return new Property("date", "dateTime", "The date  (and optionally time) when the structure definition 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 structure definition changes.", 0, 1, date);
2984        case 1447404028: /*publisher*/  return new Property("publisher", "string", "The name of the organization or individual that published the structure definition.", 0, 1, publisher);
2985        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);
2986        case -1724546052: /*description*/  return new Property("description", "markdown", "A free text natural language description of the structure definition from a consumer's perspective.", 0, 1, description);
2987        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 structure definition instances.", 0, java.lang.Integer.MAX_VALUE, useContext);
2988        case -507075711: /*jurisdiction*/  return new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the structure definition is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction);
2989        case -220463842: /*purpose*/  return new Property("purpose", "markdown", "Explanation of why this structure definition is needed and why it has been designed as it has.", 0, 1, purpose);
2990        case 1522889671: /*copyright*/  return new Property("copyright", "markdown", "A copyright statement relating to the structure definition and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the structure definition.", 0, 1, copyright);
2991        case -814408215: /*keyword*/  return new Property("keyword", "Coding", "A set of key words or terms from external terminologies that may be used to assist with indexing and searching of templates nby describing the use of this structure definition, or the content it describes.", 0, java.lang.Integer.MAX_VALUE, keyword);
2992        case 461006061: /*fhirVersion*/  return new Property("fhirVersion", "code", "The version of the FHIR specification on which this StructureDefinition is based - this is the formal version of the specification, without the revision number, e.g. [publication].[major].[minor], which is 4.2.0. for this version.", 0, 1, fhirVersion);
2993        case 837556430: /*mapping*/  return new Property("mapping", "", "An external specification that the content is mapped to.", 0, java.lang.Integer.MAX_VALUE, mapping);
2994        case 3292052: /*kind*/  return new Property("kind", "code", "Defines the kind of structure that this definition is describing.", 0, 1, kind);
2995        case 1732898850: /*abstract*/  return new Property("abstract", "boolean", "Whether structure this definition describes is abstract or not  - that is, whether the structure is not intended to be instantiated. For Resources and Data types, abstract types will never be exchanged  between systems.", 0, 1, abstract_);
2996        case 951530927: /*context*/  return new Property("context", "", "Identifies the types of resource or data type elements to which the extension can be applied.", 0, java.lang.Integer.MAX_VALUE, context);
2997        case -802505007: /*contextInvariant*/  return new Property("contextInvariant", "string", "A set of rules as FHIRPath Invariants about when the extension can be used (e.g. co-occurrence variants for the extension). All the rules must be true.", 0, java.lang.Integer.MAX_VALUE, contextInvariant);
2998        case 3575610: /*type*/  return new Property("type", "uri", "The type this structure describes. If the derivation kind is 'specialization' then this is the master definition for a type, and there is always one of these (a data type, an extension, a resource, including abstract ones). Otherwise the structure definition is a constraint on the stated type (and in this case, the type cannot be an abstract type).  References are URLs that are relative to http://hl7.org/fhir/StructureDefinition e.g. \"string\" is a reference to http://hl7.org/fhir/StructureDefinition/string. Absolute URLs are only allowed in logical models.", 0, 1, type);
2999        case 1139771140: /*baseDefinition*/  return new Property("baseDefinition", "canonical(StructureDefinition)", "An absolute URI that is the base structure from which this type is derived, either by specialization or constraint.", 0, 1, baseDefinition);
3000        case -1353885513: /*derivation*/  return new Property("derivation", "code", "How the type relates to the baseDefinition.", 0, 1, derivation);
3001        case 284874180: /*snapshot*/  return new Property("snapshot", "", "A snapshot view is expressed in a standalone form that can be used and interpreted without considering the base StructureDefinition.", 0, 1, snapshot);
3002        case -1196150917: /*differential*/  return new Property("differential", "", "A differential view is expressed relative to the base StructureDefinition - a statement of differences that it applies.", 0, 1, differential);
3003        default: return super.getNamedProperty(_hash, _name, _checkValid);
3004        }
3005
3006      }
3007
3008      @Override
3009      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3010        switch (hash) {
3011        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType
3012        case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier
3013        case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType
3014        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
3015        case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType
3016        case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<PublicationStatus>
3017        case -404562712: /*experimental*/ return this.experimental == null ? new Base[0] : new Base[] {this.experimental}; // BooleanType
3018        case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType
3019        case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType
3020        case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail
3021        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType
3022        case -669707736: /*useContext*/ return this.useContext == null ? new Base[0] : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext
3023        case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept
3024        case -220463842: /*purpose*/ return this.purpose == null ? new Base[0] : new Base[] {this.purpose}; // MarkdownType
3025        case 1522889671: /*copyright*/ return this.copyright == null ? new Base[0] : new Base[] {this.copyright}; // MarkdownType
3026        case -814408215: /*keyword*/ return this.keyword == null ? new Base[0] : this.keyword.toArray(new Base[this.keyword.size()]); // Coding
3027        case 461006061: /*fhirVersion*/ return this.fhirVersion == null ? new Base[0] : new Base[] {this.fhirVersion}; // Enumeration<FHIRVersion>
3028        case 837556430: /*mapping*/ return this.mapping == null ? new Base[0] : this.mapping.toArray(new Base[this.mapping.size()]); // StructureDefinitionMappingComponent
3029        case 3292052: /*kind*/ return this.kind == null ? new Base[0] : new Base[] {this.kind}; // Enumeration<StructureDefinitionKind>
3030        case 1732898850: /*abstract*/ return this.abstract_ == null ? new Base[0] : new Base[] {this.abstract_}; // BooleanType
3031        case 951530927: /*context*/ return this.context == null ? new Base[0] : this.context.toArray(new Base[this.context.size()]); // StructureDefinitionContextComponent
3032        case -802505007: /*contextInvariant*/ return this.contextInvariant == null ? new Base[0] : this.contextInvariant.toArray(new Base[this.contextInvariant.size()]); // StringType
3033        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // UriType
3034        case 1139771140: /*baseDefinition*/ return this.baseDefinition == null ? new Base[0] : new Base[] {this.baseDefinition}; // CanonicalType
3035        case -1353885513: /*derivation*/ return this.derivation == null ? new Base[0] : new Base[] {this.derivation}; // Enumeration<TypeDerivationRule>
3036        case 284874180: /*snapshot*/ return this.snapshot == null ? new Base[0] : new Base[] {this.snapshot}; // StructureDefinitionSnapshotComponent
3037        case -1196150917: /*differential*/ return this.differential == null ? new Base[0] : new Base[] {this.differential}; // StructureDefinitionDifferentialComponent
3038        default: return super.getProperty(hash, name, checkValid);
3039        }
3040
3041      }
3042
3043      @Override
3044      public Base setProperty(int hash, String name, Base value) throws FHIRException {
3045        switch (hash) {
3046        case 116079: // url
3047          this.url = TypeConvertor.castToUri(value); // UriType
3048          return value;
3049        case -1618432855: // identifier
3050          this.getIdentifier().add(TypeConvertor.castToIdentifier(value)); // Identifier
3051          return value;
3052        case 351608024: // version
3053          this.version = TypeConvertor.castToString(value); // StringType
3054          return value;
3055        case 3373707: // name
3056          this.name = TypeConvertor.castToString(value); // StringType
3057          return value;
3058        case 110371416: // title
3059          this.title = TypeConvertor.castToString(value); // StringType
3060          return value;
3061        case -892481550: // status
3062          value = new PublicationStatusEnumFactory().fromType(TypeConvertor.castToCode(value));
3063          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
3064          return value;
3065        case -404562712: // experimental
3066          this.experimental = TypeConvertor.castToBoolean(value); // BooleanType
3067          return value;
3068        case 3076014: // date
3069          this.date = TypeConvertor.castToDateTime(value); // DateTimeType
3070          return value;
3071        case 1447404028: // publisher
3072          this.publisher = TypeConvertor.castToString(value); // StringType
3073          return value;
3074        case 951526432: // contact
3075          this.getContact().add(TypeConvertor.castToContactDetail(value)); // ContactDetail
3076          return value;
3077        case -1724546052: // description
3078          this.description = TypeConvertor.castToMarkdown(value); // MarkdownType
3079          return value;
3080        case -669707736: // useContext
3081          this.getUseContext().add(TypeConvertor.castToUsageContext(value)); // UsageContext
3082          return value;
3083        case -507075711: // jurisdiction
3084          this.getJurisdiction().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept
3085          return value;
3086        case -220463842: // purpose
3087          this.purpose = TypeConvertor.castToMarkdown(value); // MarkdownType
3088          return value;
3089        case 1522889671: // copyright
3090          this.copyright = TypeConvertor.castToMarkdown(value); // MarkdownType
3091          return value;
3092        case -814408215: // keyword
3093          this.getKeyword().add(TypeConvertor.castToCoding(value)); // Coding
3094          return value;
3095        case 461006061: // fhirVersion
3096          value = new FHIRVersionEnumFactory().fromType(TypeConvertor.castToCode(value));
3097          this.fhirVersion = (Enumeration) value; // Enumeration<FHIRVersion>
3098          return value;
3099        case 837556430: // mapping
3100          this.getMapping().add((StructureDefinitionMappingComponent) value); // StructureDefinitionMappingComponent
3101          return value;
3102        case 3292052: // kind
3103          value = new StructureDefinitionKindEnumFactory().fromType(TypeConvertor.castToCode(value));
3104          this.kind = (Enumeration) value; // Enumeration<StructureDefinitionKind>
3105          return value;
3106        case 1732898850: // abstract
3107          this.abstract_ = TypeConvertor.castToBoolean(value); // BooleanType
3108          return value;
3109        case 951530927: // context
3110          this.getContext().add((StructureDefinitionContextComponent) value); // StructureDefinitionContextComponent
3111          return value;
3112        case -802505007: // contextInvariant
3113          this.getContextInvariant().add(TypeConvertor.castToString(value)); // StringType
3114          return value;
3115        case 3575610: // type
3116          this.type = TypeConvertor.castToUri(value); // UriType
3117          return value;
3118        case 1139771140: // baseDefinition
3119          this.baseDefinition = TypeConvertor.castToCanonical(value); // CanonicalType
3120          return value;
3121        case -1353885513: // derivation
3122          value = new TypeDerivationRuleEnumFactory().fromType(TypeConvertor.castToCode(value));
3123          this.derivation = (Enumeration) value; // Enumeration<TypeDerivationRule>
3124          return value;
3125        case 284874180: // snapshot
3126          this.snapshot = (StructureDefinitionSnapshotComponent) value; // StructureDefinitionSnapshotComponent
3127          return value;
3128        case -1196150917: // differential
3129          this.differential = (StructureDefinitionDifferentialComponent) value; // StructureDefinitionDifferentialComponent
3130          return value;
3131        default: return super.setProperty(hash, name, value);
3132        }
3133
3134      }
3135
3136      @Override
3137      public Base setProperty(String name, Base value) throws FHIRException {
3138        if (name.equals("url")) {
3139          this.url = TypeConvertor.castToUri(value); // UriType
3140        } else if (name.equals("identifier")) {
3141          this.getIdentifier().add(TypeConvertor.castToIdentifier(value));
3142        } else if (name.equals("version")) {
3143          this.version = TypeConvertor.castToString(value); // StringType
3144        } else if (name.equals("name")) {
3145          this.name = TypeConvertor.castToString(value); // StringType
3146        } else if (name.equals("title")) {
3147          this.title = TypeConvertor.castToString(value); // StringType
3148        } else if (name.equals("status")) {
3149          value = new PublicationStatusEnumFactory().fromType(TypeConvertor.castToCode(value));
3150          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
3151        } else if (name.equals("experimental")) {
3152          this.experimental = TypeConvertor.castToBoolean(value); // BooleanType
3153        } else if (name.equals("date")) {
3154          this.date = TypeConvertor.castToDateTime(value); // DateTimeType
3155        } else if (name.equals("publisher")) {
3156          this.publisher = TypeConvertor.castToString(value); // StringType
3157        } else if (name.equals("contact")) {
3158          this.getContact().add(TypeConvertor.castToContactDetail(value));
3159        } else if (name.equals("description")) {
3160          this.description = TypeConvertor.castToMarkdown(value); // MarkdownType
3161        } else if (name.equals("useContext")) {
3162          this.getUseContext().add(TypeConvertor.castToUsageContext(value));
3163        } else if (name.equals("jurisdiction")) {
3164          this.getJurisdiction().add(TypeConvertor.castToCodeableConcept(value));
3165        } else if (name.equals("purpose")) {
3166          this.purpose = TypeConvertor.castToMarkdown(value); // MarkdownType
3167        } else if (name.equals("copyright")) {
3168          this.copyright = TypeConvertor.castToMarkdown(value); // MarkdownType
3169        } else if (name.equals("keyword")) {
3170          this.getKeyword().add(TypeConvertor.castToCoding(value));
3171        } else if (name.equals("fhirVersion")) {
3172          value = new FHIRVersionEnumFactory().fromType(TypeConvertor.castToCode(value));
3173          this.fhirVersion = (Enumeration) value; // Enumeration<FHIRVersion>
3174        } else if (name.equals("mapping")) {
3175          this.getMapping().add((StructureDefinitionMappingComponent) value);
3176        } else if (name.equals("kind")) {
3177          value = new StructureDefinitionKindEnumFactory().fromType(TypeConvertor.castToCode(value));
3178          this.kind = (Enumeration) value; // Enumeration<StructureDefinitionKind>
3179        } else if (name.equals("abstract")) {
3180          this.abstract_ = TypeConvertor.castToBoolean(value); // BooleanType
3181        } else if (name.equals("context")) {
3182          this.getContext().add((StructureDefinitionContextComponent) value);
3183        } else if (name.equals("contextInvariant")) {
3184          this.getContextInvariant().add(TypeConvertor.castToString(value));
3185        } else if (name.equals("type")) {
3186          this.type = TypeConvertor.castToUri(value); // UriType
3187        } else if (name.equals("baseDefinition")) {
3188          this.baseDefinition = TypeConvertor.castToCanonical(value); // CanonicalType
3189        } else if (name.equals("derivation")) {
3190          value = new TypeDerivationRuleEnumFactory().fromType(TypeConvertor.castToCode(value));
3191          this.derivation = (Enumeration) value; // Enumeration<TypeDerivationRule>
3192        } else if (name.equals("snapshot")) {
3193          this.snapshot = (StructureDefinitionSnapshotComponent) value; // StructureDefinitionSnapshotComponent
3194        } else if (name.equals("differential")) {
3195          this.differential = (StructureDefinitionDifferentialComponent) value; // StructureDefinitionDifferentialComponent
3196        } else
3197          return super.setProperty(name, value);
3198        return value;
3199      }
3200
3201      @Override
3202      public Base makeProperty(int hash, String name) throws FHIRException {
3203        switch (hash) {
3204        case 116079:  return getUrlElement();
3205        case -1618432855:  return addIdentifier(); 
3206        case 351608024:  return getVersionElement();
3207        case 3373707:  return getNameElement();
3208        case 110371416:  return getTitleElement();
3209        case -892481550:  return getStatusElement();
3210        case -404562712:  return getExperimentalElement();
3211        case 3076014:  return getDateElement();
3212        case 1447404028:  return getPublisherElement();
3213        case 951526432:  return addContact(); 
3214        case -1724546052:  return getDescriptionElement();
3215        case -669707736:  return addUseContext(); 
3216        case -507075711:  return addJurisdiction(); 
3217        case -220463842:  return getPurposeElement();
3218        case 1522889671:  return getCopyrightElement();
3219        case -814408215:  return addKeyword(); 
3220        case 461006061:  return getFhirVersionElement();
3221        case 837556430:  return addMapping(); 
3222        case 3292052:  return getKindElement();
3223        case 1732898850:  return getAbstractElement();
3224        case 951530927:  return addContext(); 
3225        case -802505007:  return addContextInvariantElement();
3226        case 3575610:  return getTypeElement();
3227        case 1139771140:  return getBaseDefinitionElement();
3228        case -1353885513:  return getDerivationElement();
3229        case 284874180:  return getSnapshot();
3230        case -1196150917:  return getDifferential();
3231        default: return super.makeProperty(hash, name);
3232        }
3233
3234      }
3235
3236      @Override
3237      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3238        switch (hash) {
3239        case 116079: /*url*/ return new String[] {"uri"};
3240        case -1618432855: /*identifier*/ return new String[] {"Identifier"};
3241        case 351608024: /*version*/ return new String[] {"string"};
3242        case 3373707: /*name*/ return new String[] {"string"};
3243        case 110371416: /*title*/ return new String[] {"string"};
3244        case -892481550: /*status*/ return new String[] {"code"};
3245        case -404562712: /*experimental*/ return new String[] {"boolean"};
3246        case 3076014: /*date*/ return new String[] {"dateTime"};
3247        case 1447404028: /*publisher*/ return new String[] {"string"};
3248        case 951526432: /*contact*/ return new String[] {"ContactDetail"};
3249        case -1724546052: /*description*/ return new String[] {"markdown"};
3250        case -669707736: /*useContext*/ return new String[] {"UsageContext"};
3251        case -507075711: /*jurisdiction*/ return new String[] {"CodeableConcept"};
3252        case -220463842: /*purpose*/ return new String[] {"markdown"};
3253        case 1522889671: /*copyright*/ return new String[] {"markdown"};
3254        case -814408215: /*keyword*/ return new String[] {"Coding"};
3255        case 461006061: /*fhirVersion*/ return new String[] {"code"};
3256        case 837556430: /*mapping*/ return new String[] {};
3257        case 3292052: /*kind*/ return new String[] {"code"};
3258        case 1732898850: /*abstract*/ return new String[] {"boolean"};
3259        case 951530927: /*context*/ return new String[] {};
3260        case -802505007: /*contextInvariant*/ return new String[] {"string"};
3261        case 3575610: /*type*/ return new String[] {"uri"};
3262        case 1139771140: /*baseDefinition*/ return new String[] {"canonical"};
3263        case -1353885513: /*derivation*/ return new String[] {"code"};
3264        case 284874180: /*snapshot*/ return new String[] {};
3265        case -1196150917: /*differential*/ return new String[] {};
3266        default: return super.getTypesForProperty(hash, name);
3267        }
3268
3269      }
3270
3271      @Override
3272      public Base addChild(String name) throws FHIRException {
3273        if (name.equals("url")) {
3274          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.url");
3275        }
3276        else if (name.equals("identifier")) {
3277          return addIdentifier();
3278        }
3279        else if (name.equals("version")) {
3280          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.version");
3281        }
3282        else if (name.equals("name")) {
3283          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.name");
3284        }
3285        else if (name.equals("title")) {
3286          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.title");
3287        }
3288        else if (name.equals("status")) {
3289          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.status");
3290        }
3291        else if (name.equals("experimental")) {
3292          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.experimental");
3293        }
3294        else if (name.equals("date")) {
3295          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.date");
3296        }
3297        else if (name.equals("publisher")) {
3298          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.publisher");
3299        }
3300        else if (name.equals("contact")) {
3301          return addContact();
3302        }
3303        else if (name.equals("description")) {
3304          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.description");
3305        }
3306        else if (name.equals("useContext")) {
3307          return addUseContext();
3308        }
3309        else if (name.equals("jurisdiction")) {
3310          return addJurisdiction();
3311        }
3312        else if (name.equals("purpose")) {
3313          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.purpose");
3314        }
3315        else if (name.equals("copyright")) {
3316          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.copyright");
3317        }
3318        else if (name.equals("keyword")) {
3319          return addKeyword();
3320        }
3321        else if (name.equals("fhirVersion")) {
3322          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.fhirVersion");
3323        }
3324        else if (name.equals("mapping")) {
3325          return addMapping();
3326        }
3327        else if (name.equals("kind")) {
3328          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.kind");
3329        }
3330        else if (name.equals("abstract")) {
3331          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.abstract");
3332        }
3333        else if (name.equals("context")) {
3334          return addContext();
3335        }
3336        else if (name.equals("contextInvariant")) {
3337          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.contextInvariant");
3338        }
3339        else if (name.equals("type")) {
3340          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.type");
3341        }
3342        else if (name.equals("baseDefinition")) {
3343          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.baseDefinition");
3344        }
3345        else if (name.equals("derivation")) {
3346          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.derivation");
3347        }
3348        else if (name.equals("snapshot")) {
3349          this.snapshot = new StructureDefinitionSnapshotComponent();
3350          return this.snapshot;
3351        }
3352        else if (name.equals("differential")) {
3353          this.differential = new StructureDefinitionDifferentialComponent();
3354          return this.differential;
3355        }
3356        else
3357          return super.addChild(name);
3358      }
3359
3360  public String fhirType() {
3361    return "StructureDefinition";
3362
3363  }
3364
3365      public StructureDefinition copy() {
3366        StructureDefinition dst = new StructureDefinition();
3367        copyValues(dst);
3368        return dst;
3369      }
3370
3371      public void copyValues(StructureDefinition dst) {
3372        super.copyValues(dst);
3373        dst.url = url == null ? null : url.copy();
3374        if (identifier != null) {
3375          dst.identifier = new ArrayList<Identifier>();
3376          for (Identifier i : identifier)
3377            dst.identifier.add(i.copy());
3378        };
3379        dst.version = version == null ? null : version.copy();
3380        dst.name = name == null ? null : name.copy();
3381        dst.title = title == null ? null : title.copy();
3382        dst.status = status == null ? null : status.copy();
3383        dst.experimental = experimental == null ? null : experimental.copy();
3384        dst.date = date == null ? null : date.copy();
3385        dst.publisher = publisher == null ? null : publisher.copy();
3386        if (contact != null) {
3387          dst.contact = new ArrayList<ContactDetail>();
3388          for (ContactDetail i : contact)
3389            dst.contact.add(i.copy());
3390        };
3391        dst.description = description == null ? null : description.copy();
3392        if (useContext != null) {
3393          dst.useContext = new ArrayList<UsageContext>();
3394          for (UsageContext i : useContext)
3395            dst.useContext.add(i.copy());
3396        };
3397        if (jurisdiction != null) {
3398          dst.jurisdiction = new ArrayList<CodeableConcept>();
3399          for (CodeableConcept i : jurisdiction)
3400            dst.jurisdiction.add(i.copy());
3401        };
3402        dst.purpose = purpose == null ? null : purpose.copy();
3403        dst.copyright = copyright == null ? null : copyright.copy();
3404        if (keyword != null) {
3405          dst.keyword = new ArrayList<Coding>();
3406          for (Coding i : keyword)
3407            dst.keyword.add(i.copy());
3408        };
3409        dst.fhirVersion = fhirVersion == null ? null : fhirVersion.copy();
3410        if (mapping != null) {
3411          dst.mapping = new ArrayList<StructureDefinitionMappingComponent>();
3412          for (StructureDefinitionMappingComponent i : mapping)
3413            dst.mapping.add(i.copy());
3414        };
3415        dst.kind = kind == null ? null : kind.copy();
3416        dst.abstract_ = abstract_ == null ? null : abstract_.copy();
3417        if (context != null) {
3418          dst.context = new ArrayList<StructureDefinitionContextComponent>();
3419          for (StructureDefinitionContextComponent i : context)
3420            dst.context.add(i.copy());
3421        };
3422        if (contextInvariant != null) {
3423          dst.contextInvariant = new ArrayList<StringType>();
3424          for (StringType i : contextInvariant)
3425            dst.contextInvariant.add(i.copy());
3426        };
3427        dst.type = type == null ? null : type.copy();
3428        dst.baseDefinition = baseDefinition == null ? null : baseDefinition.copy();
3429        dst.derivation = derivation == null ? null : derivation.copy();
3430        dst.snapshot = snapshot == null ? null : snapshot.copy();
3431        dst.differential = differential == null ? null : differential.copy();
3432      }
3433
3434      protected StructureDefinition typedCopy() {
3435        return copy();
3436      }
3437
3438      @Override
3439      public boolean equalsDeep(Base other_) {
3440        if (!super.equalsDeep(other_))
3441          return false;
3442        if (!(other_ instanceof StructureDefinition))
3443          return false;
3444        StructureDefinition o = (StructureDefinition) other_;
3445        return compareDeep(url, o.url, true) && compareDeep(identifier, o.identifier, true) && compareDeep(version, o.version, true)
3446           && compareDeep(name, o.name, true) && compareDeep(title, o.title, true) && compareDeep(status, o.status, true)
3447           && compareDeep(experimental, o.experimental, true) && compareDeep(date, o.date, true) && compareDeep(publisher, o.publisher, true)
3448           && compareDeep(contact, o.contact, true) && compareDeep(description, o.description, true) && compareDeep(useContext, o.useContext, true)
3449           && compareDeep(jurisdiction, o.jurisdiction, true) && compareDeep(purpose, o.purpose, true) && compareDeep(copyright, o.copyright, true)
3450           && compareDeep(keyword, o.keyword, true) && compareDeep(fhirVersion, o.fhirVersion, true) && compareDeep(mapping, o.mapping, true)
3451           && compareDeep(kind, o.kind, true) && compareDeep(abstract_, o.abstract_, true) && compareDeep(context, o.context, true)
3452           && compareDeep(contextInvariant, o.contextInvariant, true) && compareDeep(type, o.type, true) && compareDeep(baseDefinition, o.baseDefinition, true)
3453           && compareDeep(derivation, o.derivation, true) && compareDeep(snapshot, o.snapshot, true) && compareDeep(differential, o.differential, true)
3454          ;
3455      }
3456
3457      @Override
3458      public boolean equalsShallow(Base other_) {
3459        if (!super.equalsShallow(other_))
3460          return false;
3461        if (!(other_ instanceof StructureDefinition))
3462          return false;
3463        StructureDefinition o = (StructureDefinition) other_;
3464        return compareValues(url, o.url, true) && compareValues(version, o.version, true) && compareValues(name, o.name, true)
3465           && compareValues(title, o.title, true) && compareValues(status, o.status, true) && compareValues(experimental, o.experimental, true)
3466           && compareValues(date, o.date, true) && compareValues(publisher, o.publisher, true) && compareValues(description, o.description, true)
3467           && compareValues(purpose, o.purpose, true) && compareValues(copyright, o.copyright, true) && compareValues(fhirVersion, o.fhirVersion, true)
3468           && compareValues(kind, o.kind, true) && compareValues(abstract_, o.abstract_, true) && compareValues(contextInvariant, o.contextInvariant, true)
3469           && compareValues(type, o.type, true) && compareValues(baseDefinition, o.baseDefinition, true) && compareValues(derivation, o.derivation, true)
3470          ;
3471      }
3472
3473      public boolean isEmpty() {
3474        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(url, identifier, version
3475          , name, title, status, experimental, date, publisher, contact, description, useContext
3476          , jurisdiction, purpose, copyright, keyword, fhirVersion, mapping, kind, abstract_
3477          , context, contextInvariant, type, baseDefinition, derivation, snapshot, differential
3478          );
3479      }
3480
3481  @Override
3482  public ResourceType getResourceType() {
3483    return ResourceType.StructureDefinition;
3484   }
3485
3486 /**
3487   * Search parameter: <b>abstract</b>
3488   * <p>
3489   * Description: <b>Whether the structure is abstract</b><br>
3490   * Type: <b>token</b><br>
3491   * Path: <b>StructureDefinition.abstract</b><br>
3492   * </p>
3493   */
3494  @SearchParamDefinition(name="abstract", path="StructureDefinition.abstract", description="Whether the structure is abstract", type="token" )
3495  public static final String SP_ABSTRACT = "abstract";
3496 /**
3497   * <b>Fluent Client</b> search parameter constant for <b>abstract</b>
3498   * <p>
3499   * Description: <b>Whether the structure is abstract</b><br>
3500   * Type: <b>token</b><br>
3501   * Path: <b>StructureDefinition.abstract</b><br>
3502   * </p>
3503   */
3504  public static final ca.uhn.fhir.rest.gclient.TokenClientParam ABSTRACT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_ABSTRACT);
3505
3506 /**
3507   * Search parameter: <b>base-path</b>
3508   * <p>
3509   * Description: <b>Path that identifies the base element</b><br>
3510   * Type: <b>token</b><br>
3511   * Path: <b>StructureDefinition.snapshot.element.base.path | StructureDefinition.differential.element.base.path</b><br>
3512   * </p>
3513   */
3514  @SearchParamDefinition(name="base-path", path="StructureDefinition.snapshot.element.base.path | StructureDefinition.differential.element.base.path", description="Path that identifies the base element", type="token" )
3515  public static final String SP_BASE_PATH = "base-path";
3516 /**
3517   * <b>Fluent Client</b> search parameter constant for <b>base-path</b>
3518   * <p>
3519   * Description: <b>Path that identifies the base element</b><br>
3520   * Type: <b>token</b><br>
3521   * Path: <b>StructureDefinition.snapshot.element.base.path | StructureDefinition.differential.element.base.path</b><br>
3522   * </p>
3523   */
3524  public static final ca.uhn.fhir.rest.gclient.TokenClientParam BASE_PATH = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_BASE_PATH);
3525
3526 /**
3527   * Search parameter: <b>base</b>
3528   * <p>
3529   * Description: <b>Definition that this type is constrained/specialized from</b><br>
3530   * Type: <b>reference</b><br>
3531   * Path: <b>StructureDefinition.baseDefinition</b><br>
3532   * </p>
3533   */
3534  @SearchParamDefinition(name="base", path="StructureDefinition.baseDefinition", description="Definition that this type is constrained/specialized from", type="reference", target={StructureDefinition.class } )
3535  public static final String SP_BASE = "base";
3536 /**
3537   * <b>Fluent Client</b> search parameter constant for <b>base</b>
3538   * <p>
3539   * Description: <b>Definition that this type is constrained/specialized from</b><br>
3540   * Type: <b>reference</b><br>
3541   * Path: <b>StructureDefinition.baseDefinition</b><br>
3542   * </p>
3543   */
3544  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam BASE = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_BASE);
3545
3546/**
3547   * Constant for fluent queries to be used to add include statements. Specifies
3548   * the path value of "<b>StructureDefinition:base</b>".
3549   */
3550  public static final ca.uhn.fhir.model.api.Include INCLUDE_BASE = new ca.uhn.fhir.model.api.Include("StructureDefinition:base").toLocked();
3551
3552 /**
3553   * Search parameter: <b>derivation</b>
3554   * <p>
3555   * Description: <b>specialization | constraint - How relates to base definition</b><br>
3556   * Type: <b>token</b><br>
3557   * Path: <b>StructureDefinition.derivation</b><br>
3558   * </p>
3559   */
3560  @SearchParamDefinition(name="derivation", path="StructureDefinition.derivation", description="specialization | constraint - How relates to base definition", type="token" )
3561  public static final String SP_DERIVATION = "derivation";
3562 /**
3563   * <b>Fluent Client</b> search parameter constant for <b>derivation</b>
3564   * <p>
3565   * Description: <b>specialization | constraint - How relates to base definition</b><br>
3566   * Type: <b>token</b><br>
3567   * Path: <b>StructureDefinition.derivation</b><br>
3568   * </p>
3569   */
3570  public static final ca.uhn.fhir.rest.gclient.TokenClientParam DERIVATION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_DERIVATION);
3571
3572 /**
3573   * Search parameter: <b>experimental</b>
3574   * <p>
3575   * Description: <b>For testing purposes, not real usage</b><br>
3576   * Type: <b>token</b><br>
3577   * Path: <b>StructureDefinition.experimental</b><br>
3578   * </p>
3579   */
3580  @SearchParamDefinition(name="experimental", path="StructureDefinition.experimental", description="For testing purposes, not real usage", type="token" )
3581  public static final String SP_EXPERIMENTAL = "experimental";
3582 /**
3583   * <b>Fluent Client</b> search parameter constant for <b>experimental</b>
3584   * <p>
3585   * Description: <b>For testing purposes, not real usage</b><br>
3586   * Type: <b>token</b><br>
3587   * Path: <b>StructureDefinition.experimental</b><br>
3588   * </p>
3589   */
3590  public static final ca.uhn.fhir.rest.gclient.TokenClientParam EXPERIMENTAL = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_EXPERIMENTAL);
3591
3592 /**
3593   * Search parameter: <b>ext-context</b>
3594   * <p>
3595   * Description: <b>The system is the URL for the context-type: e.g. http://hl7.org/fhir/extension-context-type#element|CodeableConcept.text</b><br>
3596   * Type: <b>token</b><br>
3597   * Path: <b>StructureDefinition.context</b><br>
3598   * </p>
3599   */
3600  @SearchParamDefinition(name="ext-context", path="StructureDefinition.context", description="The system is the URL for the context-type: e.g. http://hl7.org/fhir/extension-context-type#element|CodeableConcept.text", type="token" )
3601  public static final String SP_EXT_CONTEXT = "ext-context";
3602 /**
3603   * <b>Fluent Client</b> search parameter constant for <b>ext-context</b>
3604   * <p>
3605   * Description: <b>The system is the URL for the context-type: e.g. http://hl7.org/fhir/extension-context-type#element|CodeableConcept.text</b><br>
3606   * Type: <b>token</b><br>
3607   * Path: <b>StructureDefinition.context</b><br>
3608   * </p>
3609   */
3610  public static final ca.uhn.fhir.rest.gclient.TokenClientParam EXT_CONTEXT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_EXT_CONTEXT);
3611
3612 /**
3613   * Search parameter: <b>keyword</b>
3614   * <p>
3615   * Description: <b>A code for the StructureDefinition</b><br>
3616   * Type: <b>token</b><br>
3617   * Path: <b>StructureDefinition.keyword</b><br>
3618   * </p>
3619   */
3620  @SearchParamDefinition(name="keyword", path="StructureDefinition.keyword", description="A code for the StructureDefinition", type="token" )
3621  public static final String SP_KEYWORD = "keyword";
3622 /**
3623   * <b>Fluent Client</b> search parameter constant for <b>keyword</b>
3624   * <p>
3625   * Description: <b>A code for the StructureDefinition</b><br>
3626   * Type: <b>token</b><br>
3627   * Path: <b>StructureDefinition.keyword</b><br>
3628   * </p>
3629   */
3630  public static final ca.uhn.fhir.rest.gclient.TokenClientParam KEYWORD = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_KEYWORD);
3631
3632 /**
3633   * Search parameter: <b>kind</b>
3634   * <p>
3635   * Description: <b>primitive-type | complex-type | resource | logical</b><br>
3636   * Type: <b>token</b><br>
3637   * Path: <b>StructureDefinition.kind</b><br>
3638   * </p>
3639   */
3640  @SearchParamDefinition(name="kind", path="StructureDefinition.kind", description="primitive-type | complex-type | resource | logical", type="token" )
3641  public static final String SP_KIND = "kind";
3642 /**
3643   * <b>Fluent Client</b> search parameter constant for <b>kind</b>
3644   * <p>
3645   * Description: <b>primitive-type | complex-type | resource | logical</b><br>
3646   * Type: <b>token</b><br>
3647   * Path: <b>StructureDefinition.kind</b><br>
3648   * </p>
3649   */
3650  public static final ca.uhn.fhir.rest.gclient.TokenClientParam KIND = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_KIND);
3651
3652 /**
3653   * Search parameter: <b>path</b>
3654   * <p>
3655   * Description: <b>A path that is constrained in the StructureDefinition</b><br>
3656   * Type: <b>token</b><br>
3657   * Path: <b>StructureDefinition.snapshot.element.path | StructureDefinition.differential.element.path</b><br>
3658   * </p>
3659   */
3660  @SearchParamDefinition(name="path", path="StructureDefinition.snapshot.element.path | StructureDefinition.differential.element.path", description="A path that is constrained in the StructureDefinition", type="token" )
3661  public static final String SP_PATH = "path";
3662 /**
3663   * <b>Fluent Client</b> search parameter constant for <b>path</b>
3664   * <p>
3665   * Description: <b>A path that is constrained in the StructureDefinition</b><br>
3666   * Type: <b>token</b><br>
3667   * Path: <b>StructureDefinition.snapshot.element.path | StructureDefinition.differential.element.path</b><br>
3668   * </p>
3669   */
3670  public static final ca.uhn.fhir.rest.gclient.TokenClientParam PATH = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_PATH);
3671
3672 /**
3673   * Search parameter: <b>type</b>
3674   * <p>
3675   * Description: <b>Type defined or constrained by this structure</b><br>
3676   * Type: <b>uri</b><br>
3677   * Path: <b>StructureDefinition.type</b><br>
3678   * </p>
3679   */
3680  @SearchParamDefinition(name="type", path="StructureDefinition.type", description="Type defined or constrained by this structure", type="uri" )
3681  public static final String SP_TYPE = "type";
3682 /**
3683   * <b>Fluent Client</b> search parameter constant for <b>type</b>
3684   * <p>
3685   * Description: <b>Type defined or constrained by this structure</b><br>
3686   * Type: <b>uri</b><br>
3687   * Path: <b>StructureDefinition.type</b><br>
3688   * </p>
3689   */
3690  public static final ca.uhn.fhir.rest.gclient.UriClientParam TYPE = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_TYPE);
3691
3692 /**
3693   * Search parameter: <b>valueset</b>
3694   * <p>
3695   * Description: <b>A vocabulary binding reference</b><br>
3696   * Type: <b>reference</b><br>
3697   * Path: <b>StructureDefinition.snapshot.element.binding.valueSet</b><br>
3698   * </p>
3699   */
3700  @SearchParamDefinition(name="valueset", path="StructureDefinition.snapshot.element.binding.valueSet", description="A vocabulary binding reference", type="reference", target={ValueSet.class } )
3701  public static final String SP_VALUESET = "valueset";
3702 /**
3703   * <b>Fluent Client</b> search parameter constant for <b>valueset</b>
3704   * <p>
3705   * Description: <b>A vocabulary binding reference</b><br>
3706   * Type: <b>reference</b><br>
3707   * Path: <b>StructureDefinition.snapshot.element.binding.valueSet</b><br>
3708   * </p>
3709   */
3710  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam VALUESET = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_VALUESET);
3711
3712/**
3713   * Constant for fluent queries to be used to add include statements. Specifies
3714   * the path value of "<b>StructureDefinition:valueset</b>".
3715   */
3716  public static final ca.uhn.fhir.model.api.Include INCLUDE_VALUESET = new ca.uhn.fhir.model.api.Include("StructureDefinition:valueset").toLocked();
3717
3718 /**
3719   * Search parameter: <b>context-quantity</b>
3720   * <p>
3721   * Description: <b>Multiple Resources: 
3722
3723* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement
3724* [CodeSystem](codesystem.html): A quantity- or range-valued use context assigned to the code system
3725* [CompartmentDefinition](compartmentdefinition.html): A quantity- or range-valued use context assigned to the compartment definition
3726* [ConceptMap](conceptmap.html): A quantity- or range-valued use context assigned to the concept map
3727* [GraphDefinition](graphdefinition.html): A quantity- or range-valued use context assigned to the graph definition
3728* [ImplementationGuide](implementationguide.html): A quantity- or range-valued use context assigned to the implementation guide
3729* [MessageDefinition](messagedefinition.html): A quantity- or range-valued use context assigned to the message definition
3730* [NamingSystem](namingsystem.html): A quantity- or range-valued use context assigned to the naming system
3731* [OperationDefinition](operationdefinition.html): A quantity- or range-valued use context assigned to the operation definition
3732* [SearchParameter](searchparameter.html): A quantity- or range-valued use context assigned to the search parameter
3733* [StructureDefinition](structuredefinition.html): A quantity- or range-valued use context assigned to the structure definition
3734* [StructureMap](structuremap.html): A quantity- or range-valued use context assigned to the structure map
3735* [TerminologyCapabilities](terminologycapabilities.html): A quantity- or range-valued use context assigned to the terminology capabilities
3736* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set
3737</b><br>
3738   * Type: <b>quantity</b><br>
3739   * 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>
3740   * </p>
3741   */
3742  @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" )
3743  public static final String SP_CONTEXT_QUANTITY = "context-quantity";
3744 /**
3745   * <b>Fluent Client</b> search parameter constant for <b>context-quantity</b>
3746   * <p>
3747   * Description: <b>Multiple Resources: 
3748
3749* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement
3750* [CodeSystem](codesystem.html): A quantity- or range-valued use context assigned to the code system
3751* [CompartmentDefinition](compartmentdefinition.html): A quantity- or range-valued use context assigned to the compartment definition
3752* [ConceptMap](conceptmap.html): A quantity- or range-valued use context assigned to the concept map
3753* [GraphDefinition](graphdefinition.html): A quantity- or range-valued use context assigned to the graph definition
3754* [ImplementationGuide](implementationguide.html): A quantity- or range-valued use context assigned to the implementation guide
3755* [MessageDefinition](messagedefinition.html): A quantity- or range-valued use context assigned to the message definition
3756* [NamingSystem](namingsystem.html): A quantity- or range-valued use context assigned to the naming system
3757* [OperationDefinition](operationdefinition.html): A quantity- or range-valued use context assigned to the operation definition
3758* [SearchParameter](searchparameter.html): A quantity- or range-valued use context assigned to the search parameter
3759* [StructureDefinition](structuredefinition.html): A quantity- or range-valued use context assigned to the structure definition
3760* [StructureMap](structuremap.html): A quantity- or range-valued use context assigned to the structure map
3761* [TerminologyCapabilities](terminologycapabilities.html): A quantity- or range-valued use context assigned to the terminology capabilities
3762* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set
3763</b><br>
3764   * Type: <b>quantity</b><br>
3765   * 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>
3766   * </p>
3767   */
3768  public static final ca.uhn.fhir.rest.gclient.QuantityClientParam CONTEXT_QUANTITY = new ca.uhn.fhir.rest.gclient.QuantityClientParam(SP_CONTEXT_QUANTITY);
3769
3770 /**
3771   * Search parameter: <b>context-type-quantity</b>
3772   * <p>
3773   * Description: <b>Multiple Resources: 
3774
3775* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement
3776* [CodeSystem](codesystem.html): A use context type and quantity- or range-based value assigned to the code system
3777* [CompartmentDefinition](compartmentdefinition.html): A use context type and quantity- or range-based value assigned to the compartment definition
3778* [ConceptMap](conceptmap.html): A use context type and quantity- or range-based value assigned to the concept map
3779* [GraphDefinition](graphdefinition.html): A use context type and quantity- or range-based value assigned to the graph definition
3780* [ImplementationGuide](implementationguide.html): A use context type and quantity- or range-based value assigned to the implementation guide
3781* [MessageDefinition](messagedefinition.html): A use context type and quantity- or range-based value assigned to the message definition
3782* [NamingSystem](namingsystem.html): A use context type and quantity- or range-based value assigned to the naming system
3783* [OperationDefinition](operationdefinition.html): A use context type and quantity- or range-based value assigned to the operation definition
3784* [SearchParameter](searchparameter.html): A use context type and quantity- or range-based value assigned to the search parameter
3785* [StructureDefinition](structuredefinition.html): A use context type and quantity- or range-based value assigned to the structure definition
3786* [StructureMap](structuremap.html): A use context type and quantity- or range-based value assigned to the structure map
3787* [TerminologyCapabilities](terminologycapabilities.html): A use context type and quantity- or range-based value assigned to the terminology capabilities
3788* [ValueSet](valueset.html): A use context type and quantity- or range-based value assigned to the value set
3789</b><br>
3790   * Type: <b>composite</b><br>
3791   * 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>
3792   * </p>
3793   */
3794  @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"} )
3795  public static final String SP_CONTEXT_TYPE_QUANTITY = "context-type-quantity";
3796 /**
3797   * <b>Fluent Client</b> search parameter constant for <b>context-type-quantity</b>
3798   * <p>
3799   * Description: <b>Multiple Resources: 
3800
3801* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement
3802* [CodeSystem](codesystem.html): A use context type and quantity- or range-based value assigned to the code system
3803* [CompartmentDefinition](compartmentdefinition.html): A use context type and quantity- or range-based value assigned to the compartment definition
3804* [ConceptMap](conceptmap.html): A use context type and quantity- or range-based value assigned to the concept map
3805* [GraphDefinition](graphdefinition.html): A use context type and quantity- or range-based value assigned to the graph definition
3806* [ImplementationGuide](implementationguide.html): A use context type and quantity- or range-based value assigned to the implementation guide
3807* [MessageDefinition](messagedefinition.html): A use context type and quantity- or range-based value assigned to the message definition
3808* [NamingSystem](namingsystem.html): A use context type and quantity- or range-based value assigned to the naming system
3809* [OperationDefinition](operationdefinition.html): A use context type and quantity- or range-based value assigned to the operation definition
3810* [SearchParameter](searchparameter.html): A use context type and quantity- or range-based value assigned to the search parameter
3811* [StructureDefinition](structuredefinition.html): A use context type and quantity- or range-based value assigned to the structure definition
3812* [StructureMap](structuremap.html): A use context type and quantity- or range-based value assigned to the structure map
3813* [TerminologyCapabilities](terminologycapabilities.html): A use context type and quantity- or range-based value assigned to the terminology capabilities
3814* [ValueSet](valueset.html): A use context type and quantity- or range-based value assigned to the value set
3815</b><br>
3816   * Type: <b>composite</b><br>
3817   * 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>
3818   * </p>
3819   */
3820  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);
3821
3822 /**
3823   * Search parameter: <b>context-type-value</b>
3824   * <p>
3825   * Description: <b>Multiple Resources: 
3826
3827* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement
3828* [CodeSystem](codesystem.html): A use context type and value assigned to the code system
3829* [CompartmentDefinition](compartmentdefinition.html): A use context type and value assigned to the compartment definition
3830* [ConceptMap](conceptmap.html): A use context type and value assigned to the concept map
3831* [GraphDefinition](graphdefinition.html): A use context type and value assigned to the graph definition
3832* [ImplementationGuide](implementationguide.html): A use context type and value assigned to the implementation guide
3833* [MessageDefinition](messagedefinition.html): A use context type and value assigned to the message definition
3834* [NamingSystem](namingsystem.html): A use context type and value assigned to the naming system
3835* [OperationDefinition](operationdefinition.html): A use context type and value assigned to the operation definition
3836* [SearchParameter](searchparameter.html): A use context type and value assigned to the search parameter
3837* [StructureDefinition](structuredefinition.html): A use context type and value assigned to the structure definition
3838* [StructureMap](structuremap.html): A use context type and value assigned to the structure map
3839* [TerminologyCapabilities](terminologycapabilities.html): A use context type and value assigned to the terminology capabilities
3840* [ValueSet](valueset.html): A use context type and value assigned to the value set
3841</b><br>
3842   * Type: <b>composite</b><br>
3843   * 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>
3844   * </p>
3845   */
3846  @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"} )
3847  public static final String SP_CONTEXT_TYPE_VALUE = "context-type-value";
3848 /**
3849   * <b>Fluent Client</b> search parameter constant for <b>context-type-value</b>
3850   * <p>
3851   * Description: <b>Multiple Resources: 
3852
3853* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement
3854* [CodeSystem](codesystem.html): A use context type and value assigned to the code system
3855* [CompartmentDefinition](compartmentdefinition.html): A use context type and value assigned to the compartment definition
3856* [ConceptMap](conceptmap.html): A use context type and value assigned to the concept map
3857* [GraphDefinition](graphdefinition.html): A use context type and value assigned to the graph definition
3858* [ImplementationGuide](implementationguide.html): A use context type and value assigned to the implementation guide
3859* [MessageDefinition](messagedefinition.html): A use context type and value assigned to the message definition
3860* [NamingSystem](namingsystem.html): A use context type and value assigned to the naming system
3861* [OperationDefinition](operationdefinition.html): A use context type and value assigned to the operation definition
3862* [SearchParameter](searchparameter.html): A use context type and value assigned to the search parameter
3863* [StructureDefinition](structuredefinition.html): A use context type and value assigned to the structure definition
3864* [StructureMap](structuremap.html): A use context type and value assigned to the structure map
3865* [TerminologyCapabilities](terminologycapabilities.html): A use context type and value assigned to the terminology capabilities
3866* [ValueSet](valueset.html): A use context type and value assigned to the value set
3867</b><br>
3868   * Type: <b>composite</b><br>
3869   * 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>
3870   * </p>
3871   */
3872  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);
3873
3874 /**
3875   * Search parameter: <b>context-type</b>
3876   * <p>
3877   * Description: <b>Multiple Resources: 
3878
3879* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement
3880* [CodeSystem](codesystem.html): A type of use context assigned to the code system
3881* [CompartmentDefinition](compartmentdefinition.html): A type of use context assigned to the compartment definition
3882* [ConceptMap](conceptmap.html): A type of use context assigned to the concept map
3883* [GraphDefinition](graphdefinition.html): A type of use context assigned to the graph definition
3884* [ImplementationGuide](implementationguide.html): A type of use context assigned to the implementation guide
3885* [MessageDefinition](messagedefinition.html): A type of use context assigned to the message definition
3886* [NamingSystem](namingsystem.html): A type of use context assigned to the naming system
3887* [OperationDefinition](operationdefinition.html): A type of use context assigned to the operation definition
3888* [SearchParameter](searchparameter.html): A type of use context assigned to the search parameter
3889* [StructureDefinition](structuredefinition.html): A type of use context assigned to the structure definition
3890* [StructureMap](structuremap.html): A type of use context assigned to the structure map
3891* [TerminologyCapabilities](terminologycapabilities.html): A type of use context assigned to the terminology capabilities
3892* [ValueSet](valueset.html): A type of use context assigned to the value set
3893</b><br>
3894   * Type: <b>token</b><br>
3895   * 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>
3896   * </p>
3897   */
3898  @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" )
3899  public static final String SP_CONTEXT_TYPE = "context-type";
3900 /**
3901   * <b>Fluent Client</b> search parameter constant for <b>context-type</b>
3902   * <p>
3903   * Description: <b>Multiple Resources: 
3904
3905* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement
3906* [CodeSystem](codesystem.html): A type of use context assigned to the code system
3907* [CompartmentDefinition](compartmentdefinition.html): A type of use context assigned to the compartment definition
3908* [ConceptMap](conceptmap.html): A type of use context assigned to the concept map
3909* [GraphDefinition](graphdefinition.html): A type of use context assigned to the graph definition
3910* [ImplementationGuide](implementationguide.html): A type of use context assigned to the implementation guide
3911* [MessageDefinition](messagedefinition.html): A type of use context assigned to the message definition
3912* [NamingSystem](namingsystem.html): A type of use context assigned to the naming system
3913* [OperationDefinition](operationdefinition.html): A type of use context assigned to the operation definition
3914* [SearchParameter](searchparameter.html): A type of use context assigned to the search parameter
3915* [StructureDefinition](structuredefinition.html): A type of use context assigned to the structure definition
3916* [StructureMap](structuremap.html): A type of use context assigned to the structure map
3917* [TerminologyCapabilities](terminologycapabilities.html): A type of use context assigned to the terminology capabilities
3918* [ValueSet](valueset.html): A type of use context assigned to the value set
3919</b><br>
3920   * Type: <b>token</b><br>
3921   * 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>
3922   * </p>
3923   */
3924  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT_TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT_TYPE);
3925
3926 /**
3927   * Search parameter: <b>context</b>
3928   * <p>
3929   * Description: <b>Multiple Resources: 
3930
3931* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement
3932* [CodeSystem](codesystem.html): A use context assigned to the code system
3933* [CompartmentDefinition](compartmentdefinition.html): A use context assigned to the compartment definition
3934* [ConceptMap](conceptmap.html): A use context assigned to the concept map
3935* [GraphDefinition](graphdefinition.html): A use context assigned to the graph definition
3936* [ImplementationGuide](implementationguide.html): A use context assigned to the implementation guide
3937* [MessageDefinition](messagedefinition.html): A use context assigned to the message definition
3938* [NamingSystem](namingsystem.html): A use context assigned to the naming system
3939* [OperationDefinition](operationdefinition.html): A use context assigned to the operation definition
3940* [SearchParameter](searchparameter.html): A use context assigned to the search parameter
3941* [StructureDefinition](structuredefinition.html): A use context assigned to the structure definition
3942* [StructureMap](structuremap.html): A use context assigned to the structure map
3943* [TerminologyCapabilities](terminologycapabilities.html): A use context assigned to the terminology capabilities
3944* [ValueSet](valueset.html): A use context assigned to the value set
3945</b><br>
3946   * Type: <b>token</b><br>
3947   * 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>
3948   * </p>
3949   */
3950  @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" )
3951  public static final String SP_CONTEXT = "context";
3952 /**
3953   * <b>Fluent Client</b> search parameter constant for <b>context</b>
3954   * <p>
3955   * Description: <b>Multiple Resources: 
3956
3957* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement
3958* [CodeSystem](codesystem.html): A use context assigned to the code system
3959* [CompartmentDefinition](compartmentdefinition.html): A use context assigned to the compartment definition
3960* [ConceptMap](conceptmap.html): A use context assigned to the concept map
3961* [GraphDefinition](graphdefinition.html): A use context assigned to the graph definition
3962* [ImplementationGuide](implementationguide.html): A use context assigned to the implementation guide
3963* [MessageDefinition](messagedefinition.html): A use context assigned to the message definition
3964* [NamingSystem](namingsystem.html): A use context assigned to the naming system
3965* [OperationDefinition](operationdefinition.html): A use context assigned to the operation definition
3966* [SearchParameter](searchparameter.html): A use context assigned to the search parameter
3967* [StructureDefinition](structuredefinition.html): A use context assigned to the structure definition
3968* [StructureMap](structuremap.html): A use context assigned to the structure map
3969* [TerminologyCapabilities](terminologycapabilities.html): A use context assigned to the terminology capabilities
3970* [ValueSet](valueset.html): A use context assigned to the value set
3971</b><br>
3972   * Type: <b>token</b><br>
3973   * 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>
3974   * </p>
3975   */
3976  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT);
3977
3978 /**
3979   * Search parameter: <b>date</b>
3980   * <p>
3981   * Description: <b>Multiple Resources: 
3982
3983* [CapabilityStatement](capabilitystatement.html): The capability statement publication date
3984* [CodeSystem](codesystem.html): The code system publication date
3985* [CompartmentDefinition](compartmentdefinition.html): The compartment definition publication date
3986* [ConceptMap](conceptmap.html): The concept map publication date
3987* [GraphDefinition](graphdefinition.html): The graph definition publication date
3988* [ImplementationGuide](implementationguide.html): The implementation guide publication date
3989* [MessageDefinition](messagedefinition.html): The message definition publication date
3990* [NamingSystem](namingsystem.html): The naming system publication date
3991* [OperationDefinition](operationdefinition.html): The operation definition publication date
3992* [SearchParameter](searchparameter.html): The search parameter publication date
3993* [StructureDefinition](structuredefinition.html): The structure definition publication date
3994* [StructureMap](structuremap.html): The structure map publication date
3995* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date
3996* [ValueSet](valueset.html): The value set publication date
3997</b><br>
3998   * Type: <b>date</b><br>
3999   * 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>
4000   * </p>
4001   */
4002  @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" )
4003  public static final String SP_DATE = "date";
4004 /**
4005   * <b>Fluent Client</b> search parameter constant for <b>date</b>
4006   * <p>
4007   * Description: <b>Multiple Resources: 
4008
4009* [CapabilityStatement](capabilitystatement.html): The capability statement publication date
4010* [CodeSystem](codesystem.html): The code system publication date
4011* [CompartmentDefinition](compartmentdefinition.html): The compartment definition publication date
4012* [ConceptMap](conceptmap.html): The concept map publication date
4013* [GraphDefinition](graphdefinition.html): The graph definition publication date
4014* [ImplementationGuide](implementationguide.html): The implementation guide publication date
4015* [MessageDefinition](messagedefinition.html): The message definition publication date
4016* [NamingSystem](namingsystem.html): The naming system publication date
4017* [OperationDefinition](operationdefinition.html): The operation definition publication date
4018* [SearchParameter](searchparameter.html): The search parameter publication date
4019* [StructureDefinition](structuredefinition.html): The structure definition publication date
4020* [StructureMap](structuremap.html): The structure map publication date
4021* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date
4022* [ValueSet](valueset.html): The value set publication date
4023</b><br>
4024   * Type: <b>date</b><br>
4025   * 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>
4026   * </p>
4027   */
4028  public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE);
4029
4030 /**
4031   * Search parameter: <b>description</b>
4032   * <p>
4033   * Description: <b>Multiple Resources: 
4034
4035* [CapabilityStatement](capabilitystatement.html): The description of the capability statement
4036* [CodeSystem](codesystem.html): The description of the code system
4037* [CompartmentDefinition](compartmentdefinition.html): The description of the compartment definition
4038* [ConceptMap](conceptmap.html): The description of the concept map
4039* [GraphDefinition](graphdefinition.html): The description of the graph definition
4040* [ImplementationGuide](implementationguide.html): The description of the implementation guide
4041* [MessageDefinition](messagedefinition.html): The description of the message definition
4042* [NamingSystem](namingsystem.html): The description of the naming system
4043* [OperationDefinition](operationdefinition.html): The description of the operation definition
4044* [SearchParameter](searchparameter.html): The description of the search parameter
4045* [StructureDefinition](structuredefinition.html): The description of the structure definition
4046* [StructureMap](structuremap.html): The description of the structure map
4047* [TerminologyCapabilities](terminologycapabilities.html): The description of the terminology capabilities
4048* [ValueSet](valueset.html): The description of the value set
4049</b><br>
4050   * Type: <b>string</b><br>
4051   * 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>
4052   * </p>
4053   */
4054  @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" )
4055  public static final String SP_DESCRIPTION = "description";
4056 /**
4057   * <b>Fluent Client</b> search parameter constant for <b>description</b>
4058   * <p>
4059   * Description: <b>Multiple Resources: 
4060
4061* [CapabilityStatement](capabilitystatement.html): The description of the capability statement
4062* [CodeSystem](codesystem.html): The description of the code system
4063* [CompartmentDefinition](compartmentdefinition.html): The description of the compartment definition
4064* [ConceptMap](conceptmap.html): The description of the concept map
4065* [GraphDefinition](graphdefinition.html): The description of the graph definition
4066* [ImplementationGuide](implementationguide.html): The description of the implementation guide
4067* [MessageDefinition](messagedefinition.html): The description of the message definition
4068* [NamingSystem](namingsystem.html): The description of the naming system
4069* [OperationDefinition](operationdefinition.html): The description of the operation definition
4070* [SearchParameter](searchparameter.html): The description of the search parameter
4071* [StructureDefinition](structuredefinition.html): The description of the structure definition
4072* [StructureMap](structuremap.html): The description of the structure map
4073* [TerminologyCapabilities](terminologycapabilities.html): The description of the terminology capabilities
4074* [ValueSet](valueset.html): The description of the value set
4075</b><br>
4076   * Type: <b>string</b><br>
4077   * 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>
4078   * </p>
4079   */
4080  public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION);
4081
4082 /**
4083   * Search parameter: <b>identifier</b>
4084   * <p>
4085   * Description: <b>Multiple Resources: 
4086
4087* [CodeSystem](codesystem.html): External identifier for the code system
4088* [ConceptMap](conceptmap.html): External identifier for the concept map
4089* [MessageDefinition](messagedefinition.html): External identifier for the message definition
4090* [StructureDefinition](structuredefinition.html): External identifier for the structure definition
4091* [StructureMap](structuremap.html): External identifier for the structure map
4092* [ValueSet](valueset.html): External identifier for the value set
4093</b><br>
4094   * Type: <b>token</b><br>
4095   * Path: <b>CodeSystem.identifier | ConceptMap.identifier | MessageDefinition.identifier | StructureDefinition.identifier | StructureMap.identifier | ValueSet.identifier</b><br>
4096   * </p>
4097   */
4098  @SearchParamDefinition(name="identifier", path="CodeSystem.identifier | ConceptMap.identifier | MessageDefinition.identifier | StructureDefinition.identifier | StructureMap.identifier | ValueSet.identifier", description="Multiple Resources: \r\n\r\n* [CodeSystem](codesystem.html): External identifier for the code system\r\n* [ConceptMap](conceptmap.html): External identifier for the concept map\r\n* [MessageDefinition](messagedefinition.html): External identifier for the message definition\r\n* [StructureDefinition](structuredefinition.html): External identifier for the structure definition\r\n* [StructureMap](structuremap.html): External identifier for the structure map\r\n* [ValueSet](valueset.html): External identifier for the value set\r\n", type="token" )
4099  public static final String SP_IDENTIFIER = "identifier";
4100 /**
4101   * <b>Fluent Client</b> search parameter constant for <b>identifier</b>
4102   * <p>
4103   * Description: <b>Multiple Resources: 
4104
4105* [CodeSystem](codesystem.html): External identifier for the code system
4106* [ConceptMap](conceptmap.html): External identifier for the concept map
4107* [MessageDefinition](messagedefinition.html): External identifier for the message definition
4108* [StructureDefinition](structuredefinition.html): External identifier for the structure definition
4109* [StructureMap](structuremap.html): External identifier for the structure map
4110* [ValueSet](valueset.html): External identifier for the value set
4111</b><br>
4112   * Type: <b>token</b><br>
4113   * Path: <b>CodeSystem.identifier | ConceptMap.identifier | MessageDefinition.identifier | StructureDefinition.identifier | StructureMap.identifier | ValueSet.identifier</b><br>
4114   * </p>
4115   */
4116  public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER);
4117
4118 /**
4119   * Search parameter: <b>jurisdiction</b>
4120   * <p>
4121   * Description: <b>Multiple Resources: 
4122
4123* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement
4124* [CodeSystem](codesystem.html): Intended jurisdiction for the code system
4125* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map
4126* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition
4127* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide
4128* [MessageDefinition](messagedefinition.html): Intended jurisdiction for the message definition
4129* [NamingSystem](namingsystem.html): Intended jurisdiction for the naming system
4130* [OperationDefinition](operationdefinition.html): Intended jurisdiction for the operation definition
4131* [SearchParameter](searchparameter.html): Intended jurisdiction for the search parameter
4132* [StructureDefinition](structuredefinition.html): Intended jurisdiction for the structure definition
4133* [StructureMap](structuremap.html): Intended jurisdiction for the structure map
4134* [TerminologyCapabilities](terminologycapabilities.html): Intended jurisdiction for the terminology capabilities
4135* [ValueSet](valueset.html): Intended jurisdiction for the value set
4136</b><br>
4137   * Type: <b>token</b><br>
4138   * 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>
4139   * </p>
4140   */
4141  @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" )
4142  public static final String SP_JURISDICTION = "jurisdiction";
4143 /**
4144   * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b>
4145   * <p>
4146   * Description: <b>Multiple Resources: 
4147
4148* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement
4149* [CodeSystem](codesystem.html): Intended jurisdiction for the code system
4150* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map
4151* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition
4152* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide
4153* [MessageDefinition](messagedefinition.html): Intended jurisdiction for the message definition
4154* [NamingSystem](namingsystem.html): Intended jurisdiction for the naming system
4155* [OperationDefinition](operationdefinition.html): Intended jurisdiction for the operation definition
4156* [SearchParameter](searchparameter.html): Intended jurisdiction for the search parameter
4157* [StructureDefinition](structuredefinition.html): Intended jurisdiction for the structure definition
4158* [StructureMap](structuremap.html): Intended jurisdiction for the structure map
4159* [TerminologyCapabilities](terminologycapabilities.html): Intended jurisdiction for the terminology capabilities
4160* [ValueSet](valueset.html): Intended jurisdiction for the value set
4161</b><br>
4162   * Type: <b>token</b><br>
4163   * 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>
4164   * </p>
4165   */
4166  public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_JURISDICTION);
4167
4168 /**
4169   * Search parameter: <b>name</b>
4170   * <p>
4171   * Description: <b>Multiple Resources: 
4172
4173* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement
4174* [CodeSystem](codesystem.html): Computationally friendly name of the code system
4175* [CompartmentDefinition](compartmentdefinition.html): Computationally friendly name of the compartment definition
4176* [ConceptMap](conceptmap.html): Computationally friendly name of the concept map
4177* [GraphDefinition](graphdefinition.html): Computationally friendly name of the graph definition
4178* [ImplementationGuide](implementationguide.html): Computationally friendly name of the implementation guide
4179* [MessageDefinition](messagedefinition.html): Computationally friendly name of the message definition
4180* [NamingSystem](namingsystem.html): Computationally friendly name of the naming system
4181* [OperationDefinition](operationdefinition.html): Computationally friendly name of the operation definition
4182* [SearchParameter](searchparameter.html): Computationally friendly name of the search parameter
4183* [StructureDefinition](structuredefinition.html): Computationally friendly name of the structure definition
4184* [StructureMap](structuremap.html): Computationally friendly name of the structure map
4185* [TerminologyCapabilities](terminologycapabilities.html): Computationally friendly name of the terminology capabilities
4186* [ValueSet](valueset.html): Computationally friendly name of the value set
4187</b><br>
4188   * Type: <b>string</b><br>
4189   * 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>
4190   * </p>
4191   */
4192  @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" )
4193  public static final String SP_NAME = "name";
4194 /**
4195   * <b>Fluent Client</b> search parameter constant for <b>name</b>
4196   * <p>
4197   * Description: <b>Multiple Resources: 
4198
4199* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement
4200* [CodeSystem](codesystem.html): Computationally friendly name of the code system
4201* [CompartmentDefinition](compartmentdefinition.html): Computationally friendly name of the compartment definition
4202* [ConceptMap](conceptmap.html): Computationally friendly name of the concept map
4203* [GraphDefinition](graphdefinition.html): Computationally friendly name of the graph definition
4204* [ImplementationGuide](implementationguide.html): Computationally friendly name of the implementation guide
4205* [MessageDefinition](messagedefinition.html): Computationally friendly name of the message definition
4206* [NamingSystem](namingsystem.html): Computationally friendly name of the naming system
4207* [OperationDefinition](operationdefinition.html): Computationally friendly name of the operation definition
4208* [SearchParameter](searchparameter.html): Computationally friendly name of the search parameter
4209* [StructureDefinition](structuredefinition.html): Computationally friendly name of the structure definition
4210* [StructureMap](structuremap.html): Computationally friendly name of the structure map
4211* [TerminologyCapabilities](terminologycapabilities.html): Computationally friendly name of the terminology capabilities
4212* [ValueSet](valueset.html): Computationally friendly name of the value set
4213</b><br>
4214   * Type: <b>string</b><br>
4215   * 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>
4216   * </p>
4217   */
4218  public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME);
4219
4220 /**
4221   * Search parameter: <b>publisher</b>
4222   * <p>
4223   * Description: <b>Multiple Resources: 
4224
4225* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement
4226* [CodeSystem](codesystem.html): Name of the publisher of the code system
4227* [CompartmentDefinition](compartmentdefinition.html): Name of the publisher of the compartment definition
4228* [ConceptMap](conceptmap.html): Name of the publisher of the concept map
4229* [GraphDefinition](graphdefinition.html): Name of the publisher of the graph definition
4230* [ImplementationGuide](implementationguide.html): Name of the publisher of the implementation guide
4231* [MessageDefinition](messagedefinition.html): Name of the publisher of the message definition
4232* [NamingSystem](namingsystem.html): Name of the publisher of the naming system
4233* [OperationDefinition](operationdefinition.html): Name of the publisher of the operation definition
4234* [SearchParameter](searchparameter.html): Name of the publisher of the search parameter
4235* [StructureDefinition](structuredefinition.html): Name of the publisher of the structure definition
4236* [StructureMap](structuremap.html): Name of the publisher of the structure map
4237* [TerminologyCapabilities](terminologycapabilities.html): Name of the publisher of the terminology capabilities
4238* [ValueSet](valueset.html): Name of the publisher of the value set
4239</b><br>
4240   * Type: <b>string</b><br>
4241   * 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>
4242   * </p>
4243   */
4244  @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" )
4245  public static final String SP_PUBLISHER = "publisher";
4246 /**
4247   * <b>Fluent Client</b> search parameter constant for <b>publisher</b>
4248   * <p>
4249   * Description: <b>Multiple Resources: 
4250
4251* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement
4252* [CodeSystem](codesystem.html): Name of the publisher of the code system
4253* [CompartmentDefinition](compartmentdefinition.html): Name of the publisher of the compartment definition
4254* [ConceptMap](conceptmap.html): Name of the publisher of the concept map
4255* [GraphDefinition](graphdefinition.html): Name of the publisher of the graph definition
4256* [ImplementationGuide](implementationguide.html): Name of the publisher of the implementation guide
4257* [MessageDefinition](messagedefinition.html): Name of the publisher of the message definition
4258* [NamingSystem](namingsystem.html): Name of the publisher of the naming system
4259* [OperationDefinition](operationdefinition.html): Name of the publisher of the operation definition
4260* [SearchParameter](searchparameter.html): Name of the publisher of the search parameter
4261* [StructureDefinition](structuredefinition.html): Name of the publisher of the structure definition
4262* [StructureMap](structuremap.html): Name of the publisher of the structure map
4263* [TerminologyCapabilities](terminologycapabilities.html): Name of the publisher of the terminology capabilities
4264* [ValueSet](valueset.html): Name of the publisher of the value set
4265</b><br>
4266   * Type: <b>string</b><br>
4267   * 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>
4268   * </p>
4269   */
4270  public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_PUBLISHER);
4271
4272 /**
4273   * Search parameter: <b>status</b>
4274   * <p>
4275   * Description: <b>Multiple Resources: 
4276
4277* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement
4278* [CodeSystem](codesystem.html): The current status of the code system
4279* [CompartmentDefinition](compartmentdefinition.html): The current status of the compartment definition
4280* [ConceptMap](conceptmap.html): The current status of the concept map
4281* [GraphDefinition](graphdefinition.html): The current status of the graph definition
4282* [ImplementationGuide](implementationguide.html): The current status of the implementation guide
4283* [MessageDefinition](messagedefinition.html): The current status of the message definition
4284* [NamingSystem](namingsystem.html): The current status of the naming system
4285* [OperationDefinition](operationdefinition.html): The current status of the operation definition
4286* [SearchParameter](searchparameter.html): The current status of the search parameter
4287* [StructureDefinition](structuredefinition.html): The current status of the structure definition
4288* [StructureMap](structuremap.html): The current status of the structure map
4289* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities
4290* [ValueSet](valueset.html): The current status of the value set
4291</b><br>
4292   * Type: <b>token</b><br>
4293   * 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>
4294   * </p>
4295   */
4296  @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" )
4297  public static final String SP_STATUS = "status";
4298 /**
4299   * <b>Fluent Client</b> search parameter constant for <b>status</b>
4300   * <p>
4301   * Description: <b>Multiple Resources: 
4302
4303* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement
4304* [CodeSystem](codesystem.html): The current status of the code system
4305* [CompartmentDefinition](compartmentdefinition.html): The current status of the compartment definition
4306* [ConceptMap](conceptmap.html): The current status of the concept map
4307* [GraphDefinition](graphdefinition.html): The current status of the graph definition
4308* [ImplementationGuide](implementationguide.html): The current status of the implementation guide
4309* [MessageDefinition](messagedefinition.html): The current status of the message definition
4310* [NamingSystem](namingsystem.html): The current status of the naming system
4311* [OperationDefinition](operationdefinition.html): The current status of the operation definition
4312* [SearchParameter](searchparameter.html): The current status of the search parameter
4313* [StructureDefinition](structuredefinition.html): The current status of the structure definition
4314* [StructureMap](structuremap.html): The current status of the structure map
4315* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities
4316* [ValueSet](valueset.html): The current status of the value set
4317</b><br>
4318   * Type: <b>token</b><br>
4319   * 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>
4320   * </p>
4321   */
4322  public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS);
4323
4324 /**
4325   * Search parameter: <b>title</b>
4326   * <p>
4327   * Description: <b>Multiple Resources: 
4328
4329* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement
4330* [CodeSystem](codesystem.html): The human-friendly name of the code system
4331* [ConceptMap](conceptmap.html): The human-friendly name of the concept map
4332* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide
4333* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition
4334* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition
4335* [StructureDefinition](structuredefinition.html): The human-friendly name of the structure definition
4336* [StructureMap](structuremap.html): The human-friendly name of the structure map
4337* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities
4338* [ValueSet](valueset.html): The human-friendly name of the value set
4339</b><br>
4340   * Type: <b>string</b><br>
4341   * Path: <b>CapabilityStatement.title | CodeSystem.title | ConceptMap.title | ImplementationGuide.title | MessageDefinition.title | OperationDefinition.title | StructureDefinition.title | StructureMap.title | TerminologyCapabilities.title | ValueSet.title</b><br>
4342   * </p>
4343   */
4344  @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" )
4345  public static final String SP_TITLE = "title";
4346 /**
4347   * <b>Fluent Client</b> search parameter constant for <b>title</b>
4348   * <p>
4349   * Description: <b>Multiple Resources: 
4350
4351* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement
4352* [CodeSystem](codesystem.html): The human-friendly name of the code system
4353* [ConceptMap](conceptmap.html): The human-friendly name of the concept map
4354* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide
4355* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition
4356* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition
4357* [StructureDefinition](structuredefinition.html): The human-friendly name of the structure definition
4358* [StructureMap](structuremap.html): The human-friendly name of the structure map
4359* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities
4360* [ValueSet](valueset.html): The human-friendly name of the value set
4361</b><br>
4362   * Type: <b>string</b><br>
4363   * Path: <b>CapabilityStatement.title | CodeSystem.title | ConceptMap.title | ImplementationGuide.title | MessageDefinition.title | OperationDefinition.title | StructureDefinition.title | StructureMap.title | TerminologyCapabilities.title | ValueSet.title</b><br>
4364   * </p>
4365   */
4366  public static final ca.uhn.fhir.rest.gclient.StringClientParam TITLE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_TITLE);
4367
4368 /**
4369   * Search parameter: <b>url</b>
4370   * <p>
4371   * Description: <b>Multiple Resources: 
4372
4373* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement
4374* [CodeSystem](codesystem.html): The uri that identifies the code system
4375* [CompartmentDefinition](compartmentdefinition.html): The uri that identifies the compartment definition
4376* [ConceptMap](conceptmap.html): The uri that identifies the concept map
4377* [GraphDefinition](graphdefinition.html): The uri that identifies the graph definition
4378* [ImplementationGuide](implementationguide.html): The uri that identifies the implementation guide
4379* [MessageDefinition](messagedefinition.html): The uri that identifies the message definition
4380* [NamingSystem](namingsystem.html): The uri that identifies the naming system
4381* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition
4382* [SearchParameter](searchparameter.html): The uri that identifies the search parameter
4383* [StructureDefinition](structuredefinition.html): The uri that identifies the structure definition
4384* [StructureMap](structuremap.html): The uri that identifies the structure map
4385* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities
4386* [ValueSet](valueset.html): The uri that identifies the value set
4387</b><br>
4388   * Type: <b>uri</b><br>
4389   * 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>
4390   * </p>
4391   */
4392  @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" )
4393  public static final String SP_URL = "url";
4394 /**
4395   * <b>Fluent Client</b> search parameter constant for <b>url</b>
4396   * <p>
4397   * Description: <b>Multiple Resources: 
4398
4399* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement
4400* [CodeSystem](codesystem.html): The uri that identifies the code system
4401* [CompartmentDefinition](compartmentdefinition.html): The uri that identifies the compartment definition
4402* [ConceptMap](conceptmap.html): The uri that identifies the concept map
4403* [GraphDefinition](graphdefinition.html): The uri that identifies the graph definition
4404* [ImplementationGuide](implementationguide.html): The uri that identifies the implementation guide
4405* [MessageDefinition](messagedefinition.html): The uri that identifies the message definition
4406* [NamingSystem](namingsystem.html): The uri that identifies the naming system
4407* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition
4408* [SearchParameter](searchparameter.html): The uri that identifies the search parameter
4409* [StructureDefinition](structuredefinition.html): The uri that identifies the structure definition
4410* [StructureMap](structuremap.html): The uri that identifies the structure map
4411* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities
4412* [ValueSet](valueset.html): The uri that identifies the value set
4413</b><br>
4414   * Type: <b>uri</b><br>
4415   * 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>
4416   * </p>
4417   */
4418  public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL);
4419
4420 /**
4421   * Search parameter: <b>version</b>
4422   * <p>
4423   * Description: <b>Multiple Resources: 
4424
4425* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement
4426* [CodeSystem](codesystem.html): The business version of the code system
4427* [CompartmentDefinition](compartmentdefinition.html): The business version of the compartment definition
4428* [ConceptMap](conceptmap.html): The business version of the concept map
4429* [GraphDefinition](graphdefinition.html): The business version of the graph definition
4430* [ImplementationGuide](implementationguide.html): The business version of the implementation guide
4431* [MessageDefinition](messagedefinition.html): The business version of the message definition
4432* [NamingSystem](namingsystem.html): The business version of the naming system
4433* [OperationDefinition](operationdefinition.html): The business version of the operation definition
4434* [SearchParameter](searchparameter.html): The business version of the search parameter
4435* [StructureDefinition](structuredefinition.html): The business version of the structure definition
4436* [StructureMap](structuremap.html): The business version of the structure map
4437* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities
4438* [ValueSet](valueset.html): The business version of the value set
4439</b><br>
4440   * Type: <b>token</b><br>
4441   * 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>
4442   * </p>
4443   */
4444  @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" )
4445  public static final String SP_VERSION = "version";
4446 /**
4447   * <b>Fluent Client</b> search parameter constant for <b>version</b>
4448   * <p>
4449   * Description: <b>Multiple Resources: 
4450
4451* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement
4452* [CodeSystem](codesystem.html): The business version of the code system
4453* [CompartmentDefinition](compartmentdefinition.html): The business version of the compartment definition
4454* [ConceptMap](conceptmap.html): The business version of the concept map
4455* [GraphDefinition](graphdefinition.html): The business version of the graph definition
4456* [ImplementationGuide](implementationguide.html): The business version of the implementation guide
4457* [MessageDefinition](messagedefinition.html): The business version of the message definition
4458* [NamingSystem](namingsystem.html): The business version of the naming system
4459* [OperationDefinition](operationdefinition.html): The business version of the operation definition
4460* [SearchParameter](searchparameter.html): The business version of the search parameter
4461* [StructureDefinition](structuredefinition.html): The business version of the structure definition
4462* [StructureMap](structuremap.html): The business version of the structure map
4463* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities
4464* [ValueSet](valueset.html): The business version of the value set
4465</b><br>
4466   * Type: <b>token</b><br>
4467   * 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>
4468   * </p>
4469   */
4470  public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VERSION);
4471
4472// Manual code (from Configuration.txt)t:
4473
4474  public String describeType() {
4475    if ("Extension".equals(getType()))
4476      return "Extension" ;
4477    switch (getKind()) {
4478    case COMPLEXTYPE: return getDerivation() == TypeDerivationRule.CONSTRAINT ? "DataType Constraint" : "DataType" ;
4479    case LOGICAL: return getDerivation() == TypeDerivationRule.CONSTRAINT ? "Logical Model" : "Logical Model Profile";
4480    case PRIMITIVETYPE: return getDerivation() == TypeDerivationRule.CONSTRAINT ? "PrimitiveType Constraint" : "PrimitiveType";
4481    case RESOURCE: return getDerivation() == TypeDerivationRule.CONSTRAINT ? "Resource Profile" : "Resource";
4482    default:
4483      return "Definition";
4484    }
4485  }
4486 
4487
4488// end addition
4489
4490}
4491