001package org.hl7.fhir.dstu3.model;
002
003/*
004  Copyright (c) 2011+, HL7, Inc.
005  All rights reserved.
006  
007  Redistribution and use in source and binary forms, with or without modification, 
008  are permitted provided that the following conditions are met:
009  
010   * Redistributions of source code must retain the above copyright notice, this 
011     list of conditions and the following disclaimer.
012   * Redistributions in binary form must reproduce the above copyright notice, 
013     this list of conditions and the following disclaimer in the documentation 
014     and/or other materials provided with the distribution.
015   * Neither the name of HL7 nor the names of its contributors may be used to 
016     endorse or promote products derived from this software without specific 
017     prior written permission.
018  
019  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
020  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
021  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
022  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
023  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
024  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
025  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
026  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
027  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
028  POSSIBILITY OF SUCH DAMAGE.
029  
030*/
031
032// Generated on Fri, Mar 16, 2018 15:21+1100 for FHIR v3.0.1
033
034import java.util.*;
035
036import java.math.*;
037import org.hl7.fhir.utilities.Utilities;
038import ca.uhn.fhir.model.api.annotation.ResourceDef;
039import ca.uhn.fhir.model.api.annotation.SearchParamDefinition;
040import ca.uhn.fhir.model.api.annotation.Child;
041import ca.uhn.fhir.model.api.annotation.ChildOrder;
042import ca.uhn.fhir.model.api.annotation.Description;
043import ca.uhn.fhir.model.api.annotation.Block;
044import org.hl7.fhir.instance.model.api.*;
045import org.hl7.fhir.exceptions.FHIRException;
046import org.hl7.fhir.exceptions.FHIRFormatError;
047/**
048 * Raw data describing a biological sequence.
049 */
050@ResourceDef(name="Sequence", profile="http://hl7.org/fhir/StructureDefinition/Sequence")
051public class Sequence extends DomainResource {
052
053    public enum SequenceType {
054        /**
055         * Amino acid sequence
056         */
057        AA, 
058        /**
059         * DNA Sequence
060         */
061        DNA, 
062        /**
063         * RNA Sequence
064         */
065        RNA, 
066        /**
067         * added to help the parsers with the generic types
068         */
069        NULL;
070        public static SequenceType fromCode(String codeString) throws FHIRException {
071            if (codeString == null || "".equals(codeString))
072                return null;
073        if ("aa".equals(codeString))
074          return AA;
075        if ("dna".equals(codeString))
076          return DNA;
077        if ("rna".equals(codeString))
078          return RNA;
079        if (Configuration.isAcceptInvalidEnums())
080          return null;
081        else
082          throw new FHIRException("Unknown SequenceType code '"+codeString+"'");
083        }
084        public String toCode() {
085          switch (this) {
086            case AA: return "aa";
087            case DNA: return "dna";
088            case RNA: return "rna";
089            default: return "?";
090          }
091        }
092        public String getSystem() {
093          switch (this) {
094            case AA: return "http://hl7.org/fhir/sequence-type";
095            case DNA: return "http://hl7.org/fhir/sequence-type";
096            case RNA: return "http://hl7.org/fhir/sequence-type";
097            default: return "?";
098          }
099        }
100        public String getDefinition() {
101          switch (this) {
102            case AA: return "Amino acid sequence";
103            case DNA: return "DNA Sequence";
104            case RNA: return "RNA Sequence";
105            default: return "?";
106          }
107        }
108        public String getDisplay() {
109          switch (this) {
110            case AA: return "AA Sequence";
111            case DNA: return "DNA Sequence";
112            case RNA: return "RNA Sequence";
113            default: return "?";
114          }
115        }
116    }
117
118  public static class SequenceTypeEnumFactory implements EnumFactory<SequenceType> {
119    public SequenceType fromCode(String codeString) throws IllegalArgumentException {
120      if (codeString == null || "".equals(codeString))
121            if (codeString == null || "".equals(codeString))
122                return null;
123        if ("aa".equals(codeString))
124          return SequenceType.AA;
125        if ("dna".equals(codeString))
126          return SequenceType.DNA;
127        if ("rna".equals(codeString))
128          return SequenceType.RNA;
129        throw new IllegalArgumentException("Unknown SequenceType code '"+codeString+"'");
130        }
131        public Enumeration<SequenceType> fromType(Base code) throws FHIRException {
132          if (code == null)
133            return null;
134          if (code.isEmpty())
135            return new Enumeration<SequenceType>(this);
136          String codeString = ((PrimitiveType) code).asStringValue();
137          if (codeString == null || "".equals(codeString))
138            return null;
139        if ("aa".equals(codeString))
140          return new Enumeration<SequenceType>(this, SequenceType.AA);
141        if ("dna".equals(codeString))
142          return new Enumeration<SequenceType>(this, SequenceType.DNA);
143        if ("rna".equals(codeString))
144          return new Enumeration<SequenceType>(this, SequenceType.RNA);
145        throw new FHIRException("Unknown SequenceType code '"+codeString+"'");
146        }
147    public String toCode(SequenceType code) {
148      if (code == SequenceType.AA)
149        return "aa";
150      if (code == SequenceType.DNA)
151        return "dna";
152      if (code == SequenceType.RNA)
153        return "rna";
154      return "?";
155      }
156    public String toSystem(SequenceType code) {
157      return code.getSystem();
158      }
159    }
160
161    public enum QualityType {
162        /**
163         * INDEL Comparison
164         */
165        INDEL, 
166        /**
167         * SNP Comparison
168         */
169        SNP, 
170        /**
171         * UNKNOWN Comparison
172         */
173        UNKNOWN, 
174        /**
175         * added to help the parsers with the generic types
176         */
177        NULL;
178        public static QualityType fromCode(String codeString) throws FHIRException {
179            if (codeString == null || "".equals(codeString))
180                return null;
181        if ("indel".equals(codeString))
182          return INDEL;
183        if ("snp".equals(codeString))
184          return SNP;
185        if ("unknown".equals(codeString))
186          return UNKNOWN;
187        if (Configuration.isAcceptInvalidEnums())
188          return null;
189        else
190          throw new FHIRException("Unknown QualityType code '"+codeString+"'");
191        }
192        public String toCode() {
193          switch (this) {
194            case INDEL: return "indel";
195            case SNP: return "snp";
196            case UNKNOWN: return "unknown";
197            default: return "?";
198          }
199        }
200        public String getSystem() {
201          switch (this) {
202            case INDEL: return "http://hl7.org/fhir/quality-type";
203            case SNP: return "http://hl7.org/fhir/quality-type";
204            case UNKNOWN: return "http://hl7.org/fhir/quality-type";
205            default: return "?";
206          }
207        }
208        public String getDefinition() {
209          switch (this) {
210            case INDEL: return "INDEL Comparison";
211            case SNP: return "SNP Comparison";
212            case UNKNOWN: return "UNKNOWN Comparison";
213            default: return "?";
214          }
215        }
216        public String getDisplay() {
217          switch (this) {
218            case INDEL: return "INDEL Comparison";
219            case SNP: return "SNP Comparison";
220            case UNKNOWN: return "UNKNOWN Comparison";
221            default: return "?";
222          }
223        }
224    }
225
226  public static class QualityTypeEnumFactory implements EnumFactory<QualityType> {
227    public QualityType fromCode(String codeString) throws IllegalArgumentException {
228      if (codeString == null || "".equals(codeString))
229            if (codeString == null || "".equals(codeString))
230                return null;
231        if ("indel".equals(codeString))
232          return QualityType.INDEL;
233        if ("snp".equals(codeString))
234          return QualityType.SNP;
235        if ("unknown".equals(codeString))
236          return QualityType.UNKNOWN;
237        throw new IllegalArgumentException("Unknown QualityType code '"+codeString+"'");
238        }
239        public Enumeration<QualityType> fromType(Base code) throws FHIRException {
240          if (code == null)
241            return null;
242          if (code.isEmpty())
243            return new Enumeration<QualityType>(this);
244          String codeString = ((PrimitiveType) code).asStringValue();
245          if (codeString == null || "".equals(codeString))
246            return null;
247        if ("indel".equals(codeString))
248          return new Enumeration<QualityType>(this, QualityType.INDEL);
249        if ("snp".equals(codeString))
250          return new Enumeration<QualityType>(this, QualityType.SNP);
251        if ("unknown".equals(codeString))
252          return new Enumeration<QualityType>(this, QualityType.UNKNOWN);
253        throw new FHIRException("Unknown QualityType code '"+codeString+"'");
254        }
255    public String toCode(QualityType code) {
256      if (code == QualityType.INDEL)
257        return "indel";
258      if (code == QualityType.SNP)
259        return "snp";
260      if (code == QualityType.UNKNOWN)
261        return "unknown";
262      return "?";
263      }
264    public String toSystem(QualityType code) {
265      return code.getSystem();
266      }
267    }
268
269    public enum RepositoryType {
270        /**
271         * When URL is clicked, the resource can be seen directly (by webpage or by download link format)
272         */
273        DIRECTLINK, 
274        /**
275         * When the API method (e.g. [base_url]/[parameter]) related with the URL of the website is executed, the resource can be seen directly (usually in JSON or XML format)
276         */
277        OPENAPI, 
278        /**
279         * When logged into the website, the resource can be seen.
280         */
281        LOGIN, 
282        /**
283         * When logged in and  follow the API in the website related with URL, the resource can be seen.
284         */
285        OAUTH, 
286        /**
287         * Some other complicated or particular way to get resource from URL.
288         */
289        OTHER, 
290        /**
291         * added to help the parsers with the generic types
292         */
293        NULL;
294        public static RepositoryType fromCode(String codeString) throws FHIRException {
295            if (codeString == null || "".equals(codeString))
296                return null;
297        if ("directlink".equals(codeString))
298          return DIRECTLINK;
299        if ("openapi".equals(codeString))
300          return OPENAPI;
301        if ("login".equals(codeString))
302          return LOGIN;
303        if ("oauth".equals(codeString))
304          return OAUTH;
305        if ("other".equals(codeString))
306          return OTHER;
307        if (Configuration.isAcceptInvalidEnums())
308          return null;
309        else
310          throw new FHIRException("Unknown RepositoryType code '"+codeString+"'");
311        }
312        public String toCode() {
313          switch (this) {
314            case DIRECTLINK: return "directlink";
315            case OPENAPI: return "openapi";
316            case LOGIN: return "login";
317            case OAUTH: return "oauth";
318            case OTHER: return "other";
319            default: return "?";
320          }
321        }
322        public String getSystem() {
323          switch (this) {
324            case DIRECTLINK: return "http://hl7.org/fhir/repository-type";
325            case OPENAPI: return "http://hl7.org/fhir/repository-type";
326            case LOGIN: return "http://hl7.org/fhir/repository-type";
327            case OAUTH: return "http://hl7.org/fhir/repository-type";
328            case OTHER: return "http://hl7.org/fhir/repository-type";
329            default: return "?";
330          }
331        }
332        public String getDefinition() {
333          switch (this) {
334            case DIRECTLINK: return "When URL is clicked, the resource can be seen directly (by webpage or by download link format)";
335            case OPENAPI: return "When the API method (e.g. [base_url]/[parameter]) related with the URL of the website is executed, the resource can be seen directly (usually in JSON or XML format)";
336            case LOGIN: return "When logged into the website, the resource can be seen.";
337            case OAUTH: return "When logged in and  follow the API in the website related with URL, the resource can be seen.";
338            case OTHER: return "Some other complicated or particular way to get resource from URL.";
339            default: return "?";
340          }
341        }
342        public String getDisplay() {
343          switch (this) {
344            case DIRECTLINK: return "Click and see";
345            case OPENAPI: return "The URL is the RESTful or other kind of API that can access to the result.";
346            case LOGIN: return "Result cannot be access unless an account is logged in";
347            case OAUTH: return "Result need to be fetched with API and need LOGIN( or cookies are required when visiting the link of resource)";
348            case OTHER: return "Some other complicated or particular way to get resource from URL.";
349            default: return "?";
350          }
351        }
352    }
353
354  public static class RepositoryTypeEnumFactory implements EnumFactory<RepositoryType> {
355    public RepositoryType fromCode(String codeString) throws IllegalArgumentException {
356      if (codeString == null || "".equals(codeString))
357            if (codeString == null || "".equals(codeString))
358                return null;
359        if ("directlink".equals(codeString))
360          return RepositoryType.DIRECTLINK;
361        if ("openapi".equals(codeString))
362          return RepositoryType.OPENAPI;
363        if ("login".equals(codeString))
364          return RepositoryType.LOGIN;
365        if ("oauth".equals(codeString))
366          return RepositoryType.OAUTH;
367        if ("other".equals(codeString))
368          return RepositoryType.OTHER;
369        throw new IllegalArgumentException("Unknown RepositoryType code '"+codeString+"'");
370        }
371        public Enumeration<RepositoryType> fromType(Base code) throws FHIRException {
372          if (code == null)
373            return null;
374          if (code.isEmpty())
375            return new Enumeration<RepositoryType>(this);
376          String codeString = ((PrimitiveType) code).asStringValue();
377          if (codeString == null || "".equals(codeString))
378            return null;
379        if ("directlink".equals(codeString))
380          return new Enumeration<RepositoryType>(this, RepositoryType.DIRECTLINK);
381        if ("openapi".equals(codeString))
382          return new Enumeration<RepositoryType>(this, RepositoryType.OPENAPI);
383        if ("login".equals(codeString))
384          return new Enumeration<RepositoryType>(this, RepositoryType.LOGIN);
385        if ("oauth".equals(codeString))
386          return new Enumeration<RepositoryType>(this, RepositoryType.OAUTH);
387        if ("other".equals(codeString))
388          return new Enumeration<RepositoryType>(this, RepositoryType.OTHER);
389        throw new FHIRException("Unknown RepositoryType code '"+codeString+"'");
390        }
391    public String toCode(RepositoryType code) {
392      if (code == RepositoryType.DIRECTLINK)
393        return "directlink";
394      if (code == RepositoryType.OPENAPI)
395        return "openapi";
396      if (code == RepositoryType.LOGIN)
397        return "login";
398      if (code == RepositoryType.OAUTH)
399        return "oauth";
400      if (code == RepositoryType.OTHER)
401        return "other";
402      return "?";
403      }
404    public String toSystem(RepositoryType code) {
405      return code.getSystem();
406      }
407    }
408
409    @Block()
410    public static class SequenceReferenceSeqComponent extends BackboneElement implements IBaseBackboneElement {
411        /**
412         * Structural unit composed of a nucleic acid molecule which controls its own replication through the interaction of specific proteins at one or more origins of replication ([SO:0000340](http://www.sequenceontology.org/browser/current_svn/term/SO:0000340)).
413         */
414        @Child(name = "chromosome", type = {CodeableConcept.class}, order=1, min=0, max=1, modifier=false, summary=true)
415        @Description(shortDefinition="Chromosome containing genetic finding", formalDefinition="Structural unit composed of a nucleic acid molecule which controls its own replication through the interaction of specific proteins at one or more origins of replication ([SO:0000340](http://www.sequenceontology.org/browser/current_svn/term/SO:0000340))." )
416        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/chromosome-human")
417        protected CodeableConcept chromosome;
418
419        /**
420         * The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'.  Version number must be included if a versioned release of a primary build was used.
421         */
422        @Child(name = "genomeBuild", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true)
423        @Description(shortDefinition="The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'", formalDefinition="The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'.  Version number must be included if a versioned release of a primary build was used." )
424        protected StringType genomeBuild;
425
426        /**
427         * Reference identifier of reference sequence submitted to NCBI. It must match the type in the Sequence.type field. For example, the prefix, “NG_” identifies reference sequence for genes, “NM_” for messenger RNA transcripts, and “NP_” for amino acid sequences.
428         */
429        @Child(name = "referenceSeqId", type = {CodeableConcept.class}, order=3, min=0, max=1, modifier=false, summary=true)
430        @Description(shortDefinition="Reference identifier", formalDefinition="Reference identifier of reference sequence submitted to NCBI. It must match the type in the Sequence.type field. For example, the prefix, “NG_” identifies reference sequence for genes, “NM_” for messenger RNA transcripts, and “NP_” for amino acid sequences." )
431        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/sequence-referenceSeq")
432        protected CodeableConcept referenceSeqId;
433
434        /**
435         * A Pointer to another Sequence entity as reference sequence.
436         */
437        @Child(name = "referenceSeqPointer", type = {Sequence.class}, order=4, min=0, max=1, modifier=false, summary=true)
438        @Description(shortDefinition="A Pointer to another Sequence entity as reference sequence", formalDefinition="A Pointer to another Sequence entity as reference sequence." )
439        protected Reference referenceSeqPointer;
440
441        /**
442         * The actual object that is the target of the reference (A Pointer to another Sequence entity as reference sequence.)
443         */
444        protected Sequence referenceSeqPointerTarget;
445
446        /**
447         * A string like "ACGT".
448         */
449        @Child(name = "referenceSeqString", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=true)
450        @Description(shortDefinition="A string to represent reference sequence", formalDefinition="A string like \"ACGT\"." )
451        protected StringType referenceSeqString;
452
453        /**
454         * Directionality of DNA sequence. Available values are "1" for the plus strand (5' to 3')/Watson/Sense/positive  and "-1" for the minus strand(3' to 5')/Crick/Antisense/negative.
455         */
456        @Child(name = "strand", type = {IntegerType.class}, order=6, min=0, max=1, modifier=false, summary=true)
457        @Description(shortDefinition="Directionality of DNA ( +1/-1)", formalDefinition="Directionality of DNA sequence. Available values are \"1\" for the plus strand (5' to 3')/Watson/Sense/positive  and \"-1\" for the minus strand(3' to 5')/Crick/Antisense/negative." )
458        protected IntegerType strand;
459
460        /**
461         * Start position of the window on the reference sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.
462         */
463        @Child(name = "windowStart", type = {IntegerType.class}, order=7, min=1, max=1, modifier=false, summary=true)
464        @Description(shortDefinition="Start position of the window on the  reference sequence", formalDefinition="Start position of the window on the reference sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive." )
465        protected IntegerType windowStart;
466
467        /**
468         * End position of the window on the reference sequence. If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.
469         */
470        @Child(name = "windowEnd", type = {IntegerType.class}, order=8, min=1, max=1, modifier=false, summary=true)
471        @Description(shortDefinition="End position of the window on the reference sequence", formalDefinition="End position of the window on the reference sequence. If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position." )
472        protected IntegerType windowEnd;
473
474        private static final long serialVersionUID = -1675617731L;
475
476    /**
477     * Constructor
478     */
479      public SequenceReferenceSeqComponent() {
480        super();
481      }
482
483    /**
484     * Constructor
485     */
486      public SequenceReferenceSeqComponent(IntegerType windowStart, IntegerType windowEnd) {
487        super();
488        this.windowStart = windowStart;
489        this.windowEnd = windowEnd;
490      }
491
492        /**
493         * @return {@link #chromosome} (Structural unit composed of a nucleic acid molecule which controls its own replication through the interaction of specific proteins at one or more origins of replication ([SO:0000340](http://www.sequenceontology.org/browser/current_svn/term/SO:0000340)).)
494         */
495        public CodeableConcept getChromosome() { 
496          if (this.chromosome == null)
497            if (Configuration.errorOnAutoCreate())
498              throw new Error("Attempt to auto-create SequenceReferenceSeqComponent.chromosome");
499            else if (Configuration.doAutoCreate())
500              this.chromosome = new CodeableConcept(); // cc
501          return this.chromosome;
502        }
503
504        public boolean hasChromosome() { 
505          return this.chromosome != null && !this.chromosome.isEmpty();
506        }
507
508        /**
509         * @param value {@link #chromosome} (Structural unit composed of a nucleic acid molecule which controls its own replication through the interaction of specific proteins at one or more origins of replication ([SO:0000340](http://www.sequenceontology.org/browser/current_svn/term/SO:0000340)).)
510         */
511        public SequenceReferenceSeqComponent setChromosome(CodeableConcept value)  { 
512          this.chromosome = value;
513          return this;
514        }
515
516        /**
517         * @return {@link #genomeBuild} (The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'.  Version number must be included if a versioned release of a primary build was used.). This is the underlying object with id, value and extensions. The accessor "getGenomeBuild" gives direct access to the value
518         */
519        public StringType getGenomeBuildElement() { 
520          if (this.genomeBuild == null)
521            if (Configuration.errorOnAutoCreate())
522              throw new Error("Attempt to auto-create SequenceReferenceSeqComponent.genomeBuild");
523            else if (Configuration.doAutoCreate())
524              this.genomeBuild = new StringType(); // bb
525          return this.genomeBuild;
526        }
527
528        public boolean hasGenomeBuildElement() { 
529          return this.genomeBuild != null && !this.genomeBuild.isEmpty();
530        }
531
532        public boolean hasGenomeBuild() { 
533          return this.genomeBuild != null && !this.genomeBuild.isEmpty();
534        }
535
536        /**
537         * @param value {@link #genomeBuild} (The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'.  Version number must be included if a versioned release of a primary build was used.). This is the underlying object with id, value and extensions. The accessor "getGenomeBuild" gives direct access to the value
538         */
539        public SequenceReferenceSeqComponent setGenomeBuildElement(StringType value) { 
540          this.genomeBuild = value;
541          return this;
542        }
543
544        /**
545         * @return The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'.  Version number must be included if a versioned release of a primary build was used.
546         */
547        public String getGenomeBuild() { 
548          return this.genomeBuild == null ? null : this.genomeBuild.getValue();
549        }
550
551        /**
552         * @param value The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'.  Version number must be included if a versioned release of a primary build was used.
553         */
554        public SequenceReferenceSeqComponent setGenomeBuild(String value) { 
555          if (Utilities.noString(value))
556            this.genomeBuild = null;
557          else {
558            if (this.genomeBuild == null)
559              this.genomeBuild = new StringType();
560            this.genomeBuild.setValue(value);
561          }
562          return this;
563        }
564
565        /**
566         * @return {@link #referenceSeqId} (Reference identifier of reference sequence submitted to NCBI. It must match the type in the Sequence.type field. For example, the prefix, “NG_” identifies reference sequence for genes, “NM_” for messenger RNA transcripts, and “NP_” for amino acid sequences.)
567         */
568        public CodeableConcept getReferenceSeqId() { 
569          if (this.referenceSeqId == null)
570            if (Configuration.errorOnAutoCreate())
571              throw new Error("Attempt to auto-create SequenceReferenceSeqComponent.referenceSeqId");
572            else if (Configuration.doAutoCreate())
573              this.referenceSeqId = new CodeableConcept(); // cc
574          return this.referenceSeqId;
575        }
576
577        public boolean hasReferenceSeqId() { 
578          return this.referenceSeqId != null && !this.referenceSeqId.isEmpty();
579        }
580
581        /**
582         * @param value {@link #referenceSeqId} (Reference identifier of reference sequence submitted to NCBI. It must match the type in the Sequence.type field. For example, the prefix, “NG_” identifies reference sequence for genes, “NM_” for messenger RNA transcripts, and “NP_” for amino acid sequences.)
583         */
584        public SequenceReferenceSeqComponent setReferenceSeqId(CodeableConcept value)  { 
585          this.referenceSeqId = value;
586          return this;
587        }
588
589        /**
590         * @return {@link #referenceSeqPointer} (A Pointer to another Sequence entity as reference sequence.)
591         */
592        public Reference getReferenceSeqPointer() { 
593          if (this.referenceSeqPointer == null)
594            if (Configuration.errorOnAutoCreate())
595              throw new Error("Attempt to auto-create SequenceReferenceSeqComponent.referenceSeqPointer");
596            else if (Configuration.doAutoCreate())
597              this.referenceSeqPointer = new Reference(); // cc
598          return this.referenceSeqPointer;
599        }
600
601        public boolean hasReferenceSeqPointer() { 
602          return this.referenceSeqPointer != null && !this.referenceSeqPointer.isEmpty();
603        }
604
605        /**
606         * @param value {@link #referenceSeqPointer} (A Pointer to another Sequence entity as reference sequence.)
607         */
608        public SequenceReferenceSeqComponent setReferenceSeqPointer(Reference value)  { 
609          this.referenceSeqPointer = value;
610          return this;
611        }
612
613        /**
614         * @return {@link #referenceSeqPointer} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (A Pointer to another Sequence entity as reference sequence.)
615         */
616        public Sequence getReferenceSeqPointerTarget() { 
617          if (this.referenceSeqPointerTarget == null)
618            if (Configuration.errorOnAutoCreate())
619              throw new Error("Attempt to auto-create SequenceReferenceSeqComponent.referenceSeqPointer");
620            else if (Configuration.doAutoCreate())
621              this.referenceSeqPointerTarget = new Sequence(); // aa
622          return this.referenceSeqPointerTarget;
623        }
624
625        /**
626         * @param value {@link #referenceSeqPointer} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (A Pointer to another Sequence entity as reference sequence.)
627         */
628        public SequenceReferenceSeqComponent setReferenceSeqPointerTarget(Sequence value) { 
629          this.referenceSeqPointerTarget = value;
630          return this;
631        }
632
633        /**
634         * @return {@link #referenceSeqString} (A string like "ACGT".). This is the underlying object with id, value and extensions. The accessor "getReferenceSeqString" gives direct access to the value
635         */
636        public StringType getReferenceSeqStringElement() { 
637          if (this.referenceSeqString == null)
638            if (Configuration.errorOnAutoCreate())
639              throw new Error("Attempt to auto-create SequenceReferenceSeqComponent.referenceSeqString");
640            else if (Configuration.doAutoCreate())
641              this.referenceSeqString = new StringType(); // bb
642          return this.referenceSeqString;
643        }
644
645        public boolean hasReferenceSeqStringElement() { 
646          return this.referenceSeqString != null && !this.referenceSeqString.isEmpty();
647        }
648
649        public boolean hasReferenceSeqString() { 
650          return this.referenceSeqString != null && !this.referenceSeqString.isEmpty();
651        }
652
653        /**
654         * @param value {@link #referenceSeqString} (A string like "ACGT".). This is the underlying object with id, value and extensions. The accessor "getReferenceSeqString" gives direct access to the value
655         */
656        public SequenceReferenceSeqComponent setReferenceSeqStringElement(StringType value) { 
657          this.referenceSeqString = value;
658          return this;
659        }
660
661        /**
662         * @return A string like "ACGT".
663         */
664        public String getReferenceSeqString() { 
665          return this.referenceSeqString == null ? null : this.referenceSeqString.getValue();
666        }
667
668        /**
669         * @param value A string like "ACGT".
670         */
671        public SequenceReferenceSeqComponent setReferenceSeqString(String value) { 
672          if (Utilities.noString(value))
673            this.referenceSeqString = null;
674          else {
675            if (this.referenceSeqString == null)
676              this.referenceSeqString = new StringType();
677            this.referenceSeqString.setValue(value);
678          }
679          return this;
680        }
681
682        /**
683         * @return {@link #strand} (Directionality of DNA sequence. Available values are "1" for the plus strand (5' to 3')/Watson/Sense/positive  and "-1" for the minus strand(3' to 5')/Crick/Antisense/negative.). This is the underlying object with id, value and extensions. The accessor "getStrand" gives direct access to the value
684         */
685        public IntegerType getStrandElement() { 
686          if (this.strand == null)
687            if (Configuration.errorOnAutoCreate())
688              throw new Error("Attempt to auto-create SequenceReferenceSeqComponent.strand");
689            else if (Configuration.doAutoCreate())
690              this.strand = new IntegerType(); // bb
691          return this.strand;
692        }
693
694        public boolean hasStrandElement() { 
695          return this.strand != null && !this.strand.isEmpty();
696        }
697
698        public boolean hasStrand() { 
699          return this.strand != null && !this.strand.isEmpty();
700        }
701
702        /**
703         * @param value {@link #strand} (Directionality of DNA sequence. Available values are "1" for the plus strand (5' to 3')/Watson/Sense/positive  and "-1" for the minus strand(3' to 5')/Crick/Antisense/negative.). This is the underlying object with id, value and extensions. The accessor "getStrand" gives direct access to the value
704         */
705        public SequenceReferenceSeqComponent setStrandElement(IntegerType value) { 
706          this.strand = value;
707          return this;
708        }
709
710        /**
711         * @return Directionality of DNA sequence. Available values are "1" for the plus strand (5' to 3')/Watson/Sense/positive  and "-1" for the minus strand(3' to 5')/Crick/Antisense/negative.
712         */
713        public int getStrand() { 
714          return this.strand == null || this.strand.isEmpty() ? 0 : this.strand.getValue();
715        }
716
717        /**
718         * @param value Directionality of DNA sequence. Available values are "1" for the plus strand (5' to 3')/Watson/Sense/positive  and "-1" for the minus strand(3' to 5')/Crick/Antisense/negative.
719         */
720        public SequenceReferenceSeqComponent setStrand(int value) { 
721            if (this.strand == null)
722              this.strand = new IntegerType();
723            this.strand.setValue(value);
724          return this;
725        }
726
727        /**
728         * @return {@link #windowStart} (Start position of the window on the reference sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.). This is the underlying object with id, value and extensions. The accessor "getWindowStart" gives direct access to the value
729         */
730        public IntegerType getWindowStartElement() { 
731          if (this.windowStart == null)
732            if (Configuration.errorOnAutoCreate())
733              throw new Error("Attempt to auto-create SequenceReferenceSeqComponent.windowStart");
734            else if (Configuration.doAutoCreate())
735              this.windowStart = new IntegerType(); // bb
736          return this.windowStart;
737        }
738
739        public boolean hasWindowStartElement() { 
740          return this.windowStart != null && !this.windowStart.isEmpty();
741        }
742
743        public boolean hasWindowStart() { 
744          return this.windowStart != null && !this.windowStart.isEmpty();
745        }
746
747        /**
748         * @param value {@link #windowStart} (Start position of the window on the reference sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.). This is the underlying object with id, value and extensions. The accessor "getWindowStart" gives direct access to the value
749         */
750        public SequenceReferenceSeqComponent setWindowStartElement(IntegerType value) { 
751          this.windowStart = value;
752          return this;
753        }
754
755        /**
756         * @return Start position of the window on the reference sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.
757         */
758        public int getWindowStart() { 
759          return this.windowStart == null || this.windowStart.isEmpty() ? 0 : this.windowStart.getValue();
760        }
761
762        /**
763         * @param value Start position of the window on the reference sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.
764         */
765        public SequenceReferenceSeqComponent setWindowStart(int value) { 
766            if (this.windowStart == null)
767              this.windowStart = new IntegerType();
768            this.windowStart.setValue(value);
769          return this;
770        }
771
772        /**
773         * @return {@link #windowEnd} (End position of the window on the reference sequence. If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.). This is the underlying object with id, value and extensions. The accessor "getWindowEnd" gives direct access to the value
774         */
775        public IntegerType getWindowEndElement() { 
776          if (this.windowEnd == null)
777            if (Configuration.errorOnAutoCreate())
778              throw new Error("Attempt to auto-create SequenceReferenceSeqComponent.windowEnd");
779            else if (Configuration.doAutoCreate())
780              this.windowEnd = new IntegerType(); // bb
781          return this.windowEnd;
782        }
783
784        public boolean hasWindowEndElement() { 
785          return this.windowEnd != null && !this.windowEnd.isEmpty();
786        }
787
788        public boolean hasWindowEnd() { 
789          return this.windowEnd != null && !this.windowEnd.isEmpty();
790        }
791
792        /**
793         * @param value {@link #windowEnd} (End position of the window on the reference sequence. If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.). This is the underlying object with id, value and extensions. The accessor "getWindowEnd" gives direct access to the value
794         */
795        public SequenceReferenceSeqComponent setWindowEndElement(IntegerType value) { 
796          this.windowEnd = value;
797          return this;
798        }
799
800        /**
801         * @return End position of the window on the reference sequence. If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.
802         */
803        public int getWindowEnd() { 
804          return this.windowEnd == null || this.windowEnd.isEmpty() ? 0 : this.windowEnd.getValue();
805        }
806
807        /**
808         * @param value End position of the window on the reference sequence. If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.
809         */
810        public SequenceReferenceSeqComponent setWindowEnd(int value) { 
811            if (this.windowEnd == null)
812              this.windowEnd = new IntegerType();
813            this.windowEnd.setValue(value);
814          return this;
815        }
816
817        protected void listChildren(List<Property> children) {
818          super.listChildren(children);
819          children.add(new Property("chromosome", "CodeableConcept", "Structural unit composed of a nucleic acid molecule which controls its own replication through the interaction of specific proteins at one or more origins of replication ([SO:0000340](http://www.sequenceontology.org/browser/current_svn/term/SO:0000340)).", 0, 1, chromosome));
820          children.add(new Property("genomeBuild", "string", "The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'.  Version number must be included if a versioned release of a primary build was used.", 0, 1, genomeBuild));
821          children.add(new Property("referenceSeqId", "CodeableConcept", "Reference identifier of reference sequence submitted to NCBI. It must match the type in the Sequence.type field. For example, the prefix, “NG_” identifies reference sequence for genes, “NM_” for messenger RNA transcripts, and “NP_” for amino acid sequences.", 0, 1, referenceSeqId));
822          children.add(new Property("referenceSeqPointer", "Reference(Sequence)", "A Pointer to another Sequence entity as reference sequence.", 0, 1, referenceSeqPointer));
823          children.add(new Property("referenceSeqString", "string", "A string like \"ACGT\".", 0, 1, referenceSeqString));
824          children.add(new Property("strand", "integer", "Directionality of DNA sequence. Available values are \"1\" for the plus strand (5' to 3')/Watson/Sense/positive  and \"-1\" for the minus strand(3' to 5')/Crick/Antisense/negative.", 0, 1, strand));
825          children.add(new Property("windowStart", "integer", "Start position of the window on the reference sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.", 0, 1, windowStart));
826          children.add(new Property("windowEnd", "integer", "End position of the window on the reference sequence. If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.", 0, 1, windowEnd));
827        }
828
829        @Override
830        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
831          switch (_hash) {
832          case -1499470472: /*chromosome*/  return new Property("chromosome", "CodeableConcept", "Structural unit composed of a nucleic acid molecule which controls its own replication through the interaction of specific proteins at one or more origins of replication ([SO:0000340](http://www.sequenceontology.org/browser/current_svn/term/SO:0000340)).", 0, 1, chromosome);
833          case 1061239735: /*genomeBuild*/  return new Property("genomeBuild", "string", "The Genome Build used for reference, following GRCh build versions e.g. 'GRCh 37'.  Version number must be included if a versioned release of a primary build was used.", 0, 1, genomeBuild);
834          case -1911500465: /*referenceSeqId*/  return new Property("referenceSeqId", "CodeableConcept", "Reference identifier of reference sequence submitted to NCBI. It must match the type in the Sequence.type field. For example, the prefix, “NG_” identifies reference sequence for genes, “NM_” for messenger RNA transcripts, and “NP_” for amino acid sequences.", 0, 1, referenceSeqId);
835          case 1923414665: /*referenceSeqPointer*/  return new Property("referenceSeqPointer", "Reference(Sequence)", "A Pointer to another Sequence entity as reference sequence.", 0, 1, referenceSeqPointer);
836          case -1648301499: /*referenceSeqString*/  return new Property("referenceSeqString", "string", "A string like \"ACGT\".", 0, 1, referenceSeqString);
837          case -891993594: /*strand*/  return new Property("strand", "integer", "Directionality of DNA sequence. Available values are \"1\" for the plus strand (5' to 3')/Watson/Sense/positive  and \"-1\" for the minus strand(3' to 5')/Crick/Antisense/negative.", 0, 1, strand);
838          case 1903685202: /*windowStart*/  return new Property("windowStart", "integer", "Start position of the window on the reference sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.", 0, 1, windowStart);
839          case -217026869: /*windowEnd*/  return new Property("windowEnd", "integer", "End position of the window on the reference sequence. If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.", 0, 1, windowEnd);
840          default: return super.getNamedProperty(_hash, _name, _checkValid);
841          }
842
843        }
844
845      @Override
846      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
847        switch (hash) {
848        case -1499470472: /*chromosome*/ return this.chromosome == null ? new Base[0] : new Base[] {this.chromosome}; // CodeableConcept
849        case 1061239735: /*genomeBuild*/ return this.genomeBuild == null ? new Base[0] : new Base[] {this.genomeBuild}; // StringType
850        case -1911500465: /*referenceSeqId*/ return this.referenceSeqId == null ? new Base[0] : new Base[] {this.referenceSeqId}; // CodeableConcept
851        case 1923414665: /*referenceSeqPointer*/ return this.referenceSeqPointer == null ? new Base[0] : new Base[] {this.referenceSeqPointer}; // Reference
852        case -1648301499: /*referenceSeqString*/ return this.referenceSeqString == null ? new Base[0] : new Base[] {this.referenceSeqString}; // StringType
853        case -891993594: /*strand*/ return this.strand == null ? new Base[0] : new Base[] {this.strand}; // IntegerType
854        case 1903685202: /*windowStart*/ return this.windowStart == null ? new Base[0] : new Base[] {this.windowStart}; // IntegerType
855        case -217026869: /*windowEnd*/ return this.windowEnd == null ? new Base[0] : new Base[] {this.windowEnd}; // IntegerType
856        default: return super.getProperty(hash, name, checkValid);
857        }
858
859      }
860
861      @Override
862      public Base setProperty(int hash, String name, Base value) throws FHIRException {
863        switch (hash) {
864        case -1499470472: // chromosome
865          this.chromosome = castToCodeableConcept(value); // CodeableConcept
866          return value;
867        case 1061239735: // genomeBuild
868          this.genomeBuild = castToString(value); // StringType
869          return value;
870        case -1911500465: // referenceSeqId
871          this.referenceSeqId = castToCodeableConcept(value); // CodeableConcept
872          return value;
873        case 1923414665: // referenceSeqPointer
874          this.referenceSeqPointer = castToReference(value); // Reference
875          return value;
876        case -1648301499: // referenceSeqString
877          this.referenceSeqString = castToString(value); // StringType
878          return value;
879        case -891993594: // strand
880          this.strand = castToInteger(value); // IntegerType
881          return value;
882        case 1903685202: // windowStart
883          this.windowStart = castToInteger(value); // IntegerType
884          return value;
885        case -217026869: // windowEnd
886          this.windowEnd = castToInteger(value); // IntegerType
887          return value;
888        default: return super.setProperty(hash, name, value);
889        }
890
891      }
892
893      @Override
894      public Base setProperty(String name, Base value) throws FHIRException {
895        if (name.equals("chromosome")) {
896          this.chromosome = castToCodeableConcept(value); // CodeableConcept
897        } else if (name.equals("genomeBuild")) {
898          this.genomeBuild = castToString(value); // StringType
899        } else if (name.equals("referenceSeqId")) {
900          this.referenceSeqId = castToCodeableConcept(value); // CodeableConcept
901        } else if (name.equals("referenceSeqPointer")) {
902          this.referenceSeqPointer = castToReference(value); // Reference
903        } else if (name.equals("referenceSeqString")) {
904          this.referenceSeqString = castToString(value); // StringType
905        } else if (name.equals("strand")) {
906          this.strand = castToInteger(value); // IntegerType
907        } else if (name.equals("windowStart")) {
908          this.windowStart = castToInteger(value); // IntegerType
909        } else if (name.equals("windowEnd")) {
910          this.windowEnd = castToInteger(value); // IntegerType
911        } else
912          return super.setProperty(name, value);
913        return value;
914      }
915
916      @Override
917      public Base makeProperty(int hash, String name) throws FHIRException {
918        switch (hash) {
919        case -1499470472:  return getChromosome(); 
920        case 1061239735:  return getGenomeBuildElement();
921        case -1911500465:  return getReferenceSeqId(); 
922        case 1923414665:  return getReferenceSeqPointer(); 
923        case -1648301499:  return getReferenceSeqStringElement();
924        case -891993594:  return getStrandElement();
925        case 1903685202:  return getWindowStartElement();
926        case -217026869:  return getWindowEndElement();
927        default: return super.makeProperty(hash, name);
928        }
929
930      }
931
932      @Override
933      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
934        switch (hash) {
935        case -1499470472: /*chromosome*/ return new String[] {"CodeableConcept"};
936        case 1061239735: /*genomeBuild*/ return new String[] {"string"};
937        case -1911500465: /*referenceSeqId*/ return new String[] {"CodeableConcept"};
938        case 1923414665: /*referenceSeqPointer*/ return new String[] {"Reference"};
939        case -1648301499: /*referenceSeqString*/ return new String[] {"string"};
940        case -891993594: /*strand*/ return new String[] {"integer"};
941        case 1903685202: /*windowStart*/ return new String[] {"integer"};
942        case -217026869: /*windowEnd*/ return new String[] {"integer"};
943        default: return super.getTypesForProperty(hash, name);
944        }
945
946      }
947
948      @Override
949      public Base addChild(String name) throws FHIRException {
950        if (name.equals("chromosome")) {
951          this.chromosome = new CodeableConcept();
952          return this.chromosome;
953        }
954        else if (name.equals("genomeBuild")) {
955          throw new FHIRException("Cannot call addChild on a primitive type Sequence.genomeBuild");
956        }
957        else if (name.equals("referenceSeqId")) {
958          this.referenceSeqId = new CodeableConcept();
959          return this.referenceSeqId;
960        }
961        else if (name.equals("referenceSeqPointer")) {
962          this.referenceSeqPointer = new Reference();
963          return this.referenceSeqPointer;
964        }
965        else if (name.equals("referenceSeqString")) {
966          throw new FHIRException("Cannot call addChild on a primitive type Sequence.referenceSeqString");
967        }
968        else if (name.equals("strand")) {
969          throw new FHIRException("Cannot call addChild on a primitive type Sequence.strand");
970        }
971        else if (name.equals("windowStart")) {
972          throw new FHIRException("Cannot call addChild on a primitive type Sequence.windowStart");
973        }
974        else if (name.equals("windowEnd")) {
975          throw new FHIRException("Cannot call addChild on a primitive type Sequence.windowEnd");
976        }
977        else
978          return super.addChild(name);
979      }
980
981      public SequenceReferenceSeqComponent copy() {
982        SequenceReferenceSeqComponent dst = new SequenceReferenceSeqComponent();
983        copyValues(dst);
984        dst.chromosome = chromosome == null ? null : chromosome.copy();
985        dst.genomeBuild = genomeBuild == null ? null : genomeBuild.copy();
986        dst.referenceSeqId = referenceSeqId == null ? null : referenceSeqId.copy();
987        dst.referenceSeqPointer = referenceSeqPointer == null ? null : referenceSeqPointer.copy();
988        dst.referenceSeqString = referenceSeqString == null ? null : referenceSeqString.copy();
989        dst.strand = strand == null ? null : strand.copy();
990        dst.windowStart = windowStart == null ? null : windowStart.copy();
991        dst.windowEnd = windowEnd == null ? null : windowEnd.copy();
992        return dst;
993      }
994
995      @Override
996      public boolean equalsDeep(Base other_) {
997        if (!super.equalsDeep(other_))
998          return false;
999        if (!(other_ instanceof SequenceReferenceSeqComponent))
1000          return false;
1001        SequenceReferenceSeqComponent o = (SequenceReferenceSeqComponent) other_;
1002        return compareDeep(chromosome, o.chromosome, true) && compareDeep(genomeBuild, o.genomeBuild, true)
1003           && compareDeep(referenceSeqId, o.referenceSeqId, true) && compareDeep(referenceSeqPointer, o.referenceSeqPointer, true)
1004           && compareDeep(referenceSeqString, o.referenceSeqString, true) && compareDeep(strand, o.strand, true)
1005           && compareDeep(windowStart, o.windowStart, true) && compareDeep(windowEnd, o.windowEnd, true);
1006      }
1007
1008      @Override
1009      public boolean equalsShallow(Base other_) {
1010        if (!super.equalsShallow(other_))
1011          return false;
1012        if (!(other_ instanceof SequenceReferenceSeqComponent))
1013          return false;
1014        SequenceReferenceSeqComponent o = (SequenceReferenceSeqComponent) other_;
1015        return compareValues(genomeBuild, o.genomeBuild, true) && compareValues(referenceSeqString, o.referenceSeqString, true)
1016           && compareValues(strand, o.strand, true) && compareValues(windowStart, o.windowStart, true) && compareValues(windowEnd, o.windowEnd, true)
1017          ;
1018      }
1019
1020      public boolean isEmpty() {
1021        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(chromosome, genomeBuild, referenceSeqId
1022          , referenceSeqPointer, referenceSeqString, strand, windowStart, windowEnd);
1023      }
1024
1025  public String fhirType() {
1026    return "Sequence.referenceSeq";
1027
1028  }
1029
1030  }
1031
1032    @Block()
1033    public static class SequenceVariantComponent extends BackboneElement implements IBaseBackboneElement {
1034        /**
1035         * Start position of the variant on the  reference sequence.If the coordinate system is either 0-based or 1-based, then start position is inclusive.
1036         */
1037        @Child(name = "start", type = {IntegerType.class}, order=1, min=0, max=1, modifier=false, summary=true)
1038        @Description(shortDefinition="Start position of the variant on the  reference sequence", formalDefinition="Start position of the variant on the  reference sequence.If the coordinate system is either 0-based or 1-based, then start position is inclusive." )
1039        protected IntegerType start;
1040
1041        /**
1042         * End position of the variant on the reference sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.
1043         */
1044        @Child(name = "end", type = {IntegerType.class}, order=2, min=0, max=1, modifier=false, summary=true)
1045        @Description(shortDefinition="End position of the variant on the reference sequence", formalDefinition="End position of the variant on the reference sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position." )
1046        protected IntegerType end;
1047
1048        /**
1049         * An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)).  Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the observed  sequence. When the sequence  type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.
1050         */
1051        @Child(name = "observedAllele", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=true)
1052        @Description(shortDefinition="Allele that was observed", formalDefinition="An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)).  Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the observed  sequence. When the sequence  type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end." )
1053        protected StringType observedAllele;
1054
1055        /**
1056         * An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the reference sequence. When the sequence  type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.
1057         */
1058        @Child(name = "referenceAllele", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=true)
1059        @Description(shortDefinition="Allele in the reference sequence", formalDefinition="An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the reference sequence. When the sequence  type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end." )
1060        protected StringType referenceAllele;
1061
1062        /**
1063         * Extended CIGAR string for aligning the sequence with reference bases. See detailed documentation [here](http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm).
1064         */
1065        @Child(name = "cigar", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=true)
1066        @Description(shortDefinition="Extended CIGAR string for aligning the sequence with reference bases", formalDefinition="Extended CIGAR string for aligning the sequence with reference bases. See detailed documentation [here](http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm)." )
1067        protected StringType cigar;
1068
1069        /**
1070         * A pointer to an Observation containing variant information.
1071         */
1072        @Child(name = "variantPointer", type = {Observation.class}, order=6, min=0, max=1, modifier=false, summary=true)
1073        @Description(shortDefinition="Pointer to observed variant information", formalDefinition="A pointer to an Observation containing variant information." )
1074        protected Reference variantPointer;
1075
1076        /**
1077         * The actual object that is the target of the reference (A pointer to an Observation containing variant information.)
1078         */
1079        protected Observation variantPointerTarget;
1080
1081        private static final long serialVersionUID = 105611837L;
1082
1083    /**
1084     * Constructor
1085     */
1086      public SequenceVariantComponent() {
1087        super();
1088      }
1089
1090        /**
1091         * @return {@link #start} (Start position of the variant on the  reference sequence.If the coordinate system is either 0-based or 1-based, then start position is inclusive.). This is the underlying object with id, value and extensions. The accessor "getStart" gives direct access to the value
1092         */
1093        public IntegerType getStartElement() { 
1094          if (this.start == null)
1095            if (Configuration.errorOnAutoCreate())
1096              throw new Error("Attempt to auto-create SequenceVariantComponent.start");
1097            else if (Configuration.doAutoCreate())
1098              this.start = new IntegerType(); // bb
1099          return this.start;
1100        }
1101
1102        public boolean hasStartElement() { 
1103          return this.start != null && !this.start.isEmpty();
1104        }
1105
1106        public boolean hasStart() { 
1107          return this.start != null && !this.start.isEmpty();
1108        }
1109
1110        /**
1111         * @param value {@link #start} (Start position of the variant on the  reference sequence.If the coordinate system is either 0-based or 1-based, then start position is inclusive.). This is the underlying object with id, value and extensions. The accessor "getStart" gives direct access to the value
1112         */
1113        public SequenceVariantComponent setStartElement(IntegerType value) { 
1114          this.start = value;
1115          return this;
1116        }
1117
1118        /**
1119         * @return Start position of the variant on the  reference sequence.If the coordinate system is either 0-based or 1-based, then start position is inclusive.
1120         */
1121        public int getStart() { 
1122          return this.start == null || this.start.isEmpty() ? 0 : this.start.getValue();
1123        }
1124
1125        /**
1126         * @param value Start position of the variant on the  reference sequence.If the coordinate system is either 0-based or 1-based, then start position is inclusive.
1127         */
1128        public SequenceVariantComponent setStart(int value) { 
1129            if (this.start == null)
1130              this.start = new IntegerType();
1131            this.start.setValue(value);
1132          return this;
1133        }
1134
1135        /**
1136         * @return {@link #end} (End position of the variant on the reference sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.). This is the underlying object with id, value and extensions. The accessor "getEnd" gives direct access to the value
1137         */
1138        public IntegerType getEndElement() { 
1139          if (this.end == null)
1140            if (Configuration.errorOnAutoCreate())
1141              throw new Error("Attempt to auto-create SequenceVariantComponent.end");
1142            else if (Configuration.doAutoCreate())
1143              this.end = new IntegerType(); // bb
1144          return this.end;
1145        }
1146
1147        public boolean hasEndElement() { 
1148          return this.end != null && !this.end.isEmpty();
1149        }
1150
1151        public boolean hasEnd() { 
1152          return this.end != null && !this.end.isEmpty();
1153        }
1154
1155        /**
1156         * @param value {@link #end} (End position of the variant on the reference sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.). This is the underlying object with id, value and extensions. The accessor "getEnd" gives direct access to the value
1157         */
1158        public SequenceVariantComponent setEndElement(IntegerType value) { 
1159          this.end = value;
1160          return this;
1161        }
1162
1163        /**
1164         * @return End position of the variant on the reference sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.
1165         */
1166        public int getEnd() { 
1167          return this.end == null || this.end.isEmpty() ? 0 : this.end.getValue();
1168        }
1169
1170        /**
1171         * @param value End position of the variant on the reference sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.
1172         */
1173        public SequenceVariantComponent setEnd(int value) { 
1174            if (this.end == null)
1175              this.end = new IntegerType();
1176            this.end.setValue(value);
1177          return this;
1178        }
1179
1180        /**
1181         * @return {@link #observedAllele} (An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)).  Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the observed  sequence. When the sequence  type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.). This is the underlying object with id, value and extensions. The accessor "getObservedAllele" gives direct access to the value
1182         */
1183        public StringType getObservedAlleleElement() { 
1184          if (this.observedAllele == null)
1185            if (Configuration.errorOnAutoCreate())
1186              throw new Error("Attempt to auto-create SequenceVariantComponent.observedAllele");
1187            else if (Configuration.doAutoCreate())
1188              this.observedAllele = new StringType(); // bb
1189          return this.observedAllele;
1190        }
1191
1192        public boolean hasObservedAlleleElement() { 
1193          return this.observedAllele != null && !this.observedAllele.isEmpty();
1194        }
1195
1196        public boolean hasObservedAllele() { 
1197          return this.observedAllele != null && !this.observedAllele.isEmpty();
1198        }
1199
1200        /**
1201         * @param value {@link #observedAllele} (An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)).  Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the observed  sequence. When the sequence  type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.). This is the underlying object with id, value and extensions. The accessor "getObservedAllele" gives direct access to the value
1202         */
1203        public SequenceVariantComponent setObservedAlleleElement(StringType value) { 
1204          this.observedAllele = value;
1205          return this;
1206        }
1207
1208        /**
1209         * @return An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)).  Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the observed  sequence. When the sequence  type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.
1210         */
1211        public String getObservedAllele() { 
1212          return this.observedAllele == null ? null : this.observedAllele.getValue();
1213        }
1214
1215        /**
1216         * @param value An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)).  Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the observed  sequence. When the sequence  type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.
1217         */
1218        public SequenceVariantComponent setObservedAllele(String value) { 
1219          if (Utilities.noString(value))
1220            this.observedAllele = null;
1221          else {
1222            if (this.observedAllele == null)
1223              this.observedAllele = new StringType();
1224            this.observedAllele.setValue(value);
1225          }
1226          return this;
1227        }
1228
1229        /**
1230         * @return {@link #referenceAllele} (An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the reference sequence. When the sequence  type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.). This is the underlying object with id, value and extensions. The accessor "getReferenceAllele" gives direct access to the value
1231         */
1232        public StringType getReferenceAlleleElement() { 
1233          if (this.referenceAllele == null)
1234            if (Configuration.errorOnAutoCreate())
1235              throw new Error("Attempt to auto-create SequenceVariantComponent.referenceAllele");
1236            else if (Configuration.doAutoCreate())
1237              this.referenceAllele = new StringType(); // bb
1238          return this.referenceAllele;
1239        }
1240
1241        public boolean hasReferenceAlleleElement() { 
1242          return this.referenceAllele != null && !this.referenceAllele.isEmpty();
1243        }
1244
1245        public boolean hasReferenceAllele() { 
1246          return this.referenceAllele != null && !this.referenceAllele.isEmpty();
1247        }
1248
1249        /**
1250         * @param value {@link #referenceAllele} (An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the reference sequence. When the sequence  type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.). This is the underlying object with id, value and extensions. The accessor "getReferenceAllele" gives direct access to the value
1251         */
1252        public SequenceVariantComponent setReferenceAlleleElement(StringType value) { 
1253          this.referenceAllele = value;
1254          return this;
1255        }
1256
1257        /**
1258         * @return An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the reference sequence. When the sequence  type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.
1259         */
1260        public String getReferenceAllele() { 
1261          return this.referenceAllele == null ? null : this.referenceAllele.getValue();
1262        }
1263
1264        /**
1265         * @param value An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the reference sequence. When the sequence  type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.
1266         */
1267        public SequenceVariantComponent setReferenceAllele(String value) { 
1268          if (Utilities.noString(value))
1269            this.referenceAllele = null;
1270          else {
1271            if (this.referenceAllele == null)
1272              this.referenceAllele = new StringType();
1273            this.referenceAllele.setValue(value);
1274          }
1275          return this;
1276        }
1277
1278        /**
1279         * @return {@link #cigar} (Extended CIGAR string for aligning the sequence with reference bases. See detailed documentation [here](http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm).). This is the underlying object with id, value and extensions. The accessor "getCigar" gives direct access to the value
1280         */
1281        public StringType getCigarElement() { 
1282          if (this.cigar == null)
1283            if (Configuration.errorOnAutoCreate())
1284              throw new Error("Attempt to auto-create SequenceVariantComponent.cigar");
1285            else if (Configuration.doAutoCreate())
1286              this.cigar = new StringType(); // bb
1287          return this.cigar;
1288        }
1289
1290        public boolean hasCigarElement() { 
1291          return this.cigar != null && !this.cigar.isEmpty();
1292        }
1293
1294        public boolean hasCigar() { 
1295          return this.cigar != null && !this.cigar.isEmpty();
1296        }
1297
1298        /**
1299         * @param value {@link #cigar} (Extended CIGAR string for aligning the sequence with reference bases. See detailed documentation [here](http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm).). This is the underlying object with id, value and extensions. The accessor "getCigar" gives direct access to the value
1300         */
1301        public SequenceVariantComponent setCigarElement(StringType value) { 
1302          this.cigar = value;
1303          return this;
1304        }
1305
1306        /**
1307         * @return Extended CIGAR string for aligning the sequence with reference bases. See detailed documentation [here](http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm).
1308         */
1309        public String getCigar() { 
1310          return this.cigar == null ? null : this.cigar.getValue();
1311        }
1312
1313        /**
1314         * @param value Extended CIGAR string for aligning the sequence with reference bases. See detailed documentation [here](http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm).
1315         */
1316        public SequenceVariantComponent setCigar(String value) { 
1317          if (Utilities.noString(value))
1318            this.cigar = null;
1319          else {
1320            if (this.cigar == null)
1321              this.cigar = new StringType();
1322            this.cigar.setValue(value);
1323          }
1324          return this;
1325        }
1326
1327        /**
1328         * @return {@link #variantPointer} (A pointer to an Observation containing variant information.)
1329         */
1330        public Reference getVariantPointer() { 
1331          if (this.variantPointer == null)
1332            if (Configuration.errorOnAutoCreate())
1333              throw new Error("Attempt to auto-create SequenceVariantComponent.variantPointer");
1334            else if (Configuration.doAutoCreate())
1335              this.variantPointer = new Reference(); // cc
1336          return this.variantPointer;
1337        }
1338
1339        public boolean hasVariantPointer() { 
1340          return this.variantPointer != null && !this.variantPointer.isEmpty();
1341        }
1342
1343        /**
1344         * @param value {@link #variantPointer} (A pointer to an Observation containing variant information.)
1345         */
1346        public SequenceVariantComponent setVariantPointer(Reference value)  { 
1347          this.variantPointer = value;
1348          return this;
1349        }
1350
1351        /**
1352         * @return {@link #variantPointer} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (A pointer to an Observation containing variant information.)
1353         */
1354        public Observation getVariantPointerTarget() { 
1355          if (this.variantPointerTarget == null)
1356            if (Configuration.errorOnAutoCreate())
1357              throw new Error("Attempt to auto-create SequenceVariantComponent.variantPointer");
1358            else if (Configuration.doAutoCreate())
1359              this.variantPointerTarget = new Observation(); // aa
1360          return this.variantPointerTarget;
1361        }
1362
1363        /**
1364         * @param value {@link #variantPointer} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (A pointer to an Observation containing variant information.)
1365         */
1366        public SequenceVariantComponent setVariantPointerTarget(Observation value) { 
1367          this.variantPointerTarget = value;
1368          return this;
1369        }
1370
1371        protected void listChildren(List<Property> children) {
1372          super.listChildren(children);
1373          children.add(new Property("start", "integer", "Start position of the variant on the  reference sequence.If the coordinate system is either 0-based or 1-based, then start position is inclusive.", 0, 1, start));
1374          children.add(new Property("end", "integer", "End position of the variant on the reference sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.", 0, 1, end));
1375          children.add(new Property("observedAllele", "string", "An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)).  Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the observed  sequence. When the sequence  type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.", 0, 1, observedAllele));
1376          children.add(new Property("referenceAllele", "string", "An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the reference sequence. When the sequence  type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.", 0, 1, referenceAllele));
1377          children.add(new Property("cigar", "string", "Extended CIGAR string for aligning the sequence with reference bases. See detailed documentation [here](http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm).", 0, 1, cigar));
1378          children.add(new Property("variantPointer", "Reference(Observation)", "A pointer to an Observation containing variant information.", 0, 1, variantPointer));
1379        }
1380
1381        @Override
1382        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1383          switch (_hash) {
1384          case 109757538: /*start*/  return new Property("start", "integer", "Start position of the variant on the  reference sequence.If the coordinate system is either 0-based or 1-based, then start position is inclusive.", 0, 1, start);
1385          case 100571: /*end*/  return new Property("end", "integer", "End position of the variant on the reference sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.", 0, 1, end);
1386          case -1418745787: /*observedAllele*/  return new Property("observedAllele", "string", "An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)).  Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the observed  sequence. When the sequence  type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.", 0, 1, observedAllele);
1387          case 364045960: /*referenceAllele*/  return new Property("referenceAllele", "string", "An allele is one of a set of coexisting sequence variants of a gene ([SO:0001023](http://www.sequenceontology.org/browser/current_svn/term/SO:0001023)). Nucleotide(s)/amino acids from start position of sequence to stop position of sequence on the positive (+) strand of the reference sequence. When the sequence  type is DNA, it should be the sequence on the positive (+) strand. This will lay in the range between variant.start and variant.end.", 0, 1, referenceAllele);
1388          case 94658738: /*cigar*/  return new Property("cigar", "string", "Extended CIGAR string for aligning the sequence with reference bases. See detailed documentation [here](http://support.illumina.com/help/SequencingAnalysisWorkflow/Content/Vault/Informatics/Sequencing_Analysis/CASAVA/swSEQ_mCA_ExtendedCIGARFormat.htm).", 0, 1, cigar);
1389          case -1654319624: /*variantPointer*/  return new Property("variantPointer", "Reference(Observation)", "A pointer to an Observation containing variant information.", 0, 1, variantPointer);
1390          default: return super.getNamedProperty(_hash, _name, _checkValid);
1391          }
1392
1393        }
1394
1395      @Override
1396      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1397        switch (hash) {
1398        case 109757538: /*start*/ return this.start == null ? new Base[0] : new Base[] {this.start}; // IntegerType
1399        case 100571: /*end*/ return this.end == null ? new Base[0] : new Base[] {this.end}; // IntegerType
1400        case -1418745787: /*observedAllele*/ return this.observedAllele == null ? new Base[0] : new Base[] {this.observedAllele}; // StringType
1401        case 364045960: /*referenceAllele*/ return this.referenceAllele == null ? new Base[0] : new Base[] {this.referenceAllele}; // StringType
1402        case 94658738: /*cigar*/ return this.cigar == null ? new Base[0] : new Base[] {this.cigar}; // StringType
1403        case -1654319624: /*variantPointer*/ return this.variantPointer == null ? new Base[0] : new Base[] {this.variantPointer}; // Reference
1404        default: return super.getProperty(hash, name, checkValid);
1405        }
1406
1407      }
1408
1409      @Override
1410      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1411        switch (hash) {
1412        case 109757538: // start
1413          this.start = castToInteger(value); // IntegerType
1414          return value;
1415        case 100571: // end
1416          this.end = castToInteger(value); // IntegerType
1417          return value;
1418        case -1418745787: // observedAllele
1419          this.observedAllele = castToString(value); // StringType
1420          return value;
1421        case 364045960: // referenceAllele
1422          this.referenceAllele = castToString(value); // StringType
1423          return value;
1424        case 94658738: // cigar
1425          this.cigar = castToString(value); // StringType
1426          return value;
1427        case -1654319624: // variantPointer
1428          this.variantPointer = castToReference(value); // Reference
1429          return value;
1430        default: return super.setProperty(hash, name, value);
1431        }
1432
1433      }
1434
1435      @Override
1436      public Base setProperty(String name, Base value) throws FHIRException {
1437        if (name.equals("start")) {
1438          this.start = castToInteger(value); // IntegerType
1439        } else if (name.equals("end")) {
1440          this.end = castToInteger(value); // IntegerType
1441        } else if (name.equals("observedAllele")) {
1442          this.observedAllele = castToString(value); // StringType
1443        } else if (name.equals("referenceAllele")) {
1444          this.referenceAllele = castToString(value); // StringType
1445        } else if (name.equals("cigar")) {
1446          this.cigar = castToString(value); // StringType
1447        } else if (name.equals("variantPointer")) {
1448          this.variantPointer = castToReference(value); // Reference
1449        } else
1450          return super.setProperty(name, value);
1451        return value;
1452      }
1453
1454      @Override
1455      public Base makeProperty(int hash, String name) throws FHIRException {
1456        switch (hash) {
1457        case 109757538:  return getStartElement();
1458        case 100571:  return getEndElement();
1459        case -1418745787:  return getObservedAlleleElement();
1460        case 364045960:  return getReferenceAlleleElement();
1461        case 94658738:  return getCigarElement();
1462        case -1654319624:  return getVariantPointer(); 
1463        default: return super.makeProperty(hash, name);
1464        }
1465
1466      }
1467
1468      @Override
1469      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1470        switch (hash) {
1471        case 109757538: /*start*/ return new String[] {"integer"};
1472        case 100571: /*end*/ return new String[] {"integer"};
1473        case -1418745787: /*observedAllele*/ return new String[] {"string"};
1474        case 364045960: /*referenceAllele*/ return new String[] {"string"};
1475        case 94658738: /*cigar*/ return new String[] {"string"};
1476        case -1654319624: /*variantPointer*/ return new String[] {"Reference"};
1477        default: return super.getTypesForProperty(hash, name);
1478        }
1479
1480      }
1481
1482      @Override
1483      public Base addChild(String name) throws FHIRException {
1484        if (name.equals("start")) {
1485          throw new FHIRException("Cannot call addChild on a primitive type Sequence.start");
1486        }
1487        else if (name.equals("end")) {
1488          throw new FHIRException("Cannot call addChild on a primitive type Sequence.end");
1489        }
1490        else if (name.equals("observedAllele")) {
1491          throw new FHIRException("Cannot call addChild on a primitive type Sequence.observedAllele");
1492        }
1493        else if (name.equals("referenceAllele")) {
1494          throw new FHIRException("Cannot call addChild on a primitive type Sequence.referenceAllele");
1495        }
1496        else if (name.equals("cigar")) {
1497          throw new FHIRException("Cannot call addChild on a primitive type Sequence.cigar");
1498        }
1499        else if (name.equals("variantPointer")) {
1500          this.variantPointer = new Reference();
1501          return this.variantPointer;
1502        }
1503        else
1504          return super.addChild(name);
1505      }
1506
1507      public SequenceVariantComponent copy() {
1508        SequenceVariantComponent dst = new SequenceVariantComponent();
1509        copyValues(dst);
1510        dst.start = start == null ? null : start.copy();
1511        dst.end = end == null ? null : end.copy();
1512        dst.observedAllele = observedAllele == null ? null : observedAllele.copy();
1513        dst.referenceAllele = referenceAllele == null ? null : referenceAllele.copy();
1514        dst.cigar = cigar == null ? null : cigar.copy();
1515        dst.variantPointer = variantPointer == null ? null : variantPointer.copy();
1516        return dst;
1517      }
1518
1519      @Override
1520      public boolean equalsDeep(Base other_) {
1521        if (!super.equalsDeep(other_))
1522          return false;
1523        if (!(other_ instanceof SequenceVariantComponent))
1524          return false;
1525        SequenceVariantComponent o = (SequenceVariantComponent) other_;
1526        return compareDeep(start, o.start, true) && compareDeep(end, o.end, true) && compareDeep(observedAllele, o.observedAllele, true)
1527           && compareDeep(referenceAllele, o.referenceAllele, true) && compareDeep(cigar, o.cigar, true) && compareDeep(variantPointer, o.variantPointer, true)
1528          ;
1529      }
1530
1531      @Override
1532      public boolean equalsShallow(Base other_) {
1533        if (!super.equalsShallow(other_))
1534          return false;
1535        if (!(other_ instanceof SequenceVariantComponent))
1536          return false;
1537        SequenceVariantComponent o = (SequenceVariantComponent) other_;
1538        return compareValues(start, o.start, true) && compareValues(end, o.end, true) && compareValues(observedAllele, o.observedAllele, true)
1539           && compareValues(referenceAllele, o.referenceAllele, true) && compareValues(cigar, o.cigar, true);
1540      }
1541
1542      public boolean isEmpty() {
1543        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(start, end, observedAllele
1544          , referenceAllele, cigar, variantPointer);
1545      }
1546
1547  public String fhirType() {
1548    return "Sequence.variant";
1549
1550  }
1551
1552  }
1553
1554    @Block()
1555    public static class SequenceQualityComponent extends BackboneElement implements IBaseBackboneElement {
1556        /**
1557         * INDEL / SNP / Undefined variant.
1558         */
1559        @Child(name = "type", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true)
1560        @Description(shortDefinition="indel | snp | unknown", formalDefinition="INDEL / SNP / Undefined variant." )
1561        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/quality-type")
1562        protected Enumeration<QualityType> type;
1563
1564        /**
1565         * Gold standard sequence used for comparing against.
1566         */
1567        @Child(name = "standardSequence", type = {CodeableConcept.class}, order=2, min=0, max=1, modifier=false, summary=true)
1568        @Description(shortDefinition="Standard sequence for comparison", formalDefinition="Gold standard sequence used for comparing against." )
1569        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/sequence-quality-standardSequence")
1570        protected CodeableConcept standardSequence;
1571
1572        /**
1573         * Start position of the sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.
1574         */
1575        @Child(name = "start", type = {IntegerType.class}, order=3, min=0, max=1, modifier=false, summary=true)
1576        @Description(shortDefinition="Start position of the sequence", formalDefinition="Start position of the sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive." )
1577        protected IntegerType start;
1578
1579        /**
1580         * End position of the sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.
1581         */
1582        @Child(name = "end", type = {IntegerType.class}, order=4, min=0, max=1, modifier=false, summary=true)
1583        @Description(shortDefinition="End position of the sequence", formalDefinition="End position of the sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position." )
1584        protected IntegerType end;
1585
1586        /**
1587         * The score of an experimentally derived feature such as a p-value ([SO:0001685](http://www.sequenceontology.org/browser/current_svn/term/SO:0001685)).
1588         */
1589        @Child(name = "score", type = {Quantity.class}, order=5, min=0, max=1, modifier=false, summary=true)
1590        @Description(shortDefinition="Quality score for the comparison", formalDefinition="The score of an experimentally derived feature such as a p-value ([SO:0001685](http://www.sequenceontology.org/browser/current_svn/term/SO:0001685))." )
1591        protected Quantity score;
1592
1593        /**
1594         * Which method is used to get sequence quality.
1595         */
1596        @Child(name = "method", type = {CodeableConcept.class}, order=6, min=0, max=1, modifier=false, summary=true)
1597        @Description(shortDefinition="Method to get quality", formalDefinition="Which method is used to get sequence quality." )
1598        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/sequence-quality-method")
1599        protected CodeableConcept method;
1600
1601        /**
1602         * True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.
1603         */
1604        @Child(name = "truthTP", type = {DecimalType.class}, order=7, min=0, max=1, modifier=false, summary=true)
1605        @Description(shortDefinition="True positives from the perspective of the truth data", formalDefinition="True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event." )
1606        protected DecimalType truthTP;
1607
1608        /**
1609         * True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.
1610         */
1611        @Child(name = "queryTP", type = {DecimalType.class}, order=8, min=0, max=1, modifier=false, summary=true)
1612        @Description(shortDefinition="True positives from the perspective of the query data", formalDefinition="True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event." )
1613        protected DecimalType queryTP;
1614
1615        /**
1616         * False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here.
1617         */
1618        @Child(name = "truthFN", type = {DecimalType.class}, order=9, min=0, max=1, modifier=false, summary=true)
1619        @Description(shortDefinition="False negatives", formalDefinition="False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here." )
1620        protected DecimalType truthFN;
1621
1622        /**
1623         * False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here.
1624         */
1625        @Child(name = "queryFP", type = {DecimalType.class}, order=10, min=0, max=1, modifier=false, summary=true)
1626        @Description(shortDefinition="False positives", formalDefinition="False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here." )
1627        protected DecimalType queryFP;
1628
1629        /**
1630         * The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar).
1631         */
1632        @Child(name = "gtFP", type = {DecimalType.class}, order=11, min=0, max=1, modifier=false, summary=true)
1633        @Description(shortDefinition="False positives where the non-REF alleles in the Truth and Query Call Sets match", formalDefinition="The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar)." )
1634        protected DecimalType gtFP;
1635
1636        /**
1637         * QUERY.TP / (QUERY.TP + QUERY.FP).
1638         */
1639        @Child(name = "precision", type = {DecimalType.class}, order=12, min=0, max=1, modifier=false, summary=true)
1640        @Description(shortDefinition="Precision of comparison", formalDefinition="QUERY.TP / (QUERY.TP + QUERY.FP)." )
1641        protected DecimalType precision;
1642
1643        /**
1644         * TRUTH.TP / (TRUTH.TP + TRUTH.FN).
1645         */
1646        @Child(name = "recall", type = {DecimalType.class}, order=13, min=0, max=1, modifier=false, summary=true)
1647        @Description(shortDefinition="Recall of comparison", formalDefinition="TRUTH.TP / (TRUTH.TP + TRUTH.FN)." )
1648        protected DecimalType recall;
1649
1650        /**
1651         * Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall).
1652         */
1653        @Child(name = "fScore", type = {DecimalType.class}, order=14, min=0, max=1, modifier=false, summary=true)
1654        @Description(shortDefinition="F-score", formalDefinition="Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall)." )
1655        protected DecimalType fScore;
1656
1657        private static final long serialVersionUID = -383644463L;
1658
1659    /**
1660     * Constructor
1661     */
1662      public SequenceQualityComponent() {
1663        super();
1664      }
1665
1666    /**
1667     * Constructor
1668     */
1669      public SequenceQualityComponent(Enumeration<QualityType> type) {
1670        super();
1671        this.type = type;
1672      }
1673
1674        /**
1675         * @return {@link #type} (INDEL / SNP / Undefined variant.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
1676         */
1677        public Enumeration<QualityType> getTypeElement() { 
1678          if (this.type == null)
1679            if (Configuration.errorOnAutoCreate())
1680              throw new Error("Attempt to auto-create SequenceQualityComponent.type");
1681            else if (Configuration.doAutoCreate())
1682              this.type = new Enumeration<QualityType>(new QualityTypeEnumFactory()); // bb
1683          return this.type;
1684        }
1685
1686        public boolean hasTypeElement() { 
1687          return this.type != null && !this.type.isEmpty();
1688        }
1689
1690        public boolean hasType() { 
1691          return this.type != null && !this.type.isEmpty();
1692        }
1693
1694        /**
1695         * @param value {@link #type} (INDEL / SNP / Undefined variant.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
1696         */
1697        public SequenceQualityComponent setTypeElement(Enumeration<QualityType> value) { 
1698          this.type = value;
1699          return this;
1700        }
1701
1702        /**
1703         * @return INDEL / SNP / Undefined variant.
1704         */
1705        public QualityType getType() { 
1706          return this.type == null ? null : this.type.getValue();
1707        }
1708
1709        /**
1710         * @param value INDEL / SNP / Undefined variant.
1711         */
1712        public SequenceQualityComponent setType(QualityType value) { 
1713            if (this.type == null)
1714              this.type = new Enumeration<QualityType>(new QualityTypeEnumFactory());
1715            this.type.setValue(value);
1716          return this;
1717        }
1718
1719        /**
1720         * @return {@link #standardSequence} (Gold standard sequence used for comparing against.)
1721         */
1722        public CodeableConcept getStandardSequence() { 
1723          if (this.standardSequence == null)
1724            if (Configuration.errorOnAutoCreate())
1725              throw new Error("Attempt to auto-create SequenceQualityComponent.standardSequence");
1726            else if (Configuration.doAutoCreate())
1727              this.standardSequence = new CodeableConcept(); // cc
1728          return this.standardSequence;
1729        }
1730
1731        public boolean hasStandardSequence() { 
1732          return this.standardSequence != null && !this.standardSequence.isEmpty();
1733        }
1734
1735        /**
1736         * @param value {@link #standardSequence} (Gold standard sequence used for comparing against.)
1737         */
1738        public SequenceQualityComponent setStandardSequence(CodeableConcept value)  { 
1739          this.standardSequence = value;
1740          return this;
1741        }
1742
1743        /**
1744         * @return {@link #start} (Start position of the sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.). This is the underlying object with id, value and extensions. The accessor "getStart" gives direct access to the value
1745         */
1746        public IntegerType getStartElement() { 
1747          if (this.start == null)
1748            if (Configuration.errorOnAutoCreate())
1749              throw new Error("Attempt to auto-create SequenceQualityComponent.start");
1750            else if (Configuration.doAutoCreate())
1751              this.start = new IntegerType(); // bb
1752          return this.start;
1753        }
1754
1755        public boolean hasStartElement() { 
1756          return this.start != null && !this.start.isEmpty();
1757        }
1758
1759        public boolean hasStart() { 
1760          return this.start != null && !this.start.isEmpty();
1761        }
1762
1763        /**
1764         * @param value {@link #start} (Start position of the sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.). This is the underlying object with id, value and extensions. The accessor "getStart" gives direct access to the value
1765         */
1766        public SequenceQualityComponent setStartElement(IntegerType value) { 
1767          this.start = value;
1768          return this;
1769        }
1770
1771        /**
1772         * @return Start position of the sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.
1773         */
1774        public int getStart() { 
1775          return this.start == null || this.start.isEmpty() ? 0 : this.start.getValue();
1776        }
1777
1778        /**
1779         * @param value Start position of the sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.
1780         */
1781        public SequenceQualityComponent setStart(int value) { 
1782            if (this.start == null)
1783              this.start = new IntegerType();
1784            this.start.setValue(value);
1785          return this;
1786        }
1787
1788        /**
1789         * @return {@link #end} (End position of the sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.). This is the underlying object with id, value and extensions. The accessor "getEnd" gives direct access to the value
1790         */
1791        public IntegerType getEndElement() { 
1792          if (this.end == null)
1793            if (Configuration.errorOnAutoCreate())
1794              throw new Error("Attempt to auto-create SequenceQualityComponent.end");
1795            else if (Configuration.doAutoCreate())
1796              this.end = new IntegerType(); // bb
1797          return this.end;
1798        }
1799
1800        public boolean hasEndElement() { 
1801          return this.end != null && !this.end.isEmpty();
1802        }
1803
1804        public boolean hasEnd() { 
1805          return this.end != null && !this.end.isEmpty();
1806        }
1807
1808        /**
1809         * @param value {@link #end} (End position of the sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.). This is the underlying object with id, value and extensions. The accessor "getEnd" gives direct access to the value
1810         */
1811        public SequenceQualityComponent setEndElement(IntegerType value) { 
1812          this.end = value;
1813          return this;
1814        }
1815
1816        /**
1817         * @return End position of the sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.
1818         */
1819        public int getEnd() { 
1820          return this.end == null || this.end.isEmpty() ? 0 : this.end.getValue();
1821        }
1822
1823        /**
1824         * @param value End position of the sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.
1825         */
1826        public SequenceQualityComponent setEnd(int value) { 
1827            if (this.end == null)
1828              this.end = new IntegerType();
1829            this.end.setValue(value);
1830          return this;
1831        }
1832
1833        /**
1834         * @return {@link #score} (The score of an experimentally derived feature such as a p-value ([SO:0001685](http://www.sequenceontology.org/browser/current_svn/term/SO:0001685)).)
1835         */
1836        public Quantity getScore() { 
1837          if (this.score == null)
1838            if (Configuration.errorOnAutoCreate())
1839              throw new Error("Attempt to auto-create SequenceQualityComponent.score");
1840            else if (Configuration.doAutoCreate())
1841              this.score = new Quantity(); // cc
1842          return this.score;
1843        }
1844
1845        public boolean hasScore() { 
1846          return this.score != null && !this.score.isEmpty();
1847        }
1848
1849        /**
1850         * @param value {@link #score} (The score of an experimentally derived feature such as a p-value ([SO:0001685](http://www.sequenceontology.org/browser/current_svn/term/SO:0001685)).)
1851         */
1852        public SequenceQualityComponent setScore(Quantity value)  { 
1853          this.score = value;
1854          return this;
1855        }
1856
1857        /**
1858         * @return {@link #method} (Which method is used to get sequence quality.)
1859         */
1860        public CodeableConcept getMethod() { 
1861          if (this.method == null)
1862            if (Configuration.errorOnAutoCreate())
1863              throw new Error("Attempt to auto-create SequenceQualityComponent.method");
1864            else if (Configuration.doAutoCreate())
1865              this.method = new CodeableConcept(); // cc
1866          return this.method;
1867        }
1868
1869        public boolean hasMethod() { 
1870          return this.method != null && !this.method.isEmpty();
1871        }
1872
1873        /**
1874         * @param value {@link #method} (Which method is used to get sequence quality.)
1875         */
1876        public SequenceQualityComponent setMethod(CodeableConcept value)  { 
1877          this.method = value;
1878          return this;
1879        }
1880
1881        /**
1882         * @return {@link #truthTP} (True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.). This is the underlying object with id, value and extensions. The accessor "getTruthTP" gives direct access to the value
1883         */
1884        public DecimalType getTruthTPElement() { 
1885          if (this.truthTP == null)
1886            if (Configuration.errorOnAutoCreate())
1887              throw new Error("Attempt to auto-create SequenceQualityComponent.truthTP");
1888            else if (Configuration.doAutoCreate())
1889              this.truthTP = new DecimalType(); // bb
1890          return this.truthTP;
1891        }
1892
1893        public boolean hasTruthTPElement() { 
1894          return this.truthTP != null && !this.truthTP.isEmpty();
1895        }
1896
1897        public boolean hasTruthTP() { 
1898          return this.truthTP != null && !this.truthTP.isEmpty();
1899        }
1900
1901        /**
1902         * @param value {@link #truthTP} (True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.). This is the underlying object with id, value and extensions. The accessor "getTruthTP" gives direct access to the value
1903         */
1904        public SequenceQualityComponent setTruthTPElement(DecimalType value) { 
1905          this.truthTP = value;
1906          return this;
1907        }
1908
1909        /**
1910         * @return True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.
1911         */
1912        public BigDecimal getTruthTP() { 
1913          return this.truthTP == null ? null : this.truthTP.getValue();
1914        }
1915
1916        /**
1917         * @param value True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.
1918         */
1919        public SequenceQualityComponent setTruthTP(BigDecimal value) { 
1920          if (value == null)
1921            this.truthTP = null;
1922          else {
1923            if (this.truthTP == null)
1924              this.truthTP = new DecimalType();
1925            this.truthTP.setValue(value);
1926          }
1927          return this;
1928        }
1929
1930        /**
1931         * @param value True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.
1932         */
1933        public SequenceQualityComponent setTruthTP(long value) { 
1934              this.truthTP = new DecimalType();
1935            this.truthTP.setValue(value);
1936          return this;
1937        }
1938
1939        /**
1940         * @param value True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.
1941         */
1942        public SequenceQualityComponent setTruthTP(double value) { 
1943              this.truthTP = new DecimalType();
1944            this.truthTP.setValue(value);
1945          return this;
1946        }
1947
1948        /**
1949         * @return {@link #queryTP} (True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.). This is the underlying object with id, value and extensions. The accessor "getQueryTP" gives direct access to the value
1950         */
1951        public DecimalType getQueryTPElement() { 
1952          if (this.queryTP == null)
1953            if (Configuration.errorOnAutoCreate())
1954              throw new Error("Attempt to auto-create SequenceQualityComponent.queryTP");
1955            else if (Configuration.doAutoCreate())
1956              this.queryTP = new DecimalType(); // bb
1957          return this.queryTP;
1958        }
1959
1960        public boolean hasQueryTPElement() { 
1961          return this.queryTP != null && !this.queryTP.isEmpty();
1962        }
1963
1964        public boolean hasQueryTP() { 
1965          return this.queryTP != null && !this.queryTP.isEmpty();
1966        }
1967
1968        /**
1969         * @param value {@link #queryTP} (True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.). This is the underlying object with id, value and extensions. The accessor "getQueryTP" gives direct access to the value
1970         */
1971        public SequenceQualityComponent setQueryTPElement(DecimalType value) { 
1972          this.queryTP = value;
1973          return this;
1974        }
1975
1976        /**
1977         * @return True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.
1978         */
1979        public BigDecimal getQueryTP() { 
1980          return this.queryTP == null ? null : this.queryTP.getValue();
1981        }
1982
1983        /**
1984         * @param value True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.
1985         */
1986        public SequenceQualityComponent setQueryTP(BigDecimal value) { 
1987          if (value == null)
1988            this.queryTP = null;
1989          else {
1990            if (this.queryTP == null)
1991              this.queryTP = new DecimalType();
1992            this.queryTP.setValue(value);
1993          }
1994          return this;
1995        }
1996
1997        /**
1998         * @param value True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.
1999         */
2000        public SequenceQualityComponent setQueryTP(long value) { 
2001              this.queryTP = new DecimalType();
2002            this.queryTP.setValue(value);
2003          return this;
2004        }
2005
2006        /**
2007         * @param value True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.
2008         */
2009        public SequenceQualityComponent setQueryTP(double value) { 
2010              this.queryTP = new DecimalType();
2011            this.queryTP.setValue(value);
2012          return this;
2013        }
2014
2015        /**
2016         * @return {@link #truthFN} (False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here.). This is the underlying object with id, value and extensions. The accessor "getTruthFN" gives direct access to the value
2017         */
2018        public DecimalType getTruthFNElement() { 
2019          if (this.truthFN == null)
2020            if (Configuration.errorOnAutoCreate())
2021              throw new Error("Attempt to auto-create SequenceQualityComponent.truthFN");
2022            else if (Configuration.doAutoCreate())
2023              this.truthFN = new DecimalType(); // bb
2024          return this.truthFN;
2025        }
2026
2027        public boolean hasTruthFNElement() { 
2028          return this.truthFN != null && !this.truthFN.isEmpty();
2029        }
2030
2031        public boolean hasTruthFN() { 
2032          return this.truthFN != null && !this.truthFN.isEmpty();
2033        }
2034
2035        /**
2036         * @param value {@link #truthFN} (False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here.). This is the underlying object with id, value and extensions. The accessor "getTruthFN" gives direct access to the value
2037         */
2038        public SequenceQualityComponent setTruthFNElement(DecimalType value) { 
2039          this.truthFN = value;
2040          return this;
2041        }
2042
2043        /**
2044         * @return False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here.
2045         */
2046        public BigDecimal getTruthFN() { 
2047          return this.truthFN == null ? null : this.truthFN.getValue();
2048        }
2049
2050        /**
2051         * @param value False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here.
2052         */
2053        public SequenceQualityComponent setTruthFN(BigDecimal value) { 
2054          if (value == null)
2055            this.truthFN = null;
2056          else {
2057            if (this.truthFN == null)
2058              this.truthFN = new DecimalType();
2059            this.truthFN.setValue(value);
2060          }
2061          return this;
2062        }
2063
2064        /**
2065         * @param value False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here.
2066         */
2067        public SequenceQualityComponent setTruthFN(long value) { 
2068              this.truthFN = new DecimalType();
2069            this.truthFN.setValue(value);
2070          return this;
2071        }
2072
2073        /**
2074         * @param value False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here.
2075         */
2076        public SequenceQualityComponent setTruthFN(double value) { 
2077              this.truthFN = new DecimalType();
2078            this.truthFN.setValue(value);
2079          return this;
2080        }
2081
2082        /**
2083         * @return {@link #queryFP} (False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here.). This is the underlying object with id, value and extensions. The accessor "getQueryFP" gives direct access to the value
2084         */
2085        public DecimalType getQueryFPElement() { 
2086          if (this.queryFP == null)
2087            if (Configuration.errorOnAutoCreate())
2088              throw new Error("Attempt to auto-create SequenceQualityComponent.queryFP");
2089            else if (Configuration.doAutoCreate())
2090              this.queryFP = new DecimalType(); // bb
2091          return this.queryFP;
2092        }
2093
2094        public boolean hasQueryFPElement() { 
2095          return this.queryFP != null && !this.queryFP.isEmpty();
2096        }
2097
2098        public boolean hasQueryFP() { 
2099          return this.queryFP != null && !this.queryFP.isEmpty();
2100        }
2101
2102        /**
2103         * @param value {@link #queryFP} (False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here.). This is the underlying object with id, value and extensions. The accessor "getQueryFP" gives direct access to the value
2104         */
2105        public SequenceQualityComponent setQueryFPElement(DecimalType value) { 
2106          this.queryFP = value;
2107          return this;
2108        }
2109
2110        /**
2111         * @return False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here.
2112         */
2113        public BigDecimal getQueryFP() { 
2114          return this.queryFP == null ? null : this.queryFP.getValue();
2115        }
2116
2117        /**
2118         * @param value False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here.
2119         */
2120        public SequenceQualityComponent setQueryFP(BigDecimal value) { 
2121          if (value == null)
2122            this.queryFP = null;
2123          else {
2124            if (this.queryFP == null)
2125              this.queryFP = new DecimalType();
2126            this.queryFP.setValue(value);
2127          }
2128          return this;
2129        }
2130
2131        /**
2132         * @param value False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here.
2133         */
2134        public SequenceQualityComponent setQueryFP(long value) { 
2135              this.queryFP = new DecimalType();
2136            this.queryFP.setValue(value);
2137          return this;
2138        }
2139
2140        /**
2141         * @param value False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here.
2142         */
2143        public SequenceQualityComponent setQueryFP(double value) { 
2144              this.queryFP = new DecimalType();
2145            this.queryFP.setValue(value);
2146          return this;
2147        }
2148
2149        /**
2150         * @return {@link #gtFP} (The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar).). This is the underlying object with id, value and extensions. The accessor "getGtFP" gives direct access to the value
2151         */
2152        public DecimalType getGtFPElement() { 
2153          if (this.gtFP == null)
2154            if (Configuration.errorOnAutoCreate())
2155              throw new Error("Attempt to auto-create SequenceQualityComponent.gtFP");
2156            else if (Configuration.doAutoCreate())
2157              this.gtFP = new DecimalType(); // bb
2158          return this.gtFP;
2159        }
2160
2161        public boolean hasGtFPElement() { 
2162          return this.gtFP != null && !this.gtFP.isEmpty();
2163        }
2164
2165        public boolean hasGtFP() { 
2166          return this.gtFP != null && !this.gtFP.isEmpty();
2167        }
2168
2169        /**
2170         * @param value {@link #gtFP} (The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar).). This is the underlying object with id, value and extensions. The accessor "getGtFP" gives direct access to the value
2171         */
2172        public SequenceQualityComponent setGtFPElement(DecimalType value) { 
2173          this.gtFP = value;
2174          return this;
2175        }
2176
2177        /**
2178         * @return The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar).
2179         */
2180        public BigDecimal getGtFP() { 
2181          return this.gtFP == null ? null : this.gtFP.getValue();
2182        }
2183
2184        /**
2185         * @param value The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar).
2186         */
2187        public SequenceQualityComponent setGtFP(BigDecimal value) { 
2188          if (value == null)
2189            this.gtFP = null;
2190          else {
2191            if (this.gtFP == null)
2192              this.gtFP = new DecimalType();
2193            this.gtFP.setValue(value);
2194          }
2195          return this;
2196        }
2197
2198        /**
2199         * @param value The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar).
2200         */
2201        public SequenceQualityComponent setGtFP(long value) { 
2202              this.gtFP = new DecimalType();
2203            this.gtFP.setValue(value);
2204          return this;
2205        }
2206
2207        /**
2208         * @param value The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar).
2209         */
2210        public SequenceQualityComponent setGtFP(double value) { 
2211              this.gtFP = new DecimalType();
2212            this.gtFP.setValue(value);
2213          return this;
2214        }
2215
2216        /**
2217         * @return {@link #precision} (QUERY.TP / (QUERY.TP + QUERY.FP).). This is the underlying object with id, value and extensions. The accessor "getPrecision" gives direct access to the value
2218         */
2219        public DecimalType getPrecisionElement() { 
2220          if (this.precision == null)
2221            if (Configuration.errorOnAutoCreate())
2222              throw new Error("Attempt to auto-create SequenceQualityComponent.precision");
2223            else if (Configuration.doAutoCreate())
2224              this.precision = new DecimalType(); // bb
2225          return this.precision;
2226        }
2227
2228        public boolean hasPrecisionElement() { 
2229          return this.precision != null && !this.precision.isEmpty();
2230        }
2231
2232        public boolean hasPrecision() { 
2233          return this.precision != null && !this.precision.isEmpty();
2234        }
2235
2236        /**
2237         * @param value {@link #precision} (QUERY.TP / (QUERY.TP + QUERY.FP).). This is the underlying object with id, value and extensions. The accessor "getPrecision" gives direct access to the value
2238         */
2239        public SequenceQualityComponent setPrecisionElement(DecimalType value) { 
2240          this.precision = value;
2241          return this;
2242        }
2243
2244        /**
2245         * @return QUERY.TP / (QUERY.TP + QUERY.FP).
2246         */
2247        public BigDecimal getPrecision() { 
2248          return this.precision == null ? null : this.precision.getValue();
2249        }
2250
2251        /**
2252         * @param value QUERY.TP / (QUERY.TP + QUERY.FP).
2253         */
2254        public SequenceQualityComponent setPrecision(BigDecimal value) { 
2255          if (value == null)
2256            this.precision = null;
2257          else {
2258            if (this.precision == null)
2259              this.precision = new DecimalType();
2260            this.precision.setValue(value);
2261          }
2262          return this;
2263        }
2264
2265        /**
2266         * @param value QUERY.TP / (QUERY.TP + QUERY.FP).
2267         */
2268        public SequenceQualityComponent setPrecision(long value) { 
2269              this.precision = new DecimalType();
2270            this.precision.setValue(value);
2271          return this;
2272        }
2273
2274        /**
2275         * @param value QUERY.TP / (QUERY.TP + QUERY.FP).
2276         */
2277        public SequenceQualityComponent setPrecision(double value) { 
2278              this.precision = new DecimalType();
2279            this.precision.setValue(value);
2280          return this;
2281        }
2282
2283        /**
2284         * @return {@link #recall} (TRUTH.TP / (TRUTH.TP + TRUTH.FN).). This is the underlying object with id, value and extensions. The accessor "getRecall" gives direct access to the value
2285         */
2286        public DecimalType getRecallElement() { 
2287          if (this.recall == null)
2288            if (Configuration.errorOnAutoCreate())
2289              throw new Error("Attempt to auto-create SequenceQualityComponent.recall");
2290            else if (Configuration.doAutoCreate())
2291              this.recall = new DecimalType(); // bb
2292          return this.recall;
2293        }
2294
2295        public boolean hasRecallElement() { 
2296          return this.recall != null && !this.recall.isEmpty();
2297        }
2298
2299        public boolean hasRecall() { 
2300          return this.recall != null && !this.recall.isEmpty();
2301        }
2302
2303        /**
2304         * @param value {@link #recall} (TRUTH.TP / (TRUTH.TP + TRUTH.FN).). This is the underlying object with id, value and extensions. The accessor "getRecall" gives direct access to the value
2305         */
2306        public SequenceQualityComponent setRecallElement(DecimalType value) { 
2307          this.recall = value;
2308          return this;
2309        }
2310
2311        /**
2312         * @return TRUTH.TP / (TRUTH.TP + TRUTH.FN).
2313         */
2314        public BigDecimal getRecall() { 
2315          return this.recall == null ? null : this.recall.getValue();
2316        }
2317
2318        /**
2319         * @param value TRUTH.TP / (TRUTH.TP + TRUTH.FN).
2320         */
2321        public SequenceQualityComponent setRecall(BigDecimal value) { 
2322          if (value == null)
2323            this.recall = null;
2324          else {
2325            if (this.recall == null)
2326              this.recall = new DecimalType();
2327            this.recall.setValue(value);
2328          }
2329          return this;
2330        }
2331
2332        /**
2333         * @param value TRUTH.TP / (TRUTH.TP + TRUTH.FN).
2334         */
2335        public SequenceQualityComponent setRecall(long value) { 
2336              this.recall = new DecimalType();
2337            this.recall.setValue(value);
2338          return this;
2339        }
2340
2341        /**
2342         * @param value TRUTH.TP / (TRUTH.TP + TRUTH.FN).
2343         */
2344        public SequenceQualityComponent setRecall(double value) { 
2345              this.recall = new DecimalType();
2346            this.recall.setValue(value);
2347          return this;
2348        }
2349
2350        /**
2351         * @return {@link #fScore} (Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall).). This is the underlying object with id, value and extensions. The accessor "getFScore" gives direct access to the value
2352         */
2353        public DecimalType getFScoreElement() { 
2354          if (this.fScore == null)
2355            if (Configuration.errorOnAutoCreate())
2356              throw new Error("Attempt to auto-create SequenceQualityComponent.fScore");
2357            else if (Configuration.doAutoCreate())
2358              this.fScore = new DecimalType(); // bb
2359          return this.fScore;
2360        }
2361
2362        public boolean hasFScoreElement() { 
2363          return this.fScore != null && !this.fScore.isEmpty();
2364        }
2365
2366        public boolean hasFScore() { 
2367          return this.fScore != null && !this.fScore.isEmpty();
2368        }
2369
2370        /**
2371         * @param value {@link #fScore} (Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall).). This is the underlying object with id, value and extensions. The accessor "getFScore" gives direct access to the value
2372         */
2373        public SequenceQualityComponent setFScoreElement(DecimalType value) { 
2374          this.fScore = value;
2375          return this;
2376        }
2377
2378        /**
2379         * @return Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall).
2380         */
2381        public BigDecimal getFScore() { 
2382          return this.fScore == null ? null : this.fScore.getValue();
2383        }
2384
2385        /**
2386         * @param value Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall).
2387         */
2388        public SequenceQualityComponent setFScore(BigDecimal value) { 
2389          if (value == null)
2390            this.fScore = null;
2391          else {
2392            if (this.fScore == null)
2393              this.fScore = new DecimalType();
2394            this.fScore.setValue(value);
2395          }
2396          return this;
2397        }
2398
2399        /**
2400         * @param value Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall).
2401         */
2402        public SequenceQualityComponent setFScore(long value) { 
2403              this.fScore = new DecimalType();
2404            this.fScore.setValue(value);
2405          return this;
2406        }
2407
2408        /**
2409         * @param value Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall).
2410         */
2411        public SequenceQualityComponent setFScore(double value) { 
2412              this.fScore = new DecimalType();
2413            this.fScore.setValue(value);
2414          return this;
2415        }
2416
2417        protected void listChildren(List<Property> children) {
2418          super.listChildren(children);
2419          children.add(new Property("type", "code", "INDEL / SNP / Undefined variant.", 0, 1, type));
2420          children.add(new Property("standardSequence", "CodeableConcept", "Gold standard sequence used for comparing against.", 0, 1, standardSequence));
2421          children.add(new Property("start", "integer", "Start position of the sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.", 0, 1, start));
2422          children.add(new Property("end", "integer", "End position of the sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.", 0, 1, end));
2423          children.add(new Property("score", "Quantity", "The score of an experimentally derived feature such as a p-value ([SO:0001685](http://www.sequenceontology.org/browser/current_svn/term/SO:0001685)).", 0, 1, score));
2424          children.add(new Property("method", "CodeableConcept", "Which method is used to get sequence quality.", 0, 1, method));
2425          children.add(new Property("truthTP", "decimal", "True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.", 0, 1, truthTP));
2426          children.add(new Property("queryTP", "decimal", "True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.", 0, 1, queryTP));
2427          children.add(new Property("truthFN", "decimal", "False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here.", 0, 1, truthFN));
2428          children.add(new Property("queryFP", "decimal", "False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here.", 0, 1, queryFP));
2429          children.add(new Property("gtFP", "decimal", "The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar).", 0, 1, gtFP));
2430          children.add(new Property("precision", "decimal", "QUERY.TP / (QUERY.TP + QUERY.FP).", 0, 1, precision));
2431          children.add(new Property("recall", "decimal", "TRUTH.TP / (TRUTH.TP + TRUTH.FN).", 0, 1, recall));
2432          children.add(new Property("fScore", "decimal", "Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall).", 0, 1, fScore));
2433        }
2434
2435        @Override
2436        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2437          switch (_hash) {
2438          case 3575610: /*type*/  return new Property("type", "code", "INDEL / SNP / Undefined variant.", 0, 1, type);
2439          case -1861227106: /*standardSequence*/  return new Property("standardSequence", "CodeableConcept", "Gold standard sequence used for comparing against.", 0, 1, standardSequence);
2440          case 109757538: /*start*/  return new Property("start", "integer", "Start position of the sequence. If the coordinate system is either 0-based or 1-based, then start position is inclusive.", 0, 1, start);
2441          case 100571: /*end*/  return new Property("end", "integer", "End position of the sequence.If the coordinate system is 0-based then end is is exclusive and does not include the last position. If the coordinate system is 1-base, then end is inclusive and includes the last position.", 0, 1, end);
2442          case 109264530: /*score*/  return new Property("score", "Quantity", "The score of an experimentally derived feature such as a p-value ([SO:0001685](http://www.sequenceontology.org/browser/current_svn/term/SO:0001685)).", 0, 1, score);
2443          case -1077554975: /*method*/  return new Property("method", "CodeableConcept", "Which method is used to get sequence quality.", 0, 1, method);
2444          case -1048421849: /*truthTP*/  return new Property("truthTP", "decimal", "True positives, from the perspective of the truth data, i.e. the number of sites in the Truth Call Set for which there are paths through the Query Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.", 0, 1, truthTP);
2445          case 655102276: /*queryTP*/  return new Property("queryTP", "decimal", "True positives, from the perspective of the query data, i.e. the number of sites in the Query Call Set for which there are paths through the Truth Call Set that are consistent with all of the alleles at this site, and for which there is an accurate genotype call for the event.", 0, 1, queryTP);
2446          case -1048422285: /*truthFN*/  return new Property("truthFN", "decimal", "False negatives, i.e. the number of sites in the Truth Call Set for which there is no path through the Query Call Set that is consistent with all of the alleles at this site, or sites for which there is an inaccurate genotype call for the event. Sites with correct variant but incorrect genotype are counted here.", 0, 1, truthFN);
2447          case 655101842: /*queryFP*/  return new Property("queryFP", "decimal", "False positives, i.e. the number of sites in the Query Call Set for which there is no path through the Truth Call Set that is consistent with this site. Sites with correct variant but incorrect genotype are counted here.", 0, 1, queryFP);
2448          case 3182199: /*gtFP*/  return new Property("gtFP", "decimal", "The number of false positives where the non-REF alleles in the Truth and Query Call Sets match (i.e. cases where the truth is 1/1 and the query is 0/1 or similar).", 0, 1, gtFP);
2449          case -1376177026: /*precision*/  return new Property("precision", "decimal", "QUERY.TP / (QUERY.TP + QUERY.FP).", 0, 1, precision);
2450          case -934922479: /*recall*/  return new Property("recall", "decimal", "TRUTH.TP / (TRUTH.TP + TRUTH.FN).", 0, 1, recall);
2451          case -1295082036: /*fScore*/  return new Property("fScore", "decimal", "Harmonic mean of Recall and Precision, computed as: 2 * precision * recall / (precision + recall).", 0, 1, fScore);
2452          default: return super.getNamedProperty(_hash, _name, _checkValid);
2453          }
2454
2455        }
2456
2457      @Override
2458      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2459        switch (hash) {
2460        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<QualityType>
2461        case -1861227106: /*standardSequence*/ return this.standardSequence == null ? new Base[0] : new Base[] {this.standardSequence}; // CodeableConcept
2462        case 109757538: /*start*/ return this.start == null ? new Base[0] : new Base[] {this.start}; // IntegerType
2463        case 100571: /*end*/ return this.end == null ? new Base[0] : new Base[] {this.end}; // IntegerType
2464        case 109264530: /*score*/ return this.score == null ? new Base[0] : new Base[] {this.score}; // Quantity
2465        case -1077554975: /*method*/ return this.method == null ? new Base[0] : new Base[] {this.method}; // CodeableConcept
2466        case -1048421849: /*truthTP*/ return this.truthTP == null ? new Base[0] : new Base[] {this.truthTP}; // DecimalType
2467        case 655102276: /*queryTP*/ return this.queryTP == null ? new Base[0] : new Base[] {this.queryTP}; // DecimalType
2468        case -1048422285: /*truthFN*/ return this.truthFN == null ? new Base[0] : new Base[] {this.truthFN}; // DecimalType
2469        case 655101842: /*queryFP*/ return this.queryFP == null ? new Base[0] : new Base[] {this.queryFP}; // DecimalType
2470        case 3182199: /*gtFP*/ return this.gtFP == null ? new Base[0] : new Base[] {this.gtFP}; // DecimalType
2471        case -1376177026: /*precision*/ return this.precision == null ? new Base[0] : new Base[] {this.precision}; // DecimalType
2472        case -934922479: /*recall*/ return this.recall == null ? new Base[0] : new Base[] {this.recall}; // DecimalType
2473        case -1295082036: /*fScore*/ return this.fScore == null ? new Base[0] : new Base[] {this.fScore}; // DecimalType
2474        default: return super.getProperty(hash, name, checkValid);
2475        }
2476
2477      }
2478
2479      @Override
2480      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2481        switch (hash) {
2482        case 3575610: // type
2483          value = new QualityTypeEnumFactory().fromType(castToCode(value));
2484          this.type = (Enumeration) value; // Enumeration<QualityType>
2485          return value;
2486        case -1861227106: // standardSequence
2487          this.standardSequence = castToCodeableConcept(value); // CodeableConcept
2488          return value;
2489        case 109757538: // start
2490          this.start = castToInteger(value); // IntegerType
2491          return value;
2492        case 100571: // end
2493          this.end = castToInteger(value); // IntegerType
2494          return value;
2495        case 109264530: // score
2496          this.score = castToQuantity(value); // Quantity
2497          return value;
2498        case -1077554975: // method
2499          this.method = castToCodeableConcept(value); // CodeableConcept
2500          return value;
2501        case -1048421849: // truthTP
2502          this.truthTP = castToDecimal(value); // DecimalType
2503          return value;
2504        case 655102276: // queryTP
2505          this.queryTP = castToDecimal(value); // DecimalType
2506          return value;
2507        case -1048422285: // truthFN
2508          this.truthFN = castToDecimal(value); // DecimalType
2509          return value;
2510        case 655101842: // queryFP
2511          this.queryFP = castToDecimal(value); // DecimalType
2512          return value;
2513        case 3182199: // gtFP
2514          this.gtFP = castToDecimal(value); // DecimalType
2515          return value;
2516        case -1376177026: // precision
2517          this.precision = castToDecimal(value); // DecimalType
2518          return value;
2519        case -934922479: // recall
2520          this.recall = castToDecimal(value); // DecimalType
2521          return value;
2522        case -1295082036: // fScore
2523          this.fScore = castToDecimal(value); // DecimalType
2524          return value;
2525        default: return super.setProperty(hash, name, value);
2526        }
2527
2528      }
2529
2530      @Override
2531      public Base setProperty(String name, Base value) throws FHIRException {
2532        if (name.equals("type")) {
2533          value = new QualityTypeEnumFactory().fromType(castToCode(value));
2534          this.type = (Enumeration) value; // Enumeration<QualityType>
2535        } else if (name.equals("standardSequence")) {
2536          this.standardSequence = castToCodeableConcept(value); // CodeableConcept
2537        } else if (name.equals("start")) {
2538          this.start = castToInteger(value); // IntegerType
2539        } else if (name.equals("end")) {
2540          this.end = castToInteger(value); // IntegerType
2541        } else if (name.equals("score")) {
2542          this.score = castToQuantity(value); // Quantity
2543        } else if (name.equals("method")) {
2544          this.method = castToCodeableConcept(value); // CodeableConcept
2545        } else if (name.equals("truthTP")) {
2546          this.truthTP = castToDecimal(value); // DecimalType
2547        } else if (name.equals("queryTP")) {
2548          this.queryTP = castToDecimal(value); // DecimalType
2549        } else if (name.equals("truthFN")) {
2550          this.truthFN = castToDecimal(value); // DecimalType
2551        } else if (name.equals("queryFP")) {
2552          this.queryFP = castToDecimal(value); // DecimalType
2553        } else if (name.equals("gtFP")) {
2554          this.gtFP = castToDecimal(value); // DecimalType
2555        } else if (name.equals("precision")) {
2556          this.precision = castToDecimal(value); // DecimalType
2557        } else if (name.equals("recall")) {
2558          this.recall = castToDecimal(value); // DecimalType
2559        } else if (name.equals("fScore")) {
2560          this.fScore = castToDecimal(value); // DecimalType
2561        } else
2562          return super.setProperty(name, value);
2563        return value;
2564      }
2565
2566      @Override
2567      public Base makeProperty(int hash, String name) throws FHIRException {
2568        switch (hash) {
2569        case 3575610:  return getTypeElement();
2570        case -1861227106:  return getStandardSequence(); 
2571        case 109757538:  return getStartElement();
2572        case 100571:  return getEndElement();
2573        case 109264530:  return getScore(); 
2574        case -1077554975:  return getMethod(); 
2575        case -1048421849:  return getTruthTPElement();
2576        case 655102276:  return getQueryTPElement();
2577        case -1048422285:  return getTruthFNElement();
2578        case 655101842:  return getQueryFPElement();
2579        case 3182199:  return getGtFPElement();
2580        case -1376177026:  return getPrecisionElement();
2581        case -934922479:  return getRecallElement();
2582        case -1295082036:  return getFScoreElement();
2583        default: return super.makeProperty(hash, name);
2584        }
2585
2586      }
2587
2588      @Override
2589      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2590        switch (hash) {
2591        case 3575610: /*type*/ return new String[] {"code"};
2592        case -1861227106: /*standardSequence*/ return new String[] {"CodeableConcept"};
2593        case 109757538: /*start*/ return new String[] {"integer"};
2594        case 100571: /*end*/ return new String[] {"integer"};
2595        case 109264530: /*score*/ return new String[] {"Quantity"};
2596        case -1077554975: /*method*/ return new String[] {"CodeableConcept"};
2597        case -1048421849: /*truthTP*/ return new String[] {"decimal"};
2598        case 655102276: /*queryTP*/ return new String[] {"decimal"};
2599        case -1048422285: /*truthFN*/ return new String[] {"decimal"};
2600        case 655101842: /*queryFP*/ return new String[] {"decimal"};
2601        case 3182199: /*gtFP*/ return new String[] {"decimal"};
2602        case -1376177026: /*precision*/ return new String[] {"decimal"};
2603        case -934922479: /*recall*/ return new String[] {"decimal"};
2604        case -1295082036: /*fScore*/ return new String[] {"decimal"};
2605        default: return super.getTypesForProperty(hash, name);
2606        }
2607
2608      }
2609
2610      @Override
2611      public Base addChild(String name) throws FHIRException {
2612        if (name.equals("type")) {
2613          throw new FHIRException("Cannot call addChild on a primitive type Sequence.type");
2614        }
2615        else if (name.equals("standardSequence")) {
2616          this.standardSequence = new CodeableConcept();
2617          return this.standardSequence;
2618        }
2619        else if (name.equals("start")) {
2620          throw new FHIRException("Cannot call addChild on a primitive type Sequence.start");
2621        }
2622        else if (name.equals("end")) {
2623          throw new FHIRException("Cannot call addChild on a primitive type Sequence.end");
2624        }
2625        else if (name.equals("score")) {
2626          this.score = new Quantity();
2627          return this.score;
2628        }
2629        else if (name.equals("method")) {
2630          this.method = new CodeableConcept();
2631          return this.method;
2632        }
2633        else if (name.equals("truthTP")) {
2634          throw new FHIRException("Cannot call addChild on a primitive type Sequence.truthTP");
2635        }
2636        else if (name.equals("queryTP")) {
2637          throw new FHIRException("Cannot call addChild on a primitive type Sequence.queryTP");
2638        }
2639        else if (name.equals("truthFN")) {
2640          throw new FHIRException("Cannot call addChild on a primitive type Sequence.truthFN");
2641        }
2642        else if (name.equals("queryFP")) {
2643          throw new FHIRException("Cannot call addChild on a primitive type Sequence.queryFP");
2644        }
2645        else if (name.equals("gtFP")) {
2646          throw new FHIRException("Cannot call addChild on a primitive type Sequence.gtFP");
2647        }
2648        else if (name.equals("precision")) {
2649          throw new FHIRException("Cannot call addChild on a primitive type Sequence.precision");
2650        }
2651        else if (name.equals("recall")) {
2652          throw new FHIRException("Cannot call addChild on a primitive type Sequence.recall");
2653        }
2654        else if (name.equals("fScore")) {
2655          throw new FHIRException("Cannot call addChild on a primitive type Sequence.fScore");
2656        }
2657        else
2658          return super.addChild(name);
2659      }
2660
2661      public SequenceQualityComponent copy() {
2662        SequenceQualityComponent dst = new SequenceQualityComponent();
2663        copyValues(dst);
2664        dst.type = type == null ? null : type.copy();
2665        dst.standardSequence = standardSequence == null ? null : standardSequence.copy();
2666        dst.start = start == null ? null : start.copy();
2667        dst.end = end == null ? null : end.copy();
2668        dst.score = score == null ? null : score.copy();
2669        dst.method = method == null ? null : method.copy();
2670        dst.truthTP = truthTP == null ? null : truthTP.copy();
2671        dst.queryTP = queryTP == null ? null : queryTP.copy();
2672        dst.truthFN = truthFN == null ? null : truthFN.copy();
2673        dst.queryFP = queryFP == null ? null : queryFP.copy();
2674        dst.gtFP = gtFP == null ? null : gtFP.copy();
2675        dst.precision = precision == null ? null : precision.copy();
2676        dst.recall = recall == null ? null : recall.copy();
2677        dst.fScore = fScore == null ? null : fScore.copy();
2678        return dst;
2679      }
2680
2681      @Override
2682      public boolean equalsDeep(Base other_) {
2683        if (!super.equalsDeep(other_))
2684          return false;
2685        if (!(other_ instanceof SequenceQualityComponent))
2686          return false;
2687        SequenceQualityComponent o = (SequenceQualityComponent) other_;
2688        return compareDeep(type, o.type, true) && compareDeep(standardSequence, o.standardSequence, true)
2689           && compareDeep(start, o.start, true) && compareDeep(end, o.end, true) && compareDeep(score, o.score, true)
2690           && compareDeep(method, o.method, true) && compareDeep(truthTP, o.truthTP, true) && compareDeep(queryTP, o.queryTP, true)
2691           && compareDeep(truthFN, o.truthFN, true) && compareDeep(queryFP, o.queryFP, true) && compareDeep(gtFP, o.gtFP, true)
2692           && compareDeep(precision, o.precision, true) && compareDeep(recall, o.recall, true) && compareDeep(fScore, o.fScore, true)
2693          ;
2694      }
2695
2696      @Override
2697      public boolean equalsShallow(Base other_) {
2698        if (!super.equalsShallow(other_))
2699          return false;
2700        if (!(other_ instanceof SequenceQualityComponent))
2701          return false;
2702        SequenceQualityComponent o = (SequenceQualityComponent) other_;
2703        return compareValues(type, o.type, true) && compareValues(start, o.start, true) && compareValues(end, o.end, true)
2704           && compareValues(truthTP, o.truthTP, true) && compareValues(queryTP, o.queryTP, true) && compareValues(truthFN, o.truthFN, true)
2705           && compareValues(queryFP, o.queryFP, true) && compareValues(gtFP, o.gtFP, true) && compareValues(precision, o.precision, true)
2706           && compareValues(recall, o.recall, true) && compareValues(fScore, o.fScore, true);
2707      }
2708
2709      public boolean isEmpty() {
2710        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, standardSequence, start
2711          , end, score, method, truthTP, queryTP, truthFN, queryFP, gtFP, precision
2712          , recall, fScore);
2713      }
2714
2715  public String fhirType() {
2716    return "Sequence.quality";
2717
2718  }
2719
2720  }
2721
2722    @Block()
2723    public static class SequenceRepositoryComponent extends BackboneElement implements IBaseBackboneElement {
2724        /**
2725         * Click and see / RESTful API / Need login to see / RESTful API with authentication / Other ways to see resource.
2726         */
2727        @Child(name = "type", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true)
2728        @Description(shortDefinition="directlink | openapi | login | oauth | other", formalDefinition="Click and see / RESTful API / Need login to see / RESTful API with authentication / Other ways to see resource." )
2729        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/repository-type")
2730        protected Enumeration<RepositoryType> type;
2731
2732        /**
2733         * URI of an external repository which contains further details about the genetics data.
2734         */
2735        @Child(name = "url", type = {UriType.class}, order=2, min=0, max=1, modifier=false, summary=true)
2736        @Description(shortDefinition="URI of the repository", formalDefinition="URI of an external repository which contains further details about the genetics data." )
2737        protected UriType url;
2738
2739        /**
2740         * URI of an external repository which contains further details about the genetics data.
2741         */
2742        @Child(name = "name", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=true)
2743        @Description(shortDefinition="Repository's name", formalDefinition="URI of an external repository which contains further details about the genetics data." )
2744        protected StringType name;
2745
2746        /**
2747         * Id of the variant in this external repository. The server will understand how to use this id to call for more info about datasets in external repository.
2748         */
2749        @Child(name = "datasetId", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=true)
2750        @Description(shortDefinition="Id of the dataset that used to call for dataset in repository", formalDefinition="Id of the variant in this external repository. The server will understand how to use this id to call for more info about datasets in external repository." )
2751        protected StringType datasetId;
2752
2753        /**
2754         * Id of the variantset in this external repository. The server will understand how to use this id to call for more info about variantsets in external repository.
2755         */
2756        @Child(name = "variantsetId", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=true)
2757        @Description(shortDefinition="Id of the variantset that used to call for variantset in repository", formalDefinition="Id of the variantset in this external repository. The server will understand how to use this id to call for more info about variantsets in external repository." )
2758        protected StringType variantsetId;
2759
2760        /**
2761         * Id of the read in this external repository.
2762         */
2763        @Child(name = "readsetId", type = {StringType.class}, order=6, min=0, max=1, modifier=false, summary=true)
2764        @Description(shortDefinition="Id of the read", formalDefinition="Id of the read in this external repository." )
2765        protected StringType readsetId;
2766
2767        private static final long serialVersionUID = -899243265L;
2768
2769    /**
2770     * Constructor
2771     */
2772      public SequenceRepositoryComponent() {
2773        super();
2774      }
2775
2776    /**
2777     * Constructor
2778     */
2779      public SequenceRepositoryComponent(Enumeration<RepositoryType> type) {
2780        super();
2781        this.type = type;
2782      }
2783
2784        /**
2785         * @return {@link #type} (Click and see / RESTful API / Need login to see / RESTful API with authentication / Other ways to see resource.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
2786         */
2787        public Enumeration<RepositoryType> getTypeElement() { 
2788          if (this.type == null)
2789            if (Configuration.errorOnAutoCreate())
2790              throw new Error("Attempt to auto-create SequenceRepositoryComponent.type");
2791            else if (Configuration.doAutoCreate())
2792              this.type = new Enumeration<RepositoryType>(new RepositoryTypeEnumFactory()); // bb
2793          return this.type;
2794        }
2795
2796        public boolean hasTypeElement() { 
2797          return this.type != null && !this.type.isEmpty();
2798        }
2799
2800        public boolean hasType() { 
2801          return this.type != null && !this.type.isEmpty();
2802        }
2803
2804        /**
2805         * @param value {@link #type} (Click and see / RESTful API / Need login to see / RESTful API with authentication / Other ways to see resource.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
2806         */
2807        public SequenceRepositoryComponent setTypeElement(Enumeration<RepositoryType> value) { 
2808          this.type = value;
2809          return this;
2810        }
2811
2812        /**
2813         * @return Click and see / RESTful API / Need login to see / RESTful API with authentication / Other ways to see resource.
2814         */
2815        public RepositoryType getType() { 
2816          return this.type == null ? null : this.type.getValue();
2817        }
2818
2819        /**
2820         * @param value Click and see / RESTful API / Need login to see / RESTful API with authentication / Other ways to see resource.
2821         */
2822        public SequenceRepositoryComponent setType(RepositoryType value) { 
2823            if (this.type == null)
2824              this.type = new Enumeration<RepositoryType>(new RepositoryTypeEnumFactory());
2825            this.type.setValue(value);
2826          return this;
2827        }
2828
2829        /**
2830         * @return {@link #url} (URI of an external repository which contains further details about the genetics data.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
2831         */
2832        public UriType getUrlElement() { 
2833          if (this.url == null)
2834            if (Configuration.errorOnAutoCreate())
2835              throw new Error("Attempt to auto-create SequenceRepositoryComponent.url");
2836            else if (Configuration.doAutoCreate())
2837              this.url = new UriType(); // bb
2838          return this.url;
2839        }
2840
2841        public boolean hasUrlElement() { 
2842          return this.url != null && !this.url.isEmpty();
2843        }
2844
2845        public boolean hasUrl() { 
2846          return this.url != null && !this.url.isEmpty();
2847        }
2848
2849        /**
2850         * @param value {@link #url} (URI of an external repository which contains further details about the genetics data.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
2851         */
2852        public SequenceRepositoryComponent setUrlElement(UriType value) { 
2853          this.url = value;
2854          return this;
2855        }
2856
2857        /**
2858         * @return URI of an external repository which contains further details about the genetics data.
2859         */
2860        public String getUrl() { 
2861          return this.url == null ? null : this.url.getValue();
2862        }
2863
2864        /**
2865         * @param value URI of an external repository which contains further details about the genetics data.
2866         */
2867        public SequenceRepositoryComponent setUrl(String value) { 
2868          if (Utilities.noString(value))
2869            this.url = null;
2870          else {
2871            if (this.url == null)
2872              this.url = new UriType();
2873            this.url.setValue(value);
2874          }
2875          return this;
2876        }
2877
2878        /**
2879         * @return {@link #name} (URI of an external repository which contains further details about the genetics data.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
2880         */
2881        public StringType getNameElement() { 
2882          if (this.name == null)
2883            if (Configuration.errorOnAutoCreate())
2884              throw new Error("Attempt to auto-create SequenceRepositoryComponent.name");
2885            else if (Configuration.doAutoCreate())
2886              this.name = new StringType(); // bb
2887          return this.name;
2888        }
2889
2890        public boolean hasNameElement() { 
2891          return this.name != null && !this.name.isEmpty();
2892        }
2893
2894        public boolean hasName() { 
2895          return this.name != null && !this.name.isEmpty();
2896        }
2897
2898        /**
2899         * @param value {@link #name} (URI of an external repository which contains further details about the genetics data.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
2900         */
2901        public SequenceRepositoryComponent setNameElement(StringType value) { 
2902          this.name = value;
2903          return this;
2904        }
2905
2906        /**
2907         * @return URI of an external repository which contains further details about the genetics data.
2908         */
2909        public String getName() { 
2910          return this.name == null ? null : this.name.getValue();
2911        }
2912
2913        /**
2914         * @param value URI of an external repository which contains further details about the genetics data.
2915         */
2916        public SequenceRepositoryComponent setName(String value) { 
2917          if (Utilities.noString(value))
2918            this.name = null;
2919          else {
2920            if (this.name == null)
2921              this.name = new StringType();
2922            this.name.setValue(value);
2923          }
2924          return this;
2925        }
2926
2927        /**
2928         * @return {@link #datasetId} (Id of the variant in this external repository. The server will understand how to use this id to call for more info about datasets in external repository.). This is the underlying object with id, value and extensions. The accessor "getDatasetId" gives direct access to the value
2929         */
2930        public StringType getDatasetIdElement() { 
2931          if (this.datasetId == null)
2932            if (Configuration.errorOnAutoCreate())
2933              throw new Error("Attempt to auto-create SequenceRepositoryComponent.datasetId");
2934            else if (Configuration.doAutoCreate())
2935              this.datasetId = new StringType(); // bb
2936          return this.datasetId;
2937        }
2938
2939        public boolean hasDatasetIdElement() { 
2940          return this.datasetId != null && !this.datasetId.isEmpty();
2941        }
2942
2943        public boolean hasDatasetId() { 
2944          return this.datasetId != null && !this.datasetId.isEmpty();
2945        }
2946
2947        /**
2948         * @param value {@link #datasetId} (Id of the variant in this external repository. The server will understand how to use this id to call for more info about datasets in external repository.). This is the underlying object with id, value and extensions. The accessor "getDatasetId" gives direct access to the value
2949         */
2950        public SequenceRepositoryComponent setDatasetIdElement(StringType value) { 
2951          this.datasetId = value;
2952          return this;
2953        }
2954
2955        /**
2956         * @return Id of the variant in this external repository. The server will understand how to use this id to call for more info about datasets in external repository.
2957         */
2958        public String getDatasetId() { 
2959          return this.datasetId == null ? null : this.datasetId.getValue();
2960        }
2961
2962        /**
2963         * @param value Id of the variant in this external repository. The server will understand how to use this id to call for more info about datasets in external repository.
2964         */
2965        public SequenceRepositoryComponent setDatasetId(String value) { 
2966          if (Utilities.noString(value))
2967            this.datasetId = null;
2968          else {
2969            if (this.datasetId == null)
2970              this.datasetId = new StringType();
2971            this.datasetId.setValue(value);
2972          }
2973          return this;
2974        }
2975
2976        /**
2977         * @return {@link #variantsetId} (Id of the variantset in this external repository. The server will understand how to use this id to call for more info about variantsets in external repository.). This is the underlying object with id, value and extensions. The accessor "getVariantsetId" gives direct access to the value
2978         */
2979        public StringType getVariantsetIdElement() { 
2980          if (this.variantsetId == null)
2981            if (Configuration.errorOnAutoCreate())
2982              throw new Error("Attempt to auto-create SequenceRepositoryComponent.variantsetId");
2983            else if (Configuration.doAutoCreate())
2984              this.variantsetId = new StringType(); // bb
2985          return this.variantsetId;
2986        }
2987
2988        public boolean hasVariantsetIdElement() { 
2989          return this.variantsetId != null && !this.variantsetId.isEmpty();
2990        }
2991
2992        public boolean hasVariantsetId() { 
2993          return this.variantsetId != null && !this.variantsetId.isEmpty();
2994        }
2995
2996        /**
2997         * @param value {@link #variantsetId} (Id of the variantset in this external repository. The server will understand how to use this id to call for more info about variantsets in external repository.). This is the underlying object with id, value and extensions. The accessor "getVariantsetId" gives direct access to the value
2998         */
2999        public SequenceRepositoryComponent setVariantsetIdElement(StringType value) { 
3000          this.variantsetId = value;
3001          return this;
3002        }
3003
3004        /**
3005         * @return Id of the variantset in this external repository. The server will understand how to use this id to call for more info about variantsets in external repository.
3006         */
3007        public String getVariantsetId() { 
3008          return this.variantsetId == null ? null : this.variantsetId.getValue();
3009        }
3010
3011        /**
3012         * @param value Id of the variantset in this external repository. The server will understand how to use this id to call for more info about variantsets in external repository.
3013         */
3014        public SequenceRepositoryComponent setVariantsetId(String value) { 
3015          if (Utilities.noString(value))
3016            this.variantsetId = null;
3017          else {
3018            if (this.variantsetId == null)
3019              this.variantsetId = new StringType();
3020            this.variantsetId.setValue(value);
3021          }
3022          return this;
3023        }
3024
3025        /**
3026         * @return {@link #readsetId} (Id of the read in this external repository.). This is the underlying object with id, value and extensions. The accessor "getReadsetId" gives direct access to the value
3027         */
3028        public StringType getReadsetIdElement() { 
3029          if (this.readsetId == null)
3030            if (Configuration.errorOnAutoCreate())
3031              throw new Error("Attempt to auto-create SequenceRepositoryComponent.readsetId");
3032            else if (Configuration.doAutoCreate())
3033              this.readsetId = new StringType(); // bb
3034          return this.readsetId;
3035        }
3036
3037        public boolean hasReadsetIdElement() { 
3038          return this.readsetId != null && !this.readsetId.isEmpty();
3039        }
3040
3041        public boolean hasReadsetId() { 
3042          return this.readsetId != null && !this.readsetId.isEmpty();
3043        }
3044
3045        /**
3046         * @param value {@link #readsetId} (Id of the read in this external repository.). This is the underlying object with id, value and extensions. The accessor "getReadsetId" gives direct access to the value
3047         */
3048        public SequenceRepositoryComponent setReadsetIdElement(StringType value) { 
3049          this.readsetId = value;
3050          return this;
3051        }
3052
3053        /**
3054         * @return Id of the read in this external repository.
3055         */
3056        public String getReadsetId() { 
3057          return this.readsetId == null ? null : this.readsetId.getValue();
3058        }
3059
3060        /**
3061         * @param value Id of the read in this external repository.
3062         */
3063        public SequenceRepositoryComponent setReadsetId(String value) { 
3064          if (Utilities.noString(value))
3065            this.readsetId = null;
3066          else {
3067            if (this.readsetId == null)
3068              this.readsetId = new StringType();
3069            this.readsetId.setValue(value);
3070          }
3071          return this;
3072        }
3073
3074        protected void listChildren(List<Property> children) {
3075          super.listChildren(children);
3076          children.add(new Property("type", "code", "Click and see / RESTful API / Need login to see / RESTful API with authentication / Other ways to see resource.", 0, 1, type));
3077          children.add(new Property("url", "uri", "URI of an external repository which contains further details about the genetics data.", 0, 1, url));
3078          children.add(new Property("name", "string", "URI of an external repository which contains further details about the genetics data.", 0, 1, name));
3079          children.add(new Property("datasetId", "string", "Id of the variant in this external repository. The server will understand how to use this id to call for more info about datasets in external repository.", 0, 1, datasetId));
3080          children.add(new Property("variantsetId", "string", "Id of the variantset in this external repository. The server will understand how to use this id to call for more info about variantsets in external repository.", 0, 1, variantsetId));
3081          children.add(new Property("readsetId", "string", "Id of the read in this external repository.", 0, 1, readsetId));
3082        }
3083
3084        @Override
3085        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3086          switch (_hash) {
3087          case 3575610: /*type*/  return new Property("type", "code", "Click and see / RESTful API / Need login to see / RESTful API with authentication / Other ways to see resource.", 0, 1, type);
3088          case 116079: /*url*/  return new Property("url", "uri", "URI of an external repository which contains further details about the genetics data.", 0, 1, url);
3089          case 3373707: /*name*/  return new Property("name", "string", "URI of an external repository which contains further details about the genetics data.", 0, 1, name);
3090          case -345342029: /*datasetId*/  return new Property("datasetId", "string", "Id of the variant in this external repository. The server will understand how to use this id to call for more info about datasets in external repository.", 0, 1, datasetId);
3091          case 1929752504: /*variantsetId*/  return new Property("variantsetId", "string", "Id of the variantset in this external repository. The server will understand how to use this id to call for more info about variantsets in external repository.", 0, 1, variantsetId);
3092          case -1095407289: /*readsetId*/  return new Property("readsetId", "string", "Id of the read in this external repository.", 0, 1, readsetId);
3093          default: return super.getNamedProperty(_hash, _name, _checkValid);
3094          }
3095
3096        }
3097
3098      @Override
3099      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3100        switch (hash) {
3101        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<RepositoryType>
3102        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType
3103        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
3104        case -345342029: /*datasetId*/ return this.datasetId == null ? new Base[0] : new Base[] {this.datasetId}; // StringType
3105        case 1929752504: /*variantsetId*/ return this.variantsetId == null ? new Base[0] : new Base[] {this.variantsetId}; // StringType
3106        case -1095407289: /*readsetId*/ return this.readsetId == null ? new Base[0] : new Base[] {this.readsetId}; // StringType
3107        default: return super.getProperty(hash, name, checkValid);
3108        }
3109
3110      }
3111
3112      @Override
3113      public Base setProperty(int hash, String name, Base value) throws FHIRException {
3114        switch (hash) {
3115        case 3575610: // type
3116          value = new RepositoryTypeEnumFactory().fromType(castToCode(value));
3117          this.type = (Enumeration) value; // Enumeration<RepositoryType>
3118          return value;
3119        case 116079: // url
3120          this.url = castToUri(value); // UriType
3121          return value;
3122        case 3373707: // name
3123          this.name = castToString(value); // StringType
3124          return value;
3125        case -345342029: // datasetId
3126          this.datasetId = castToString(value); // StringType
3127          return value;
3128        case 1929752504: // variantsetId
3129          this.variantsetId = castToString(value); // StringType
3130          return value;
3131        case -1095407289: // readsetId
3132          this.readsetId = castToString(value); // StringType
3133          return value;
3134        default: return super.setProperty(hash, name, value);
3135        }
3136
3137      }
3138
3139      @Override
3140      public Base setProperty(String name, Base value) throws FHIRException {
3141        if (name.equals("type")) {
3142          value = new RepositoryTypeEnumFactory().fromType(castToCode(value));
3143          this.type = (Enumeration) value; // Enumeration<RepositoryType>
3144        } else if (name.equals("url")) {
3145          this.url = castToUri(value); // UriType
3146        } else if (name.equals("name")) {
3147          this.name = castToString(value); // StringType
3148        } else if (name.equals("datasetId")) {
3149          this.datasetId = castToString(value); // StringType
3150        } else if (name.equals("variantsetId")) {
3151          this.variantsetId = castToString(value); // StringType
3152        } else if (name.equals("readsetId")) {
3153          this.readsetId = castToString(value); // StringType
3154        } else
3155          return super.setProperty(name, value);
3156        return value;
3157      }
3158
3159      @Override
3160      public Base makeProperty(int hash, String name) throws FHIRException {
3161        switch (hash) {
3162        case 3575610:  return getTypeElement();
3163        case 116079:  return getUrlElement();
3164        case 3373707:  return getNameElement();
3165        case -345342029:  return getDatasetIdElement();
3166        case 1929752504:  return getVariantsetIdElement();
3167        case -1095407289:  return getReadsetIdElement();
3168        default: return super.makeProperty(hash, name);
3169        }
3170
3171      }
3172
3173      @Override
3174      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3175        switch (hash) {
3176        case 3575610: /*type*/ return new String[] {"code"};
3177        case 116079: /*url*/ return new String[] {"uri"};
3178        case 3373707: /*name*/ return new String[] {"string"};
3179        case -345342029: /*datasetId*/ return new String[] {"string"};
3180        case 1929752504: /*variantsetId*/ return new String[] {"string"};
3181        case -1095407289: /*readsetId*/ return new String[] {"string"};
3182        default: return super.getTypesForProperty(hash, name);
3183        }
3184
3185      }
3186
3187      @Override
3188      public Base addChild(String name) throws FHIRException {
3189        if (name.equals("type")) {
3190          throw new FHIRException("Cannot call addChild on a primitive type Sequence.type");
3191        }
3192        else if (name.equals("url")) {
3193          throw new FHIRException("Cannot call addChild on a primitive type Sequence.url");
3194        }
3195        else if (name.equals("name")) {
3196          throw new FHIRException("Cannot call addChild on a primitive type Sequence.name");
3197        }
3198        else if (name.equals("datasetId")) {
3199          throw new FHIRException("Cannot call addChild on a primitive type Sequence.datasetId");
3200        }
3201        else if (name.equals("variantsetId")) {
3202          throw new FHIRException("Cannot call addChild on a primitive type Sequence.variantsetId");
3203        }
3204        else if (name.equals("readsetId")) {
3205          throw new FHIRException("Cannot call addChild on a primitive type Sequence.readsetId");
3206        }
3207        else
3208          return super.addChild(name);
3209      }
3210
3211      public SequenceRepositoryComponent copy() {
3212        SequenceRepositoryComponent dst = new SequenceRepositoryComponent();
3213        copyValues(dst);
3214        dst.type = type == null ? null : type.copy();
3215        dst.url = url == null ? null : url.copy();
3216        dst.name = name == null ? null : name.copy();
3217        dst.datasetId = datasetId == null ? null : datasetId.copy();
3218        dst.variantsetId = variantsetId == null ? null : variantsetId.copy();
3219        dst.readsetId = readsetId == null ? null : readsetId.copy();
3220        return dst;
3221      }
3222
3223      @Override
3224      public boolean equalsDeep(Base other_) {
3225        if (!super.equalsDeep(other_))
3226          return false;
3227        if (!(other_ instanceof SequenceRepositoryComponent))
3228          return false;
3229        SequenceRepositoryComponent o = (SequenceRepositoryComponent) other_;
3230        return compareDeep(type, o.type, true) && compareDeep(url, o.url, true) && compareDeep(name, o.name, true)
3231           && compareDeep(datasetId, o.datasetId, true) && compareDeep(variantsetId, o.variantsetId, true)
3232           && compareDeep(readsetId, o.readsetId, true);
3233      }
3234
3235      @Override
3236      public boolean equalsShallow(Base other_) {
3237        if (!super.equalsShallow(other_))
3238          return false;
3239        if (!(other_ instanceof SequenceRepositoryComponent))
3240          return false;
3241        SequenceRepositoryComponent o = (SequenceRepositoryComponent) other_;
3242        return compareValues(type, o.type, true) && compareValues(url, o.url, true) && compareValues(name, o.name, true)
3243           && compareValues(datasetId, o.datasetId, true) && compareValues(variantsetId, o.variantsetId, true)
3244           && compareValues(readsetId, o.readsetId, true);
3245      }
3246
3247      public boolean isEmpty() {
3248        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, url, name, datasetId
3249          , variantsetId, readsetId);
3250      }
3251
3252  public String fhirType() {
3253    return "Sequence.repository";
3254
3255  }
3256
3257  }
3258
3259    /**
3260     * A unique identifier for this particular sequence instance. This is a FHIR-defined id.
3261     */
3262    @Child(name = "identifier", type = {Identifier.class}, order=0, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
3263    @Description(shortDefinition="Unique ID for this particular sequence. This is a FHIR-defined id", formalDefinition="A unique identifier for this particular sequence instance. This is a FHIR-defined id." )
3264    protected List<Identifier> identifier;
3265
3266    /**
3267     * Amino Acid Sequence/ DNA Sequence / RNA Sequence.
3268     */
3269    @Child(name = "type", type = {CodeType.class}, order=1, min=0, max=1, modifier=false, summary=true)
3270    @Description(shortDefinition="aa | dna | rna", formalDefinition="Amino Acid Sequence/ DNA Sequence / RNA Sequence." )
3271    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/sequence-type")
3272    protected Enumeration<SequenceType> type;
3273
3274    /**
3275     * Whether the sequence is numbered starting at 0 (0-based numbering or coordinates, inclusive start, exclusive end) or starting at 1 (1-based numbering, inclusive start and inclusive end).
3276     */
3277    @Child(name = "coordinateSystem", type = {IntegerType.class}, order=2, min=1, max=1, modifier=false, summary=true)
3278    @Description(shortDefinition="Base number of coordinate system (0 for 0-based numbering or coordinates, inclusive start, exclusive end, 1 for 1-based numbering, inclusive start, inclusive end)", formalDefinition="Whether the sequence is numbered starting at 0 (0-based numbering or coordinates, inclusive start, exclusive end) or starting at 1 (1-based numbering, inclusive start and inclusive end)." )
3279    protected IntegerType coordinateSystem;
3280
3281    /**
3282     * The patient whose sequencing results are described by this resource.
3283     */
3284    @Child(name = "patient", type = {Patient.class}, order=3, min=0, max=1, modifier=false, summary=true)
3285    @Description(shortDefinition="Who and/or what this is about", formalDefinition="The patient whose sequencing results are described by this resource." )
3286    protected Reference patient;
3287
3288    /**
3289     * The actual object that is the target of the reference (The patient whose sequencing results are described by this resource.)
3290     */
3291    protected Patient patientTarget;
3292
3293    /**
3294     * Specimen used for sequencing.
3295     */
3296    @Child(name = "specimen", type = {Specimen.class}, order=4, min=0, max=1, modifier=false, summary=true)
3297    @Description(shortDefinition="Specimen used for sequencing", formalDefinition="Specimen used for sequencing." )
3298    protected Reference specimen;
3299
3300    /**
3301     * The actual object that is the target of the reference (Specimen used for sequencing.)
3302     */
3303    protected Specimen specimenTarget;
3304
3305    /**
3306     * The method for sequencing, for example, chip information.
3307     */
3308    @Child(name = "device", type = {Device.class}, order=5, min=0, max=1, modifier=false, summary=true)
3309    @Description(shortDefinition="The method for sequencing", formalDefinition="The method for sequencing, for example, chip information." )
3310    protected Reference device;
3311
3312    /**
3313     * The actual object that is the target of the reference (The method for sequencing, for example, chip information.)
3314     */
3315    protected Device deviceTarget;
3316
3317    /**
3318     * The organization or lab that should be responsible for this result.
3319     */
3320    @Child(name = "performer", type = {Organization.class}, order=6, min=0, max=1, modifier=false, summary=true)
3321    @Description(shortDefinition="Who should be responsible for test result", formalDefinition="The organization or lab that should be responsible for this result." )
3322    protected Reference performer;
3323
3324    /**
3325     * The actual object that is the target of the reference (The organization or lab that should be responsible for this result.)
3326     */
3327    protected Organization performerTarget;
3328
3329    /**
3330     * The number of copies of the seqeunce of interest. (RNASeq).
3331     */
3332    @Child(name = "quantity", type = {Quantity.class}, order=7, min=0, max=1, modifier=false, summary=true)
3333    @Description(shortDefinition="The number of copies of the seqeunce of interest.  (RNASeq)", formalDefinition="The number of copies of the seqeunce of interest. (RNASeq)." )
3334    protected Quantity quantity;
3335
3336    /**
3337     * A sequence that is used as a reference to describe variants that are present in a sequence analyzed.
3338     */
3339    @Child(name = "referenceSeq", type = {}, order=8, min=0, max=1, modifier=false, summary=true)
3340    @Description(shortDefinition="A sequence used as reference", formalDefinition="A sequence that is used as a reference to describe variants that are present in a sequence analyzed." )
3341    protected SequenceReferenceSeqComponent referenceSeq;
3342
3343    /**
3344     * The definition of variant here originates from Sequence ontology ([variant_of](http://www.sequenceontology.org/browser/current_svn/term/variant_of)). This element can represent amino acid or nucleic sequence change(including insertion,deletion,SNP,etc.)  It can represent some complex mutation or segment variation with the assist of CIGAR string.
3345     */
3346    @Child(name = "variant", type = {}, order=9, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
3347    @Description(shortDefinition="Variant in sequence", formalDefinition="The definition of variant here originates from Sequence ontology ([variant_of](http://www.sequenceontology.org/browser/current_svn/term/variant_of)). This element can represent amino acid or nucleic sequence change(including insertion,deletion,SNP,etc.)  It can represent some complex mutation or segment variation with the assist of CIGAR string." )
3348    protected List<SequenceVariantComponent> variant;
3349
3350    /**
3351     * Sequence that was observed. It is the result marked by referenceSeq along with variant records on referenceSeq. This shall starts from referenceSeq.windowStart and end by referenceSeq.windowEnd.
3352     */
3353    @Child(name = "observedSeq", type = {StringType.class}, order=10, min=0, max=1, modifier=false, summary=true)
3354    @Description(shortDefinition="Sequence that was observed", formalDefinition="Sequence that was observed. It is the result marked by referenceSeq along with variant records on referenceSeq. This shall starts from referenceSeq.windowStart and end by referenceSeq.windowEnd." )
3355    protected StringType observedSeq;
3356
3357    /**
3358     * An experimental feature attribute that defines the quality of the feature in a quantitative way, such as a phred quality score ([SO:0001686](http://www.sequenceontology.org/browser/current_svn/term/SO:0001686)).
3359     */
3360    @Child(name = "quality", type = {}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
3361    @Description(shortDefinition="An set of value as quality of sequence", formalDefinition="An experimental feature attribute that defines the quality of the feature in a quantitative way, such as a phred quality score ([SO:0001686](http://www.sequenceontology.org/browser/current_svn/term/SO:0001686))." )
3362    protected List<SequenceQualityComponent> quality;
3363
3364    /**
3365     * Coverage (read depth or depth) is the average number of reads representing a given nucleotide in the reconstructed sequence.
3366     */
3367    @Child(name = "readCoverage", type = {IntegerType.class}, order=12, min=0, max=1, modifier=false, summary=true)
3368    @Description(shortDefinition="Average number of reads representing a given nucleotide in the reconstructed sequence", formalDefinition="Coverage (read depth or depth) is the average number of reads representing a given nucleotide in the reconstructed sequence." )
3369    protected IntegerType readCoverage;
3370
3371    /**
3372     * Configurations of the external repository. The repository shall store target's observedSeq or records related with target's observedSeq.
3373     */
3374    @Child(name = "repository", type = {}, order=13, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
3375    @Description(shortDefinition="External repository which contains detailed report related with observedSeq in this resource", formalDefinition="Configurations of the external repository. The repository shall store target's observedSeq or records related with target's observedSeq." )
3376    protected List<SequenceRepositoryComponent> repository;
3377
3378    /**
3379     * Pointer to next atomic sequence which at most contains one variant.
3380     */
3381    @Child(name = "pointer", type = {Sequence.class}, order=14, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
3382    @Description(shortDefinition="Pointer to next atomic sequence", formalDefinition="Pointer to next atomic sequence which at most contains one variant." )
3383    protected List<Reference> pointer;
3384    /**
3385     * The actual objects that are the target of the reference (Pointer to next atomic sequence which at most contains one variant.)
3386     */
3387    protected List<Sequence> pointerTarget;
3388
3389
3390    private static final long serialVersionUID = -2101352712L;
3391
3392  /**
3393   * Constructor
3394   */
3395    public Sequence() {
3396      super();
3397    }
3398
3399  /**
3400   * Constructor
3401   */
3402    public Sequence(IntegerType coordinateSystem) {
3403      super();
3404      this.coordinateSystem = coordinateSystem;
3405    }
3406
3407    /**
3408     * @return {@link #identifier} (A unique identifier for this particular sequence instance. This is a FHIR-defined id.)
3409     */
3410    public List<Identifier> getIdentifier() { 
3411      if (this.identifier == null)
3412        this.identifier = new ArrayList<Identifier>();
3413      return this.identifier;
3414    }
3415
3416    /**
3417     * @return Returns a reference to <code>this</code> for easy method chaining
3418     */
3419    public Sequence setIdentifier(List<Identifier> theIdentifier) { 
3420      this.identifier = theIdentifier;
3421      return this;
3422    }
3423
3424    public boolean hasIdentifier() { 
3425      if (this.identifier == null)
3426        return false;
3427      for (Identifier item : this.identifier)
3428        if (!item.isEmpty())
3429          return true;
3430      return false;
3431    }
3432
3433    public Identifier addIdentifier() { //3
3434      Identifier t = new Identifier();
3435      if (this.identifier == null)
3436        this.identifier = new ArrayList<Identifier>();
3437      this.identifier.add(t);
3438      return t;
3439    }
3440
3441    public Sequence addIdentifier(Identifier t) { //3
3442      if (t == null)
3443        return this;
3444      if (this.identifier == null)
3445        this.identifier = new ArrayList<Identifier>();
3446      this.identifier.add(t);
3447      return this;
3448    }
3449
3450    /**
3451     * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist
3452     */
3453    public Identifier getIdentifierFirstRep() { 
3454      if (getIdentifier().isEmpty()) {
3455        addIdentifier();
3456      }
3457      return getIdentifier().get(0);
3458    }
3459
3460    /**
3461     * @return {@link #type} (Amino Acid Sequence/ DNA Sequence / RNA Sequence.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
3462     */
3463    public Enumeration<SequenceType> getTypeElement() { 
3464      if (this.type == null)
3465        if (Configuration.errorOnAutoCreate())
3466          throw new Error("Attempt to auto-create Sequence.type");
3467        else if (Configuration.doAutoCreate())
3468          this.type = new Enumeration<SequenceType>(new SequenceTypeEnumFactory()); // bb
3469      return this.type;
3470    }
3471
3472    public boolean hasTypeElement() { 
3473      return this.type != null && !this.type.isEmpty();
3474    }
3475
3476    public boolean hasType() { 
3477      return this.type != null && !this.type.isEmpty();
3478    }
3479
3480    /**
3481     * @param value {@link #type} (Amino Acid Sequence/ DNA Sequence / RNA Sequence.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
3482     */
3483    public Sequence setTypeElement(Enumeration<SequenceType> value) { 
3484      this.type = value;
3485      return this;
3486    }
3487
3488    /**
3489     * @return Amino Acid Sequence/ DNA Sequence / RNA Sequence.
3490     */
3491    public SequenceType getType() { 
3492      return this.type == null ? null : this.type.getValue();
3493    }
3494
3495    /**
3496     * @param value Amino Acid Sequence/ DNA Sequence / RNA Sequence.
3497     */
3498    public Sequence setType(SequenceType value) { 
3499      if (value == null)
3500        this.type = null;
3501      else {
3502        if (this.type == null)
3503          this.type = new Enumeration<SequenceType>(new SequenceTypeEnumFactory());
3504        this.type.setValue(value);
3505      }
3506      return this;
3507    }
3508
3509    /**
3510     * @return {@link #coordinateSystem} (Whether the sequence is numbered starting at 0 (0-based numbering or coordinates, inclusive start, exclusive end) or starting at 1 (1-based numbering, inclusive start and inclusive end).). This is the underlying object with id, value and extensions. The accessor "getCoordinateSystem" gives direct access to the value
3511     */
3512    public IntegerType getCoordinateSystemElement() { 
3513      if (this.coordinateSystem == null)
3514        if (Configuration.errorOnAutoCreate())
3515          throw new Error("Attempt to auto-create Sequence.coordinateSystem");
3516        else if (Configuration.doAutoCreate())
3517          this.coordinateSystem = new IntegerType(); // bb
3518      return this.coordinateSystem;
3519    }
3520
3521    public boolean hasCoordinateSystemElement() { 
3522      return this.coordinateSystem != null && !this.coordinateSystem.isEmpty();
3523    }
3524
3525    public boolean hasCoordinateSystem() { 
3526      return this.coordinateSystem != null && !this.coordinateSystem.isEmpty();
3527    }
3528
3529    /**
3530     * @param value {@link #coordinateSystem} (Whether the sequence is numbered starting at 0 (0-based numbering or coordinates, inclusive start, exclusive end) or starting at 1 (1-based numbering, inclusive start and inclusive end).). This is the underlying object with id, value and extensions. The accessor "getCoordinateSystem" gives direct access to the value
3531     */
3532    public Sequence setCoordinateSystemElement(IntegerType value) { 
3533      this.coordinateSystem = value;
3534      return this;
3535    }
3536
3537    /**
3538     * @return Whether the sequence is numbered starting at 0 (0-based numbering or coordinates, inclusive start, exclusive end) or starting at 1 (1-based numbering, inclusive start and inclusive end).
3539     */
3540    public int getCoordinateSystem() { 
3541      return this.coordinateSystem == null || this.coordinateSystem.isEmpty() ? 0 : this.coordinateSystem.getValue();
3542    }
3543
3544    /**
3545     * @param value Whether the sequence is numbered starting at 0 (0-based numbering or coordinates, inclusive start, exclusive end) or starting at 1 (1-based numbering, inclusive start and inclusive end).
3546     */
3547    public Sequence setCoordinateSystem(int value) { 
3548        if (this.coordinateSystem == null)
3549          this.coordinateSystem = new IntegerType();
3550        this.coordinateSystem.setValue(value);
3551      return this;
3552    }
3553
3554    /**
3555     * @return {@link #patient} (The patient whose sequencing results are described by this resource.)
3556     */
3557    public Reference getPatient() { 
3558      if (this.patient == null)
3559        if (Configuration.errorOnAutoCreate())
3560          throw new Error("Attempt to auto-create Sequence.patient");
3561        else if (Configuration.doAutoCreate())
3562          this.patient = new Reference(); // cc
3563      return this.patient;
3564    }
3565
3566    public boolean hasPatient() { 
3567      return this.patient != null && !this.patient.isEmpty();
3568    }
3569
3570    /**
3571     * @param value {@link #patient} (The patient whose sequencing results are described by this resource.)
3572     */
3573    public Sequence setPatient(Reference value)  { 
3574      this.patient = value;
3575      return this;
3576    }
3577
3578    /**
3579     * @return {@link #patient} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The patient whose sequencing results are described by this resource.)
3580     */
3581    public Patient getPatientTarget() { 
3582      if (this.patientTarget == null)
3583        if (Configuration.errorOnAutoCreate())
3584          throw new Error("Attempt to auto-create Sequence.patient");
3585        else if (Configuration.doAutoCreate())
3586          this.patientTarget = new Patient(); // aa
3587      return this.patientTarget;
3588    }
3589
3590    /**
3591     * @param value {@link #patient} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The patient whose sequencing results are described by this resource.)
3592     */
3593    public Sequence setPatientTarget(Patient value) { 
3594      this.patientTarget = value;
3595      return this;
3596    }
3597
3598    /**
3599     * @return {@link #specimen} (Specimen used for sequencing.)
3600     */
3601    public Reference getSpecimen() { 
3602      if (this.specimen == null)
3603        if (Configuration.errorOnAutoCreate())
3604          throw new Error("Attempt to auto-create Sequence.specimen");
3605        else if (Configuration.doAutoCreate())
3606          this.specimen = new Reference(); // cc
3607      return this.specimen;
3608    }
3609
3610    public boolean hasSpecimen() { 
3611      return this.specimen != null && !this.specimen.isEmpty();
3612    }
3613
3614    /**
3615     * @param value {@link #specimen} (Specimen used for sequencing.)
3616     */
3617    public Sequence setSpecimen(Reference value)  { 
3618      this.specimen = value;
3619      return this;
3620    }
3621
3622    /**
3623     * @return {@link #specimen} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (Specimen used for sequencing.)
3624     */
3625    public Specimen getSpecimenTarget() { 
3626      if (this.specimenTarget == null)
3627        if (Configuration.errorOnAutoCreate())
3628          throw new Error("Attempt to auto-create Sequence.specimen");
3629        else if (Configuration.doAutoCreate())
3630          this.specimenTarget = new Specimen(); // aa
3631      return this.specimenTarget;
3632    }
3633
3634    /**
3635     * @param value {@link #specimen} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (Specimen used for sequencing.)
3636     */
3637    public Sequence setSpecimenTarget(Specimen value) { 
3638      this.specimenTarget = value;
3639      return this;
3640    }
3641
3642    /**
3643     * @return {@link #device} (The method for sequencing, for example, chip information.)
3644     */
3645    public Reference getDevice() { 
3646      if (this.device == null)
3647        if (Configuration.errorOnAutoCreate())
3648          throw new Error("Attempt to auto-create Sequence.device");
3649        else if (Configuration.doAutoCreate())
3650          this.device = new Reference(); // cc
3651      return this.device;
3652    }
3653
3654    public boolean hasDevice() { 
3655      return this.device != null && !this.device.isEmpty();
3656    }
3657
3658    /**
3659     * @param value {@link #device} (The method for sequencing, for example, chip information.)
3660     */
3661    public Sequence setDevice(Reference value)  { 
3662      this.device = value;
3663      return this;
3664    }
3665
3666    /**
3667     * @return {@link #device} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The method for sequencing, for example, chip information.)
3668     */
3669    public Device getDeviceTarget() { 
3670      if (this.deviceTarget == null)
3671        if (Configuration.errorOnAutoCreate())
3672          throw new Error("Attempt to auto-create Sequence.device");
3673        else if (Configuration.doAutoCreate())
3674          this.deviceTarget = new Device(); // aa
3675      return this.deviceTarget;
3676    }
3677
3678    /**
3679     * @param value {@link #device} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The method for sequencing, for example, chip information.)
3680     */
3681    public Sequence setDeviceTarget(Device value) { 
3682      this.deviceTarget = value;
3683      return this;
3684    }
3685
3686    /**
3687     * @return {@link #performer} (The organization or lab that should be responsible for this result.)
3688     */
3689    public Reference getPerformer() { 
3690      if (this.performer == null)
3691        if (Configuration.errorOnAutoCreate())
3692          throw new Error("Attempt to auto-create Sequence.performer");
3693        else if (Configuration.doAutoCreate())
3694          this.performer = new Reference(); // cc
3695      return this.performer;
3696    }
3697
3698    public boolean hasPerformer() { 
3699      return this.performer != null && !this.performer.isEmpty();
3700    }
3701
3702    /**
3703     * @param value {@link #performer} (The organization or lab that should be responsible for this result.)
3704     */
3705    public Sequence setPerformer(Reference value)  { 
3706      this.performer = value;
3707      return this;
3708    }
3709
3710    /**
3711     * @return {@link #performer} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The organization or lab that should be responsible for this result.)
3712     */
3713    public Organization getPerformerTarget() { 
3714      if (this.performerTarget == null)
3715        if (Configuration.errorOnAutoCreate())
3716          throw new Error("Attempt to auto-create Sequence.performer");
3717        else if (Configuration.doAutoCreate())
3718          this.performerTarget = new Organization(); // aa
3719      return this.performerTarget;
3720    }
3721
3722    /**
3723     * @param value {@link #performer} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The organization or lab that should be responsible for this result.)
3724     */
3725    public Sequence setPerformerTarget(Organization value) { 
3726      this.performerTarget = value;
3727      return this;
3728    }
3729
3730    /**
3731     * @return {@link #quantity} (The number of copies of the seqeunce of interest. (RNASeq).)
3732     */
3733    public Quantity getQuantity() { 
3734      if (this.quantity == null)
3735        if (Configuration.errorOnAutoCreate())
3736          throw new Error("Attempt to auto-create Sequence.quantity");
3737        else if (Configuration.doAutoCreate())
3738          this.quantity = new Quantity(); // cc
3739      return this.quantity;
3740    }
3741
3742    public boolean hasQuantity() { 
3743      return this.quantity != null && !this.quantity.isEmpty();
3744    }
3745
3746    /**
3747     * @param value {@link #quantity} (The number of copies of the seqeunce of interest. (RNASeq).)
3748     */
3749    public Sequence setQuantity(Quantity value)  { 
3750      this.quantity = value;
3751      return this;
3752    }
3753
3754    /**
3755     * @return {@link #referenceSeq} (A sequence that is used as a reference to describe variants that are present in a sequence analyzed.)
3756     */
3757    public SequenceReferenceSeqComponent getReferenceSeq() { 
3758      if (this.referenceSeq == null)
3759        if (Configuration.errorOnAutoCreate())
3760          throw new Error("Attempt to auto-create Sequence.referenceSeq");
3761        else if (Configuration.doAutoCreate())
3762          this.referenceSeq = new SequenceReferenceSeqComponent(); // cc
3763      return this.referenceSeq;
3764    }
3765
3766    public boolean hasReferenceSeq() { 
3767      return this.referenceSeq != null && !this.referenceSeq.isEmpty();
3768    }
3769
3770    /**
3771     * @param value {@link #referenceSeq} (A sequence that is used as a reference to describe variants that are present in a sequence analyzed.)
3772     */
3773    public Sequence setReferenceSeq(SequenceReferenceSeqComponent value)  { 
3774      this.referenceSeq = value;
3775      return this;
3776    }
3777
3778    /**
3779     * @return {@link #variant} (The definition of variant here originates from Sequence ontology ([variant_of](http://www.sequenceontology.org/browser/current_svn/term/variant_of)). This element can represent amino acid or nucleic sequence change(including insertion,deletion,SNP,etc.)  It can represent some complex mutation or segment variation with the assist of CIGAR string.)
3780     */
3781    public List<SequenceVariantComponent> getVariant() { 
3782      if (this.variant == null)
3783        this.variant = new ArrayList<SequenceVariantComponent>();
3784      return this.variant;
3785    }
3786
3787    /**
3788     * @return Returns a reference to <code>this</code> for easy method chaining
3789     */
3790    public Sequence setVariant(List<SequenceVariantComponent> theVariant) { 
3791      this.variant = theVariant;
3792      return this;
3793    }
3794
3795    public boolean hasVariant() { 
3796      if (this.variant == null)
3797        return false;
3798      for (SequenceVariantComponent item : this.variant)
3799        if (!item.isEmpty())
3800          return true;
3801      return false;
3802    }
3803
3804    public SequenceVariantComponent addVariant() { //3
3805      SequenceVariantComponent t = new SequenceVariantComponent();
3806      if (this.variant == null)
3807        this.variant = new ArrayList<SequenceVariantComponent>();
3808      this.variant.add(t);
3809      return t;
3810    }
3811
3812    public Sequence addVariant(SequenceVariantComponent t) { //3
3813      if (t == null)
3814        return this;
3815      if (this.variant == null)
3816        this.variant = new ArrayList<SequenceVariantComponent>();
3817      this.variant.add(t);
3818      return this;
3819    }
3820
3821    /**
3822     * @return The first repetition of repeating field {@link #variant}, creating it if it does not already exist
3823     */
3824    public SequenceVariantComponent getVariantFirstRep() { 
3825      if (getVariant().isEmpty()) {
3826        addVariant();
3827      }
3828      return getVariant().get(0);
3829    }
3830
3831    /**
3832     * @return {@link #observedSeq} (Sequence that was observed. It is the result marked by referenceSeq along with variant records on referenceSeq. This shall starts from referenceSeq.windowStart and end by referenceSeq.windowEnd.). This is the underlying object with id, value and extensions. The accessor "getObservedSeq" gives direct access to the value
3833     */
3834    public StringType getObservedSeqElement() { 
3835      if (this.observedSeq == null)
3836        if (Configuration.errorOnAutoCreate())
3837          throw new Error("Attempt to auto-create Sequence.observedSeq");
3838        else if (Configuration.doAutoCreate())
3839          this.observedSeq = new StringType(); // bb
3840      return this.observedSeq;
3841    }
3842
3843    public boolean hasObservedSeqElement() { 
3844      return this.observedSeq != null && !this.observedSeq.isEmpty();
3845    }
3846
3847    public boolean hasObservedSeq() { 
3848      return this.observedSeq != null && !this.observedSeq.isEmpty();
3849    }
3850
3851    /**
3852     * @param value {@link #observedSeq} (Sequence that was observed. It is the result marked by referenceSeq along with variant records on referenceSeq. This shall starts from referenceSeq.windowStart and end by referenceSeq.windowEnd.). This is the underlying object with id, value and extensions. The accessor "getObservedSeq" gives direct access to the value
3853     */
3854    public Sequence setObservedSeqElement(StringType value) { 
3855      this.observedSeq = value;
3856      return this;
3857    }
3858
3859    /**
3860     * @return Sequence that was observed. It is the result marked by referenceSeq along with variant records on referenceSeq. This shall starts from referenceSeq.windowStart and end by referenceSeq.windowEnd.
3861     */
3862    public String getObservedSeq() { 
3863      return this.observedSeq == null ? null : this.observedSeq.getValue();
3864    }
3865
3866    /**
3867     * @param value Sequence that was observed. It is the result marked by referenceSeq along with variant records on referenceSeq. This shall starts from referenceSeq.windowStart and end by referenceSeq.windowEnd.
3868     */
3869    public Sequence setObservedSeq(String value) { 
3870      if (Utilities.noString(value))
3871        this.observedSeq = null;
3872      else {
3873        if (this.observedSeq == null)
3874          this.observedSeq = new StringType();
3875        this.observedSeq.setValue(value);
3876      }
3877      return this;
3878    }
3879
3880    /**
3881     * @return {@link #quality} (An experimental feature attribute that defines the quality of the feature in a quantitative way, such as a phred quality score ([SO:0001686](http://www.sequenceontology.org/browser/current_svn/term/SO:0001686)).)
3882     */
3883    public List<SequenceQualityComponent> getQuality() { 
3884      if (this.quality == null)
3885        this.quality = new ArrayList<SequenceQualityComponent>();
3886      return this.quality;
3887    }
3888
3889    /**
3890     * @return Returns a reference to <code>this</code> for easy method chaining
3891     */
3892    public Sequence setQuality(List<SequenceQualityComponent> theQuality) { 
3893      this.quality = theQuality;
3894      return this;
3895    }
3896
3897    public boolean hasQuality() { 
3898      if (this.quality == null)
3899        return false;
3900      for (SequenceQualityComponent item : this.quality)
3901        if (!item.isEmpty())
3902          return true;
3903      return false;
3904    }
3905
3906    public SequenceQualityComponent addQuality() { //3
3907      SequenceQualityComponent t = new SequenceQualityComponent();
3908      if (this.quality == null)
3909        this.quality = new ArrayList<SequenceQualityComponent>();
3910      this.quality.add(t);
3911      return t;
3912    }
3913
3914    public Sequence addQuality(SequenceQualityComponent t) { //3
3915      if (t == null)
3916        return this;
3917      if (this.quality == null)
3918        this.quality = new ArrayList<SequenceQualityComponent>();
3919      this.quality.add(t);
3920      return this;
3921    }
3922
3923    /**
3924     * @return The first repetition of repeating field {@link #quality}, creating it if it does not already exist
3925     */
3926    public SequenceQualityComponent getQualityFirstRep() { 
3927      if (getQuality().isEmpty()) {
3928        addQuality();
3929      }
3930      return getQuality().get(0);
3931    }
3932
3933    /**
3934     * @return {@link #readCoverage} (Coverage (read depth or depth) is the average number of reads representing a given nucleotide in the reconstructed sequence.). This is the underlying object with id, value and extensions. The accessor "getReadCoverage" gives direct access to the value
3935     */
3936    public IntegerType getReadCoverageElement() { 
3937      if (this.readCoverage == null)
3938        if (Configuration.errorOnAutoCreate())
3939          throw new Error("Attempt to auto-create Sequence.readCoverage");
3940        else if (Configuration.doAutoCreate())
3941          this.readCoverage = new IntegerType(); // bb
3942      return this.readCoverage;
3943    }
3944
3945    public boolean hasReadCoverageElement() { 
3946      return this.readCoverage != null && !this.readCoverage.isEmpty();
3947    }
3948
3949    public boolean hasReadCoverage() { 
3950      return this.readCoverage != null && !this.readCoverage.isEmpty();
3951    }
3952
3953    /**
3954     * @param value {@link #readCoverage} (Coverage (read depth or depth) is the average number of reads representing a given nucleotide in the reconstructed sequence.). This is the underlying object with id, value and extensions. The accessor "getReadCoverage" gives direct access to the value
3955     */
3956    public Sequence setReadCoverageElement(IntegerType value) { 
3957      this.readCoverage = value;
3958      return this;
3959    }
3960
3961    /**
3962     * @return Coverage (read depth or depth) is the average number of reads representing a given nucleotide in the reconstructed sequence.
3963     */
3964    public int getReadCoverage() { 
3965      return this.readCoverage == null || this.readCoverage.isEmpty() ? 0 : this.readCoverage.getValue();
3966    }
3967
3968    /**
3969     * @param value Coverage (read depth or depth) is the average number of reads representing a given nucleotide in the reconstructed sequence.
3970     */
3971    public Sequence setReadCoverage(int value) { 
3972        if (this.readCoverage == null)
3973          this.readCoverage = new IntegerType();
3974        this.readCoverage.setValue(value);
3975      return this;
3976    }
3977
3978    /**
3979     * @return {@link #repository} (Configurations of the external repository. The repository shall store target's observedSeq or records related with target's observedSeq.)
3980     */
3981    public List<SequenceRepositoryComponent> getRepository() { 
3982      if (this.repository == null)
3983        this.repository = new ArrayList<SequenceRepositoryComponent>();
3984      return this.repository;
3985    }
3986
3987    /**
3988     * @return Returns a reference to <code>this</code> for easy method chaining
3989     */
3990    public Sequence setRepository(List<SequenceRepositoryComponent> theRepository) { 
3991      this.repository = theRepository;
3992      return this;
3993    }
3994
3995    public boolean hasRepository() { 
3996      if (this.repository == null)
3997        return false;
3998      for (SequenceRepositoryComponent item : this.repository)
3999        if (!item.isEmpty())
4000          return true;
4001      return false;
4002    }
4003
4004    public SequenceRepositoryComponent addRepository() { //3
4005      SequenceRepositoryComponent t = new SequenceRepositoryComponent();
4006      if (this.repository == null)
4007        this.repository = new ArrayList<SequenceRepositoryComponent>();
4008      this.repository.add(t);
4009      return t;
4010    }
4011
4012    public Sequence addRepository(SequenceRepositoryComponent t) { //3
4013      if (t == null)
4014        return this;
4015      if (this.repository == null)
4016        this.repository = new ArrayList<SequenceRepositoryComponent>();
4017      this.repository.add(t);
4018      return this;
4019    }
4020
4021    /**
4022     * @return The first repetition of repeating field {@link #repository}, creating it if it does not already exist
4023     */
4024    public SequenceRepositoryComponent getRepositoryFirstRep() { 
4025      if (getRepository().isEmpty()) {
4026        addRepository();
4027      }
4028      return getRepository().get(0);
4029    }
4030
4031    /**
4032     * @return {@link #pointer} (Pointer to next atomic sequence which at most contains one variant.)
4033     */
4034    public List<Reference> getPointer() { 
4035      if (this.pointer == null)
4036        this.pointer = new ArrayList<Reference>();
4037      return this.pointer;
4038    }
4039
4040    /**
4041     * @return Returns a reference to <code>this</code> for easy method chaining
4042     */
4043    public Sequence setPointer(List<Reference> thePointer) { 
4044      this.pointer = thePointer;
4045      return this;
4046    }
4047
4048    public boolean hasPointer() { 
4049      if (this.pointer == null)
4050        return false;
4051      for (Reference item : this.pointer)
4052        if (!item.isEmpty())
4053          return true;
4054      return false;
4055    }
4056
4057    public Reference addPointer() { //3
4058      Reference t = new Reference();
4059      if (this.pointer == null)
4060        this.pointer = new ArrayList<Reference>();
4061      this.pointer.add(t);
4062      return t;
4063    }
4064
4065    public Sequence addPointer(Reference t) { //3
4066      if (t == null)
4067        return this;
4068      if (this.pointer == null)
4069        this.pointer = new ArrayList<Reference>();
4070      this.pointer.add(t);
4071      return this;
4072    }
4073
4074    /**
4075     * @return The first repetition of repeating field {@link #pointer}, creating it if it does not already exist
4076     */
4077    public Reference getPointerFirstRep() { 
4078      if (getPointer().isEmpty()) {
4079        addPointer();
4080      }
4081      return getPointer().get(0);
4082    }
4083
4084    /**
4085     * @deprecated Use Reference#setResource(IBaseResource) instead
4086     */
4087    @Deprecated
4088    public List<Sequence> getPointerTarget() { 
4089      if (this.pointerTarget == null)
4090        this.pointerTarget = new ArrayList<Sequence>();
4091      return this.pointerTarget;
4092    }
4093
4094    /**
4095     * @deprecated Use Reference#setResource(IBaseResource) instead
4096     */
4097    @Deprecated
4098    public Sequence addPointerTarget() { 
4099      Sequence r = new Sequence();
4100      if (this.pointerTarget == null)
4101        this.pointerTarget = new ArrayList<Sequence>();
4102      this.pointerTarget.add(r);
4103      return r;
4104    }
4105
4106      protected void listChildren(List<Property> children) {
4107        super.listChildren(children);
4108        children.add(new Property("identifier", "Identifier", "A unique identifier for this particular sequence instance. This is a FHIR-defined id.", 0, java.lang.Integer.MAX_VALUE, identifier));
4109        children.add(new Property("type", "code", "Amino Acid Sequence/ DNA Sequence / RNA Sequence.", 0, 1, type));
4110        children.add(new Property("coordinateSystem", "integer", "Whether the sequence is numbered starting at 0 (0-based numbering or coordinates, inclusive start, exclusive end) or starting at 1 (1-based numbering, inclusive start and inclusive end).", 0, 1, coordinateSystem));
4111        children.add(new Property("patient", "Reference(Patient)", "The patient whose sequencing results are described by this resource.", 0, 1, patient));
4112        children.add(new Property("specimen", "Reference(Specimen)", "Specimen used for sequencing.", 0, 1, specimen));
4113        children.add(new Property("device", "Reference(Device)", "The method for sequencing, for example, chip information.", 0, 1, device));
4114        children.add(new Property("performer", "Reference(Organization)", "The organization or lab that should be responsible for this result.", 0, 1, performer));
4115        children.add(new Property("quantity", "Quantity", "The number of copies of the seqeunce of interest. (RNASeq).", 0, 1, quantity));
4116        children.add(new Property("referenceSeq", "", "A sequence that is used as a reference to describe variants that are present in a sequence analyzed.", 0, 1, referenceSeq));
4117        children.add(new Property("variant", "", "The definition of variant here originates from Sequence ontology ([variant_of](http://www.sequenceontology.org/browser/current_svn/term/variant_of)). This element can represent amino acid or nucleic sequence change(including insertion,deletion,SNP,etc.)  It can represent some complex mutation or segment variation with the assist of CIGAR string.", 0, java.lang.Integer.MAX_VALUE, variant));
4118        children.add(new Property("observedSeq", "string", "Sequence that was observed. It is the result marked by referenceSeq along with variant records on referenceSeq. This shall starts from referenceSeq.windowStart and end by referenceSeq.windowEnd.", 0, 1, observedSeq));
4119        children.add(new Property("quality", "", "An experimental feature attribute that defines the quality of the feature in a quantitative way, such as a phred quality score ([SO:0001686](http://www.sequenceontology.org/browser/current_svn/term/SO:0001686)).", 0, java.lang.Integer.MAX_VALUE, quality));
4120        children.add(new Property("readCoverage", "integer", "Coverage (read depth or depth) is the average number of reads representing a given nucleotide in the reconstructed sequence.", 0, 1, readCoverage));
4121        children.add(new Property("repository", "", "Configurations of the external repository. The repository shall store target's observedSeq or records related with target's observedSeq.", 0, java.lang.Integer.MAX_VALUE, repository));
4122        children.add(new Property("pointer", "Reference(Sequence)", "Pointer to next atomic sequence which at most contains one variant.", 0, java.lang.Integer.MAX_VALUE, pointer));
4123      }
4124
4125      @Override
4126      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
4127        switch (_hash) {
4128        case -1618432855: /*identifier*/  return new Property("identifier", "Identifier", "A unique identifier for this particular sequence instance. This is a FHIR-defined id.", 0, java.lang.Integer.MAX_VALUE, identifier);
4129        case 3575610: /*type*/  return new Property("type", "code", "Amino Acid Sequence/ DNA Sequence / RNA Sequence.", 0, 1, type);
4130        case 354212295: /*coordinateSystem*/  return new Property("coordinateSystem", "integer", "Whether the sequence is numbered starting at 0 (0-based numbering or coordinates, inclusive start, exclusive end) or starting at 1 (1-based numbering, inclusive start and inclusive end).", 0, 1, coordinateSystem);
4131        case -791418107: /*patient*/  return new Property("patient", "Reference(Patient)", "The patient whose sequencing results are described by this resource.", 0, 1, patient);
4132        case -2132868344: /*specimen*/  return new Property("specimen", "Reference(Specimen)", "Specimen used for sequencing.", 0, 1, specimen);
4133        case -1335157162: /*device*/  return new Property("device", "Reference(Device)", "The method for sequencing, for example, chip information.", 0, 1, device);
4134        case 481140686: /*performer*/  return new Property("performer", "Reference(Organization)", "The organization or lab that should be responsible for this result.", 0, 1, performer);
4135        case -1285004149: /*quantity*/  return new Property("quantity", "Quantity", "The number of copies of the seqeunce of interest. (RNASeq).", 0, 1, quantity);
4136        case -502547180: /*referenceSeq*/  return new Property("referenceSeq", "", "A sequence that is used as a reference to describe variants that are present in a sequence analyzed.", 0, 1, referenceSeq);
4137        case 236785797: /*variant*/  return new Property("variant", "", "The definition of variant here originates from Sequence ontology ([variant_of](http://www.sequenceontology.org/browser/current_svn/term/variant_of)). This element can represent amino acid or nucleic sequence change(including insertion,deletion,SNP,etc.)  It can represent some complex mutation or segment variation with the assist of CIGAR string.", 0, java.lang.Integer.MAX_VALUE, variant);
4138        case 125541495: /*observedSeq*/  return new Property("observedSeq", "string", "Sequence that was observed. It is the result marked by referenceSeq along with variant records on referenceSeq. This shall starts from referenceSeq.windowStart and end by referenceSeq.windowEnd.", 0, 1, observedSeq);
4139        case 651215103: /*quality*/  return new Property("quality", "", "An experimental feature attribute that defines the quality of the feature in a quantitative way, such as a phred quality score ([SO:0001686](http://www.sequenceontology.org/browser/current_svn/term/SO:0001686)).", 0, java.lang.Integer.MAX_VALUE, quality);
4140        case -1798816354: /*readCoverage*/  return new Property("readCoverage", "integer", "Coverage (read depth or depth) is the average number of reads representing a given nucleotide in the reconstructed sequence.", 0, 1, readCoverage);
4141        case 1950800714: /*repository*/  return new Property("repository", "", "Configurations of the external repository. The repository shall store target's observedSeq or records related with target's observedSeq.", 0, java.lang.Integer.MAX_VALUE, repository);
4142        case -400605635: /*pointer*/  return new Property("pointer", "Reference(Sequence)", "Pointer to next atomic sequence which at most contains one variant.", 0, java.lang.Integer.MAX_VALUE, pointer);
4143        default: return super.getNamedProperty(_hash, _name, _checkValid);
4144        }
4145
4146      }
4147
4148      @Override
4149      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
4150        switch (hash) {
4151        case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier
4152        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<SequenceType>
4153        case 354212295: /*coordinateSystem*/ return this.coordinateSystem == null ? new Base[0] : new Base[] {this.coordinateSystem}; // IntegerType
4154        case -791418107: /*patient*/ return this.patient == null ? new Base[0] : new Base[] {this.patient}; // Reference
4155        case -2132868344: /*specimen*/ return this.specimen == null ? new Base[0] : new Base[] {this.specimen}; // Reference
4156        case -1335157162: /*device*/ return this.device == null ? new Base[0] : new Base[] {this.device}; // Reference
4157        case 481140686: /*performer*/ return this.performer == null ? new Base[0] : new Base[] {this.performer}; // Reference
4158        case -1285004149: /*quantity*/ return this.quantity == null ? new Base[0] : new Base[] {this.quantity}; // Quantity
4159        case -502547180: /*referenceSeq*/ return this.referenceSeq == null ? new Base[0] : new Base[] {this.referenceSeq}; // SequenceReferenceSeqComponent
4160        case 236785797: /*variant*/ return this.variant == null ? new Base[0] : this.variant.toArray(new Base[this.variant.size()]); // SequenceVariantComponent
4161        case 125541495: /*observedSeq*/ return this.observedSeq == null ? new Base[0] : new Base[] {this.observedSeq}; // StringType
4162        case 651215103: /*quality*/ return this.quality == null ? new Base[0] : this.quality.toArray(new Base[this.quality.size()]); // SequenceQualityComponent
4163        case -1798816354: /*readCoverage*/ return this.readCoverage == null ? new Base[0] : new Base[] {this.readCoverage}; // IntegerType
4164        case 1950800714: /*repository*/ return this.repository == null ? new Base[0] : this.repository.toArray(new Base[this.repository.size()]); // SequenceRepositoryComponent
4165        case -400605635: /*pointer*/ return this.pointer == null ? new Base[0] : this.pointer.toArray(new Base[this.pointer.size()]); // Reference
4166        default: return super.getProperty(hash, name, checkValid);
4167        }
4168
4169      }
4170
4171      @Override
4172      public Base setProperty(int hash, String name, Base value) throws FHIRException {
4173        switch (hash) {
4174        case -1618432855: // identifier
4175          this.getIdentifier().add(castToIdentifier(value)); // Identifier
4176          return value;
4177        case 3575610: // type
4178          value = new SequenceTypeEnumFactory().fromType(castToCode(value));
4179          this.type = (Enumeration) value; // Enumeration<SequenceType>
4180          return value;
4181        case 354212295: // coordinateSystem
4182          this.coordinateSystem = castToInteger(value); // IntegerType
4183          return value;
4184        case -791418107: // patient
4185          this.patient = castToReference(value); // Reference
4186          return value;
4187        case -2132868344: // specimen
4188          this.specimen = castToReference(value); // Reference
4189          return value;
4190        case -1335157162: // device
4191          this.device = castToReference(value); // Reference
4192          return value;
4193        case 481140686: // performer
4194          this.performer = castToReference(value); // Reference
4195          return value;
4196        case -1285004149: // quantity
4197          this.quantity = castToQuantity(value); // Quantity
4198          return value;
4199        case -502547180: // referenceSeq
4200          this.referenceSeq = (SequenceReferenceSeqComponent) value; // SequenceReferenceSeqComponent
4201          return value;
4202        case 236785797: // variant
4203          this.getVariant().add((SequenceVariantComponent) value); // SequenceVariantComponent
4204          return value;
4205        case 125541495: // observedSeq
4206          this.observedSeq = castToString(value); // StringType
4207          return value;
4208        case 651215103: // quality
4209          this.getQuality().add((SequenceQualityComponent) value); // SequenceQualityComponent
4210          return value;
4211        case -1798816354: // readCoverage
4212          this.readCoverage = castToInteger(value); // IntegerType
4213          return value;
4214        case 1950800714: // repository
4215          this.getRepository().add((SequenceRepositoryComponent) value); // SequenceRepositoryComponent
4216          return value;
4217        case -400605635: // pointer
4218          this.getPointer().add(castToReference(value)); // Reference
4219          return value;
4220        default: return super.setProperty(hash, name, value);
4221        }
4222
4223      }
4224
4225      @Override
4226      public Base setProperty(String name, Base value) throws FHIRException {
4227        if (name.equals("identifier")) {
4228          this.getIdentifier().add(castToIdentifier(value));
4229        } else if (name.equals("type")) {
4230          value = new SequenceTypeEnumFactory().fromType(castToCode(value));
4231          this.type = (Enumeration) value; // Enumeration<SequenceType>
4232        } else if (name.equals("coordinateSystem")) {
4233          this.coordinateSystem = castToInteger(value); // IntegerType
4234        } else if (name.equals("patient")) {
4235          this.patient = castToReference(value); // Reference
4236        } else if (name.equals("specimen")) {
4237          this.specimen = castToReference(value); // Reference
4238        } else if (name.equals("device")) {
4239          this.device = castToReference(value); // Reference
4240        } else if (name.equals("performer")) {
4241          this.performer = castToReference(value); // Reference
4242        } else if (name.equals("quantity")) {
4243          this.quantity = castToQuantity(value); // Quantity
4244        } else if (name.equals("referenceSeq")) {
4245          this.referenceSeq = (SequenceReferenceSeqComponent) value; // SequenceReferenceSeqComponent
4246        } else if (name.equals("variant")) {
4247          this.getVariant().add((SequenceVariantComponent) value);
4248        } else if (name.equals("observedSeq")) {
4249          this.observedSeq = castToString(value); // StringType
4250        } else if (name.equals("quality")) {
4251          this.getQuality().add((SequenceQualityComponent) value);
4252        } else if (name.equals("readCoverage")) {
4253          this.readCoverage = castToInteger(value); // IntegerType
4254        } else if (name.equals("repository")) {
4255          this.getRepository().add((SequenceRepositoryComponent) value);
4256        } else if (name.equals("pointer")) {
4257          this.getPointer().add(castToReference(value));
4258        } else
4259          return super.setProperty(name, value);
4260        return value;
4261      }
4262
4263      @Override
4264      public Base makeProperty(int hash, String name) throws FHIRException {
4265        switch (hash) {
4266        case -1618432855:  return addIdentifier(); 
4267        case 3575610:  return getTypeElement();
4268        case 354212295:  return getCoordinateSystemElement();
4269        case -791418107:  return getPatient(); 
4270        case -2132868344:  return getSpecimen(); 
4271        case -1335157162:  return getDevice(); 
4272        case 481140686:  return getPerformer(); 
4273        case -1285004149:  return getQuantity(); 
4274        case -502547180:  return getReferenceSeq(); 
4275        case 236785797:  return addVariant(); 
4276        case 125541495:  return getObservedSeqElement();
4277        case 651215103:  return addQuality(); 
4278        case -1798816354:  return getReadCoverageElement();
4279        case 1950800714:  return addRepository(); 
4280        case -400605635:  return addPointer(); 
4281        default: return super.makeProperty(hash, name);
4282        }
4283
4284      }
4285
4286      @Override
4287      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
4288        switch (hash) {
4289        case -1618432855: /*identifier*/ return new String[] {"Identifier"};
4290        case 3575610: /*type*/ return new String[] {"code"};
4291        case 354212295: /*coordinateSystem*/ return new String[] {"integer"};
4292        case -791418107: /*patient*/ return new String[] {"Reference"};
4293        case -2132868344: /*specimen*/ return new String[] {"Reference"};
4294        case -1335157162: /*device*/ return new String[] {"Reference"};
4295        case 481140686: /*performer*/ return new String[] {"Reference"};
4296        case -1285004149: /*quantity*/ return new String[] {"Quantity"};
4297        case -502547180: /*referenceSeq*/ return new String[] {};
4298        case 236785797: /*variant*/ return new String[] {};
4299        case 125541495: /*observedSeq*/ return new String[] {"string"};
4300        case 651215103: /*quality*/ return new String[] {};
4301        case -1798816354: /*readCoverage*/ return new String[] {"integer"};
4302        case 1950800714: /*repository*/ return new String[] {};
4303        case -400605635: /*pointer*/ return new String[] {"Reference"};
4304        default: return super.getTypesForProperty(hash, name);
4305        }
4306
4307      }
4308
4309      @Override
4310      public Base addChild(String name) throws FHIRException {
4311        if (name.equals("identifier")) {
4312          return addIdentifier();
4313        }
4314        else if (name.equals("type")) {
4315          throw new FHIRException("Cannot call addChild on a primitive type Sequence.type");
4316        }
4317        else if (name.equals("coordinateSystem")) {
4318          throw new FHIRException("Cannot call addChild on a primitive type Sequence.coordinateSystem");
4319        }
4320        else if (name.equals("patient")) {
4321          this.patient = new Reference();
4322          return this.patient;
4323        }
4324        else if (name.equals("specimen")) {
4325          this.specimen = new Reference();
4326          return this.specimen;
4327        }
4328        else if (name.equals("device")) {
4329          this.device = new Reference();
4330          return this.device;
4331        }
4332        else if (name.equals("performer")) {
4333          this.performer = new Reference();
4334          return this.performer;
4335        }
4336        else if (name.equals("quantity")) {
4337          this.quantity = new Quantity();
4338          return this.quantity;
4339        }
4340        else if (name.equals("referenceSeq")) {
4341          this.referenceSeq = new SequenceReferenceSeqComponent();
4342          return this.referenceSeq;
4343        }
4344        else if (name.equals("variant")) {
4345          return addVariant();
4346        }
4347        else if (name.equals("observedSeq")) {
4348          throw new FHIRException("Cannot call addChild on a primitive type Sequence.observedSeq");
4349        }
4350        else if (name.equals("quality")) {
4351          return addQuality();
4352        }
4353        else if (name.equals("readCoverage")) {
4354          throw new FHIRException("Cannot call addChild on a primitive type Sequence.readCoverage");
4355        }
4356        else if (name.equals("repository")) {
4357          return addRepository();
4358        }
4359        else if (name.equals("pointer")) {
4360          return addPointer();
4361        }
4362        else
4363          return super.addChild(name);
4364      }
4365
4366  public String fhirType() {
4367    return "Sequence";
4368
4369  }
4370
4371      public Sequence copy() {
4372        Sequence dst = new Sequence();
4373        copyValues(dst);
4374        if (identifier != null) {
4375          dst.identifier = new ArrayList<Identifier>();
4376          for (Identifier i : identifier)
4377            dst.identifier.add(i.copy());
4378        };
4379        dst.type = type == null ? null : type.copy();
4380        dst.coordinateSystem = coordinateSystem == null ? null : coordinateSystem.copy();
4381        dst.patient = patient == null ? null : patient.copy();
4382        dst.specimen = specimen == null ? null : specimen.copy();
4383        dst.device = device == null ? null : device.copy();
4384        dst.performer = performer == null ? null : performer.copy();
4385        dst.quantity = quantity == null ? null : quantity.copy();
4386        dst.referenceSeq = referenceSeq == null ? null : referenceSeq.copy();
4387        if (variant != null) {
4388          dst.variant = new ArrayList<SequenceVariantComponent>();
4389          for (SequenceVariantComponent i : variant)
4390            dst.variant.add(i.copy());
4391        };
4392        dst.observedSeq = observedSeq == null ? null : observedSeq.copy();
4393        if (quality != null) {
4394          dst.quality = new ArrayList<SequenceQualityComponent>();
4395          for (SequenceQualityComponent i : quality)
4396            dst.quality.add(i.copy());
4397        };
4398        dst.readCoverage = readCoverage == null ? null : readCoverage.copy();
4399        if (repository != null) {
4400          dst.repository = new ArrayList<SequenceRepositoryComponent>();
4401          for (SequenceRepositoryComponent i : repository)
4402            dst.repository.add(i.copy());
4403        };
4404        if (pointer != null) {
4405          dst.pointer = new ArrayList<Reference>();
4406          for (Reference i : pointer)
4407            dst.pointer.add(i.copy());
4408        };
4409        return dst;
4410      }
4411
4412      protected Sequence typedCopy() {
4413        return copy();
4414      }
4415
4416      @Override
4417      public boolean equalsDeep(Base other_) {
4418        if (!super.equalsDeep(other_))
4419          return false;
4420        if (!(other_ instanceof Sequence))
4421          return false;
4422        Sequence o = (Sequence) other_;
4423        return compareDeep(identifier, o.identifier, true) && compareDeep(type, o.type, true) && compareDeep(coordinateSystem, o.coordinateSystem, true)
4424           && compareDeep(patient, o.patient, true) && compareDeep(specimen, o.specimen, true) && compareDeep(device, o.device, true)
4425           && compareDeep(performer, o.performer, true) && compareDeep(quantity, o.quantity, true) && compareDeep(referenceSeq, o.referenceSeq, true)
4426           && compareDeep(variant, o.variant, true) && compareDeep(observedSeq, o.observedSeq, true) && compareDeep(quality, o.quality, true)
4427           && compareDeep(readCoverage, o.readCoverage, true) && compareDeep(repository, o.repository, true)
4428           && compareDeep(pointer, o.pointer, true);
4429      }
4430
4431      @Override
4432      public boolean equalsShallow(Base other_) {
4433        if (!super.equalsShallow(other_))
4434          return false;
4435        if (!(other_ instanceof Sequence))
4436          return false;
4437        Sequence o = (Sequence) other_;
4438        return compareValues(type, o.type, true) && compareValues(coordinateSystem, o.coordinateSystem, true)
4439           && compareValues(observedSeq, o.observedSeq, true) && compareValues(readCoverage, o.readCoverage, true)
4440          ;
4441      }
4442
4443      public boolean isEmpty() {
4444        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, type, coordinateSystem
4445          , patient, specimen, device, performer, quantity, referenceSeq, variant, observedSeq
4446          , quality, readCoverage, repository, pointer);
4447      }
4448
4449  @Override
4450  public ResourceType getResourceType() {
4451    return ResourceType.Sequence;
4452   }
4453
4454 /**
4455   * Search parameter: <b>identifier</b>
4456   * <p>
4457   * Description: <b>The unique identity for a particular sequence</b><br>
4458   * Type: <b>token</b><br>
4459   * Path: <b>Sequence.identifier</b><br>
4460   * </p>
4461   */
4462  @SearchParamDefinition(name="identifier", path="Sequence.identifier", description="The unique identity for a particular sequence", type="token" )
4463  public static final String SP_IDENTIFIER = "identifier";
4464 /**
4465   * <b>Fluent Client</b> search parameter constant for <b>identifier</b>
4466   * <p>
4467   * Description: <b>The unique identity for a particular sequence</b><br>
4468   * Type: <b>token</b><br>
4469   * Path: <b>Sequence.identifier</b><br>
4470   * </p>
4471   */
4472  public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER);
4473
4474 /**
4475   * Search parameter: <b>coordinate</b>
4476   * <p>
4477   * Description: <b>Search parameter for region of the reference DNA sequence string. This will refer to part of a locus or part of a gene where search region will be represented in 1-based system. Since the coordinateSystem can either be 0-based or 1-based, this search query will include the result of both coordinateSystem that contains the equivalent segment of the gene or whole genome sequence. For example, a search for sequence can be represented as `coordinate=1$lt345$gt123`, this means it will search for the Sequence resource on chromosome 1 and with position >123 and <345, where in 1-based system resource, all strings within region 1:124-344 will be revealed, while in 0-based system resource, all strings within region 1:123-344 will be revealed. You may want to check detail about 0-based v.s. 1-based above.</b><br>
4478   * Type: <b>composite</b><br>
4479   * Path: <b></b><br>
4480   * </p>
4481   */
4482  @SearchParamDefinition(name="coordinate", path="Sequence.variant", description="Search parameter for region of the reference DNA sequence string. This will refer to part of a locus or part of a gene where search region will be represented in 1-based system. Since the coordinateSystem can either be 0-based or 1-based, this search query will include the result of both coordinateSystem that contains the equivalent segment of the gene or whole genome sequence. For example, a search for sequence can be represented as `coordinate=1$lt345$gt123`, this means it will search for the Sequence resource on chromosome 1 and with position >123 and <345, where in 1-based system resource, all strings within region 1:124-344 will be revealed, while in 0-based system resource, all strings within region 1:123-344 will be revealed. You may want to check detail about 0-based v.s. 1-based above.", type="composite", compositeOf={"chromosome", "start"} )
4483  public static final String SP_COORDINATE = "coordinate";
4484 /**
4485   * <b>Fluent Client</b> search parameter constant for <b>coordinate</b>
4486   * <p>
4487   * Description: <b>Search parameter for region of the reference DNA sequence string. This will refer to part of a locus or part of a gene where search region will be represented in 1-based system. Since the coordinateSystem can either be 0-based or 1-based, this search query will include the result of both coordinateSystem that contains the equivalent segment of the gene or whole genome sequence. For example, a search for sequence can be represented as `coordinate=1$lt345$gt123`, this means it will search for the Sequence resource on chromosome 1 and with position >123 and <345, where in 1-based system resource, all strings within region 1:124-344 will be revealed, while in 0-based system resource, all strings within region 1:123-344 will be revealed. You may want to check detail about 0-based v.s. 1-based above.</b><br>
4488   * Type: <b>composite</b><br>
4489   * Path: <b></b><br>
4490   * </p>
4491   */
4492  public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.NumberClientParam> COORDINATE = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.NumberClientParam>(SP_COORDINATE);
4493
4494 /**
4495   * Search parameter: <b>patient</b>
4496   * <p>
4497   * Description: <b>The subject that the observation is about</b><br>
4498   * Type: <b>reference</b><br>
4499   * Path: <b>Sequence.patient</b><br>
4500   * </p>
4501   */
4502  @SearchParamDefinition(name="patient", path="Sequence.patient", description="The subject that the observation is about", type="reference", target={Patient.class } )
4503  public static final String SP_PATIENT = "patient";
4504 /**
4505   * <b>Fluent Client</b> search parameter constant for <b>patient</b>
4506   * <p>
4507   * Description: <b>The subject that the observation is about</b><br>
4508   * Type: <b>reference</b><br>
4509   * Path: <b>Sequence.patient</b><br>
4510   * </p>
4511   */
4512  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PATIENT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_PATIENT);
4513
4514/**
4515   * Constant for fluent queries to be used to add include statements. Specifies
4516   * the path value of "<b>Sequence:patient</b>".
4517   */
4518  public static final ca.uhn.fhir.model.api.Include INCLUDE_PATIENT = new ca.uhn.fhir.model.api.Include("Sequence:patient").toLocked();
4519
4520 /**
4521   * Search parameter: <b>chromosome</b>
4522   * <p>
4523   * Description: <b>Chromosome number of the reference sequence</b><br>
4524   * Type: <b>token</b><br>
4525   * Path: <b>Sequence.referenceSeq.chromosome</b><br>
4526   * </p>
4527   */
4528  @SearchParamDefinition(name="chromosome", path="Sequence.referenceSeq.chromosome", description="Chromosome number of the reference sequence", type="token" )
4529  public static final String SP_CHROMOSOME = "chromosome";
4530 /**
4531   * <b>Fluent Client</b> search parameter constant for <b>chromosome</b>
4532   * <p>
4533   * Description: <b>Chromosome number of the reference sequence</b><br>
4534   * Type: <b>token</b><br>
4535   * Path: <b>Sequence.referenceSeq.chromosome</b><br>
4536   * </p>
4537   */
4538  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CHROMOSOME = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CHROMOSOME);
4539
4540 /**
4541   * Search parameter: <b>start</b>
4542   * <p>
4543   * Description: <b>Start position (0-based inclusive, 1-based inclusive, that means the nucleic acid or amino acid at this position will be included) of the reference sequence.</b><br>
4544   * Type: <b>number</b><br>
4545   * Path: <b>Sequence.referenceSeq.windowStart</b><br>
4546   * </p>
4547   */
4548  @SearchParamDefinition(name="start", path="Sequence.referenceSeq.windowStart", description="Start position (0-based inclusive, 1-based inclusive, that means the nucleic acid or amino acid at this position will be included) of the reference sequence.", type="number" )
4549  public static final String SP_START = "start";
4550 /**
4551   * <b>Fluent Client</b> search parameter constant for <b>start</b>
4552   * <p>
4553   * Description: <b>Start position (0-based inclusive, 1-based inclusive, that means the nucleic acid or amino acid at this position will be included) of the reference sequence.</b><br>
4554   * Type: <b>number</b><br>
4555   * Path: <b>Sequence.referenceSeq.windowStart</b><br>
4556   * </p>
4557   */
4558  public static final ca.uhn.fhir.rest.gclient.NumberClientParam START = new ca.uhn.fhir.rest.gclient.NumberClientParam(SP_START);
4559
4560 /**
4561   * Search parameter: <b>end</b>
4562   * <p>
4563   * Description: <b>End position (0-based exclusive, which menas the acid at this position will not be included, 1-based inclusive, which means the acid at this position will be included) of the reference sequence.</b><br>
4564   * Type: <b>number</b><br>
4565   * Path: <b>Sequence.referenceSeq.windowEnd</b><br>
4566   * </p>
4567   */
4568  @SearchParamDefinition(name="end", path="Sequence.referenceSeq.windowEnd", description="End position (0-based exclusive, which menas the acid at this position will not be included, 1-based inclusive, which means the acid at this position will be included) of the reference sequence.", type="number" )
4569  public static final String SP_END = "end";
4570 /**
4571   * <b>Fluent Client</b> search parameter constant for <b>end</b>
4572   * <p>
4573   * Description: <b>End position (0-based exclusive, which menas the acid at this position will not be included, 1-based inclusive, which means the acid at this position will be included) of the reference sequence.</b><br>
4574   * Type: <b>number</b><br>
4575   * Path: <b>Sequence.referenceSeq.windowEnd</b><br>
4576   * </p>
4577   */
4578  public static final ca.uhn.fhir.rest.gclient.NumberClientParam END = new ca.uhn.fhir.rest.gclient.NumberClientParam(SP_END);
4579
4580 /**
4581   * Search parameter: <b>type</b>
4582   * <p>
4583   * Description: <b>Amino Acid Sequence/ DNA Sequence / RNA Sequence</b><br>
4584   * Type: <b>token</b><br>
4585   * Path: <b>Sequence.type</b><br>
4586   * </p>
4587   */
4588  @SearchParamDefinition(name="type", path="Sequence.type", description="Amino Acid Sequence/ DNA Sequence / RNA Sequence", type="token" )
4589  public static final String SP_TYPE = "type";
4590 /**
4591   * <b>Fluent Client</b> search parameter constant for <b>type</b>
4592   * <p>
4593   * Description: <b>Amino Acid Sequence/ DNA Sequence / RNA Sequence</b><br>
4594   * Type: <b>token</b><br>
4595   * Path: <b>Sequence.type</b><br>
4596   * </p>
4597   */
4598  public static final ca.uhn.fhir.rest.gclient.TokenClientParam TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_TYPE);
4599
4600
4601}
4602