001package org.hl7.fhir.dstu3.model;
002
003
004
005
006/*
007  Copyright (c) 2011+, HL7, Inc.
008  All rights reserved.
009  
010  Redistribution and use in source and binary forms, with or without modification, 
011  are permitted provided that the following conditions are met:
012  
013   * Redistributions of source code must retain the above copyright notice, this 
014     list of conditions and the following disclaimer.
015   * Redistributions in binary form must reproduce the above copyright notice, 
016     this list of conditions and the following disclaimer in the documentation 
017     and/or other materials provided with the distribution.
018   * Neither the name of HL7 nor the names of its contributors may be used to 
019     endorse or promote products derived from this software without specific 
020     prior written permission.
021  
022  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
023  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
024  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
025  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
026  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
027  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
028  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
029  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
030  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
031  POSSIBILITY OF SUCH DAMAGE.
032  
033*/
034
035// Generated on Fri, Mar 16, 2018 15:21+1100 for FHIR v3.0.x
036import java.util.ArrayList;
037import java.util.Date;
038import java.util.List;
039
040import org.hl7.fhir.dstu3.model.Enumerations.PublicationStatus;
041import org.hl7.fhir.dstu3.model.Enumerations.PublicationStatusEnumFactory;
042import org.hl7.fhir.exceptions.FHIRException;
043import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
044import org.hl7.fhir.utilities.Utilities;
045
046import ca.uhn.fhir.model.api.annotation.Block;
047import ca.uhn.fhir.model.api.annotation.Child;
048import ca.uhn.fhir.model.api.annotation.ChildOrder;
049import ca.uhn.fhir.model.api.annotation.Description;
050import ca.uhn.fhir.model.api.annotation.ResourceDef;
051import ca.uhn.fhir.model.api.annotation.SearchParamDefinition;
052/**
053 * 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.
054 */
055@ResourceDef(name="StructureDefinition", profile="http://hl7.org/fhir/Profile/StructureDefinition")
056@ChildOrder(names={"url", "identifier", "version", "name", "title", "status", "experimental", "date", "publisher", "contact", "description", "useContext", "jurisdiction", "purpose", "copyright", "keyword", "fhirVersion", "mapping", "kind", "abstract", "contextType", "context", "contextInvariant", "type", "baseDefinition", "derivation", "snapshot", "differential"})
057public class StructureDefinition extends MetadataResource {
058
059    public enum StructureDefinitionKind {
060        /**
061         * A primitive type that has a value and an extension. These can be used throughout Resource and extension definitions. Only the base specification can define primitive types.
062         */
063        PRIMITIVETYPE, 
064        /**
065         * A  complex structure that defines a set of data elements. These can be used throughout Resource and extension definitions, and in logical models.
066         */
067        COMPLEXTYPE, 
068        /**
069         * A resource defined by the FHIR specification.
070         */
071        RESOURCE, 
072        /**
073         * A conceptual package of data that will be mapped to resources for implementation.
074         */
075        LOGICAL, 
076        /**
077         * added to help the parsers with the generic types
078         */
079        NULL;
080        public static StructureDefinitionKind fromCode(String codeString) throws FHIRException {
081            if (codeString == null || "".equals(codeString))
082                return null;
083        if ("primitive-type".equals(codeString))
084          return PRIMITIVETYPE;
085        if ("complex-type".equals(codeString))
086          return COMPLEXTYPE;
087        if ("resource".equals(codeString))
088          return RESOURCE;
089        if ("logical".equals(codeString))
090          return LOGICAL;
091        if (Configuration.isAcceptInvalidEnums())
092          return null;
093        else
094          throw new FHIRException("Unknown StructureDefinitionKind code '"+codeString+"'");
095        }
096        public String toCode() {
097          switch (this) {
098            case PRIMITIVETYPE: return "primitive-type";
099            case COMPLEXTYPE: return "complex-type";
100            case RESOURCE: return "resource";
101            case LOGICAL: return "logical";
102            case NULL: return null;
103            default: return "?";
104          }
105        }
106        public String getSystem() {
107          switch (this) {
108            case PRIMITIVETYPE: return "http://hl7.org/fhir/structure-definition-kind";
109            case COMPLEXTYPE: return "http://hl7.org/fhir/structure-definition-kind";
110            case RESOURCE: return "http://hl7.org/fhir/structure-definition-kind";
111            case LOGICAL: return "http://hl7.org/fhir/structure-definition-kind";
112            case NULL: return null;
113            default: return "?";
114          }
115        }
116        public String getDefinition() {
117          switch (this) {
118            case PRIMITIVETYPE: return "A primitive type that has a value and an extension. These can be used throughout Resource and extension definitions. Only the base specification can define primitive types.";
119            case COMPLEXTYPE: return "A  complex structure that defines a set of data elements. These can be used throughout Resource and extension definitions, and in logical models.";
120            case RESOURCE: return "A resource defined by the FHIR specification.";
121            case LOGICAL: return "A conceptual package of data that will be mapped to resources for implementation.";
122            case NULL: return null;
123            default: return "?";
124          }
125        }
126        public String getDisplay() {
127          switch (this) {
128            case PRIMITIVETYPE: return "Primitive Data Type";
129            case COMPLEXTYPE: return "Complex Data Type";
130            case RESOURCE: return "Resource";
131            case LOGICAL: return "Logical Model";
132            case NULL: return null;
133            default: return "?";
134          }
135        }
136    }
137
138  public static class StructureDefinitionKindEnumFactory implements EnumFactory<StructureDefinitionKind> {
139    public StructureDefinitionKind fromCode(String codeString) throws IllegalArgumentException {
140      if (codeString == null || "".equals(codeString))
141            if (codeString == null || "".equals(codeString))
142                return null;
143        if ("primitive-type".equals(codeString))
144          return StructureDefinitionKind.PRIMITIVETYPE;
145        if ("complex-type".equals(codeString))
146          return StructureDefinitionKind.COMPLEXTYPE;
147        if ("resource".equals(codeString))
148          return StructureDefinitionKind.RESOURCE;
149        if ("logical".equals(codeString))
150          return StructureDefinitionKind.LOGICAL;
151        throw new IllegalArgumentException("Unknown StructureDefinitionKind code '"+codeString+"'");
152        }
153        public Enumeration<StructureDefinitionKind> fromType(Base code) throws FHIRException {
154          if (code == null)
155            return null;
156          if (code.isEmpty())
157            return new Enumeration<StructureDefinitionKind>(this);
158          String codeString = ((PrimitiveType) code).asStringValue();
159          if (codeString == null || "".equals(codeString))
160            return null;
161        if ("primitive-type".equals(codeString))
162          return new Enumeration<StructureDefinitionKind>(this, StructureDefinitionKind.PRIMITIVETYPE);
163        if ("complex-type".equals(codeString))
164          return new Enumeration<StructureDefinitionKind>(this, StructureDefinitionKind.COMPLEXTYPE);
165        if ("resource".equals(codeString))
166          return new Enumeration<StructureDefinitionKind>(this, StructureDefinitionKind.RESOURCE);
167        if ("logical".equals(codeString))
168          return new Enumeration<StructureDefinitionKind>(this, StructureDefinitionKind.LOGICAL);
169        throw new FHIRException("Unknown StructureDefinitionKind code '"+codeString+"'");
170        }
171    public String toCode(StructureDefinitionKind code) {
172      if (code == StructureDefinitionKind.PRIMITIVETYPE)
173        return "primitive-type";
174      if (code == StructureDefinitionKind.COMPLEXTYPE)
175        return "complex-type";
176      if (code == StructureDefinitionKind.RESOURCE)
177        return "resource";
178      if (code == StructureDefinitionKind.LOGICAL)
179        return "logical";
180      return "?";
181      }
182    public String toSystem(StructureDefinitionKind code) {
183      return code.getSystem();
184      }
185    }
186
187    public enum ExtensionContext {
188        /**
189         * The context is all elements matching a particular resource element path.
190         */
191        RESOURCE, 
192        /**
193         * The context is all nodes matching a particular data type element path (root or repeating element) or all elements referencing a particular primitive data type (expressed as the datatype name).
194         */
195        DATATYPE, 
196        /**
197         * The context is a particular extension from a particular profile, a uri that identifies the extension definition.
198         */
199        EXTENSION, 
200        /**
201         * added to help the parsers with the generic types
202         */
203        NULL;
204        public static ExtensionContext fromCode(String codeString) throws FHIRException {
205            if (codeString == null || "".equals(codeString))
206                return null;
207        if ("resource".equals(codeString))
208          return RESOURCE;
209        if ("datatype".equals(codeString))
210          return DATATYPE;
211        if ("extension".equals(codeString))
212          return EXTENSION;
213        if (Configuration.isAcceptInvalidEnums())
214          return null;
215        else
216          throw new FHIRException("Unknown ExtensionContext code '"+codeString+"'");
217        }
218        public String toCode() {
219          switch (this) {
220            case RESOURCE: return "resource";
221            case DATATYPE: return "datatype";
222            case EXTENSION: return "extension";
223            case NULL: return null;
224            default: return "?";
225          }
226        }
227        public String getSystem() {
228          switch (this) {
229            case RESOURCE: return "http://hl7.org/fhir/extension-context";
230            case DATATYPE: return "http://hl7.org/fhir/extension-context";
231            case EXTENSION: return "http://hl7.org/fhir/extension-context";
232            case NULL: return null;
233            default: return "?";
234          }
235        }
236        public String getDefinition() {
237          switch (this) {
238            case RESOURCE: return "The context is all elements matching a particular resource element path.";
239            case DATATYPE: return "The context is all nodes matching a particular data type element path (root or repeating element) or all elements referencing a particular primitive data type (expressed as the datatype name).";
240            case EXTENSION: return "The context is a particular extension from a particular profile, a uri that identifies the extension definition.";
241            case NULL: return null;
242            default: return "?";
243          }
244        }
245        public String getDisplay() {
246          switch (this) {
247            case RESOURCE: return "Resource";
248            case DATATYPE: return "Datatype";
249            case EXTENSION: return "Extension";
250            case NULL: return null;
251            default: return "?";
252          }
253        }
254    }
255
256  public static class ExtensionContextEnumFactory implements EnumFactory<ExtensionContext> {
257    public ExtensionContext fromCode(String codeString) throws IllegalArgumentException {
258      if (codeString == null || "".equals(codeString))
259            if (codeString == null || "".equals(codeString))
260                return null;
261        if ("resource".equals(codeString))
262          return ExtensionContext.RESOURCE;
263        if ("datatype".equals(codeString))
264          return ExtensionContext.DATATYPE;
265        if ("extension".equals(codeString))
266          return ExtensionContext.EXTENSION;
267        throw new IllegalArgumentException("Unknown ExtensionContext code '"+codeString+"'");
268        }
269        public Enumeration<ExtensionContext> fromType(Base code) throws FHIRException {
270          if (code == null)
271            return null;
272          if (code.isEmpty())
273            return new Enumeration<ExtensionContext>(this);
274          String codeString = ((PrimitiveType) code).asStringValue();
275          if (codeString == null || "".equals(codeString))
276            return null;
277        if ("resource".equals(codeString))
278          return new Enumeration<ExtensionContext>(this, ExtensionContext.RESOURCE);
279        if ("datatype".equals(codeString))
280          return new Enumeration<ExtensionContext>(this, ExtensionContext.DATATYPE);
281        if ("extension".equals(codeString))
282          return new Enumeration<ExtensionContext>(this, ExtensionContext.EXTENSION);
283        throw new FHIRException("Unknown ExtensionContext code '"+codeString+"'");
284        }
285    public String toCode(ExtensionContext code) {
286      if (code == ExtensionContext.RESOURCE)
287        return "resource";
288      if (code == ExtensionContext.DATATYPE)
289        return "datatype";
290      if (code == ExtensionContext.EXTENSION)
291        return "extension";
292      return "?";
293      }
294    public String toSystem(ExtensionContext code) {
295      return code.getSystem();
296      }
297    }
298
299    public enum TypeDerivationRule {
300        /**
301         * This definition defines a new type that adds additional elements to the base type
302         */
303        SPECIALIZATION, 
304        /**
305         * This definition adds additional rules to an existing concrete type
306         */
307        CONSTRAINT, 
308        /**
309         * added to help the parsers with the generic types
310         */
311        NULL;
312        public static TypeDerivationRule fromCode(String codeString) throws FHIRException {
313            if (codeString == null || "".equals(codeString))
314                return null;
315        if ("specialization".equals(codeString))
316          return SPECIALIZATION;
317        if ("constraint".equals(codeString))
318          return CONSTRAINT;
319        if (Configuration.isAcceptInvalidEnums())
320          return null;
321        else
322          throw new FHIRException("Unknown TypeDerivationRule code '"+codeString+"'");
323        }
324        public String toCode() {
325          switch (this) {
326            case SPECIALIZATION: return "specialization";
327            case CONSTRAINT: return "constraint";
328            case NULL: return null;
329            default: return "?";
330          }
331        }
332        public String getSystem() {
333          switch (this) {
334            case SPECIALIZATION: return "http://hl7.org/fhir/type-derivation-rule";
335            case CONSTRAINT: return "http://hl7.org/fhir/type-derivation-rule";
336            case NULL: return null;
337            default: return "?";
338          }
339        }
340        public String getDefinition() {
341          switch (this) {
342            case SPECIALIZATION: return "This definition defines a new type that adds additional elements to the base type";
343            case CONSTRAINT: return "This definition adds additional rules to an existing concrete type";
344            case NULL: return null;
345            default: return "?";
346          }
347        }
348        public String getDisplay() {
349          switch (this) {
350            case SPECIALIZATION: return "Specialization";
351            case CONSTRAINT: return "Constraint";
352            case NULL: return null;
353            default: return "?";
354          }
355        }
356    }
357
358  public static class TypeDerivationRuleEnumFactory implements EnumFactory<TypeDerivationRule> {
359    public TypeDerivationRule fromCode(String codeString) throws IllegalArgumentException {
360      if (codeString == null || "".equals(codeString))
361            if (codeString == null || "".equals(codeString))
362                return null;
363        if ("specialization".equals(codeString))
364          return TypeDerivationRule.SPECIALIZATION;
365        if ("constraint".equals(codeString))
366          return TypeDerivationRule.CONSTRAINT;
367        throw new IllegalArgumentException("Unknown TypeDerivationRule code '"+codeString+"'");
368        }
369        public Enumeration<TypeDerivationRule> fromType(Base code) throws FHIRException {
370          if (code == null)
371            return null;
372          if (code.isEmpty())
373            return new Enumeration<TypeDerivationRule>(this);
374          String codeString = ((PrimitiveType) code).asStringValue();
375          if (codeString == null || "".equals(codeString))
376            return null;
377        if ("specialization".equals(codeString))
378          return new Enumeration<TypeDerivationRule>(this, TypeDerivationRule.SPECIALIZATION);
379        if ("constraint".equals(codeString))
380          return new Enumeration<TypeDerivationRule>(this, TypeDerivationRule.CONSTRAINT);
381        throw new FHIRException("Unknown TypeDerivationRule code '"+codeString+"'");
382        }
383    public String toCode(TypeDerivationRule code) {
384      if (code == TypeDerivationRule.SPECIALIZATION)
385        return "specialization";
386      if (code == TypeDerivationRule.CONSTRAINT)
387        return "constraint";
388      return "?";
389      }
390    public String toSystem(TypeDerivationRule code) {
391      return code.getSystem();
392      }
393    }
394
395    @Block()
396    public static class StructureDefinitionMappingComponent extends BackboneElement implements IBaseBackboneElement {
397        /**
398         * An Internal id that is used to identify this mapping set when specific mappings are made.
399         */
400        @Child(name = "identity", type = {IdType.class}, order=1, min=1, max=1, modifier=false, summary=false)
401        @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." )
402        protected IdType identity;
403
404        /**
405         * An absolute URI that identifies the specification that this mapping is expressed to.
406         */
407        @Child(name = "uri", type = {UriType.class}, order=2, min=0, max=1, modifier=false, summary=false)
408        @Description(shortDefinition="Identifies what this mapping refers to", formalDefinition="An absolute URI that identifies the specification that this mapping is expressed to." )
409        protected UriType uri;
410
411        /**
412         * A name for the specification that is being mapped to.
413         */
414        @Child(name = "name", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=false)
415        @Description(shortDefinition="Names what this mapping refers to", formalDefinition="A name for the specification that is being mapped to." )
416        protected StringType name;
417
418        /**
419         * Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.
420         */
421        @Child(name = "comment", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=false)
422        @Description(shortDefinition="Versions, Issues, Scope limitations etc.", formalDefinition="Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage." )
423        protected StringType comment;
424
425        private static final long serialVersionUID = 9610265L;
426
427    /**
428     * Constructor
429     */
430      public StructureDefinitionMappingComponent() {
431        super();
432      }
433
434    /**
435     * Constructor
436     */
437      public StructureDefinitionMappingComponent(IdType identity) {
438        super();
439        this.identity = identity;
440      }
441
442        /**
443         * @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
444         */
445        public IdType getIdentityElement() { 
446          if (this.identity == null)
447            if (Configuration.errorOnAutoCreate())
448              throw new Error("Attempt to auto-create StructureDefinitionMappingComponent.identity");
449            else if (Configuration.doAutoCreate())
450              this.identity = new IdType(); // bb
451          return this.identity;
452        }
453
454        public boolean hasIdentityElement() { 
455          return this.identity != null && !this.identity.isEmpty();
456        }
457
458        public boolean hasIdentity() { 
459          return this.identity != null && !this.identity.isEmpty();
460        }
461
462        /**
463         * @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
464         */
465        public StructureDefinitionMappingComponent setIdentityElement(IdType value) { 
466          this.identity = value;
467          return this;
468        }
469
470        /**
471         * @return An Internal id that is used to identify this mapping set when specific mappings are made.
472         */
473        public String getIdentity() { 
474          return this.identity == null ? null : this.identity.getValue();
475        }
476
477        /**
478         * @param value An Internal id that is used to identify this mapping set when specific mappings are made.
479         */
480        public StructureDefinitionMappingComponent setIdentity(String value) { 
481            if (this.identity == null)
482              this.identity = new IdType();
483            this.identity.setValue(value);
484          return this;
485        }
486
487        /**
488         * @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
489         */
490        public UriType getUriElement() { 
491          if (this.uri == null)
492            if (Configuration.errorOnAutoCreate())
493              throw new Error("Attempt to auto-create StructureDefinitionMappingComponent.uri");
494            else if (Configuration.doAutoCreate())
495              this.uri = new UriType(); // bb
496          return this.uri;
497        }
498
499        public boolean hasUriElement() { 
500          return this.uri != null && !this.uri.isEmpty();
501        }
502
503        public boolean hasUri() { 
504          return this.uri != null && !this.uri.isEmpty();
505        }
506
507        /**
508         * @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
509         */
510        public StructureDefinitionMappingComponent setUriElement(UriType value) { 
511          this.uri = value;
512          return this;
513        }
514
515        /**
516         * @return An absolute URI that identifies the specification that this mapping is expressed to.
517         */
518        public String getUri() { 
519          return this.uri == null ? null : this.uri.getValue();
520        }
521
522        /**
523         * @param value An absolute URI that identifies the specification that this mapping is expressed to.
524         */
525        public StructureDefinitionMappingComponent setUri(String value) { 
526          if (Utilities.noString(value))
527            this.uri = null;
528          else {
529            if (this.uri == null)
530              this.uri = new UriType();
531            this.uri.setValue(value);
532          }
533          return this;
534        }
535
536        /**
537         * @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
538         */
539        public StringType getNameElement() { 
540          if (this.name == null)
541            if (Configuration.errorOnAutoCreate())
542              throw new Error("Attempt to auto-create StructureDefinitionMappingComponent.name");
543            else if (Configuration.doAutoCreate())
544              this.name = new StringType(); // bb
545          return this.name;
546        }
547
548        public boolean hasNameElement() { 
549          return this.name != null && !this.name.isEmpty();
550        }
551
552        public boolean hasName() { 
553          return this.name != null && !this.name.isEmpty();
554        }
555
556        /**
557         * @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
558         */
559        public StructureDefinitionMappingComponent setNameElement(StringType value) { 
560          this.name = value;
561          return this;
562        }
563
564        /**
565         * @return A name for the specification that is being mapped to.
566         */
567        public String getName() { 
568          return this.name == null ? null : this.name.getValue();
569        }
570
571        /**
572         * @param value A name for the specification that is being mapped to.
573         */
574        public StructureDefinitionMappingComponent setName(String value) { 
575          if (Utilities.noString(value))
576            this.name = null;
577          else {
578            if (this.name == null)
579              this.name = new StringType();
580            this.name.setValue(value);
581          }
582          return this;
583        }
584
585        /**
586         * @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
587         */
588        public StringType getCommentElement() { 
589          if (this.comment == null)
590            if (Configuration.errorOnAutoCreate())
591              throw new Error("Attempt to auto-create StructureDefinitionMappingComponent.comment");
592            else if (Configuration.doAutoCreate())
593              this.comment = new StringType(); // bb
594          return this.comment;
595        }
596
597        public boolean hasCommentElement() { 
598          return this.comment != null && !this.comment.isEmpty();
599        }
600
601        public boolean hasComment() { 
602          return this.comment != null && !this.comment.isEmpty();
603        }
604
605        /**
606         * @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
607         */
608        public StructureDefinitionMappingComponent setCommentElement(StringType value) { 
609          this.comment = value;
610          return this;
611        }
612
613        /**
614         * @return Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.
615         */
616        public String getComment() { 
617          return this.comment == null ? null : this.comment.getValue();
618        }
619
620        /**
621         * @param value Comments about this mapping, including version notes, issues, scope limitations, and other important notes for usage.
622         */
623        public StructureDefinitionMappingComponent setComment(String value) { 
624          if (Utilities.noString(value))
625            this.comment = null;
626          else {
627            if (this.comment == null)
628              this.comment = new StringType();
629            this.comment.setValue(value);
630          }
631          return this;
632        }
633
634        protected void listChildren(List<Property> children) {
635          super.listChildren(children);
636          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));
637          children.add(new Property("uri", "uri", "An absolute URI that identifies the specification that this mapping is expressed to.", 0, 1, uri));
638          children.add(new Property("name", "string", "A name for the specification that is being mapped to.", 0, 1, name));
639          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));
640        }
641
642        @Override
643        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
644          switch (_hash) {
645          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);
646          case 116076: /*uri*/  return new Property("uri", "uri", "An absolute URI that identifies the specification that this mapping is expressed to.", 0, 1, uri);
647          case 3373707: /*name*/  return new Property("name", "string", "A name for the specification that is being mapped to.", 0, 1, name);
648          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);
649          default: return super.getNamedProperty(_hash, _name, _checkValid);
650          }
651
652        }
653
654      @Override
655      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
656        switch (hash) {
657        case -135761730: /*identity*/ return this.identity == null ? new Base[0] : new Base[] {this.identity}; // IdType
658        case 116076: /*uri*/ return this.uri == null ? new Base[0] : new Base[] {this.uri}; // UriType
659        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
660        case 950398559: /*comment*/ return this.comment == null ? new Base[0] : new Base[] {this.comment}; // StringType
661        default: return super.getProperty(hash, name, checkValid);
662        }
663
664      }
665
666      @Override
667      public Base setProperty(int hash, String name, Base value) throws FHIRException {
668        switch (hash) {
669        case -135761730: // identity
670          this.identity = castToId(value); // IdType
671          return value;
672        case 116076: // uri
673          this.uri = castToUri(value); // UriType
674          return value;
675        case 3373707: // name
676          this.name = castToString(value); // StringType
677          return value;
678        case 950398559: // comment
679          this.comment = castToString(value); // StringType
680          return value;
681        default: return super.setProperty(hash, name, value);
682        }
683
684      }
685
686      @Override
687      public Base setProperty(String name, Base value) throws FHIRException {
688        if (name.equals("identity")) {
689          this.identity = castToId(value); // IdType
690        } else if (name.equals("uri")) {
691          this.uri = castToUri(value); // UriType
692        } else if (name.equals("name")) {
693          this.name = castToString(value); // StringType
694        } else if (name.equals("comment")) {
695          this.comment = castToString(value); // StringType
696        } else
697          return super.setProperty(name, value);
698        return value;
699      }
700
701      @Override
702      public Base makeProperty(int hash, String name) throws FHIRException {
703        switch (hash) {
704        case -135761730:  return getIdentityElement();
705        case 116076:  return getUriElement();
706        case 3373707:  return getNameElement();
707        case 950398559:  return getCommentElement();
708        default: return super.makeProperty(hash, name);
709        }
710
711      }
712
713      @Override
714      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
715        switch (hash) {
716        case -135761730: /*identity*/ return new String[] {"id"};
717        case 116076: /*uri*/ return new String[] {"uri"};
718        case 3373707: /*name*/ return new String[] {"string"};
719        case 950398559: /*comment*/ return new String[] {"string"};
720        default: return super.getTypesForProperty(hash, name);
721        }
722
723      }
724
725      @Override
726      public Base addChild(String name) throws FHIRException {
727        if (name.equals("identity")) {
728          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.identity");
729        }
730        else if (name.equals("uri")) {
731          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.uri");
732        }
733        else if (name.equals("name")) {
734          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.name");
735        }
736        else if (name.equals("comment")) {
737          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.comment");
738        }
739        else
740          return super.addChild(name);
741      }
742
743      public StructureDefinitionMappingComponent copy() {
744        StructureDefinitionMappingComponent dst = new StructureDefinitionMappingComponent();
745        copyValues(dst);
746        dst.identity = identity == null ? null : identity.copy();
747        dst.uri = uri == null ? null : uri.copy();
748        dst.name = name == null ? null : name.copy();
749        dst.comment = comment == null ? null : comment.copy();
750        return dst;
751      }
752
753      @Override
754      public boolean equalsDeep(Base other_) {
755        if (!super.equalsDeep(other_))
756          return false;
757        if (!(other_ instanceof StructureDefinitionMappingComponent))
758          return false;
759        StructureDefinitionMappingComponent o = (StructureDefinitionMappingComponent) other_;
760        return compareDeep(identity, o.identity, true) && compareDeep(uri, o.uri, true) && compareDeep(name, o.name, true)
761           && compareDeep(comment, o.comment, true);
762      }
763
764      @Override
765      public boolean equalsShallow(Base other_) {
766        if (!super.equalsShallow(other_))
767          return false;
768        if (!(other_ instanceof StructureDefinitionMappingComponent))
769          return false;
770        StructureDefinitionMappingComponent o = (StructureDefinitionMappingComponent) other_;
771        return compareValues(identity, o.identity, true) && compareValues(uri, o.uri, true) && compareValues(name, o.name, true)
772           && compareValues(comment, o.comment, true);
773      }
774
775      public boolean isEmpty() {
776        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identity, uri, name, comment
777          );
778      }
779
780  public String fhirType() {
781    return "StructureDefinition.mapping";
782
783  }
784
785  }
786
787    @Block()
788    public static class StructureDefinitionSnapshotComponent extends BackboneElement implements IBaseBackboneElement {
789        /**
790         * Captures constraints on each element within the resource.
791         */
792        @Child(name = "element", type = {ElementDefinition.class}, order=1, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
793        @Description(shortDefinition="Definition of elements in the resource (if no StructureDefinition)", formalDefinition="Captures constraints on each element within the resource." )
794        protected List<ElementDefinition> element;
795
796        private static final long serialVersionUID = 53896641L;
797
798    /**
799     * Constructor
800     */
801      public StructureDefinitionSnapshotComponent() {
802        super();
803      }
804
805        /**
806         * @return {@link #element} (Captures constraints on each element within the resource.)
807         */
808        public List<ElementDefinition> getElement() { 
809          if (this.element == null)
810            this.element = new ArrayList<ElementDefinition>();
811          return this.element;
812        }
813
814        /**
815         * @return Returns a reference to <code>this</code> for easy method chaining
816         */
817        public StructureDefinitionSnapshotComponent setElement(List<ElementDefinition> theElement) { 
818          this.element = theElement;
819          return this;
820        }
821
822        public boolean hasElement() { 
823          if (this.element == null)
824            return false;
825          for (ElementDefinition item : this.element)
826            if (!item.isEmpty())
827              return true;
828          return false;
829        }
830
831        public ElementDefinition addElement() { //3
832          ElementDefinition t = new ElementDefinition();
833          if (this.element == null)
834            this.element = new ArrayList<ElementDefinition>();
835          this.element.add(t);
836          return t;
837        }
838
839        public StructureDefinitionSnapshotComponent addElement(ElementDefinition t) { //3
840          if (t == null)
841            return this;
842          if (this.element == null)
843            this.element = new ArrayList<ElementDefinition>();
844          this.element.add(t);
845          return this;
846        }
847
848        /**
849         * @return The first repetition of repeating field {@link #element}, creating it if it does not already exist
850         */
851        public ElementDefinition getElementFirstRep() { 
852          if (getElement().isEmpty()) {
853            addElement();
854          }
855          return getElement().get(0);
856        }
857
858        protected void listChildren(List<Property> children) {
859          super.listChildren(children);
860          children.add(new Property("element", "ElementDefinition", "Captures constraints on each element within the resource.", 0, java.lang.Integer.MAX_VALUE, element));
861        }
862
863        @Override
864        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
865          switch (_hash) {
866          case -1662836996: /*element*/  return new Property("element", "ElementDefinition", "Captures constraints on each element within the resource.", 0, java.lang.Integer.MAX_VALUE, element);
867          default: return super.getNamedProperty(_hash, _name, _checkValid);
868          }
869
870        }
871
872      @Override
873      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
874        switch (hash) {
875        case -1662836996: /*element*/ return this.element == null ? new Base[0] : this.element.toArray(new Base[this.element.size()]); // ElementDefinition
876        default: return super.getProperty(hash, name, checkValid);
877        }
878
879      }
880
881      @Override
882      public Base setProperty(int hash, String name, Base value) throws FHIRException {
883        switch (hash) {
884        case -1662836996: // element
885          this.getElement().add(castToElementDefinition(value)); // ElementDefinition
886          return value;
887        default: return super.setProperty(hash, name, value);
888        }
889
890      }
891
892      @Override
893      public Base setProperty(String name, Base value) throws FHIRException {
894        if (name.equals("element")) {
895          this.getElement().add(castToElementDefinition(value));
896        } else
897          return super.setProperty(name, value);
898        return value;
899      }
900
901      @Override
902      public Base makeProperty(int hash, String name) throws FHIRException {
903        switch (hash) {
904        case -1662836996:  return addElement(); 
905        default: return super.makeProperty(hash, name);
906        }
907
908      }
909
910      @Override
911      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
912        switch (hash) {
913        case -1662836996: /*element*/ return new String[] {"ElementDefinition"};
914        default: return super.getTypesForProperty(hash, name);
915        }
916
917      }
918
919      @Override
920      public Base addChild(String name) throws FHIRException {
921        if (name.equals("element")) {
922          return addElement();
923        }
924        else
925          return super.addChild(name);
926      }
927
928      public StructureDefinitionSnapshotComponent copy() {
929        StructureDefinitionSnapshotComponent dst = new StructureDefinitionSnapshotComponent();
930        copyValues(dst);
931        if (element != null) {
932          dst.element = new ArrayList<ElementDefinition>();
933          for (ElementDefinition i : element)
934            dst.element.add(i.copy());
935        };
936        return dst;
937      }
938
939      @Override
940      public boolean equalsDeep(Base other_) {
941        if (!super.equalsDeep(other_))
942          return false;
943        if (!(other_ instanceof StructureDefinitionSnapshotComponent))
944          return false;
945        StructureDefinitionSnapshotComponent o = (StructureDefinitionSnapshotComponent) other_;
946        return compareDeep(element, o.element, true);
947      }
948
949      @Override
950      public boolean equalsShallow(Base other_) {
951        if (!super.equalsShallow(other_))
952          return false;
953        if (!(other_ instanceof StructureDefinitionSnapshotComponent))
954          return false;
955        StructureDefinitionSnapshotComponent o = (StructureDefinitionSnapshotComponent) other_;
956        return true;
957      }
958
959      public boolean isEmpty() {
960        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(element);
961      }
962
963  public String fhirType() {
964    return "StructureDefinition.snapshot";
965
966  }
967
968  }
969
970    @Block()
971    public static class StructureDefinitionDifferentialComponent extends BackboneElement implements IBaseBackboneElement {
972        /**
973         * Captures constraints on each element within the resource.
974         */
975        @Child(name = "element", type = {ElementDefinition.class}, order=1, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
976        @Description(shortDefinition="Definition of elements in the resource (if no StructureDefinition)", formalDefinition="Captures constraints on each element within the resource." )
977        protected List<ElementDefinition> element;
978
979        private static final long serialVersionUID = 53896641L;
980
981    /**
982     * Constructor
983     */
984      public StructureDefinitionDifferentialComponent() {
985        super();
986      }
987
988        /**
989         * @return {@link #element} (Captures constraints on each element within the resource.)
990         */
991        public List<ElementDefinition> getElement() { 
992          if (this.element == null)
993            this.element = new ArrayList<ElementDefinition>();
994          return this.element;
995        }
996
997        /**
998         * @return Returns a reference to <code>this</code> for easy method chaining
999         */
1000        public StructureDefinitionDifferentialComponent setElement(List<ElementDefinition> theElement) { 
1001          this.element = theElement;
1002          return this;
1003        }
1004
1005        public boolean hasElement() { 
1006          if (this.element == null)
1007            return false;
1008          for (ElementDefinition item : this.element)
1009            if (!item.isEmpty())
1010              return true;
1011          return false;
1012        }
1013
1014        public ElementDefinition addElement() { //3
1015          ElementDefinition t = new ElementDefinition();
1016          if (this.element == null)
1017            this.element = new ArrayList<ElementDefinition>();
1018          this.element.add(t);
1019          return t;
1020        }
1021
1022        public StructureDefinitionDifferentialComponent addElement(ElementDefinition t) { //3
1023          if (t == null)
1024            return this;
1025          if (this.element == null)
1026            this.element = new ArrayList<ElementDefinition>();
1027          this.element.add(t);
1028          return this;
1029        }
1030
1031        /**
1032         * @return The first repetition of repeating field {@link #element}, creating it if it does not already exist
1033         */
1034        public ElementDefinition getElementFirstRep() { 
1035          if (getElement().isEmpty()) {
1036            addElement();
1037          }
1038          return getElement().get(0);
1039        }
1040
1041        protected void listChildren(List<Property> children) {
1042          super.listChildren(children);
1043          children.add(new Property("element", "ElementDefinition", "Captures constraints on each element within the resource.", 0, java.lang.Integer.MAX_VALUE, element));
1044        }
1045
1046        @Override
1047        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1048          switch (_hash) {
1049          case -1662836996: /*element*/  return new Property("element", "ElementDefinition", "Captures constraints on each element within the resource.", 0, java.lang.Integer.MAX_VALUE, element);
1050          default: return super.getNamedProperty(_hash, _name, _checkValid);
1051          }
1052
1053        }
1054
1055      @Override
1056      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1057        switch (hash) {
1058        case -1662836996: /*element*/ return this.element == null ? new Base[0] : this.element.toArray(new Base[this.element.size()]); // ElementDefinition
1059        default: return super.getProperty(hash, name, checkValid);
1060        }
1061
1062      }
1063
1064      @Override
1065      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1066        switch (hash) {
1067        case -1662836996: // element
1068          this.getElement().add(castToElementDefinition(value)); // ElementDefinition
1069          return value;
1070        default: return super.setProperty(hash, name, value);
1071        }
1072
1073      }
1074
1075      @Override
1076      public Base setProperty(String name, Base value) throws FHIRException {
1077        if (name.equals("element")) {
1078          this.getElement().add(castToElementDefinition(value));
1079        } else
1080          return super.setProperty(name, value);
1081        return value;
1082      }
1083
1084      @Override
1085      public Base makeProperty(int hash, String name) throws FHIRException {
1086        switch (hash) {
1087        case -1662836996:  return addElement(); 
1088        default: return super.makeProperty(hash, name);
1089        }
1090
1091      }
1092
1093      @Override
1094      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1095        switch (hash) {
1096        case -1662836996: /*element*/ return new String[] {"ElementDefinition"};
1097        default: return super.getTypesForProperty(hash, name);
1098        }
1099
1100      }
1101
1102      @Override
1103      public Base addChild(String name) throws FHIRException {
1104        if (name.equals("element")) {
1105          return addElement();
1106        }
1107        else
1108          return super.addChild(name);
1109      }
1110
1111      public StructureDefinitionDifferentialComponent copy() {
1112        StructureDefinitionDifferentialComponent dst = new StructureDefinitionDifferentialComponent();
1113        copyValues(dst);
1114        if (element != null) {
1115          dst.element = new ArrayList<ElementDefinition>();
1116          for (ElementDefinition i : element)
1117            dst.element.add(i.copy());
1118        };
1119        return dst;
1120      }
1121
1122      @Override
1123      public boolean equalsDeep(Base other_) {
1124        if (!super.equalsDeep(other_))
1125          return false;
1126        if (!(other_ instanceof StructureDefinitionDifferentialComponent))
1127          return false;
1128        StructureDefinitionDifferentialComponent o = (StructureDefinitionDifferentialComponent) other_;
1129        return compareDeep(element, o.element, true);
1130      }
1131
1132      @Override
1133      public boolean equalsShallow(Base other_) {
1134        if (!super.equalsShallow(other_))
1135          return false;
1136        if (!(other_ instanceof StructureDefinitionDifferentialComponent))
1137          return false;
1138        StructureDefinitionDifferentialComponent o = (StructureDefinitionDifferentialComponent) other_;
1139        return true;
1140      }
1141
1142      public boolean isEmpty() {
1143        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(element);
1144      }
1145
1146  public String fhirType() {
1147    return "StructureDefinition.differential";
1148
1149  }
1150
1151  }
1152
1153    /**
1154     * 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.
1155     */
1156    @Child(name = "identifier", type = {Identifier.class}, order=0, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1157    @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." )
1158    protected List<Identifier> identifier;
1159
1160    /**
1161     * Explaination of why this structure definition is needed and why it has been designed as it has.
1162     */
1163    @Child(name = "purpose", type = {MarkdownType.class}, order=1, min=0, max=1, modifier=false, summary=false)
1164    @Description(shortDefinition="Why this structure definition is defined", formalDefinition="Explaination of why this structure definition is needed and why it has been designed as it has." )
1165    protected MarkdownType purpose;
1166
1167    /**
1168     * 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.
1169     */
1170    @Child(name = "copyright", type = {MarkdownType.class}, order=2, min=0, max=1, modifier=false, summary=false)
1171    @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." )
1172    protected MarkdownType copyright;
1173
1174    /**
1175     * A set of key words or terms from external terminologies that may be used to assist with indexing and searching of templates.
1176     */
1177    @Child(name = "keyword", type = {Coding.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1178    @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." )
1179    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/profile-code")
1180    protected List<Coding> keyword;
1181
1182    /**
1183     * 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 3.0.2 for this version.
1184     */
1185    @Child(name = "fhirVersion", type = {IdType.class}, order=4, min=0, max=1, modifier=false, summary=true)
1186    @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 3.0.2 for this version." )
1187    protected IdType fhirVersion;
1188
1189    /**
1190     * An external specification that the content is mapped to.
1191     */
1192    @Child(name = "mapping", type = {}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1193    @Description(shortDefinition="External specification that the content is mapped to", formalDefinition="An external specification that the content is mapped to." )
1194    protected List<StructureDefinitionMappingComponent> mapping;
1195
1196    /**
1197     * Defines the kind of structure that this definition is describing.
1198     */
1199    @Child(name = "kind", type = {CodeType.class}, order=6, min=1, max=1, modifier=false, summary=true)
1200    @Description(shortDefinition="primitive-type | complex-type | resource | logical", formalDefinition="Defines the kind of structure that this definition is describing." )
1201    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/structure-definition-kind")
1202    protected Enumeration<StructureDefinitionKind> kind;
1203
1204    /**
1205     * 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.
1206     */
1207    @Child(name = "abstract", type = {BooleanType.class}, order=7, min=1, max=1, modifier=false, summary=true)
1208    @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." )
1209    protected BooleanType abstract_;
1210
1211    /**
1212     * If this is an extension, Identifies the context within FHIR resources where the extension can be used.
1213     */
1214    @Child(name = "contextType", type = {CodeType.class}, order=8, min=0, max=1, modifier=false, summary=true)
1215    @Description(shortDefinition="resource | datatype | extension", formalDefinition="If this is an extension, Identifies the context within FHIR resources where the extension can be used." )
1216    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/extension-context")
1217    protected Enumeration<ExtensionContext> contextType;
1218
1219    /**
1220     * Identifies the types of resource or data type elements to which the extension can be applied.
1221     */
1222    @Child(name = "context", type = {StringType.class}, order=9, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1223    @Description(shortDefinition="Where the extension can be used in instances", formalDefinition="Identifies the types of resource or data type elements to which the extension can be applied." )
1224    protected List<StringType> context;
1225
1226    /**
1227     * A set of rules as Fluent Invariants about when the extension can be used (e.g. co-occurrence variants for the extension).
1228     */
1229    @Child(name = "contextInvariant", type = {StringType.class}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1230    @Description(shortDefinition="FHIRPath invariants - when the extension can be used", formalDefinition="A set of rules as Fluent Invariants about when the extension can be used (e.g. co-occurrence variants for the extension)." )
1231    protected List<StringType> contextInvariant;
1232
1233    /**
1234     * 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).
1235     */
1236    @Child(name = "type", type = {CodeType.class}, order=11, min=1, max=1, modifier=false, summary=true)
1237    @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)." )
1238    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/defined-types")
1239    protected CodeType type;
1240
1241    /**
1242     * An absolute URI that is the base structure from which this type is derived, either by specialization or constraint.
1243     */
1244    @Child(name = "baseDefinition", type = {UriType.class}, order=12, min=0, max=1, modifier=false, summary=true)
1245    @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." )
1246    protected UriType baseDefinition;
1247
1248    /**
1249     * How the type relates to the baseDefinition.
1250     */
1251    @Child(name = "derivation", type = {CodeType.class}, order=13, min=0, max=1, modifier=false, summary=true)
1252    @Description(shortDefinition="specialization | constraint - How relates to base definition", formalDefinition="How the type relates to the baseDefinition." )
1253    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/type-derivation-rule")
1254    protected Enumeration<TypeDerivationRule> derivation;
1255
1256    /**
1257     * A snapshot view is expressed in a stand alone form that can be used and interpreted without considering the base StructureDefinition.
1258     */
1259    @Child(name = "snapshot", type = {}, order=14, min=0, max=1, modifier=false, summary=false)
1260    @Description(shortDefinition="Snapshot view of the structure", formalDefinition="A snapshot view is expressed in a stand alone form that can be used and interpreted without considering the base StructureDefinition." )
1261    protected StructureDefinitionSnapshotComponent snapshot;
1262
1263    /**
1264     * A differential view is expressed relative to the base StructureDefinition - a statement of differences that it applies.
1265     */
1266    @Child(name = "differential", type = {}, order=15, min=0, max=1, modifier=false, summary=false)
1267    @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." )
1268    protected StructureDefinitionDifferentialComponent differential;
1269
1270    private static final long serialVersionUID = -1511739381L;
1271
1272  /**
1273   * Constructor
1274   */
1275    public StructureDefinition() {
1276      super();
1277    }
1278
1279  /**
1280   * Constructor
1281   */
1282    public StructureDefinition(UriType url, StringType name, Enumeration<PublicationStatus> status, Enumeration<StructureDefinitionKind> kind, BooleanType abstract_, CodeType type) {
1283      super();
1284      this.url = url;
1285      this.name = name;
1286      this.status = status;
1287      this.kind = kind;
1288      this.abstract_ = abstract_;
1289      this.type = type;
1290    }
1291
1292    /**
1293     * @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. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this structure definition is (or will be) published. The URL SHOULD include the major version of the structure definition. For more information see [Technical and Business Versions](resource.html#versions).). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
1294     */
1295    public UriType getUrlElement() { 
1296      if (this.url == null)
1297        if (Configuration.errorOnAutoCreate())
1298          throw new Error("Attempt to auto-create StructureDefinition.url");
1299        else if (Configuration.doAutoCreate())
1300          this.url = new UriType(); // bb
1301      return this.url;
1302    }
1303
1304    public boolean hasUrlElement() { 
1305      return this.url != null && !this.url.isEmpty();
1306    }
1307
1308    public boolean hasUrl() { 
1309      return this.url != null && !this.url.isEmpty();
1310    }
1311
1312    /**
1313     * @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. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this structure definition is (or will be) published. The URL SHOULD include the major version of the structure definition. For more information see [Technical and Business Versions](resource.html#versions).). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
1314     */
1315    public StructureDefinition setUrlElement(UriType value) { 
1316      this.url = value;
1317      return this;
1318    }
1319
1320    /**
1321     * @return An absolute URI that is used to identify this structure definition when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this structure definition is (or will be) published. The URL SHOULD include the major version of the structure definition. For more information see [Technical and Business Versions](resource.html#versions).
1322     */
1323    public String getUrl() { 
1324      return this.url == null ? null : this.url.getValue();
1325    }
1326
1327    /**
1328     * @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. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this structure definition is (or will be) published. The URL SHOULD include the major version of the structure definition. For more information see [Technical and Business Versions](resource.html#versions).
1329     */
1330    public StructureDefinition setUrl(String value) { 
1331        if (this.url == null)
1332          this.url = new UriType();
1333        this.url.setValue(value);
1334      return this;
1335    }
1336
1337    /**
1338     * @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.)
1339     */
1340    public List<Identifier> getIdentifier() { 
1341      if (this.identifier == null)
1342        this.identifier = new ArrayList<Identifier>();
1343      return this.identifier;
1344    }
1345
1346    /**
1347     * @return Returns a reference to <code>this</code> for easy method chaining
1348     */
1349    public StructureDefinition setIdentifier(List<Identifier> theIdentifier) { 
1350      this.identifier = theIdentifier;
1351      return this;
1352    }
1353
1354    public boolean hasIdentifier() { 
1355      if (this.identifier == null)
1356        return false;
1357      for (Identifier item : this.identifier)
1358        if (!item.isEmpty())
1359          return true;
1360      return false;
1361    }
1362
1363    public Identifier addIdentifier() { //3
1364      Identifier t = new Identifier();
1365      if (this.identifier == null)
1366        this.identifier = new ArrayList<Identifier>();
1367      this.identifier.add(t);
1368      return t;
1369    }
1370
1371    public StructureDefinition addIdentifier(Identifier t) { //3
1372      if (t == null)
1373        return this;
1374      if (this.identifier == null)
1375        this.identifier = new ArrayList<Identifier>();
1376      this.identifier.add(t);
1377      return this;
1378    }
1379
1380    /**
1381     * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist
1382     */
1383    public Identifier getIdentifierFirstRep() { 
1384      if (getIdentifier().isEmpty()) {
1385        addIdentifier();
1386      }
1387      return getIdentifier().get(0);
1388    }
1389
1390    /**
1391     * @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
1392     */
1393    public StringType getVersionElement() { 
1394      if (this.version == null)
1395        if (Configuration.errorOnAutoCreate())
1396          throw new Error("Attempt to auto-create StructureDefinition.version");
1397        else if (Configuration.doAutoCreate())
1398          this.version = new StringType(); // bb
1399      return this.version;
1400    }
1401
1402    public boolean hasVersionElement() { 
1403      return this.version != null && !this.version.isEmpty();
1404    }
1405
1406    public boolean hasVersion() { 
1407      return this.version != null && !this.version.isEmpty();
1408    }
1409
1410    /**
1411     * @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
1412     */
1413    public StructureDefinition setVersionElement(StringType value) { 
1414      this.version = value;
1415      return this;
1416    }
1417
1418    /**
1419     * @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.
1420     */
1421    public String getVersion() { 
1422      return this.version == null ? null : this.version.getValue();
1423    }
1424
1425    /**
1426     * @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.
1427     */
1428    public StructureDefinition setVersion(String value) { 
1429      if (Utilities.noString(value))
1430        this.version = null;
1431      else {
1432        if (this.version == null)
1433          this.version = new StringType();
1434        this.version.setValue(value);
1435      }
1436      return this;
1437    }
1438
1439    /**
1440     * @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
1441     */
1442    public StringType getNameElement() { 
1443      if (this.name == null)
1444        if (Configuration.errorOnAutoCreate())
1445          throw new Error("Attempt to auto-create StructureDefinition.name");
1446        else if (Configuration.doAutoCreate())
1447          this.name = new StringType(); // bb
1448      return this.name;
1449    }
1450
1451    public boolean hasNameElement() { 
1452      return this.name != null && !this.name.isEmpty();
1453    }
1454
1455    public boolean hasName() { 
1456      return this.name != null && !this.name.isEmpty();
1457    }
1458
1459    /**
1460     * @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
1461     */
1462    public StructureDefinition setNameElement(StringType value) { 
1463      this.name = value;
1464      return this;
1465    }
1466
1467    /**
1468     * @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.
1469     */
1470    public String getName() { 
1471      return this.name == null ? null : this.name.getValue();
1472    }
1473
1474    /**
1475     * @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.
1476     */
1477    public StructureDefinition setName(String value) { 
1478        if (this.name == null)
1479          this.name = new StringType();
1480        this.name.setValue(value);
1481      return this;
1482    }
1483
1484    /**
1485     * @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
1486     */
1487    public StringType getTitleElement() { 
1488      if (this.title == null)
1489        if (Configuration.errorOnAutoCreate())
1490          throw new Error("Attempt to auto-create StructureDefinition.title");
1491        else if (Configuration.doAutoCreate())
1492          this.title = new StringType(); // bb
1493      return this.title;
1494    }
1495
1496    public boolean hasTitleElement() { 
1497      return this.title != null && !this.title.isEmpty();
1498    }
1499
1500    public boolean hasTitle() { 
1501      return this.title != null && !this.title.isEmpty();
1502    }
1503
1504    /**
1505     * @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
1506     */
1507    public StructureDefinition setTitleElement(StringType value) { 
1508      this.title = value;
1509      return this;
1510    }
1511
1512    /**
1513     * @return A short, descriptive, user-friendly title for the structure definition.
1514     */
1515    public String getTitle() { 
1516      return this.title == null ? null : this.title.getValue();
1517    }
1518
1519    /**
1520     * @param value A short, descriptive, user-friendly title for the structure definition.
1521     */
1522    public StructureDefinition setTitle(String value) { 
1523      if (Utilities.noString(value))
1524        this.title = null;
1525      else {
1526        if (this.title == null)
1527          this.title = new StringType();
1528        this.title.setValue(value);
1529      }
1530      return this;
1531    }
1532
1533    /**
1534     * @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
1535     */
1536    public Enumeration<PublicationStatus> getStatusElement() { 
1537      if (this.status == null)
1538        if (Configuration.errorOnAutoCreate())
1539          throw new Error("Attempt to auto-create StructureDefinition.status");
1540        else if (Configuration.doAutoCreate())
1541          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb
1542      return this.status;
1543    }
1544
1545    public boolean hasStatusElement() { 
1546      return this.status != null && !this.status.isEmpty();
1547    }
1548
1549    public boolean hasStatus() { 
1550      return this.status != null && !this.status.isEmpty();
1551    }
1552
1553    /**
1554     * @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
1555     */
1556    public StructureDefinition setStatusElement(Enumeration<PublicationStatus> value) { 
1557      this.status = value;
1558      return this;
1559    }
1560
1561    /**
1562     * @return The status of this structure definition. Enables tracking the life-cycle of the content.
1563     */
1564    public PublicationStatus getStatus() { 
1565      return this.status == null ? null : this.status.getValue();
1566    }
1567
1568    /**
1569     * @param value The status of this structure definition. Enables tracking the life-cycle of the content.
1570     */
1571    public StructureDefinition setStatus(PublicationStatus value) { 
1572        if (this.status == null)
1573          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory());
1574        this.status.setValue(value);
1575      return this;
1576    }
1577
1578    /**
1579     * @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
1580     */
1581    public BooleanType getExperimentalElement() { 
1582      if (this.experimental == null)
1583        if (Configuration.errorOnAutoCreate())
1584          throw new Error("Attempt to auto-create StructureDefinition.experimental");
1585        else if (Configuration.doAutoCreate())
1586          this.experimental = new BooleanType(); // bb
1587      return this.experimental;
1588    }
1589
1590    public boolean hasExperimentalElement() { 
1591      return this.experimental != null && !this.experimental.isEmpty();
1592    }
1593
1594    public boolean hasExperimental() { 
1595      return this.experimental != null && !this.experimental.isEmpty();
1596    }
1597
1598    /**
1599     * @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
1600     */
1601    public StructureDefinition setExperimentalElement(BooleanType value) { 
1602      this.experimental = value;
1603      return this;
1604    }
1605
1606    /**
1607     * @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.
1608     */
1609    public boolean getExperimental() { 
1610      return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue();
1611    }
1612
1613    /**
1614     * @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.
1615     */
1616    public StructureDefinition setExperimental(boolean value) { 
1617        if (this.experimental == null)
1618          this.experimental = new BooleanType();
1619        this.experimental.setValue(value);
1620      return this;
1621    }
1622
1623    /**
1624     * @return {@link #date} (The date  (and optionally time) when the structure definition was published. The date must change if and 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
1625     */
1626    public DateTimeType getDateElement() { 
1627      if (this.date == null)
1628        if (Configuration.errorOnAutoCreate())
1629          throw new Error("Attempt to auto-create StructureDefinition.date");
1630        else if (Configuration.doAutoCreate())
1631          this.date = new DateTimeType(); // bb
1632      return this.date;
1633    }
1634
1635    public boolean hasDateElement() { 
1636      return this.date != null && !this.date.isEmpty();
1637    }
1638
1639    public boolean hasDate() { 
1640      return this.date != null && !this.date.isEmpty();
1641    }
1642
1643    /**
1644     * @param value {@link #date} (The date  (and optionally time) when the structure definition was published. The date must change if and 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
1645     */
1646    public StructureDefinition setDateElement(DateTimeType value) { 
1647      this.date = value;
1648      return this;
1649    }
1650
1651    /**
1652     * @return The date  (and optionally time) when the structure definition was published. The date must change if and 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.
1653     */
1654    public Date getDate() { 
1655      return this.date == null ? null : this.date.getValue();
1656    }
1657
1658    /**
1659     * @param value The date  (and optionally time) when the structure definition was published. The date must change if and 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.
1660     */
1661    public StructureDefinition setDate(Date value) { 
1662      if (value == null)
1663        this.date = null;
1664      else {
1665        if (this.date == null)
1666          this.date = new DateTimeType();
1667        this.date.setValue(value);
1668      }
1669      return this;
1670    }
1671
1672    /**
1673     * @return {@link #publisher} (The name of the individual or organization that published the structure definition.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
1674     */
1675    public StringType getPublisherElement() { 
1676      if (this.publisher == null)
1677        if (Configuration.errorOnAutoCreate())
1678          throw new Error("Attempt to auto-create StructureDefinition.publisher");
1679        else if (Configuration.doAutoCreate())
1680          this.publisher = new StringType(); // bb
1681      return this.publisher;
1682    }
1683
1684    public boolean hasPublisherElement() { 
1685      return this.publisher != null && !this.publisher.isEmpty();
1686    }
1687
1688    public boolean hasPublisher() { 
1689      return this.publisher != null && !this.publisher.isEmpty();
1690    }
1691
1692    /**
1693     * @param value {@link #publisher} (The name of the individual or organization that published the structure definition.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
1694     */
1695    public StructureDefinition setPublisherElement(StringType value) { 
1696      this.publisher = value;
1697      return this;
1698    }
1699
1700    /**
1701     * @return The name of the individual or organization that published the structure definition.
1702     */
1703    public String getPublisher() { 
1704      return this.publisher == null ? null : this.publisher.getValue();
1705    }
1706
1707    /**
1708     * @param value The name of the individual or organization that published the structure definition.
1709     */
1710    public StructureDefinition setPublisher(String value) { 
1711      if (Utilities.noString(value))
1712        this.publisher = null;
1713      else {
1714        if (this.publisher == null)
1715          this.publisher = new StringType();
1716        this.publisher.setValue(value);
1717      }
1718      return this;
1719    }
1720
1721    /**
1722     * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.)
1723     */
1724    public List<ContactDetail> getContact() { 
1725      if (this.contact == null)
1726        this.contact = new ArrayList<ContactDetail>();
1727      return this.contact;
1728    }
1729
1730    /**
1731     * @return Returns a reference to <code>this</code> for easy method chaining
1732     */
1733    public StructureDefinition setContact(List<ContactDetail> theContact) { 
1734      this.contact = theContact;
1735      return this;
1736    }
1737
1738    public boolean hasContact() { 
1739      if (this.contact == null)
1740        return false;
1741      for (ContactDetail item : this.contact)
1742        if (!item.isEmpty())
1743          return true;
1744      return false;
1745    }
1746
1747    public ContactDetail addContact() { //3
1748      ContactDetail t = new ContactDetail();
1749      if (this.contact == null)
1750        this.contact = new ArrayList<ContactDetail>();
1751      this.contact.add(t);
1752      return t;
1753    }
1754
1755    public StructureDefinition addContact(ContactDetail t) { //3
1756      if (t == null)
1757        return this;
1758      if (this.contact == null)
1759        this.contact = new ArrayList<ContactDetail>();
1760      this.contact.add(t);
1761      return this;
1762    }
1763
1764    /**
1765     * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist
1766     */
1767    public ContactDetail getContactFirstRep() { 
1768      if (getContact().isEmpty()) {
1769        addContact();
1770      }
1771      return getContact().get(0);
1772    }
1773
1774    /**
1775     * @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
1776     */
1777    public MarkdownType getDescriptionElement() { 
1778      if (this.description == null)
1779        if (Configuration.errorOnAutoCreate())
1780          throw new Error("Attempt to auto-create StructureDefinition.description");
1781        else if (Configuration.doAutoCreate())
1782          this.description = new MarkdownType(); // bb
1783      return this.description;
1784    }
1785
1786    public boolean hasDescriptionElement() { 
1787      return this.description != null && !this.description.isEmpty();
1788    }
1789
1790    public boolean hasDescription() { 
1791      return this.description != null && !this.description.isEmpty();
1792    }
1793
1794    /**
1795     * @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
1796     */
1797    public StructureDefinition setDescriptionElement(MarkdownType value) { 
1798      this.description = value;
1799      return this;
1800    }
1801
1802    /**
1803     * @return A free text natural language description of the structure definition from a consumer's perspective.
1804     */
1805    public String getDescription() { 
1806      return this.description == null ? null : this.description.getValue();
1807    }
1808
1809    /**
1810     * @param value A free text natural language description of the structure definition from a consumer's perspective.
1811     */
1812    public StructureDefinition setDescription(String value) { 
1813      if (value == null)
1814        this.description = null;
1815      else {
1816        if (this.description == null)
1817          this.description = new MarkdownType();
1818        this.description.setValue(value);
1819      }
1820      return this;
1821    }
1822
1823    /**
1824     * @return {@link #useContext} (The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate structure definition instances.)
1825     */
1826    public List<UsageContext> getUseContext() { 
1827      if (this.useContext == null)
1828        this.useContext = new ArrayList<UsageContext>();
1829      return this.useContext;
1830    }
1831
1832    /**
1833     * @return Returns a reference to <code>this</code> for easy method chaining
1834     */
1835    public StructureDefinition setUseContext(List<UsageContext> theUseContext) { 
1836      this.useContext = theUseContext;
1837      return this;
1838    }
1839
1840    public boolean hasUseContext() { 
1841      if (this.useContext == null)
1842        return false;
1843      for (UsageContext item : this.useContext)
1844        if (!item.isEmpty())
1845          return true;
1846      return false;
1847    }
1848
1849    public UsageContext addUseContext() { //3
1850      UsageContext t = new UsageContext();
1851      if (this.useContext == null)
1852        this.useContext = new ArrayList<UsageContext>();
1853      this.useContext.add(t);
1854      return t;
1855    }
1856
1857    public StructureDefinition addUseContext(UsageContext t) { //3
1858      if (t == null)
1859        return this;
1860      if (this.useContext == null)
1861        this.useContext = new ArrayList<UsageContext>();
1862      this.useContext.add(t);
1863      return this;
1864    }
1865
1866    /**
1867     * @return The first repetition of repeating field {@link #useContext}, creating it if it does not already exist
1868     */
1869    public UsageContext getUseContextFirstRep() { 
1870      if (getUseContext().isEmpty()) {
1871        addUseContext();
1872      }
1873      return getUseContext().get(0);
1874    }
1875
1876    /**
1877     * @return {@link #jurisdiction} (A legal or geographic region in which the structure definition is intended to be used.)
1878     */
1879    public List<CodeableConcept> getJurisdiction() { 
1880      if (this.jurisdiction == null)
1881        this.jurisdiction = new ArrayList<CodeableConcept>();
1882      return this.jurisdiction;
1883    }
1884
1885    /**
1886     * @return Returns a reference to <code>this</code> for easy method chaining
1887     */
1888    public StructureDefinition setJurisdiction(List<CodeableConcept> theJurisdiction) { 
1889      this.jurisdiction = theJurisdiction;
1890      return this;
1891    }
1892
1893    public boolean hasJurisdiction() { 
1894      if (this.jurisdiction == null)
1895        return false;
1896      for (CodeableConcept item : this.jurisdiction)
1897        if (!item.isEmpty())
1898          return true;
1899      return false;
1900    }
1901
1902    public CodeableConcept addJurisdiction() { //3
1903      CodeableConcept t = new CodeableConcept();
1904      if (this.jurisdiction == null)
1905        this.jurisdiction = new ArrayList<CodeableConcept>();
1906      this.jurisdiction.add(t);
1907      return t;
1908    }
1909
1910    public StructureDefinition addJurisdiction(CodeableConcept t) { //3
1911      if (t == null)
1912        return this;
1913      if (this.jurisdiction == null)
1914        this.jurisdiction = new ArrayList<CodeableConcept>();
1915      this.jurisdiction.add(t);
1916      return this;
1917    }
1918
1919    /**
1920     * @return The first repetition of repeating field {@link #jurisdiction}, creating it if it does not already exist
1921     */
1922    public CodeableConcept getJurisdictionFirstRep() { 
1923      if (getJurisdiction().isEmpty()) {
1924        addJurisdiction();
1925      }
1926      return getJurisdiction().get(0);
1927    }
1928
1929    /**
1930     * @return {@link #purpose} (Explaination 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
1931     */
1932    public MarkdownType getPurposeElement() { 
1933      if (this.purpose == null)
1934        if (Configuration.errorOnAutoCreate())
1935          throw new Error("Attempt to auto-create StructureDefinition.purpose");
1936        else if (Configuration.doAutoCreate())
1937          this.purpose = new MarkdownType(); // bb
1938      return this.purpose;
1939    }
1940
1941    public boolean hasPurposeElement() { 
1942      return this.purpose != null && !this.purpose.isEmpty();
1943    }
1944
1945    public boolean hasPurpose() { 
1946      return this.purpose != null && !this.purpose.isEmpty();
1947    }
1948
1949    /**
1950     * @param value {@link #purpose} (Explaination 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
1951     */
1952    public StructureDefinition setPurposeElement(MarkdownType value) { 
1953      this.purpose = value;
1954      return this;
1955    }
1956
1957    /**
1958     * @return Explaination of why this structure definition is needed and why it has been designed as it has.
1959     */
1960    public String getPurpose() { 
1961      return this.purpose == null ? null : this.purpose.getValue();
1962    }
1963
1964    /**
1965     * @param value Explaination of why this structure definition is needed and why it has been designed as it has.
1966     */
1967    public StructureDefinition setPurpose(String value) { 
1968      if (value == null)
1969        this.purpose = null;
1970      else {
1971        if (this.purpose == null)
1972          this.purpose = new MarkdownType();
1973        this.purpose.setValue(value);
1974      }
1975      return this;
1976    }
1977
1978    /**
1979     * @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
1980     */
1981    public MarkdownType getCopyrightElement() { 
1982      if (this.copyright == null)
1983        if (Configuration.errorOnAutoCreate())
1984          throw new Error("Attempt to auto-create StructureDefinition.copyright");
1985        else if (Configuration.doAutoCreate())
1986          this.copyright = new MarkdownType(); // bb
1987      return this.copyright;
1988    }
1989
1990    public boolean hasCopyrightElement() { 
1991      return this.copyright != null && !this.copyright.isEmpty();
1992    }
1993
1994    public boolean hasCopyright() { 
1995      return this.copyright != null && !this.copyright.isEmpty();
1996    }
1997
1998    /**
1999     * @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
2000     */
2001    public StructureDefinition setCopyrightElement(MarkdownType value) { 
2002      this.copyright = value;
2003      return this;
2004    }
2005
2006    /**
2007     * @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.
2008     */
2009    public String getCopyright() { 
2010      return this.copyright == null ? null : this.copyright.getValue();
2011    }
2012
2013    /**
2014     * @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.
2015     */
2016    public StructureDefinition setCopyright(String value) { 
2017      if (value == null)
2018        this.copyright = null;
2019      else {
2020        if (this.copyright == null)
2021          this.copyright = new MarkdownType();
2022        this.copyright.setValue(value);
2023      }
2024      return this;
2025    }
2026
2027    /**
2028     * @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.)
2029     */
2030    public List<Coding> getKeyword() { 
2031      if (this.keyword == null)
2032        this.keyword = new ArrayList<Coding>();
2033      return this.keyword;
2034    }
2035
2036    /**
2037     * @return Returns a reference to <code>this</code> for easy method chaining
2038     */
2039    public StructureDefinition setKeyword(List<Coding> theKeyword) { 
2040      this.keyword = theKeyword;
2041      return this;
2042    }
2043
2044    public boolean hasKeyword() { 
2045      if (this.keyword == null)
2046        return false;
2047      for (Coding item : this.keyword)
2048        if (!item.isEmpty())
2049          return true;
2050      return false;
2051    }
2052
2053    public Coding addKeyword() { //3
2054      Coding t = new Coding();
2055      if (this.keyword == null)
2056        this.keyword = new ArrayList<Coding>();
2057      this.keyword.add(t);
2058      return t;
2059    }
2060
2061    public StructureDefinition addKeyword(Coding t) { //3
2062      if (t == null)
2063        return this;
2064      if (this.keyword == null)
2065        this.keyword = new ArrayList<Coding>();
2066      this.keyword.add(t);
2067      return this;
2068    }
2069
2070    /**
2071     * @return The first repetition of repeating field {@link #keyword}, creating it if it does not already exist
2072     */
2073    public Coding getKeywordFirstRep() { 
2074      if (getKeyword().isEmpty()) {
2075        addKeyword();
2076      }
2077      return getKeyword().get(0);
2078    }
2079
2080    /**
2081     * @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 3.0.2 for this version.). This is the underlying object with id, value and extensions. The accessor "getFhirVersion" gives direct access to the value
2082     */
2083    public IdType getFhirVersionElement() { 
2084      if (this.fhirVersion == null)
2085        if (Configuration.errorOnAutoCreate())
2086          throw new Error("Attempt to auto-create StructureDefinition.fhirVersion");
2087        else if (Configuration.doAutoCreate())
2088          this.fhirVersion = new IdType(); // bb
2089      return this.fhirVersion;
2090    }
2091
2092    public boolean hasFhirVersionElement() { 
2093      return this.fhirVersion != null && !this.fhirVersion.isEmpty();
2094    }
2095
2096    public boolean hasFhirVersion() { 
2097      return this.fhirVersion != null && !this.fhirVersion.isEmpty();
2098    }
2099
2100    /**
2101     * @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 3.0.2 for this version.). This is the underlying object with id, value and extensions. The accessor "getFhirVersion" gives direct access to the value
2102     */
2103    public StructureDefinition setFhirVersionElement(IdType value) { 
2104      this.fhirVersion = value;
2105      return this;
2106    }
2107
2108    /**
2109     * @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 3.0.2 for this version.
2110     */
2111    public String getFhirVersion() { 
2112      return this.fhirVersion == null ? null : this.fhirVersion.getValue();
2113    }
2114
2115    /**
2116     * @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 3.0.2 for this version.
2117     */
2118    public StructureDefinition setFhirVersion(String value) { 
2119      if (Utilities.noString(value))
2120        this.fhirVersion = null;
2121      else {
2122        if (this.fhirVersion == null)
2123          this.fhirVersion = new IdType();
2124        this.fhirVersion.setValue(value);
2125      }
2126      return this;
2127    }
2128
2129    /**
2130     * @return {@link #mapping} (An external specification that the content is mapped to.)
2131     */
2132    public List<StructureDefinitionMappingComponent> getMapping() { 
2133      if (this.mapping == null)
2134        this.mapping = new ArrayList<StructureDefinitionMappingComponent>();
2135      return this.mapping;
2136    }
2137
2138    /**
2139     * @return Returns a reference to <code>this</code> for easy method chaining
2140     */
2141    public StructureDefinition setMapping(List<StructureDefinitionMappingComponent> theMapping) { 
2142      this.mapping = theMapping;
2143      return this;
2144    }
2145
2146    public boolean hasMapping() { 
2147      if (this.mapping == null)
2148        return false;
2149      for (StructureDefinitionMappingComponent item : this.mapping)
2150        if (!item.isEmpty())
2151          return true;
2152      return false;
2153    }
2154
2155    public StructureDefinitionMappingComponent addMapping() { //3
2156      StructureDefinitionMappingComponent t = new StructureDefinitionMappingComponent();
2157      if (this.mapping == null)
2158        this.mapping = new ArrayList<StructureDefinitionMappingComponent>();
2159      this.mapping.add(t);
2160      return t;
2161    }
2162
2163    public StructureDefinition addMapping(StructureDefinitionMappingComponent t) { //3
2164      if (t == null)
2165        return this;
2166      if (this.mapping == null)
2167        this.mapping = new ArrayList<StructureDefinitionMappingComponent>();
2168      this.mapping.add(t);
2169      return this;
2170    }
2171
2172    /**
2173     * @return The first repetition of repeating field {@link #mapping}, creating it if it does not already exist
2174     */
2175    public StructureDefinitionMappingComponent getMappingFirstRep() { 
2176      if (getMapping().isEmpty()) {
2177        addMapping();
2178      }
2179      return getMapping().get(0);
2180    }
2181
2182    /**
2183     * @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
2184     */
2185    public Enumeration<StructureDefinitionKind> getKindElement() { 
2186      if (this.kind == null)
2187        if (Configuration.errorOnAutoCreate())
2188          throw new Error("Attempt to auto-create StructureDefinition.kind");
2189        else if (Configuration.doAutoCreate())
2190          this.kind = new Enumeration<StructureDefinitionKind>(new StructureDefinitionKindEnumFactory()); // bb
2191      return this.kind;
2192    }
2193
2194    public boolean hasKindElement() { 
2195      return this.kind != null && !this.kind.isEmpty();
2196    }
2197
2198    public boolean hasKind() { 
2199      return this.kind != null && !this.kind.isEmpty();
2200    }
2201
2202    /**
2203     * @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
2204     */
2205    public StructureDefinition setKindElement(Enumeration<StructureDefinitionKind> value) { 
2206      this.kind = value;
2207      return this;
2208    }
2209
2210    /**
2211     * @return Defines the kind of structure that this definition is describing.
2212     */
2213    public StructureDefinitionKind getKind() { 
2214      return this.kind == null ? null : this.kind.getValue();
2215    }
2216
2217    /**
2218     * @param value Defines the kind of structure that this definition is describing.
2219     */
2220    public StructureDefinition setKind(StructureDefinitionKind value) { 
2221        if (this.kind == null)
2222          this.kind = new Enumeration<StructureDefinitionKind>(new StructureDefinitionKindEnumFactory());
2223        this.kind.setValue(value);
2224      return this;
2225    }
2226
2227    /**
2228     * @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
2229     */
2230    public BooleanType getAbstractElement() { 
2231      if (this.abstract_ == null)
2232        if (Configuration.errorOnAutoCreate())
2233          throw new Error("Attempt to auto-create StructureDefinition.abstract_");
2234        else if (Configuration.doAutoCreate())
2235          this.abstract_ = new BooleanType(); // bb
2236      return this.abstract_;
2237    }
2238
2239    public boolean hasAbstractElement() { 
2240      return this.abstract_ != null && !this.abstract_.isEmpty();
2241    }
2242
2243    public boolean hasAbstract() { 
2244      return this.abstract_ != null && !this.abstract_.isEmpty();
2245    }
2246
2247    /**
2248     * @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
2249     */
2250    public StructureDefinition setAbstractElement(BooleanType value) { 
2251      this.abstract_ = value;
2252      return this;
2253    }
2254
2255    /**
2256     * @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.
2257     */
2258    public boolean getAbstract() { 
2259      return this.abstract_ == null || this.abstract_.isEmpty() ? false : this.abstract_.getValue();
2260    }
2261
2262    /**
2263     * @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.
2264     */
2265    public StructureDefinition setAbstract(boolean value) { 
2266        if (this.abstract_ == null)
2267          this.abstract_ = new BooleanType();
2268        this.abstract_.setValue(value);
2269      return this;
2270    }
2271
2272    /**
2273     * @return {@link #contextType} (If this is an extension, Identifies the context within FHIR resources where the extension can be used.). This is the underlying object with id, value and extensions. The accessor "getContextType" gives direct access to the value
2274     */
2275    public Enumeration<ExtensionContext> getContextTypeElement() { 
2276      if (this.contextType == null)
2277        if (Configuration.errorOnAutoCreate())
2278          throw new Error("Attempt to auto-create StructureDefinition.contextType");
2279        else if (Configuration.doAutoCreate())
2280          this.contextType = new Enumeration<ExtensionContext>(new ExtensionContextEnumFactory()); // bb
2281      return this.contextType;
2282    }
2283
2284    public boolean hasContextTypeElement() { 
2285      return this.contextType != null && !this.contextType.isEmpty();
2286    }
2287
2288    public boolean hasContextType() { 
2289      return this.contextType != null && !this.contextType.isEmpty();
2290    }
2291
2292    /**
2293     * @param value {@link #contextType} (If this is an extension, Identifies the context within FHIR resources where the extension can be used.). This is the underlying object with id, value and extensions. The accessor "getContextType" gives direct access to the value
2294     */
2295    public StructureDefinition setContextTypeElement(Enumeration<ExtensionContext> value) { 
2296      this.contextType = value;
2297      return this;
2298    }
2299
2300    /**
2301     * @return If this is an extension, Identifies the context within FHIR resources where the extension can be used.
2302     */
2303    public ExtensionContext getContextType() { 
2304      return this.contextType == null ? null : this.contextType.getValue();
2305    }
2306
2307    /**
2308     * @param value If this is an extension, Identifies the context within FHIR resources where the extension can be used.
2309     */
2310    public StructureDefinition setContextType(ExtensionContext value) { 
2311      if (value == null)
2312        this.contextType = null;
2313      else {
2314        if (this.contextType == null)
2315          this.contextType = new Enumeration<ExtensionContext>(new ExtensionContextEnumFactory());
2316        this.contextType.setValue(value);
2317      }
2318      return this;
2319    }
2320
2321    /**
2322     * @return {@link #context} (Identifies the types of resource or data type elements to which the extension can be applied.)
2323     */
2324    public List<StringType> getContext() { 
2325      if (this.context == null)
2326        this.context = new ArrayList<StringType>();
2327      return this.context;
2328    }
2329
2330    /**
2331     * @return Returns a reference to <code>this</code> for easy method chaining
2332     */
2333    public StructureDefinition setContext(List<StringType> theContext) { 
2334      this.context = theContext;
2335      return this;
2336    }
2337
2338    public boolean hasContext() { 
2339      if (this.context == null)
2340        return false;
2341      for (StringType item : this.context)
2342        if (!item.isEmpty())
2343          return true;
2344      return false;
2345    }
2346
2347    /**
2348     * @return {@link #context} (Identifies the types of resource or data type elements to which the extension can be applied.)
2349     */
2350    public StringType addContextElement() {//2 
2351      StringType t = new StringType();
2352      if (this.context == null)
2353        this.context = new ArrayList<StringType>();
2354      this.context.add(t);
2355      return t;
2356    }
2357
2358    /**
2359     * @param value {@link #context} (Identifies the types of resource or data type elements to which the extension can be applied.)
2360     */
2361    public StructureDefinition addContext(String value) { //1
2362      StringType t = new StringType();
2363      t.setValue(value);
2364      if (this.context == null)
2365        this.context = new ArrayList<StringType>();
2366      this.context.add(t);
2367      return this;
2368    }
2369
2370    /**
2371     * @param value {@link #context} (Identifies the types of resource or data type elements to which the extension can be applied.)
2372     */
2373    public boolean hasContext(String value) { 
2374      if (this.context == null)
2375        return false;
2376      for (StringType v : this.context)
2377        if (v.getValue().equals(value)) // string
2378          return true;
2379      return false;
2380    }
2381
2382    /**
2383     * @return {@link #contextInvariant} (A set of rules as Fluent Invariants about when the extension can be used (e.g. co-occurrence variants for the extension).)
2384     */
2385    public List<StringType> getContextInvariant() { 
2386      if (this.contextInvariant == null)
2387        this.contextInvariant = new ArrayList<StringType>();
2388      return this.contextInvariant;
2389    }
2390
2391    /**
2392     * @return Returns a reference to <code>this</code> for easy method chaining
2393     */
2394    public StructureDefinition setContextInvariant(List<StringType> theContextInvariant) { 
2395      this.contextInvariant = theContextInvariant;
2396      return this;
2397    }
2398
2399    public boolean hasContextInvariant() { 
2400      if (this.contextInvariant == null)
2401        return false;
2402      for (StringType item : this.contextInvariant)
2403        if (!item.isEmpty())
2404          return true;
2405      return false;
2406    }
2407
2408    /**
2409     * @return {@link #contextInvariant} (A set of rules as Fluent Invariants about when the extension can be used (e.g. co-occurrence variants for the extension).)
2410     */
2411    public StringType addContextInvariantElement() {//2 
2412      StringType t = new StringType();
2413      if (this.contextInvariant == null)
2414        this.contextInvariant = new ArrayList<StringType>();
2415      this.contextInvariant.add(t);
2416      return t;
2417    }
2418
2419    /**
2420     * @param value {@link #contextInvariant} (A set of rules as Fluent Invariants about when the extension can be used (e.g. co-occurrence variants for the extension).)
2421     */
2422    public StructureDefinition addContextInvariant(String value) { //1
2423      StringType t = new StringType();
2424      t.setValue(value);
2425      if (this.contextInvariant == null)
2426        this.contextInvariant = new ArrayList<StringType>();
2427      this.contextInvariant.add(t);
2428      return this;
2429    }
2430
2431    /**
2432     * @param value {@link #contextInvariant} (A set of rules as Fluent Invariants about when the extension can be used (e.g. co-occurrence variants for the extension).)
2433     */
2434    public boolean hasContextInvariant(String value) { 
2435      if (this.contextInvariant == null)
2436        return false;
2437      for (StringType v : this.contextInvariant)
2438        if (v.getValue().equals(value)) // string
2439          return true;
2440      return false;
2441    }
2442
2443    /**
2444     * @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).). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
2445     */
2446    public CodeType getTypeElement() { 
2447      if (this.type == null)
2448        if (Configuration.errorOnAutoCreate())
2449          throw new Error("Attempt to auto-create StructureDefinition.type");
2450        else if (Configuration.doAutoCreate())
2451          this.type = new CodeType(); // bb
2452      return this.type;
2453    }
2454
2455    public boolean hasTypeElement() { 
2456      return this.type != null && !this.type.isEmpty();
2457    }
2458
2459    public boolean hasType() { 
2460      return this.type != null && !this.type.isEmpty();
2461    }
2462
2463    /**
2464     * @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).). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
2465     */
2466    public StructureDefinition setTypeElement(CodeType value) { 
2467      this.type = value;
2468      return this;
2469    }
2470
2471    /**
2472     * @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).
2473     */
2474    public String getType() { 
2475      return this.type == null ? null : this.type.getValue();
2476    }
2477
2478    /**
2479     * @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).
2480     */
2481    public StructureDefinition setType(String value) { 
2482        if (this.type == null)
2483          this.type = new CodeType();
2484        this.type.setValue(value);
2485      return this;
2486    }
2487
2488    /**
2489     * @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
2490     */
2491    public UriType getBaseDefinitionElement() { 
2492      if (this.baseDefinition == null)
2493        if (Configuration.errorOnAutoCreate())
2494          throw new Error("Attempt to auto-create StructureDefinition.baseDefinition");
2495        else if (Configuration.doAutoCreate())
2496          this.baseDefinition = new UriType(); // bb
2497      return this.baseDefinition;
2498    }
2499
2500    public boolean hasBaseDefinitionElement() { 
2501      return this.baseDefinition != null && !this.baseDefinition.isEmpty();
2502    }
2503
2504    public boolean hasBaseDefinition() { 
2505      return this.baseDefinition != null && !this.baseDefinition.isEmpty();
2506    }
2507
2508    /**
2509     * @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
2510     */
2511    public StructureDefinition setBaseDefinitionElement(UriType value) { 
2512      this.baseDefinition = value;
2513      return this;
2514    }
2515
2516    /**
2517     * @return An absolute URI that is the base structure from which this type is derived, either by specialization or constraint.
2518     */
2519    public String getBaseDefinition() { 
2520      return this.baseDefinition == null ? null : this.baseDefinition.getValue();
2521    }
2522
2523    /**
2524     * @param value An absolute URI that is the base structure from which this type is derived, either by specialization or constraint.
2525     */
2526    public StructureDefinition setBaseDefinition(String value) { 
2527      if (Utilities.noString(value))
2528        this.baseDefinition = null;
2529      else {
2530        if (this.baseDefinition == null)
2531          this.baseDefinition = new UriType();
2532        this.baseDefinition.setValue(value);
2533      }
2534      return this;
2535    }
2536
2537    /**
2538     * @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
2539     */
2540    public Enumeration<TypeDerivationRule> getDerivationElement() { 
2541      if (this.derivation == null)
2542        if (Configuration.errorOnAutoCreate())
2543          throw new Error("Attempt to auto-create StructureDefinition.derivation");
2544        else if (Configuration.doAutoCreate())
2545          this.derivation = new Enumeration<TypeDerivationRule>(new TypeDerivationRuleEnumFactory()); // bb
2546      return this.derivation;
2547    }
2548
2549    public boolean hasDerivationElement() { 
2550      return this.derivation != null && !this.derivation.isEmpty();
2551    }
2552
2553    public boolean hasDerivation() { 
2554      return this.derivation != null && !this.derivation.isEmpty();
2555    }
2556
2557    /**
2558     * @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
2559     */
2560    public StructureDefinition setDerivationElement(Enumeration<TypeDerivationRule> value) { 
2561      this.derivation = value;
2562      return this;
2563    }
2564
2565    /**
2566     * @return How the type relates to the baseDefinition.
2567     */
2568    public TypeDerivationRule getDerivation() { 
2569      return this.derivation == null ? null : this.derivation.getValue();
2570    }
2571
2572    /**
2573     * @param value How the type relates to the baseDefinition.
2574     */
2575    public StructureDefinition setDerivation(TypeDerivationRule value) { 
2576      if (value == null)
2577        this.derivation = null;
2578      else {
2579        if (this.derivation == null)
2580          this.derivation = new Enumeration<TypeDerivationRule>(new TypeDerivationRuleEnumFactory());
2581        this.derivation.setValue(value);
2582      }
2583      return this;
2584    }
2585
2586    /**
2587     * @return {@link #snapshot} (A snapshot view is expressed in a stand alone form that can be used and interpreted without considering the base StructureDefinition.)
2588     */
2589    public StructureDefinitionSnapshotComponent getSnapshot() { 
2590      if (this.snapshot == null)
2591        if (Configuration.errorOnAutoCreate())
2592          throw new Error("Attempt to auto-create StructureDefinition.snapshot");
2593        else if (Configuration.doAutoCreate())
2594          this.snapshot = new StructureDefinitionSnapshotComponent(); // cc
2595      return this.snapshot;
2596    }
2597
2598    public boolean hasSnapshot() { 
2599      return this.snapshot != null && !this.snapshot.isEmpty();
2600    }
2601
2602    /**
2603     * @param value {@link #snapshot} (A snapshot view is expressed in a stand alone form that can be used and interpreted without considering the base StructureDefinition.)
2604     */
2605    public StructureDefinition setSnapshot(StructureDefinitionSnapshotComponent value)  { 
2606      this.snapshot = value;
2607      return this;
2608    }
2609
2610    /**
2611     * @return {@link #differential} (A differential view is expressed relative to the base StructureDefinition - a statement of differences that it applies.)
2612     */
2613    public StructureDefinitionDifferentialComponent getDifferential() { 
2614      if (this.differential == null)
2615        if (Configuration.errorOnAutoCreate())
2616          throw new Error("Attempt to auto-create StructureDefinition.differential");
2617        else if (Configuration.doAutoCreate())
2618          this.differential = new StructureDefinitionDifferentialComponent(); // cc
2619      return this.differential;
2620    }
2621
2622    public boolean hasDifferential() { 
2623      return this.differential != null && !this.differential.isEmpty();
2624    }
2625
2626    /**
2627     * @param value {@link #differential} (A differential view is expressed relative to the base StructureDefinition - a statement of differences that it applies.)
2628     */
2629    public StructureDefinition setDifferential(StructureDefinitionDifferentialComponent value)  { 
2630      this.differential = value;
2631      return this;
2632    }
2633
2634      protected void listChildren(List<Property> children) {
2635        super.listChildren(children);
2636        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. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this structure definition is (or will be) published. The URL SHOULD include the major version of the structure definition. For more information see [Technical and Business Versions](resource.html#versions).", 0, 1, url));
2637        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));
2638        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));
2639        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));
2640        children.add(new Property("title", "string", "A short, descriptive, user-friendly title for the structure definition.", 0, 1, title));
2641        children.add(new Property("status", "code", "The status of this structure definition. Enables tracking the life-cycle of the content.", 0, 1, status));
2642        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));
2643        children.add(new Property("date", "dateTime", "The date  (and optionally time) when the structure definition was published. The date must change if and 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));
2644        children.add(new Property("publisher", "string", "The name of the individual or organization that published the structure definition.", 0, 1, publisher));
2645        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));
2646        children.add(new Property("description", "markdown", "A free text natural language description of the structure definition from a consumer's perspective.", 0, 1, description));
2647        children.add(new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate structure definition instances.", 0, java.lang.Integer.MAX_VALUE, useContext));
2648        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));
2649        children.add(new Property("purpose", "markdown", "Explaination of why this structure definition is needed and why it has been designed as it has.", 0, 1, purpose));
2650        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));
2651        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.", 0, java.lang.Integer.MAX_VALUE, keyword));
2652        children.add(new Property("fhirVersion", "id", "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 3.0.2 for this version.", 0, 1, fhirVersion));
2653        children.add(new Property("mapping", "", "An external specification that the content is mapped to.", 0, java.lang.Integer.MAX_VALUE, mapping));
2654        children.add(new Property("kind", "code", "Defines the kind of structure that this definition is describing.", 0, 1, kind));
2655        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_));
2656        children.add(new Property("contextType", "code", "If this is an extension, Identifies the context within FHIR resources where the extension can be used.", 0, 1, contextType));
2657        children.add(new Property("context", "string", "Identifies the types of resource or data type elements to which the extension can be applied.", 0, java.lang.Integer.MAX_VALUE, context));
2658        children.add(new Property("contextInvariant", "string", "A set of rules as Fluent Invariants about when the extension can be used (e.g. co-occurrence variants for the extension).", 0, java.lang.Integer.MAX_VALUE, contextInvariant));
2659        children.add(new Property("type", "code", "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).", 0, 1, type));
2660        children.add(new Property("baseDefinition", "uri", "An absolute URI that is the base structure from which this type is derived, either by specialization or constraint.", 0, 1, baseDefinition));
2661        children.add(new Property("derivation", "code", "How the type relates to the baseDefinition.", 0, 1, derivation));
2662        children.add(new Property("snapshot", "", "A snapshot view is expressed in a stand alone form that can be used and interpreted without considering the base StructureDefinition.", 0, 1, snapshot));
2663        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));
2664      }
2665
2666      @Override
2667      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2668        switch (_hash) {
2669        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. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this structure definition is (or will be) published. The URL SHOULD include the major version of the structure definition. For more information see [Technical and Business Versions](resource.html#versions).", 0, 1, url);
2670        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);
2671        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);
2672        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);
2673        case 110371416: /*title*/  return new Property("title", "string", "A short, descriptive, user-friendly title for the structure definition.", 0, 1, title);
2674        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);
2675        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);
2676        case 3076014: /*date*/  return new Property("date", "dateTime", "The date  (and optionally time) when the structure definition was published. The date must change if and 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);
2677        case 1447404028: /*publisher*/  return new Property("publisher", "string", "The name of the individual or organization that published the structure definition.", 0, 1, publisher);
2678        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);
2679        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);
2680        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 terms may be used to assist with indexing and searching for appropriate structure definition instances.", 0, java.lang.Integer.MAX_VALUE, useContext);
2681        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);
2682        case -220463842: /*purpose*/  return new Property("purpose", "markdown", "Explaination of why this structure definition is needed and why it has been designed as it has.", 0, 1, purpose);
2683        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);
2684        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.", 0, java.lang.Integer.MAX_VALUE, keyword);
2685        case 461006061: /*fhirVersion*/  return new Property("fhirVersion", "id", "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 3.0.2 for this version.", 0, 1, fhirVersion);
2686        case 837556430: /*mapping*/  return new Property("mapping", "", "An external specification that the content is mapped to.", 0, java.lang.Integer.MAX_VALUE, mapping);
2687        case 3292052: /*kind*/  return new Property("kind", "code", "Defines the kind of structure that this definition is describing.", 0, 1, kind);
2688        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_);
2689        case -102839927: /*contextType*/  return new Property("contextType", "code", "If this is an extension, Identifies the context within FHIR resources where the extension can be used.", 0, 1, contextType);
2690        case 951530927: /*context*/  return new Property("context", "string", "Identifies the types of resource or data type elements to which the extension can be applied.", 0, java.lang.Integer.MAX_VALUE, context);
2691        case -802505007: /*contextInvariant*/  return new Property("contextInvariant", "string", "A set of rules as Fluent Invariants about when the extension can be used (e.g. co-occurrence variants for the extension).", 0, java.lang.Integer.MAX_VALUE, contextInvariant);
2692        case 3575610: /*type*/  return new Property("type", "code", "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).", 0, 1, type);
2693        case 1139771140: /*baseDefinition*/  return new Property("baseDefinition", "uri", "An absolute URI that is the base structure from which this type is derived, either by specialization or constraint.", 0, 1, baseDefinition);
2694        case -1353885513: /*derivation*/  return new Property("derivation", "code", "How the type relates to the baseDefinition.", 0, 1, derivation);
2695        case 284874180: /*snapshot*/  return new Property("snapshot", "", "A snapshot view is expressed in a stand alone form that can be used and interpreted without considering the base StructureDefinition.", 0, 1, snapshot);
2696        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);
2697        default: return super.getNamedProperty(_hash, _name, _checkValid);
2698        }
2699
2700      }
2701
2702      @Override
2703      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2704        switch (hash) {
2705        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType
2706        case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier
2707        case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType
2708        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
2709        case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType
2710        case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<PublicationStatus>
2711        case -404562712: /*experimental*/ return this.experimental == null ? new Base[0] : new Base[] {this.experimental}; // BooleanType
2712        case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType
2713        case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType
2714        case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail
2715        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType
2716        case -669707736: /*useContext*/ return this.useContext == null ? new Base[0] : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext
2717        case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept
2718        case -220463842: /*purpose*/ return this.purpose == null ? new Base[0] : new Base[] {this.purpose}; // MarkdownType
2719        case 1522889671: /*copyright*/ return this.copyright == null ? new Base[0] : new Base[] {this.copyright}; // MarkdownType
2720        case -814408215: /*keyword*/ return this.keyword == null ? new Base[0] : this.keyword.toArray(new Base[this.keyword.size()]); // Coding
2721        case 461006061: /*fhirVersion*/ return this.fhirVersion == null ? new Base[0] : new Base[] {this.fhirVersion}; // IdType
2722        case 837556430: /*mapping*/ return this.mapping == null ? new Base[0] : this.mapping.toArray(new Base[this.mapping.size()]); // StructureDefinitionMappingComponent
2723        case 3292052: /*kind*/ return this.kind == null ? new Base[0] : new Base[] {this.kind}; // Enumeration<StructureDefinitionKind>
2724        case 1732898850: /*abstract*/ return this.abstract_ == null ? new Base[0] : new Base[] {this.abstract_}; // BooleanType
2725        case -102839927: /*contextType*/ return this.contextType == null ? new Base[0] : new Base[] {this.contextType}; // Enumeration<ExtensionContext>
2726        case 951530927: /*context*/ return this.context == null ? new Base[0] : this.context.toArray(new Base[this.context.size()]); // StringType
2727        case -802505007: /*contextInvariant*/ return this.contextInvariant == null ? new Base[0] : this.contextInvariant.toArray(new Base[this.contextInvariant.size()]); // StringType
2728        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // CodeType
2729        case 1139771140: /*baseDefinition*/ return this.baseDefinition == null ? new Base[0] : new Base[] {this.baseDefinition}; // UriType
2730        case -1353885513: /*derivation*/ return this.derivation == null ? new Base[0] : new Base[] {this.derivation}; // Enumeration<TypeDerivationRule>
2731        case 284874180: /*snapshot*/ return this.snapshot == null ? new Base[0] : new Base[] {this.snapshot}; // StructureDefinitionSnapshotComponent
2732        case -1196150917: /*differential*/ return this.differential == null ? new Base[0] : new Base[] {this.differential}; // StructureDefinitionDifferentialComponent
2733        default: return super.getProperty(hash, name, checkValid);
2734        }
2735
2736      }
2737
2738      @Override
2739      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2740        switch (hash) {
2741        case 116079: // url
2742          this.url = castToUri(value); // UriType
2743          return value;
2744        case -1618432855: // identifier
2745          this.getIdentifier().add(castToIdentifier(value)); // Identifier
2746          return value;
2747        case 351608024: // version
2748          this.version = castToString(value); // StringType
2749          return value;
2750        case 3373707: // name
2751          this.name = castToString(value); // StringType
2752          return value;
2753        case 110371416: // title
2754          this.title = castToString(value); // StringType
2755          return value;
2756        case -892481550: // status
2757          value = new PublicationStatusEnumFactory().fromType(castToCode(value));
2758          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
2759          return value;
2760        case -404562712: // experimental
2761          this.experimental = castToBoolean(value); // BooleanType
2762          return value;
2763        case 3076014: // date
2764          this.date = castToDateTime(value); // DateTimeType
2765          return value;
2766        case 1447404028: // publisher
2767          this.publisher = castToString(value); // StringType
2768          return value;
2769        case 951526432: // contact
2770          this.getContact().add(castToContactDetail(value)); // ContactDetail
2771          return value;
2772        case -1724546052: // description
2773          this.description = castToMarkdown(value); // MarkdownType
2774          return value;
2775        case -669707736: // useContext
2776          this.getUseContext().add(castToUsageContext(value)); // UsageContext
2777          return value;
2778        case -507075711: // jurisdiction
2779          this.getJurisdiction().add(castToCodeableConcept(value)); // CodeableConcept
2780          return value;
2781        case -220463842: // purpose
2782          this.purpose = castToMarkdown(value); // MarkdownType
2783          return value;
2784        case 1522889671: // copyright
2785          this.copyright = castToMarkdown(value); // MarkdownType
2786          return value;
2787        case -814408215: // keyword
2788          this.getKeyword().add(castToCoding(value)); // Coding
2789          return value;
2790        case 461006061: // fhirVersion
2791          this.fhirVersion = castToId(value); // IdType
2792          return value;
2793        case 837556430: // mapping
2794          this.getMapping().add((StructureDefinitionMappingComponent) value); // StructureDefinitionMappingComponent
2795          return value;
2796        case 3292052: // kind
2797          value = new StructureDefinitionKindEnumFactory().fromType(castToCode(value));
2798          this.kind = (Enumeration) value; // Enumeration<StructureDefinitionKind>
2799          return value;
2800        case 1732898850: // abstract
2801          this.abstract_ = castToBoolean(value); // BooleanType
2802          return value;
2803        case -102839927: // contextType
2804          value = new ExtensionContextEnumFactory().fromType(castToCode(value));
2805          this.contextType = (Enumeration) value; // Enumeration<ExtensionContext>
2806          return value;
2807        case 951530927: // context
2808          this.getContext().add(castToString(value)); // StringType
2809          return value;
2810        case -802505007: // contextInvariant
2811          this.getContextInvariant().add(castToString(value)); // StringType
2812          return value;
2813        case 3575610: // type
2814          this.type = castToCode(value); // CodeType
2815          return value;
2816        case 1139771140: // baseDefinition
2817          this.baseDefinition = castToUri(value); // UriType
2818          return value;
2819        case -1353885513: // derivation
2820          value = new TypeDerivationRuleEnumFactory().fromType(castToCode(value));
2821          this.derivation = (Enumeration) value; // Enumeration<TypeDerivationRule>
2822          return value;
2823        case 284874180: // snapshot
2824          this.snapshot = (StructureDefinitionSnapshotComponent) value; // StructureDefinitionSnapshotComponent
2825          return value;
2826        case -1196150917: // differential
2827          this.differential = (StructureDefinitionDifferentialComponent) value; // StructureDefinitionDifferentialComponent
2828          return value;
2829        default: return super.setProperty(hash, name, value);
2830        }
2831
2832      }
2833
2834      @Override
2835      public Base setProperty(String name, Base value) throws FHIRException {
2836        if (name.equals("url")) {
2837          this.url = castToUri(value); // UriType
2838        } else if (name.equals("identifier")) {
2839          this.getIdentifier().add(castToIdentifier(value));
2840        } else if (name.equals("version")) {
2841          this.version = castToString(value); // StringType
2842        } else if (name.equals("name")) {
2843          this.name = castToString(value); // StringType
2844        } else if (name.equals("title")) {
2845          this.title = castToString(value); // StringType
2846        } else if (name.equals("status")) {
2847          value = new PublicationStatusEnumFactory().fromType(castToCode(value));
2848          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
2849        } else if (name.equals("experimental")) {
2850          this.experimental = castToBoolean(value); // BooleanType
2851        } else if (name.equals("date")) {
2852          this.date = castToDateTime(value); // DateTimeType
2853        } else if (name.equals("publisher")) {
2854          this.publisher = castToString(value); // StringType
2855        } else if (name.equals("contact")) {
2856          this.getContact().add(castToContactDetail(value));
2857        } else if (name.equals("description")) {
2858          this.description = castToMarkdown(value); // MarkdownType
2859        } else if (name.equals("useContext")) {
2860          this.getUseContext().add(castToUsageContext(value));
2861        } else if (name.equals("jurisdiction")) {
2862          this.getJurisdiction().add(castToCodeableConcept(value));
2863        } else if (name.equals("purpose")) {
2864          this.purpose = castToMarkdown(value); // MarkdownType
2865        } else if (name.equals("copyright")) {
2866          this.copyright = castToMarkdown(value); // MarkdownType
2867        } else if (name.equals("keyword")) {
2868          this.getKeyword().add(castToCoding(value));
2869        } else if (name.equals("fhirVersion")) {
2870          this.fhirVersion = castToId(value); // IdType
2871        } else if (name.equals("mapping")) {
2872          this.getMapping().add((StructureDefinitionMappingComponent) value);
2873        } else if (name.equals("kind")) {
2874          value = new StructureDefinitionKindEnumFactory().fromType(castToCode(value));
2875          this.kind = (Enumeration) value; // Enumeration<StructureDefinitionKind>
2876        } else if (name.equals("abstract")) {
2877          this.abstract_ = castToBoolean(value); // BooleanType
2878        } else if (name.equals("contextType")) {
2879          value = new ExtensionContextEnumFactory().fromType(castToCode(value));
2880          this.contextType = (Enumeration) value; // Enumeration<ExtensionContext>
2881        } else if (name.equals("context")) {
2882          this.getContext().add(castToString(value));
2883        } else if (name.equals("contextInvariant")) {
2884          this.getContextInvariant().add(castToString(value));
2885        } else if (name.equals("type")) {
2886          this.type = castToCode(value); // CodeType
2887        } else if (name.equals("baseDefinition")) {
2888          this.baseDefinition = castToUri(value); // UriType
2889        } else if (name.equals("derivation")) {
2890          value = new TypeDerivationRuleEnumFactory().fromType(castToCode(value));
2891          this.derivation = (Enumeration) value; // Enumeration<TypeDerivationRule>
2892        } else if (name.equals("snapshot")) {
2893          this.snapshot = (StructureDefinitionSnapshotComponent) value; // StructureDefinitionSnapshotComponent
2894        } else if (name.equals("differential")) {
2895          this.differential = (StructureDefinitionDifferentialComponent) value; // StructureDefinitionDifferentialComponent
2896        } else
2897          return super.setProperty(name, value);
2898        return value;
2899      }
2900
2901      @Override
2902      public Base makeProperty(int hash, String name) throws FHIRException {
2903        switch (hash) {
2904        case 116079:  return getUrlElement();
2905        case -1618432855:  return addIdentifier(); 
2906        case 351608024:  return getVersionElement();
2907        case 3373707:  return getNameElement();
2908        case 110371416:  return getTitleElement();
2909        case -892481550:  return getStatusElement();
2910        case -404562712:  return getExperimentalElement();
2911        case 3076014:  return getDateElement();
2912        case 1447404028:  return getPublisherElement();
2913        case 951526432:  return addContact(); 
2914        case -1724546052:  return getDescriptionElement();
2915        case -669707736:  return addUseContext(); 
2916        case -507075711:  return addJurisdiction(); 
2917        case -220463842:  return getPurposeElement();
2918        case 1522889671:  return getCopyrightElement();
2919        case -814408215:  return addKeyword(); 
2920        case 461006061:  return getFhirVersionElement();
2921        case 837556430:  return addMapping(); 
2922        case 3292052:  return getKindElement();
2923        case 1732898850:  return getAbstractElement();
2924        case -102839927:  return getContextTypeElement();
2925        case 951530927:  return addContextElement();
2926        case -802505007:  return addContextInvariantElement();
2927        case 3575610:  return getTypeElement();
2928        case 1139771140:  return getBaseDefinitionElement();
2929        case -1353885513:  return getDerivationElement();
2930        case 284874180:  return getSnapshot(); 
2931        case -1196150917:  return getDifferential(); 
2932        default: return super.makeProperty(hash, name);
2933        }
2934
2935      }
2936
2937      @Override
2938      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2939        switch (hash) {
2940        case 116079: /*url*/ return new String[] {"uri"};
2941        case -1618432855: /*identifier*/ return new String[] {"Identifier"};
2942        case 351608024: /*version*/ return new String[] {"string"};
2943        case 3373707: /*name*/ return new String[] {"string"};
2944        case 110371416: /*title*/ return new String[] {"string"};
2945        case -892481550: /*status*/ return new String[] {"code"};
2946        case -404562712: /*experimental*/ return new String[] {"boolean"};
2947        case 3076014: /*date*/ return new String[] {"dateTime"};
2948        case 1447404028: /*publisher*/ return new String[] {"string"};
2949        case 951526432: /*contact*/ return new String[] {"ContactDetail"};
2950        case -1724546052: /*description*/ return new String[] {"markdown"};
2951        case -669707736: /*useContext*/ return new String[] {"UsageContext"};
2952        case -507075711: /*jurisdiction*/ return new String[] {"CodeableConcept"};
2953        case -220463842: /*purpose*/ return new String[] {"markdown"};
2954        case 1522889671: /*copyright*/ return new String[] {"markdown"};
2955        case -814408215: /*keyword*/ return new String[] {"Coding"};
2956        case 461006061: /*fhirVersion*/ return new String[] {"id"};
2957        case 837556430: /*mapping*/ return new String[] {};
2958        case 3292052: /*kind*/ return new String[] {"code"};
2959        case 1732898850: /*abstract*/ return new String[] {"boolean"};
2960        case -102839927: /*contextType*/ return new String[] {"code"};
2961        case 951530927: /*context*/ return new String[] {"string"};
2962        case -802505007: /*contextInvariant*/ return new String[] {"string"};
2963        case 3575610: /*type*/ return new String[] {"code"};
2964        case 1139771140: /*baseDefinition*/ return new String[] {"uri"};
2965        case -1353885513: /*derivation*/ return new String[] {"code"};
2966        case 284874180: /*snapshot*/ return new String[] {};
2967        case -1196150917: /*differential*/ return new String[] {};
2968        default: return super.getTypesForProperty(hash, name);
2969        }
2970
2971      }
2972
2973      @Override
2974      public Base addChild(String name) throws FHIRException {
2975        if (name.equals("url")) {
2976          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.url");
2977        }
2978        else if (name.equals("identifier")) {
2979          return addIdentifier();
2980        }
2981        else if (name.equals("version")) {
2982          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.version");
2983        }
2984        else if (name.equals("name")) {
2985          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.name");
2986        }
2987        else if (name.equals("title")) {
2988          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.title");
2989        }
2990        else if (name.equals("status")) {
2991          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.status");
2992        }
2993        else if (name.equals("experimental")) {
2994          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.experimental");
2995        }
2996        else if (name.equals("date")) {
2997          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.date");
2998        }
2999        else if (name.equals("publisher")) {
3000          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.publisher");
3001        }
3002        else if (name.equals("contact")) {
3003          return addContact();
3004        }
3005        else if (name.equals("description")) {
3006          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.description");
3007        }
3008        else if (name.equals("useContext")) {
3009          return addUseContext();
3010        }
3011        else if (name.equals("jurisdiction")) {
3012          return addJurisdiction();
3013        }
3014        else if (name.equals("purpose")) {
3015          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.purpose");
3016        }
3017        else if (name.equals("copyright")) {
3018          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.copyright");
3019        }
3020        else if (name.equals("keyword")) {
3021          return addKeyword();
3022        }
3023        else if (name.equals("fhirVersion")) {
3024          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.fhirVersion");
3025        }
3026        else if (name.equals("mapping")) {
3027          return addMapping();
3028        }
3029        else if (name.equals("kind")) {
3030          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.kind");
3031        }
3032        else if (name.equals("abstract")) {
3033          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.abstract");
3034        }
3035        else if (name.equals("contextType")) {
3036          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.contextType");
3037        }
3038        else if (name.equals("context")) {
3039          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.context");
3040        }
3041        else if (name.equals("contextInvariant")) {
3042          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.contextInvariant");
3043        }
3044        else if (name.equals("type")) {
3045          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.type");
3046        }
3047        else if (name.equals("baseDefinition")) {
3048          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.baseDefinition");
3049        }
3050        else if (name.equals("derivation")) {
3051          throw new FHIRException("Cannot call addChild on a primitive type StructureDefinition.derivation");
3052        }
3053        else if (name.equals("snapshot")) {
3054          this.snapshot = new StructureDefinitionSnapshotComponent();
3055          return this.snapshot;
3056        }
3057        else if (name.equals("differential")) {
3058          this.differential = new StructureDefinitionDifferentialComponent();
3059          return this.differential;
3060        }
3061        else
3062          return super.addChild(name);
3063      }
3064
3065  public String fhirType() {
3066    return "StructureDefinition";
3067
3068  }
3069
3070      public StructureDefinition copy() {
3071        StructureDefinition dst = new StructureDefinition();
3072        copyValues(dst);
3073        dst.url = url == null ? null : url.copy();
3074        if (identifier != null) {
3075          dst.identifier = new ArrayList<Identifier>();
3076          for (Identifier i : identifier)
3077            dst.identifier.add(i.copy());
3078        };
3079        dst.version = version == null ? null : version.copy();
3080        dst.name = name == null ? null : name.copy();
3081        dst.title = title == null ? null : title.copy();
3082        dst.status = status == null ? null : status.copy();
3083        dst.experimental = experimental == null ? null : experimental.copy();
3084        dst.date = date == null ? null : date.copy();
3085        dst.publisher = publisher == null ? null : publisher.copy();
3086        if (contact != null) {
3087          dst.contact = new ArrayList<ContactDetail>();
3088          for (ContactDetail i : contact)
3089            dst.contact.add(i.copy());
3090        };
3091        dst.description = description == null ? null : description.copy();
3092        if (useContext != null) {
3093          dst.useContext = new ArrayList<UsageContext>();
3094          for (UsageContext i : useContext)
3095            dst.useContext.add(i.copy());
3096        };
3097        if (jurisdiction != null) {
3098          dst.jurisdiction = new ArrayList<CodeableConcept>();
3099          for (CodeableConcept i : jurisdiction)
3100            dst.jurisdiction.add(i.copy());
3101        };
3102        dst.purpose = purpose == null ? null : purpose.copy();
3103        dst.copyright = copyright == null ? null : copyright.copy();
3104        if (keyword != null) {
3105          dst.keyword = new ArrayList<Coding>();
3106          for (Coding i : keyword)
3107            dst.keyword.add(i.copy());
3108        };
3109        dst.fhirVersion = fhirVersion == null ? null : fhirVersion.copy();
3110        if (mapping != null) {
3111          dst.mapping = new ArrayList<StructureDefinitionMappingComponent>();
3112          for (StructureDefinitionMappingComponent i : mapping)
3113            dst.mapping.add(i.copy());
3114        };
3115        dst.kind = kind == null ? null : kind.copy();
3116        dst.abstract_ = abstract_ == null ? null : abstract_.copy();
3117        dst.contextType = contextType == null ? null : contextType.copy();
3118        if (context != null) {
3119          dst.context = new ArrayList<StringType>();
3120          for (StringType i : context)
3121            dst.context.add(i.copy());
3122        };
3123        if (contextInvariant != null) {
3124          dst.contextInvariant = new ArrayList<StringType>();
3125          for (StringType i : contextInvariant)
3126            dst.contextInvariant.add(i.copy());
3127        };
3128        dst.type = type == null ? null : type.copy();
3129        dst.baseDefinition = baseDefinition == null ? null : baseDefinition.copy();
3130        dst.derivation = derivation == null ? null : derivation.copy();
3131        dst.snapshot = snapshot == null ? null : snapshot.copy();
3132        dst.differential = differential == null ? null : differential.copy();
3133        return dst;
3134      }
3135
3136      protected StructureDefinition typedCopy() {
3137        return copy();
3138      }
3139
3140      @Override
3141      public boolean equalsDeep(Base other_) {
3142        if (!super.equalsDeep(other_))
3143          return false;
3144        if (!(other_ instanceof StructureDefinition))
3145          return false;
3146        StructureDefinition o = (StructureDefinition) other_;
3147        return compareDeep(identifier, o.identifier, true) && compareDeep(purpose, o.purpose, true) && compareDeep(copyright, o.copyright, true)
3148           && compareDeep(keyword, o.keyword, true) && compareDeep(fhirVersion, o.fhirVersion, true) && compareDeep(mapping, o.mapping, true)
3149           && compareDeep(kind, o.kind, true) && compareDeep(abstract_, o.abstract_, true) && compareDeep(contextType, o.contextType, true)
3150           && compareDeep(context, o.context, true) && compareDeep(contextInvariant, o.contextInvariant, true)
3151           && compareDeep(type, o.type, true) && compareDeep(baseDefinition, o.baseDefinition, true) && compareDeep(derivation, o.derivation, true)
3152           && compareDeep(snapshot, o.snapshot, true) && compareDeep(differential, o.differential, true);
3153      }
3154
3155      @Override
3156      public boolean equalsShallow(Base other_) {
3157        if (!super.equalsShallow(other_))
3158          return false;
3159        if (!(other_ instanceof StructureDefinition))
3160          return false;
3161        StructureDefinition o = (StructureDefinition) other_;
3162        return compareValues(purpose, o.purpose, true) && compareValues(copyright, o.copyright, true) && compareValues(fhirVersion, o.fhirVersion, true)
3163           && compareValues(kind, o.kind, true) && compareValues(abstract_, o.abstract_, true) && compareValues(contextType, o.contextType, true)
3164           && compareValues(context, o.context, true) && compareValues(contextInvariant, o.contextInvariant, true)
3165           && compareValues(type, o.type, true) && compareValues(baseDefinition, o.baseDefinition, true) && compareValues(derivation, o.derivation, true)
3166          ;
3167      }
3168
3169      public boolean isEmpty() {
3170        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, purpose, copyright
3171          , keyword, fhirVersion, mapping, kind, abstract_, contextType, context, contextInvariant
3172          , type, baseDefinition, derivation, snapshot, differential);
3173      }
3174
3175  @Override
3176  public ResourceType getResourceType() {
3177    return ResourceType.StructureDefinition;
3178   }
3179
3180 /**
3181   * Search parameter: <b>date</b>
3182   * <p>
3183   * Description: <b>The structure definition publication date</b><br>
3184   * Type: <b>date</b><br>
3185   * Path: <b>StructureDefinition.date</b><br>
3186   * </p>
3187   */
3188  @SearchParamDefinition(name="date", path="StructureDefinition.date", description="The structure definition publication date", type="date" )
3189  public static final String SP_DATE = "date";
3190 /**
3191   * <b>Fluent Client</b> search parameter constant for <b>date</b>
3192   * <p>
3193   * Description: <b>The structure definition publication date</b><br>
3194   * Type: <b>date</b><br>
3195   * Path: <b>StructureDefinition.date</b><br>
3196   * </p>
3197   */
3198  public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE);
3199
3200 /**
3201   * Search parameter: <b>identifier</b>
3202   * <p>
3203   * Description: <b>External identifier for the structure definition</b><br>
3204   * Type: <b>token</b><br>
3205   * Path: <b>StructureDefinition.identifier</b><br>
3206   * </p>
3207   */
3208  @SearchParamDefinition(name="identifier", path="StructureDefinition.identifier", description="External identifier for the structure definition", type="token" )
3209  public static final String SP_IDENTIFIER = "identifier";
3210 /**
3211   * <b>Fluent Client</b> search parameter constant for <b>identifier</b>
3212   * <p>
3213   * Description: <b>External identifier for the structure definition</b><br>
3214   * Type: <b>token</b><br>
3215   * Path: <b>StructureDefinition.identifier</b><br>
3216   * </p>
3217   */
3218  public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER);
3219
3220 /**
3221   * Search parameter: <b>valueset</b>
3222   * <p>
3223   * Description: <b>A vocabulary binding reference</b><br>
3224   * Type: <b>reference</b><br>
3225   * Path: <b>StructureDefinition.snapshot.element.binding.valueSet[x]</b><br>
3226   * </p>
3227   */
3228  @SearchParamDefinition(name="valueset", path="StructureDefinition.snapshot.element.binding.valueSet", description="A vocabulary binding reference", type="reference", target={ValueSet.class } )
3229  public static final String SP_VALUESET = "valueset";
3230 /**
3231   * <b>Fluent Client</b> search parameter constant for <b>valueset</b>
3232   * <p>
3233   * Description: <b>A vocabulary binding reference</b><br>
3234   * Type: <b>reference</b><br>
3235   * Path: <b>StructureDefinition.snapshot.element.binding.valueSet[x]</b><br>
3236   * </p>
3237   */
3238  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam VALUESET = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_VALUESET);
3239
3240/**
3241   * Constant for fluent queries to be used to add include statements. Specifies
3242   * the path value of "<b>StructureDefinition:valueset</b>".
3243   */
3244  public static final ca.uhn.fhir.model.api.Include INCLUDE_VALUESET = new ca.uhn.fhir.model.api.Include("StructureDefinition:valueset").toLocked();
3245
3246 /**
3247   * Search parameter: <b>kind</b>
3248   * <p>
3249   * Description: <b>primitive-type | complex-type | resource | logical</b><br>
3250   * Type: <b>token</b><br>
3251   * Path: <b>StructureDefinition.kind</b><br>
3252   * </p>
3253   */
3254  @SearchParamDefinition(name="kind", path="StructureDefinition.kind", description="primitive-type | complex-type | resource | logical", type="token" )
3255  public static final String SP_KIND = "kind";
3256 /**
3257   * <b>Fluent Client</b> search parameter constant for <b>kind</b>
3258   * <p>
3259   * Description: <b>primitive-type | complex-type | resource | logical</b><br>
3260   * Type: <b>token</b><br>
3261   * Path: <b>StructureDefinition.kind</b><br>
3262   * </p>
3263   */
3264  public static final ca.uhn.fhir.rest.gclient.TokenClientParam KIND = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_KIND);
3265
3266 /**
3267   * Search parameter: <b>jurisdiction</b>
3268   * <p>
3269   * Description: <b>Intended jurisdiction for the structure definition</b><br>
3270   * Type: <b>token</b><br>
3271   * Path: <b>StructureDefinition.jurisdiction</b><br>
3272   * </p>
3273   */
3274  @SearchParamDefinition(name="jurisdiction", path="StructureDefinition.jurisdiction", description="Intended jurisdiction for the structure definition", type="token" )
3275  public static final String SP_JURISDICTION = "jurisdiction";
3276 /**
3277   * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b>
3278   * <p>
3279   * Description: <b>Intended jurisdiction for the structure definition</b><br>
3280   * Type: <b>token</b><br>
3281   * Path: <b>StructureDefinition.jurisdiction</b><br>
3282   * </p>
3283   */
3284  public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_JURISDICTION);
3285
3286 /**
3287   * Search parameter: <b>description</b>
3288   * <p>
3289   * Description: <b>The description of the structure definition</b><br>
3290   * Type: <b>string</b><br>
3291   * Path: <b>StructureDefinition.description</b><br>
3292   * </p>
3293   */
3294  @SearchParamDefinition(name="description", path="StructureDefinition.description", description="The description of the structure definition", type="string" )
3295  public static final String SP_DESCRIPTION = "description";
3296 /**
3297   * <b>Fluent Client</b> search parameter constant for <b>description</b>
3298   * <p>
3299   * Description: <b>The description of the structure definition</b><br>
3300   * Type: <b>string</b><br>
3301   * Path: <b>StructureDefinition.description</b><br>
3302   * </p>
3303   */
3304  public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION);
3305
3306 /**
3307   * Search parameter: <b>experimental</b>
3308   * <p>
3309   * Description: <b>For testing purposes, not real usage</b><br>
3310   * Type: <b>token</b><br>
3311   * Path: <b>StructureDefinition.experimental</b><br>
3312   * </p>
3313   */
3314  @SearchParamDefinition(name="experimental", path="StructureDefinition.experimental", description="For testing purposes, not real usage", type="token" )
3315  public static final String SP_EXPERIMENTAL = "experimental";
3316 /**
3317   * <b>Fluent Client</b> search parameter constant for <b>experimental</b>
3318   * <p>
3319   * Description: <b>For testing purposes, not real usage</b><br>
3320   * Type: <b>token</b><br>
3321   * Path: <b>StructureDefinition.experimental</b><br>
3322   * </p>
3323   */
3324  public static final ca.uhn.fhir.rest.gclient.TokenClientParam EXPERIMENTAL = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_EXPERIMENTAL);
3325
3326 /**
3327   * Search parameter: <b>context-type</b>
3328   * <p>
3329   * Description: <b>resource | datatype | extension</b><br>
3330   * Type: <b>token</b><br>
3331   * Path: <b>StructureDefinition.contextType</b><br>
3332   * </p>
3333   */
3334  @SearchParamDefinition(name="context-type", path="StructureDefinition.contextType", description="resource | datatype | extension", type="token" )
3335  public static final String SP_CONTEXT_TYPE = "context-type";
3336 /**
3337   * <b>Fluent Client</b> search parameter constant for <b>context-type</b>
3338   * <p>
3339   * Description: <b>resource | datatype | extension</b><br>
3340   * Type: <b>token</b><br>
3341   * Path: <b>StructureDefinition.contextType</b><br>
3342   * </p>
3343   */
3344  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT_TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT_TYPE);
3345
3346 /**
3347   * Search parameter: <b>abstract</b>
3348   * <p>
3349   * Description: <b>Whether the structure is abstract</b><br>
3350   * Type: <b>token</b><br>
3351   * Path: <b>StructureDefinition.abstract</b><br>
3352   * </p>
3353   */
3354  @SearchParamDefinition(name="abstract", path="StructureDefinition.abstract", description="Whether the structure is abstract", type="token" )
3355  public static final String SP_ABSTRACT = "abstract";
3356 /**
3357   * <b>Fluent Client</b> search parameter constant for <b>abstract</b>
3358   * <p>
3359   * Description: <b>Whether the structure is abstract</b><br>
3360   * Type: <b>token</b><br>
3361   * Path: <b>StructureDefinition.abstract</b><br>
3362   * </p>
3363   */
3364  public static final ca.uhn.fhir.rest.gclient.TokenClientParam ABSTRACT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_ABSTRACT);
3365
3366 /**
3367   * Search parameter: <b>title</b>
3368   * <p>
3369   * Description: <b>The human-friendly name of the structure definition</b><br>
3370   * Type: <b>string</b><br>
3371   * Path: <b>StructureDefinition.title</b><br>
3372   * </p>
3373   */
3374  @SearchParamDefinition(name="title", path="StructureDefinition.title", description="The human-friendly name of the structure definition", type="string" )
3375  public static final String SP_TITLE = "title";
3376 /**
3377   * <b>Fluent Client</b> search parameter constant for <b>title</b>
3378   * <p>
3379   * Description: <b>The human-friendly name of the structure definition</b><br>
3380   * Type: <b>string</b><br>
3381   * Path: <b>StructureDefinition.title</b><br>
3382   * </p>
3383   */
3384  public static final ca.uhn.fhir.rest.gclient.StringClientParam TITLE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_TITLE);
3385
3386 /**
3387   * Search parameter: <b>type</b>
3388   * <p>
3389   * Description: <b>Type defined or constrained by this structure</b><br>
3390   * Type: <b>token</b><br>
3391   * Path: <b>StructureDefinition.type</b><br>
3392   * </p>
3393   */
3394  @SearchParamDefinition(name="type", path="StructureDefinition.type", description="Type defined or constrained by this structure", type="token" )
3395  public static final String SP_TYPE = "type";
3396 /**
3397   * <b>Fluent Client</b> search parameter constant for <b>type</b>
3398   * <p>
3399   * Description: <b>Type defined or constrained by this structure</b><br>
3400   * Type: <b>token</b><br>
3401   * Path: <b>StructureDefinition.type</b><br>
3402   * </p>
3403   */
3404  public static final ca.uhn.fhir.rest.gclient.TokenClientParam TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_TYPE);
3405
3406 /**
3407   * Search parameter: <b>version</b>
3408   * <p>
3409   * Description: <b>The business version of the structure definition</b><br>
3410   * Type: <b>token</b><br>
3411   * Path: <b>StructureDefinition.version</b><br>
3412   * </p>
3413   */
3414  @SearchParamDefinition(name="version", path="StructureDefinition.version", description="The business version of the structure definition", type="token" )
3415  public static final String SP_VERSION = "version";
3416 /**
3417   * <b>Fluent Client</b> search parameter constant for <b>version</b>
3418   * <p>
3419   * Description: <b>The business version of the structure definition</b><br>
3420   * Type: <b>token</b><br>
3421   * Path: <b>StructureDefinition.version</b><br>
3422   * </p>
3423   */
3424  public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VERSION);
3425
3426 /**
3427   * Search parameter: <b>url</b>
3428   * <p>
3429   * Description: <b>The uri that identifies the structure definition</b><br>
3430   * Type: <b>uri</b><br>
3431   * Path: <b>StructureDefinition.url</b><br>
3432   * </p>
3433   */
3434  @SearchParamDefinition(name="url", path="StructureDefinition.url", description="The uri that identifies the structure definition", type="uri" )
3435  public static final String SP_URL = "url";
3436 /**
3437   * <b>Fluent Client</b> search parameter constant for <b>url</b>
3438   * <p>
3439   * Description: <b>The uri that identifies the structure definition</b><br>
3440   * Type: <b>uri</b><br>
3441   * Path: <b>StructureDefinition.url</b><br>
3442   * </p>
3443   */
3444  public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL);
3445
3446 /**
3447   * Search parameter: <b>path</b>
3448   * <p>
3449   * Description: <b>A path that is constrained in the profile</b><br>
3450   * Type: <b>token</b><br>
3451   * Path: <b>StructureDefinition.snapshot.element.path, StructureDefinition.differential.element.path</b><br>
3452   * </p>
3453   */
3454  @SearchParamDefinition(name="path", path="StructureDefinition.snapshot.element.path | StructureDefinition.differential.element.path", description="A path that is constrained in the profile", type="token" )
3455  public static final String SP_PATH = "path";
3456 /**
3457   * <b>Fluent Client</b> search parameter constant for <b>path</b>
3458   * <p>
3459   * Description: <b>A path that is constrained in the profile</b><br>
3460   * Type: <b>token</b><br>
3461   * Path: <b>StructureDefinition.snapshot.element.path, StructureDefinition.differential.element.path</b><br>
3462   * </p>
3463   */
3464  public static final ca.uhn.fhir.rest.gclient.TokenClientParam PATH = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_PATH);
3465
3466 /**
3467   * Search parameter: <b>ext-context</b>
3468   * <p>
3469   * Description: <b>Where the extension can be used in instances</b><br>
3470   * Type: <b>string</b><br>
3471   * Path: <b>StructureDefinition.context</b><br>
3472   * </p>
3473   */
3474  @SearchParamDefinition(name="ext-context", path="StructureDefinition.context", description="Where the extension can be used in instances", type="string" )
3475  public static final String SP_EXT_CONTEXT = "ext-context";
3476 /**
3477   * <b>Fluent Client</b> search parameter constant for <b>ext-context</b>
3478   * <p>
3479   * Description: <b>Where the extension can be used in instances</b><br>
3480   * Type: <b>string</b><br>
3481   * Path: <b>StructureDefinition.context</b><br>
3482   * </p>
3483   */
3484  public static final ca.uhn.fhir.rest.gclient.StringClientParam EXT_CONTEXT = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_EXT_CONTEXT);
3485
3486 /**
3487   * Search parameter: <b>name</b>
3488   * <p>
3489   * Description: <b>Computationally friendly name of the structure definition</b><br>
3490   * Type: <b>string</b><br>
3491   * Path: <b>StructureDefinition.name</b><br>
3492   * </p>
3493   */
3494  @SearchParamDefinition(name="name", path="StructureDefinition.name", description="Computationally friendly name of the structure definition", type="string" )
3495  public static final String SP_NAME = "name";
3496 /**
3497   * <b>Fluent Client</b> search parameter constant for <b>name</b>
3498   * <p>
3499   * Description: <b>Computationally friendly name of the structure definition</b><br>
3500   * Type: <b>string</b><br>
3501   * Path: <b>StructureDefinition.name</b><br>
3502   * </p>
3503   */
3504  public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME);
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>publisher</b>
3528   * <p>
3529   * Description: <b>Name of the publisher of the structure definition</b><br>
3530   * Type: <b>string</b><br>
3531   * Path: <b>StructureDefinition.publisher</b><br>
3532   * </p>
3533   */
3534  @SearchParamDefinition(name="publisher", path="StructureDefinition.publisher", description="Name of the publisher of the structure definition", type="string" )
3535  public static final String SP_PUBLISHER = "publisher";
3536 /**
3537   * <b>Fluent Client</b> search parameter constant for <b>publisher</b>
3538   * <p>
3539   * Description: <b>Name of the publisher of the structure definition</b><br>
3540   * Type: <b>string</b><br>
3541   * Path: <b>StructureDefinition.publisher</b><br>
3542   * </p>
3543   */
3544  public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_PUBLISHER);
3545
3546 /**
3547   * Search parameter: <b>derivation</b>
3548   * <p>
3549   * Description: <b>specialization | constraint - How relates to base definition</b><br>
3550   * Type: <b>token</b><br>
3551   * Path: <b>StructureDefinition.derivation</b><br>
3552   * </p>
3553   */
3554  @SearchParamDefinition(name="derivation", path="StructureDefinition.derivation", description="specialization | constraint - How relates to base definition", type="token" )
3555  public static final String SP_DERIVATION = "derivation";
3556 /**
3557   * <b>Fluent Client</b> search parameter constant for <b>derivation</b>
3558   * <p>
3559   * Description: <b>specialization | constraint - How relates to base definition</b><br>
3560   * Type: <b>token</b><br>
3561   * Path: <b>StructureDefinition.derivation</b><br>
3562   * </p>
3563   */
3564  public static final ca.uhn.fhir.rest.gclient.TokenClientParam DERIVATION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_DERIVATION);
3565
3566 /**
3567   * Search parameter: <b>keyword</b>
3568   * <p>
3569   * Description: <b>A code for the profile</b><br>
3570   * Type: <b>token</b><br>
3571   * Path: <b>StructureDefinition.keyword</b><br>
3572   * </p>
3573   */
3574  @SearchParamDefinition(name="keyword", path="StructureDefinition.keyword", description="A code for the profile", type="token" )
3575  public static final String SP_KEYWORD = "keyword";
3576 /**
3577   * <b>Fluent Client</b> search parameter constant for <b>keyword</b>
3578   * <p>
3579   * Description: <b>A code for the profile</b><br>
3580   * Type: <b>token</b><br>
3581   * Path: <b>StructureDefinition.keyword</b><br>
3582   * </p>
3583   */
3584  public static final ca.uhn.fhir.rest.gclient.TokenClientParam KEYWORD = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_KEYWORD);
3585
3586 /**
3587   * Search parameter: <b>status</b>
3588   * <p>
3589   * Description: <b>The current status of the structure definition</b><br>
3590   * Type: <b>token</b><br>
3591   * Path: <b>StructureDefinition.status</b><br>
3592   * </p>
3593   */
3594  @SearchParamDefinition(name="status", path="StructureDefinition.status", description="The current status of the structure definition", type="token" )
3595  public static final String SP_STATUS = "status";
3596 /**
3597   * <b>Fluent Client</b> search parameter constant for <b>status</b>
3598   * <p>
3599   * Description: <b>The current status of the structure definition</b><br>
3600   * Type: <b>token</b><br>
3601   * Path: <b>StructureDefinition.status</b><br>
3602   * </p>
3603   */
3604  public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS);
3605
3606 /**
3607   * Search parameter: <b>base</b>
3608   * <p>
3609   * Description: <b>Definition that this type is constrained/specialized from</b><br>
3610   * Type: <b>uri</b><br>
3611   * Path: <b>StructureDefinition.baseDefinition</b><br>
3612   * </p>
3613   */
3614  @SearchParamDefinition(name="base", path="StructureDefinition.baseDefinition", description="Definition that this type is constrained/specialized from", type="uri" )
3615  public static final String SP_BASE = "base";
3616 /**
3617   * <b>Fluent Client</b> search parameter constant for <b>base</b>
3618   * <p>
3619   * Description: <b>Definition that this type is constrained/specialized from</b><br>
3620   * Type: <b>uri</b><br>
3621   * Path: <b>StructureDefinition.baseDefinition</b><br>
3622   * </p>
3623   */
3624  public static final ca.uhn.fhir.rest.gclient.UriClientParam BASE = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_BASE);
3625
3626
3627}